zeropoint-node 1.0.7 → 1.0.9

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;
-}