zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,60 @@
+// a432.1.2.4.8.7.5.ts — Open Vortex/Doubling Stream Module
+//
+// This module encodes the open doubling sequence (1-2-4-8-7-5) 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→5 is the open right-hand vortex in vortex math.
+ * - It is the journey, the generative flow, the living stream before closure.
+ * - 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 = 6) {
+  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 = 6) {
+  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,5]
+
+// --- 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-5) 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.7.ts

@@ -0,0 +1,60 @@
+// 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

@@ -0,0 +1,60 @@
+// 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

@@ -0,0 +1,60 @@
+// 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.1.2.ts

@@ -0,0 +1,60 @@
+// a432.1.2.ts — Open Vortex/Doubling Stream Module (Minimal Arc)
+//
+// This module encodes the open doubling sequence (1-2) 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 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 = 2) {
+  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 = 2) {
+  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]
+
+// --- 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) 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.ts

@@ -0,0 +1,60 @@
+// a432.1.ts — Open Vortex/Doubling Stream Module (Seed Arc)
+//
+// This module encodes the open doubling sequence (1) as a living, recursive stream.
+// It is the seed of the vortex, the origin point. Digital root bridged to a432.roots (Wave 9); stream logic remains local.
+
+/**
+ * Metaphysical Principle:
+ * - The sequence 1 is the seed, the origin, the singularity in vortex math.
+ * - It is the pure generative point, the living stream before any doubling or projection.
+ * - This module is the 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 = 1) {
+  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 = 1) {
+  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]
+
+// --- Living Stream API ---
+const a432OpenDoublingVortex = {
+  digitalRoot,
+  generator: openDoublingVortexStream,
+  getSequence: getOpenDoublingSequence,
+  getNth: getOpenDoublingNth,
+  open: openSequence,
+  doc: `This module encodes the open, generative doubling vortex (1) as a stream, generator, and proof. It is the seed of 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

@@ -0,0 +1,79 @@
+// 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

@@ -0,0 +1,179 @@
+/**
+ * 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();
+    });
+  };
+}