zeropoint-node 1.0.6 → 1.0.8

package/src/verification/lean-bridge.ts

@@ -32,6 +32,7 @@
 import { createHash } from 'node:crypto'
 import { digitalRoot, throughVoid, bearingForDigit, VORTEX_SEQUENCE, VORTEX_ORBIT, VORTEX_AXIS } from '../0/index.ts'
 import { angleForDigit } from '../0/3/6/9/1/2/4/8/7/5/1/a432.math.ts'
+import { foldToLean, leanIsFixed } from '../kernel/import-graph.ts'
 import {
   GIBBS_FORMATION,
   GIBBS_SPLITTING,
@@ -737,6 +738,42 @@ export const SEALS: Record<string, Seal> = {
       return true
     },
   },
+  lean_is_a_fixed_point: {
+    basis: "LEAN is defined as the fixed point of the reachability fold, not as a number anyone chose: fold(fold(S)) = fold(S). This checks the fold on graphs whose answers are known by hand — a chain, a cycle, a disconnected node, an entry outside the graph — and checks idempotence on each. Cycles must terminate rather than reaching the answer by luck, and an unreachable node must stay out however many times the fold is applied.",
+    decide: () => {
+      const key = (s: Set<string>) => [...s].sort().join(',')
+
+      // A chain, a 2-cycle, and an isolated node, all in one graph.
+      const g = new Map<string, readonly string[]>([
+        ['a', ['b']], ['b', ['c']], ['c', []],
+        ['x', ['y']], ['y', ['x']],
+        ['z', []],
+      ])
+
+      // Reachability, by hand.
+      if (key(foldToLean(g, ['a'])) !== 'a,b,c') return false
+      // A cycle must terminate and include both nodes exactly once.
+      if (key(foldToLean(g, ['x'])) !== 'x,y') return false
+      // An isolated node is reachable only from itself.
+      if (key(foldToLean(g, ['z'])) !== 'z') return false
+      // Nothing is reachable from nothing.
+      if (foldToLean(g, []).size !== 0) return false
+      // An entry that is not in the graph contributes nothing rather than throwing.
+      if (foldToLean(g, ['absent']).size !== 0) return false
+      // z is outside the fold from a, and stays outside however often we fold.
+      if (foldToLean(g, ['a']).has('z')) return false
+
+      // The definition must be well founded on every one of these.
+      for (const entries of [['a'], ['x'], ['z'], [], ['a', 'x'], ['absent']]) {
+        if (!leanIsFixed(g, entries)) return false
+      }
+
+      // And on a graph where an entry reaches everything, lean is everything.
+      const full = new Map<string, readonly string[]>([['r', ['a', 'x', 'z']], ['a', ['b']], ['b', []], ['x', ['x']], ['z', []]])
+      if (key(foldToLean(full, ['r'])) !== 'a,b,r,x,z') return false
+      return leanIsFixed(full, ['r'])
+    },
+  },
 }
 
 // ============================================================================

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.1.2.4.8.7.ts

@@ -1,60 +0,0 @@
-// a432.1.2.4.8.7.ts — Open Vortex/Doubling Stream Module (Short Arc)
-//
-// This module encodes the open doubling sequence (1-2-4-8-7) as a living, recursive stream.
-// It is the generative arc of the vortex, not yet returned to origin. Digital root bridged to a432.roots (Wave 9); stream logic remains local.
-
-/**
- * Metaphysical Principle:
- * - The sequence 1→2→4→8→7 is the open right-hand vortex in vortex math, truncated before further progression.
- * - It is the journey, the generative flow, the living stream before closure or return.
- * - This module is a seed/arc in the living A432 matrix.
- */
-
-// --- Math: Digital Root — bridged to a432.roots (Wave 9) ---
-
-// --- Generator: Open Doubling Vortex Stream ---
-
-
-
-import { legacyDigitalRoot as digitalRoot } from './a432.roots.ts';
-
-function* openDoublingVortexStream(start = 1, length = 5) {
-  let n = start;
-  for (let i = 0; i < length; i++) {
-    yield n;
-    n = digitalRoot(n * 2);
-  }
-}
-
-// --- Utility: Get Sequence as Array ---
-function getOpenDoublingSequence(start = 1, length = 5) {
-  return [...openDoublingVortexStream(start, length)];
-}
-
-// --- Utility: Get Nth in Sequence ---
-function getOpenDoublingNth(start = 1, n = 0) {
-  let val = start;
-  for (let i = 0; i < n; i++) val = digitalRoot(val * 2);
-  return val;
-}
-
-// --- Example Usage ---
-const openSequence = getOpenDoublingSequence(); // [1,2,4,8,7]
-
-// --- Living Stream API ---
-const a432OpenDoublingVortex = {
-  digitalRoot,
-  generator: openDoublingVortexStream,
-  getSequence: getOpenDoublingSequence,
-  getNth: getOpenDoublingNth,
-  open: openSequence,
-  doc: `This module encodes the open, generative doubling vortex (1-2-4-8-7) as a stream, generator, and proof. It is the journey before closure in the A432 matrix.`
-};
-
-// --- Expose globally for debugging (browser only) ---
-if (typeof window !== 'undefined') window.a432OpenDoublingVortex = a432OpenDoublingVortex;
-
-// --- Example: Log the open sequence ---
-if (typeof process !== 'undefined' && process.env?.A432_DIGIT_STREAM_LOG) console.log('A432 Open Doubling Vortex Sequence:', openSequence);
-
-export { digitalRoot, openDoublingVortexStream, getOpenDoublingSequence, getOpenDoublingNth, a432OpenDoublingVortex };

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.1.2.4.8.ts

@@ -1,60 +0,0 @@
-// a432.1.2.4.8.ts — Open Vortex/Doubling Stream Module (Shorter Arc)
-//
-// This module encodes the open doubling sequence (1-2-4-8) as a living, recursive stream.
-// It is the generative arc of the vortex, not yet returned to origin. Digital root bridged to a432.roots (Wave 9); stream logic remains local.
-
-/**
- * Metaphysical Principle:
- * - The sequence 1→2→4→8 is the open right-hand vortex in vortex math, truncated before further progression.
- * - It is the journey, the generative flow, the living stream before closure or return.
- * - This module is a seed/arc in the living A432 matrix.
- */
-
-// --- Math: Digital Root — bridged to a432.roots (Wave 9) ---
-
-// --- Generator: Open Doubling Vortex Stream ---
-
-
-
-import { legacyDigitalRoot as digitalRoot } from './a432.roots.ts';
-
-function* openDoublingVortexStream(start = 1, length = 4) {
-  let n = start;
-  for (let i = 0; i < length; i++) {
-    yield n;
-    n = digitalRoot(n * 2);
-  }
-}
-
-// --- Utility: Get Sequence as Array ---
-function getOpenDoublingSequence(start = 1, length = 4) {
-  return [...openDoublingVortexStream(start, length)];
-}
-
-// --- Utility: Get Nth in Sequence ---
-function getOpenDoublingNth(start = 1, n = 0) {
-  let val = start;
-  for (let i = 0; i < n; i++) val = digitalRoot(val * 2);
-  return val;
-}
-
-// --- Example Usage ---
-const openSequence = getOpenDoublingSequence(); // [1,2,4,8]
-
-// --- Living Stream API ---
-const a432OpenDoublingVortex = {
-  digitalRoot,
-  generator: openDoublingVortexStream,
-  getSequence: getOpenDoublingSequence,
-  getNth: getOpenDoublingNth,
-  open: openSequence,
-  doc: `This module encodes the open, generative doubling vortex (1-2-4-8) as a stream, generator, and proof. It is the journey before closure in the A432 matrix.`
-};
-
-// --- Expose globally for debugging (browser only) ---
-if (typeof window !== 'undefined') window.a432OpenDoublingVortex = a432OpenDoublingVortex;
-
-// --- Example: Log the open sequence ---
-if (typeof process !== 'undefined' && process.env?.A432_DIGIT_STREAM_LOG) console.log('A432 Open Doubling Vortex Sequence:', openSequence);
-
-export { digitalRoot, openDoublingVortexStream, getOpenDoublingSequence, getOpenDoublingNth, a432OpenDoublingVortex };

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.1.2.4.ts

@@ -1,60 +0,0 @@
-// a432.1.2.4.ts — Open Vortex/Doubling Stream Module (Short Arc)
-//
-// This module encodes the open doubling sequence (1-2-4) as a living, recursive stream.
-// It is the generative arc of the vortex, not yet returned to origin. Digital root bridged to a432.roots (Wave 9); stream logic remains local.
-
-/**
- * Metaphysical Principle:
- * - The sequence 1→2→4 is the open right-hand vortex in vortex math, truncated before further progression.
- * - It is the journey, the generative flow, the living stream before closure or return.
- * - This module is a seed/arc in the living A432 matrix.
- */
-
-// --- Math: Digital Root — bridged to a432.roots (Wave 9) ---
-
-// --- Generator: Open Doubling Vortex Stream ---
-
-
-
-import { legacyDigitalRoot as digitalRoot } from './a432.roots.ts';
-
-function* openDoublingVortexStream(start = 1, length = 3) {
-  let n = start;
-  for (let i = 0; i < length; i++) {
-    yield n;
-    n = digitalRoot(n * 2);
-  }
-}
-
-// --- Utility: Get Sequence as Array ---
-function getOpenDoublingSequence(start = 1, length = 3) {
-  return [...openDoublingVortexStream(start, length)];
-}
-
-// --- Utility: Get Nth in Sequence ---
-function getOpenDoublingNth(start = 1, n = 0) {
-  let val = start;
-  for (let i = 0; i < n; i++) val = digitalRoot(val * 2);
-  return val;
-}
-
-// --- Example Usage ---
-const openSequence = getOpenDoublingSequence(); // [1,2,4]
-
-// --- Living Stream API ---
-const a432OpenDoublingVortex = {
-  digitalRoot,
-  generator: openDoublingVortexStream,
-  getSequence: getOpenDoublingSequence,
-  getNth: getOpenDoublingNth,
-  open: openSequence,
-  doc: `This module encodes the open, generative doubling vortex (1-2-4) as a stream, generator, and proof. It is the journey before closure in the A432 matrix.`
-};
-
-// --- Expose globally for debugging (browser only) ---
-if (typeof window !== 'undefined') window.a432OpenDoublingVortex = a432OpenDoublingVortex;
-
-// --- Example: Log the open sequence ---
-if (typeof process !== 'undefined' && process.env?.A432_DIGIT_STREAM_LOG) console.log('A432 Open Doubling Vortex Sequence:', openSequence);
-
-export { digitalRoot, openDoublingVortexStream, getOpenDoublingSequence, getOpenDoublingNth, a432OpenDoublingVortex };

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.3.6.9.trinity.ts

@@ -1,79 +0,0 @@
-// a432.3.6.9.trinity.ts
-// Canonical pregnancy/creation trinity module (3, 6, 9)
-// Encodes metaphysical and mathematical logic of pregnancy, gestation, and birth as a trinity process
-
-import { getTrinityAxis } from './a432.math.ts';
-
-/**
- * Returns the canonical trinity stages of pregnancy: Creation (3), Gestation (6), Birth (9)
- */
-export function getPregnancyTrinityStages() {
-  return [
-    { stage: 1, trinity: 3, name: 'Creation', meaning: 'Conception, seed, initiation' },
-    { stage: 2, trinity: 6, name: 'Gestation', meaning: 'Growth, recursion, nurturing' },
-    { stage: 3, trinity: 9, name: 'Birth', meaning: 'Emergence, unity, manifestation' }
-  ];
-}
-
-/**
- * Returns the canonical gestation cycle as a stream of trinity values (3, 6, 9) repeated for 9 cycles
- */
-export function getGestationCycle(cycles: number = 9) {
-  const trinity = getTrinityAxis();
-  return Array.from({ length: cycles * 3 }, (_, i) => trinity[i % 3]);
-}
-
-/**
- * Returns a metaphysical summary of the pregnancy trinity process
- */
-export function metaphysicalSummary() {
-  return 'Pregnancy is the living trinity: Creation (3), Gestation (6), Birth (9). Each stage is a harmonic act of emergence, recursion, and unity.';
-}
-
-/**
- * Renders a trinity pregnancy visualization as SVG (3 circles, color-coded, with labels)
- */
-export function renderPregnancyTrinityVisualization(currentStage: number = 0): string {
-  const stages = getPregnancyTrinityStages();
-  const colors = ['#39f', '#6f3', '#f93'];
-  const cx = 60, cy = 60, r = 36, gap = 80;
-  return `
-    <svg width="${cx * 4}" height="${cy * 2}" style="background:#111;border-radius:16px;">
-      ${stages.map((s, i) => `
-        <circle cx="${cx + i * gap}" cy="${cy}" r="${i === currentStage ? r + 8 : r}" fill="${colors[i]}" stroke="#fff" stroke-width="2">
-          <title>${s.name}: ${s.meaning}</title>
-          ${i === currentStage ? `<animate attributeName="r" values="${r};${r + 12};${r}" dur="1.2s" repeatCount="indefinite" />` : ''}
-        </circle>
-        <text x="${cx + i * gap}" y="${cy + 6}" text-anchor="middle" font-size="18" fill="#fff">${s.trinity}</text>
-        <text x="${cx + i * gap}" y="${cy + 32}" text-anchor="middle" font-size="13" fill="#ff8">${s.name}</text>
-      `).join('')}
-      <text x="${cx * 2 + gap / 2}" y="${cy * 2 - 8}" text-anchor="middle" font-size="15" fill="#8ff">Pregnancy as Living Trinity (3, 6, 9)</text>
-    </svg>
-  `;
-}
-
-/**
- * Renders a gestation cycle animation as SVG (row of trinity-colored circles, currentIndex pulses)
- */
-export function renderGestationCycleAnimation(currentIndex: number = 0, cycles: number = 9): string {
-  const trinity = getTrinityAxis();
-  const colors = ['#39f', '#6f3', '#f93'];
-  const total = cycles * 3;
-  const r = 14, gap = 36, cx = 24, cy = 32;
-  return `
-    <svg width="${cx * 2 + gap * (total - 1)}" height="${cy * 2}" style="background:#111;border-radius:12px;">
-      ${Array.from({ length: total }, (_, i) => {
-        const t = trinity[i % 3];
-        const color = colors[i % 3];
-        const isCurrent = i === currentIndex;
-        return `
-          <circle cx="${cx + i * gap}" cy="${cy}" r="${isCurrent ? r + 6 : r}" fill="${color}" stroke="#fff" stroke-width="2">
-            <title>Step ${i + 1}: Trinity ${t}</title>
-            ${isCurrent ? `<animate attributeName="r" values="${r};${r + 12};${r}" dur="1.2s" repeatCount="indefinite" />` : ''}
-          </circle>
-          <text x="${cx + i * gap}" y="${cy + 28}" text-anchor="middle" font-size="10" fill="#ff8">${t}</text>
-        `;
-      }).join('')}
-    </svg>
-  `;
-} 

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.9d.dashboard.ts

@@ -1,179 +0,0 @@
-/**
- * a432.9d.dashboard.ts — Unified nine-dimensional metaphysical UI dashboard
- *
- * Visualizes all registered metaphysical modules (chess, yin-yang, metatron, flower of life, etc.)
- * as 9 nodes in a 3D scene. Each node runs its module's animation and analytic/metaphysical overlay.
- * User can navigate between dimensions. All code is DRY, modular, and ready for extension.
- */
-import { abs, floor, round } from './a432.algebra.ts'
-import * as THREE from 'three';
-import { startChess, type ChessFrame } from './a432.chess.ts';
-import { startYinYang, type YinYangFrame } from './a432.yin.yang.ts';
-import { startMetatron, type MetatronFrame } from './a432.metatron.ts';
-import { startFlowerOfLife, type FlowerOfLifeFrame } from './a432.flower.of.life.ts';
-import { A432_RESOLVED_FRACTIONS } from './a432.resolved.ts';
-import { fractionToDecimal } from './a432.math.ts';
-// Analog signal values: exact integer ratios, collapsed to float only here
-// at the WebGL boundary. No bare decimal literal appears below.
-const G = Object.fromEntries(
-  Object.entries(A432_RESOLVED_FRACTIONS.GEOMETRY).map(([k, v]) => [k, fractionToDecimal(v)])
-) as Record<keyof typeof A432_RESOLVED_FRACTIONS.GEOMETRY, number>;
-// ...import up to 9 modules as needed
-
-function invertColor(hex: number): number {
-  return 0xffffff ^ hex;
-}
-
-// Module registry
-const modules = [
-  {
-    name: 'Chess',
-    icon: '♟️',
-    start: startChess,
-    render3D: (frame: ChessFrame, mesh: THREE.Mesh, overlay: HTMLElement) => {
-      let color = frame.polarity === 1 ? 0x00ff00 : frame.polarity === -1 ? 0xff0000 : 0x222244;
-      let alert = '';
-      // Anti-event: polarity 0 (division by n or void)
-      if (frame.polarity === 0) {
-        color = invertColor(color);
-        alert = '<span style="color:#f0f">Anti-event: Polarity inversion (void)</span>';
-      }
-      overlay.innerHTML = `<b>Chess</b><br>File: ${frame.file} Rank: ${frame.rank}<br>Linear: ${frame.linear} Vortex: ${frame.vortex}<br>${alert}`;
-      (mesh.material as THREE.MeshBasicMaterial).color.set(color);
-    }
-  },
-  {
-    name: 'Yin-Yang',
-    icon: '☯️',
-    start: startYinYang,
-    render3D: (frame: YinYangFrame, mesh: THREE.Mesh, overlay: HTMLElement) => {
-      let color = 0x00ffff;
-      let alert = '';
-      // Anti-event: angle near 180° (phase reversal)
-      if (abs(frame.angle - 180) < 10) {
-        color = invertColor(color);
-        alert = '<span style="color:#f0f">Anti-event: Phase reversal (negative harmonic)</span>';
-      }
-      overlay.innerHTML = `<b>Yin-Yang</b><br>Pos: ${frame.positiveDigit} Neg: ${frame.negativeDigit}<br>Angle: ${round(frame.angle)}°<br>${alert}`;
-      (mesh.material as THREE.MeshBasicMaterial).color.set(color);
-    }
-  },
-  {
-    name: 'Metatron',
-    icon: '✡️',
-    start: startMetatron,
-    render3D: (frame: MetatronFrame, mesh: THREE.Mesh, overlay: HTMLElement) => {
-      let color = 0xff00ff;
-      let alert = '';
-      // Anti-event: all node digits are the same (division by n)
-      if (frame.nodes.every(n => n.digit === frame.nodes[0].digit)) {
-        color = invertColor(color);
-        alert = '<span style="color:#f0f">Anti-event: All nodes identical (division by n)</span>';
-      }
-      overlay.innerHTML = `<b>Metatron</b><br>Tick: ${frame.tick}<br>Nodes: ${frame.nodes.map(n => n.digit).join(', ')}<br>${alert}`;
-      (mesh.material as THREE.MeshBasicMaterial).color.set(color);
-    }
-  },
-  {
-    name: 'Flower of Life',
-    icon: '🌸',
-    start: startFlowerOfLife,
-    render3D: (frame: FlowerOfLifeFrame, mesh: THREE.Mesh, overlay: HTMLElement) => {
-      let color = 0xffff00;
-      let alert = '';
-      // Anti-event: tick divisible by 9 (division by n)
-      if (frame.tick % 9 === 0 && frame.tick !== 0) {
-        color = invertColor(color);
-        alert = '<span style="color:#f0f">Anti-event: Division by 9 (cycle reset)</span>';
-      }
-      overlay.innerHTML = `<b>Flower of Life</b><br>${frame.metaphysical}<br>${alert}`;
-      (mesh.material as THREE.MeshBasicMaterial).color.set(color);
-    }
-  },
-  // ...add up to 9 modules
-];
-
-let activeDimension = 0; // 0-8
-
-export function show9DDashboard() {
-  // 1. Setup Three.js scene, camera, renderer
-  const scene = new THREE.Scene();
-  const camera = new THREE.PerspectiveCamera(75, 1, G.UNIT_TENTH, 1000);
-  camera.position.z = 400;
-  const renderer = new THREE.WebGLRenderer({ antialias: true });
-  renderer.setSize(600, 600);
-  renderer.domElement.style.position = 'fixed';
-  renderer.domElement.style.left = '50vw';
-  renderer.domElement.style.top = '50vh';
-  renderer.domElement.style.transform = 'translate(-50%,-50%)';
-  renderer.domElement.style.zIndex = '10060';
-  document.body.appendChild(renderer.domElement);
-
-  // 2. Create 9 nodes in a 3x3 grid
-  const nodes: { mesh: THREE.Mesh, overlay: HTMLElement, disposer: (() => void) | null }[] = [];
-  for (let i = 0; i < modules.length; i++) {
-    const geometry = new THREE.SphereGeometry(40, 32, 32);
-    const material = new THREE.MeshBasicMaterial({ color: 0x222244 });
-    const mesh = new THREE.Mesh(geometry, material);
-    // Arrange in a 3x3 grid
-    const x = ((i % 3) - 1) * 140;
-    const y = (floor(i / 3) - 1) * 140;
-    mesh.position.set(x, y, 0);
-    scene.add(mesh);
-
-    // Overlay for analytic/metaphysical info
-    const overlay = document.createElement('div');
-    overlay.style.position = 'fixed';
-    overlay.style.left = `calc(50vw + ${x}px + 60px)`;
-    overlay.style.top = `calc(50vh + ${y}px - 40px)`;
-    overlay.style.zIndex = '10061';
-    overlay.style.background = 'rgba(32,32,64,0.92)';
-    overlay.style.color = '#fff';
-    overlay.style.padding = '8px';
-    overlay.style.borderRadius = '8px';
-    overlay.style.fontFamily = 'monospace';
-    overlay.style.minWidth = '120px';
-    overlay.style.display = i === activeDimension ? 'block' : 'none';
-    document.body.appendChild(overlay);
-
-    nodes.push({ mesh, overlay, disposer: null });
-  }
-
-  // 3. Start each module’s stream and render to mesh/overlay
-  modules.forEach((mod, i) => {
-    nodes[i].disposer = mod.start((frame: any) => {
-      mod.render3D(frame, nodes[i].mesh, nodes[i].overlay);
-      nodes[i].overlay.style.display = i === activeDimension ? 'block' : 'none';
-      (nodes[i].mesh.material as THREE.MeshBasicMaterial).color.set(i === activeDimension ? 0x00ffff : 0x222244);
-    });
-  });
-
-  // 4. Navigation controls
-  document.addEventListener('keydown', (e) => {
-    if (e.key === 'ArrowRight') {
-      activeDimension = (activeDimension + 1) % modules.length;
-    } else if (e.key === 'ArrowLeft') {
-      activeDimension = (activeDimension + modules.length - 1) % modules.length;
-    }
-    nodes.forEach((n, i) => {
-      n.overlay.style.display = i === activeDimension ? 'block' : 'none';
-      (n.mesh.material as THREE.MeshBasicMaterial).color.set(i === activeDimension ? 0x00ffff : 0x222244);
-    });
-  });
-
-  // 5. Animation loop
-  function animate() {
-    requestAnimationFrame(animate);
-    renderer.render(scene, camera);
-  }
-  animate();
-
-  // 6. Cleanup function
-  return () => {
-    renderer.domElement.remove();
-    nodes.forEach(n => {
-      n.overlay.remove();
-      if (n.disposer) n.disposer();
-    });
-  };
-} 

package/src/0/3/6/9/1/2/4/8/7/5/1/a432.adapters.ts

@@ -1,96 +0,0 @@
-/**
- * a432.adapters.ts — Public-domain adapters exposing immutable snapshots of sacred streams.
- * -----------------------------------------------------------------------------------------
- * All functions are pure; they create read-only data derived from the living A432 streams
- * without leaking mutable references.  External software can visualise or sonify these
- * snapshots while the streams themselves remain under A432 control.
- */
-
-import { PI, abs, cos, floor, sin } from './a432.algebra.ts'
-import { VBM_DOUBLING, sequenceToAngles, VBM_TESLA_FREQUENCIES, VBM_SHOCK_WAVE } from './a432.vbm.math.ts';
-
-interface Vec3 { x: number; y: number; z: number; }
-
-function dr(n: number): number { let x=abs(n); while(x>=10) x=String(x).split('').reduce((a,c)=>a+Number(c),0); return x; }
-
-function generateRodinCoilPath(cycles: number, stepHeight=1, radius=1): Vec3[] {
-  const seq:number[]=[]; for(let c=0;c<cycles;c++) seq.push(...VBM_DOUBLING);
-  return seq.map((d,i)=>{
-    const ang=sequenceToAngles([d])[0]*PI/180;
-    const r=radius*(dr(d)/9);
-    return {x:r*cos(ang), y:i*stepHeight, z:r*sin(ang)};
-  });
-}
-
-function getTeslaFrequency(timeMs:number):number{
-  return VBM_TESLA_FREQUENCIES[floor(timeMs/1000)%VBM_TESLA_FREQUENCIES.length];
-}
-
-function getTrinityTorusSegments(){
-  return [3,6,9].map(d=>({startAngle:sequenceToAngles([d])[0],endAngle:sequenceToAngles([d])[0]+120,color:'#fff'}));
-}
-
-// ——————————————————————————————————————————
-// 1. Geometry snapshot helpers (WebGL/WebGPU)
-// ---------------------------------------------------------
-export interface RodinSnapshot {
-  vertices: readonly Vec3[];
-  indices: readonly number[]; // simple line strip indices
-}
-
-export function getRodinSnapshot(cycles = 3): RodinSnapshot {
-  const verts = generateRodinCoilPath(cycles);
-  const indices = verts.map((_, i) => i);
-  return { vertices: verts, indices };
-}
-
-export const TrinityTorusSnapshot = Object.freeze(getTrinityTorusSegments());
-
-// ——————————————————————————————————————————
-// 2. Audio snapshot helper (Web Audio API)
-// ---------------------------------------------------------
-export function generateSineBuffer(freq: number, seconds: number, sampleRate = 48000): Float32Array {
-  const len = floor(seconds * sampleRate);
-  const buf = new Float32Array(len);
-  const omega = 2 * PI * freq / sampleRate;
-  for (let i = 0; i < len; i++) buf[i] = sin(i * omega);
-  return buf;
-}
-
-export function getTeslaPulseBuffer(seconds = 1, sampleRate = 48000): Float32Array {
-  const freq = getTeslaFrequency(Date.now());
-  return generateSineBuffer(freq, seconds, sampleRate);
-}
-
-// ——————————————————————————————————————————
-// 3. Shock-wave pulse values (UI opacity/scale)
-// ---------------------------------------------------------
-export function shockWaveSnapshot(length = 30): readonly number[] {
-  return VBM_SHOCK_WAVE(length).map(d => d / 9);
-}
-
-// ——————————————————————————————————————————
-// 4. Snapshot serialization (base64-json) — immutable
-// ---------------------------------------------------------
-export interface A432Snapshot {
-  timestamp: number;
-  rodin: RodinSnapshot;
-  teslaFreq: number;
-  shock: readonly number[];
-}
-
-export function exportSnapshot(cycles = 3, shockLen = 30): string {
-  const snap: A432Snapshot = {
-    timestamp: Date.now(),
-    rodin: getRodinSnapshot(cycles),
-    teslaFreq: getTeslaFrequency(Date.now()),
-    shock: shockWaveSnapshot(shockLen),
-  };
-  const json = JSON.stringify(snap);
-  return Buffer.from(json, 'utf8').toString('base64');
-}
-
-export function importSnapshot(b64: string): A432Snapshot {
-  const json = Buffer.from(b64, 'base64').toString('utf8');
-  return JSON.parse(json) as A432Snapshot;
-}