zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,93 @@
+/**
+ * a432.uuid.ts — Content-addressed UUID bridge (Wave 8 purge).
+ *
+ * Random / hand-minted ids are forbidden. All generators fold through
+ * kernel `toUuid` (FNV) so same seed ⇒ same address.
+ * Cryptographic seals live in `src/integrity` (SHA content-uuid).
+ *
+ * Export names uuidV1–V5 kept as thin adapters for legacy callers.
+ */
+
+import { round } from './a432.algebra.ts'
+import {
+  toUuid,
+  merge,
+  VORTEX_ORBIT,
+  VORTEX_AXIS,
+} from '../../../../../../../../../../index.ts'
+
+const RODIN = [1, 2, 4, 8, 7, 5] as const
+
+/** Timestamp folded with label — deterministic for a given ms + label. */
+export function uuidV1(label = 'v1', at: number = 0): string {
+  const t = at || 0
+  return toUuid(`a432.uuid.v1:${label}:${t}`)
+}
+
+/** Name-based soft address (FNV). Prefer content-uuid for proofs. */
+export function uuidV3(name: string): string {
+  return toUuid(`a432.uuid.v3:${name}`)
+}
+
+/**
+ * Former Math.random path — now seed-required content address.
+ * Calling with no seed uses a fixed namespace (still deterministic, never random).
+ */
+export function uuidV4(seed = 'a432.uuid.v4:namespace'): string {
+  return toUuid(seed)
+}
+
+/** Name product folded through kernel merge. */
+export function uuidV5(name: string): string {
+  return merge(toUuid('a432.uuid.v5'), toUuid(name))
+}
+
+export function geometryUuid(step: number): string {
+  const n = step % 3 === 0 ? 3 : step % 3 === 1 ? 6 : 9
+  const d = step % 3 === 0 ? 6 : step % 3 === 1 ? 9 : 3
+  const angle = (step % 3) * 120
+  return toUuid(`a432.uuid.geometry:${n}/${d}@${angle}`)
+}
+
+export function soundUuid(step: number, base = 432): string {
+  const i = step % 6
+  const n = RODIN[i]!
+  const d = RODIN[(i + 1) % 6]!
+  const freq = round(base * (n / d))
+  return toUuid(`a432.uuid.sound:${n}/${d}@${freq}Hz`)
+}
+
+export function colorUuid(step: number): string {
+  const n = step % 3 === 0 ? 3 : step % 3 === 1 ? 6 : 9
+  const d = step % 3 === 0 ? 6 : step % 3 === 1 ? 9 : 3
+  const hue = (step % 3) * 120
+  return toUuid(`a432.uuid.color:${n}/${d}@${hue}`)
+}
+
+export function dimensionalVortexUuid(step: number): string {
+  const dim = VORTEX_ORBIT[step % VORTEX_ORBIT.length]!
+  const axis = VORTEX_AXIS[step % VORTEX_AXIS.length]!
+  return toUuid(`a432.uuid.vortex:${step}:${dim}:${axis}`)
+}
+
+export function vortexMatrixUuid(seed = 'vortex-matrix'): string {
+  return toUuid(`a432.uuid.vortex-matrix:${seed}`)
+}
+
+export function trinityMatrixUuid(seed = 'trinity-matrix'): string {
+  return toUuid(`a432.uuid.trinity-matrix:${seed}`)
+}
+
+/** Living API — all paths content-addressed. */
+export const a432UUID = {
+  uuid: uuidV4,
+  vortexMatrixUuid,
+  trinityMatrixUuid,
+  geometryUuid,
+  soundUuid,
+  colorUuid,
+  dimensionalVortexUuid,
+  doc: 'a432.uuid bridges to kernel toUuid — no random hand-minted ids.',
+}
+
+export default a432UUID

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

@@ -0,0 +1,328 @@
+/**
+ * a432.vbm.animation.ts — VBM Multidimensional Animation Module
+ * 
+ * This module creates a harmonized VBM (Vortex-Based Mathematics) animation
+ * using canonical A432 math procedures and the Rodin sequence.
+ * 
+ * Metaphysical Principle:
+ * - The animation visualizes the living vortex of consciousness through the Rodin sequence
+ * - Each point represents a digit in the sequence, moving through 3D space as harmonic waves
+ * - The torus represents the field of consciousness, with points as living thoughts
+ */
+
+import { PI, cos, sin } from './a432.algebra.ts'
+import * as THREE from 'three';
+import { 
+  RODIN_SEQUENCE, 
+  TRINITY_AXIS, 
+  digitalRoot, 
+  angleForDigit,
+  frequencyForDigit,
+  hueForDigit 
+} from './a432.math.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>;
+
+// --- Canonical VBM Animation Constants ---
+const VBM_SEQUENCE = [0, ...TRINITY_AXIS, ...RODIN_SEQUENCE] as const;
+const VBM_STEP_ANGLE = 60; // 60° per step (trinity harmonic)
+const VBM_TORUS_RADIUS = 4; // Base torus radius
+const VBM_TUBE_RADIUS = G.SCALE_SIX_FIFTH; // Tube radius for torus
+const VBM_BASE_FREQUENCY = 432; // Canonical A432 frequency
+
+// --- VBM Animation State Interface ---
+interface VBMAnimationState {
+  time: number;
+  points: VBMAnimationPoint[];
+  torus: VBMTorusGeometry;
+  scene: THREE.Scene;
+  camera: THREE.PerspectiveCamera;
+  renderer: THREE.WebGLRenderer;
+}
+
+interface VBMAnimationPoint {
+  mesh: THREE.Mesh;
+  digit: number;
+  index: number;
+  color: THREE.Color;
+  frequency: number;
+}
+
+interface VBMTorusGeometry {
+  geometry: THREE.TorusGeometry;
+  material: THREE.MeshPhongMaterial;
+  mesh: THREE.Mesh;
+}
+
+// --- Canonical VBM Color Generation ---
+function generateVBMColor(digit: number): THREE.Color {
+  const hue = hueForDigit(digit);
+  const saturation = G.OPACITY_SEVEN;
+  const lightness = G.HALF;
+  return new THREE.Color().setHSL(hue / 360, saturation, lightness);
+}
+
+// --- Canonical VBM Frequency Generation ---
+function generateVBMFrequency(digit: number): number {
+  if (TRINITY_AXIS.includes(digit)) {
+    return frequencyForDigit(digit);
+  }
+  // For non-trinity digits, use digital root scaling
+  const dr = digitalRoot(digit);
+  return VBM_BASE_FREQUENCY * (dr / 9);
+}
+
+// --- VBM Animation Point Creation ---
+function createVBMAnimationPoint(
+  digit: number, 
+  index: number, 
+  scene: THREE.Scene
+): VBMAnimationPoint {
+  const geometry = new THREE.SphereGeometry(G.DAMP_LOW, 16, 16);
+  const color = generateVBMColor(digit);
+  const material = new THREE.MeshPhongMaterial({ color });
+  const mesh = new THREE.Mesh(geometry, material);
+  
+  scene.add(mesh);
+  
+  return {
+    mesh,
+    digit,
+    index,
+    color,
+    frequency: generateVBMFrequency(digit)
+  };
+}
+
+// --- VBM Torus Creation ---
+function createVBMTorus(scene: THREE.Scene): VBMTorusGeometry {
+  const geometry = new THREE.TorusGeometry(
+    VBM_TORUS_RADIUS, 
+    VBM_TUBE_RADIUS, 
+    48, 
+    128
+  );
+  const material = new THREE.MeshPhongMaterial({
+    color: 0x222244,
+    wireframe: true,
+    opacity: G.UNIT_THIRD_TEN,
+    transparent: true
+  });
+  const mesh = new THREE.Mesh(geometry, material);
+  
+  scene.add(mesh);
+  
+  return { geometry, material, mesh };
+}
+
+// --- VBM Position Calculation (Canonical Math) ---
+function calculateVBMPosition(
+  point: VBMAnimationPoint, 
+  time: number
+): THREE.Vector3 {
+  const { digit, index } = point;
+  
+  // Phase around torus main circle (60° per step)
+  const theta = index * (VBM_STEP_ANGLE * PI / 180) + time;
+  
+  // Digital root drives minor circle
+  const dr = digitalRoot(digit);
+  const phi = (dr / 9) * PI * 2 + time * G.SCALE_THIRTEEN_TEN;
+  
+  // Torus parametric coordinates
+  const x = (VBM_TORUS_RADIUS + VBM_TUBE_RADIUS * cos(phi)) * cos(theta);
+  const y = VBM_TUBE_RADIUS * sin(phi) * G.OPACITY_SEVEN; // Squeeze factor
+  const z = (VBM_TORUS_RADIUS + VBM_TUBE_RADIUS * cos(phi)) * sin(theta);
+  
+  return new THREE.Vector3(x, y, z);
+}
+
+// --- VBM Scale Calculation (Parity-based) ---
+function calculateVBMScale(point: VBMAnimationPoint, time: number): number {
+  const { digit, index } = point;
+  const parity = digit % 2; // Even/odd determines pulsation phase
+  return 1 + G.UNIT_THIRD_TEN * sin(time * 2 + index + parity * PI);
+}
+
+// --- VBM Animation Update ---
+function updateVBMAnimation(state: VBMAnimationState): void {
+  const { points, time } = state;
+  
+  points.forEach(point => {
+    // Update position
+    const position = calculateVBMPosition(point, time);
+    point.mesh.position.copy(position);
+    
+    // Update scale (pulsation)
+    const scale = calculateVBMScale(point, time);
+    point.mesh.scale.set(scale, scale, scale);
+    
+    // Update color intensity based on frequency
+    const intensity = G.HALF + G.UNIT_THIRD_TEN * sin(time * point.frequency / 100);
+    (point.mesh.material as THREE.MeshPhongMaterial).color.setHSL(
+      point.color.getHSL({ h: 0, s: 0, l: 0 }).h,
+      G.OPACITY_SEVEN,
+      intensity
+    );
+  });
+}
+
+// --- VBM Scene Setup ---
+function setupVBMScene(): VBMAnimationState {
+  const scene = new THREE.Scene();
+  
+  // Camera setup
+  const camera = new THREE.PerspectiveCamera(
+    45, 
+    window.innerWidth / window.innerHeight, 
+    G.UNIT_TENTH, 
+    1000
+  );
+  camera.position.set(0, 5, 12);
+  
+  // Renderer setup
+  const renderer = new THREE.WebGLRenderer({ antialias: true });
+  renderer.setSize(window.innerWidth, window.innerHeight);
+  
+  // Lighting
+  scene.add(new THREE.AmbientLight(0x888888));
+  const light = new THREE.PointLight(0xffffff, G.OPACITY_FOUR_FIFTH);
+  light.position.set(10, 10, 10);
+  scene.add(light);
+  
+  // Create torus
+  const torus = createVBMTorus(scene);
+  
+  // Create animation points
+  const points: VBMAnimationPoint[] = [];
+  VBM_SEQUENCE.forEach((digit, index) => {
+    const point = createVBMAnimationPoint(digit, index, scene);
+    points.push(point);
+  });
+  
+  return {
+    time: 0,
+    points,
+    torus,
+    scene,
+    camera,
+    renderer
+  };
+}
+
+// --- VBM Animation Loop ---
+function animateVBM(state: VBMAnimationState): void {
+  const { scene, camera, renderer, time } = state;
+  
+  // Update animation state
+  updateVBMAnimation(state);
+  
+  // Render
+  renderer.render(scene, camera);
+  
+  // Update time
+  state.time += G.STEP_FINE;
+  
+  // Continue animation
+  requestAnimationFrame(() => animateVBM(state));
+}
+
+// --- VBM Resize Handler ---
+function handleVBMResize(state: VBMAnimationState): void {
+  const { renderer, camera } = state;
+  
+  renderer.setSize(window.innerWidth, window.innerHeight);
+  camera.aspect = window.innerWidth / window.innerHeight;
+  camera.updateProjectionMatrix();
+}
+
+// --- VBM Animation Controller ---
+export class VBMAnimationController {
+  private state: VBMAnimationState;
+  private isRunning: boolean = false;
+  
+  constructor() {
+    this.state = setupVBMScene();
+    this.setupEventListeners();
+  }
+  
+  private setupEventListeners(): void {
+    window.addEventListener('resize', () => {
+      handleVBMResize(this.state);
+    });
+  }
+  
+  public start(): void {
+    if (!this.isRunning) {
+      this.isRunning = true;
+      animateVBM(this.state);
+    }
+  }
+  
+  public stop(): void {
+    this.isRunning = false;
+  }
+  
+  public getRenderer(): THREE.WebGLRenderer {
+    return this.state.renderer;
+  }
+  
+  public getScene(): THREE.Scene {
+    return this.state.scene;
+  }
+  
+  public getCamera(): THREE.PerspectiveCamera {
+    return this.state.camera;
+  }
+  
+  public getPoints(): VBMAnimationPoint[] {
+    return this.state.points;
+  }
+  
+  public getSequence(): readonly number[] {
+    return VBM_SEQUENCE;
+  }
+  
+  public getTorusRadius(): number {
+    return VBM_TORUS_RADIUS;
+  }
+  
+  public getTubeRadius(): number {
+    return VBM_TUBE_RADIUS;
+  }
+  
+  public getStepAngle(): number {
+    return VBM_STEP_ANGLE;
+  }
+}
+
+// --- VBM Animation Factory ---
+export function createVBMAnimation(): VBMAnimationController {
+  return new VBMAnimationController();
+}
+
+// --- VBM Animation Constants Export ---
+export const VBM_ANIMATION_CONSTANTS = {
+  SEQUENCE: VBM_SEQUENCE,
+  STEP_ANGLE: VBM_STEP_ANGLE,
+  TORUS_RADIUS: VBM_TORUS_RADIUS,
+  TUBE_RADIUS: VBM_TUBE_RADIUS,
+  BASE_FREQUENCY: VBM_BASE_FREQUENCY
+} as const;
+
+// --- VBM Animation Documentation ---
+export const VBM_ANIMATION_DOC = {
+  purpose: 'VBM Multidimensional Animation - Visualizes the living vortex of consciousness through the Rodin sequence',
+  sequence: 'Uses canonical A432 sequence: [0, 3, 6, 9, 1, 2, 4, 8, 7, 5, 1]',
+  trinity: 'Trinity axis [3, 6, 9] represents the field of consciousness',
+  rodin: 'Rodin sequence [1, 2, 4, 8, 7, 5, 1] represents the doubling vortex',
+  torus: 'Torus geometry represents the field, points represent living thoughts',
+  animation: 'Each point moves through 3D space as harmonic waves, pulsating by parity',
+  color: 'Colors generated from hueForDigit() with frequency-based intensity',
+  frequency: 'Frequencies generated from frequencyForDigit() for trinity, digital root scaling for others'
+} as const; 

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

@@ -0,0 +1,283 @@
+/**
+ * a432.vbm.audio.ts — VBM Audio Sequence Module
+ * 
+ * This module creates harmonized audio sequences using canonical A432 math procedures
+ * and the Rodin sequence, playing tones that resonate with the vortex of consciousness.
+ * 
+ * Metaphysical Principle:
+ * - Each digit in the sequence represents a harmonic frequency in the A432 system
+ * - Trinity digits (3, 6, 9) have their own canonical frequencies
+ * - Non-trinity digits use digital root scaling for frequency calculation
+ * - The sequence creates a living sound vortex that harmonizes with consciousness
+ */
+
+import { 
+  RODIN_SEQUENCE, 
+  TRINITY_AXIS, 
+  digitalRoot, 
+  frequencyForDigit,
+  angleForDigit 
+} from './a432.math.ts';
+
+// --- Canonical VBM Audio Constants ---
+const VBM_SEQUENCE = [0, ...TRINITY_AXIS, ...RODIN_SEQUENCE] as const;
+const VBM_BASE_FREQUENCY = 432; // Canonical A432 frequency
+const VBM_DURATION = 0.18; // Duration per tone (seconds)
+const VBM_OSCILLATOR_TYPE = 'sine' as const;
+
+// --- VBM Audio State Interface ---
+interface VBMAudioState {
+  context: AudioContext | null;
+  isPlaying: boolean;
+  currentTime: number;
+  sequence: readonly number[];
+  baseFrequency: number;
+  duration: number;
+}
+
+interface VBMAudioTone {
+  frequency: number;
+  digit: number;
+  startTime: number;
+  endTime: number;
+  oscillator: OscillatorNode;
+  gainNode: GainNode;
+}
+
+// --- Canonical VBM Frequency Generation ---
+function generateVBMFrequency(digit: number): number {
+  if (digit === 0) {
+    return VBM_BASE_FREQUENCY; // Zero represents the base frequency
+  }
+  
+  if (TRINITY_AXIS.includes(digit)) {
+    return frequencyForDigit(digit); // 432, 864, 1296 Hz for trinity
+  }
+  
+  // For non-trinity digits, use digital root scaling
+  const dr = digitalRoot(digit);
+  return VBM_BASE_FREQUENCY * (dr / 9);
+}
+
+// --- VBM Audio Tone Creation ---
+function createVBMAudioTone(
+  context: AudioContext,
+  digit: number,
+  startTime: number,
+  duration: number
+): VBMAudioTone {
+  const frequency = generateVBMFrequency(digit);
+  
+  // Create oscillator
+  const oscillator = context.createOscillator();
+  oscillator.type = VBM_OSCILLATOR_TYPE;
+  oscillator.frequency.value = frequency;
+  
+  // Create gain node for volume control
+  const gainNode = context.createGain();
+  gainNode.gain.setValueAtTime(0.3, startTime); // Start at 30% volume
+  gainNode.gain.exponentialRampToValueAtTime(0.01, startTime + duration); // Fade out
+  
+  // Connect oscillator to gain to destination
+  oscillator.connect(gainNode);
+  gainNode.connect(context.destination);
+  
+  return {
+    frequency,
+    digit,
+    startTime,
+    endTime: startTime + duration,
+    oscillator,
+    gainNode
+  };
+}
+
+// --- VBM Audio Sequence Player ---
+export class VBMAudioPlayer {
+  private state: VBMAudioState;
+  private tones: VBMAudioTone[] = [];
+  
+  constructor() {
+    this.state = {
+      context: null,
+      isPlaying: false,
+      currentTime: 0,
+      sequence: VBM_SEQUENCE,
+      baseFrequency: VBM_BASE_FREQUENCY,
+      duration: VBM_DURATION
+    };
+  }
+  
+  // --- Initialize Audio Context ---
+  private async initializeAudioContext(): Promise<AudioContext> {
+    if (this.state.context && this.state.context.state !== 'closed') {
+      return this.state.context;
+    }
+    
+    const AudioContextClass = window.AudioContext || (window as any).webkitAudioContext;
+    if (!AudioContextClass) {
+      throw new Error('Web Audio API not supported');
+    }
+    
+    this.state.context = new AudioContextClass();
+    
+    // Resume context if suspended (required for user gesture)
+    if (this.state.context.state === 'suspended') {
+      await this.state.context.resume();
+    }
+    
+    return this.state.context;
+  }
+  
+  // --- Play VBM Sequence ---
+  public async playSequence(): Promise<void> {
+    try {
+      const context = await this.initializeAudioContext();
+      
+      if (this.state.isPlaying) {
+        console.log('VBM Audio: Sequence already playing');
+        return;
+      }
+      
+      this.state.isPlaying = true;
+      this.tones = [];
+      
+      let currentTime = context.currentTime;
+      
+      // Create tones for each digit in sequence
+      for (let i = 0; i < this.state.sequence.length; i++) {
+        const digit = this.state.sequence[i];
+        const tone = createVBMAudioTone(
+          context,
+          digit,
+          currentTime,
+          this.state.duration
+        );
+        
+        this.tones.push(tone);
+        
+        // Schedule tone playback
+        tone.oscillator.start(currentTime);
+        tone.oscillator.stop(currentTime + this.state.duration);
+        
+        currentTime += this.state.duration;
+      }
+      
+      // Update state
+      this.state.currentTime = currentTime;
+      
+      console.log('VBM Audio: Playing sequence with frequencies:', 
+        this.tones.map(t => `${t.digit}→${t.frequency}Hz`));
+      
+      // Schedule completion callback
+      setTimeout(() => {
+        this.state.isPlaying = false;
+        this.tones = [];
+      }, (this.state.sequence.length * this.state.duration) * 1000);
+      
+    } catch (error) {
+      console.error('VBM Audio: Error playing sequence:', error);
+      this.state.isPlaying = false;
+      throw error;
+    }
+  }
+  
+  // --- Stop VBM Sequence ---
+  public stopSequence(): void {
+    if (!this.state.isPlaying) {
+      return;
+    }
+    
+    // Stop all active tones
+    this.tones.forEach(tone => {
+      try {
+        tone.oscillator.stop();
+        tone.gainNode.gain.cancelScheduledValues(0);
+        tone.gainNode.gain.setValueAtTime(tone.gainNode.gain.value, 0);
+        tone.gainNode.gain.linearRampToValueAtTime(0, 0.1);
+      } catch (error) {
+        // Oscillator might already be stopped
+      }
+    });
+    
+    this.state.isPlaying = false;
+    this.tones = [];
+    
+    console.log('VBM Audio: Sequence stopped');
+  }
+  
+  // --- Get Sequence Information ---
+  public getSequence(): readonly number[] {
+    return this.state.sequence;
+  }
+  
+  public getFrequencies(): number[] {
+    return this.state.sequence.map(digit => generateVBMFrequency(digit));
+  }
+  
+  public getBaseFrequency(): number {
+    return this.state.baseFrequency;
+  }
+  
+  public getDuration(): number {
+    return this.state.duration;
+  }
+  
+  public isPlaying(): boolean {
+    return this.state.isPlaying;
+  }
+  
+  // --- Get Audio Context ---
+  public getAudioContext(): AudioContext | null {
+    return this.state.context;
+  }
+  
+  // --- Get Current Tones ---
+  public getCurrentTones(): VBMAudioTone[] {
+    return [...this.tones];
+  }
+}
+
+// --- VBM Audio Factory ---
+export function createVBMAudioPlayer(): VBMAudioPlayer {
+  return new VBMAudioPlayer();
+}
+
+// --- VBM Audio Constants Export ---
+export const VBM_AUDIO_CONSTANTS = {
+  SEQUENCE: VBM_SEQUENCE,
+  BASE_FREQUENCY: VBM_BASE_FREQUENCY,
+  DURATION: VBM_DURATION,
+  OSCILLATOR_TYPE: VBM_OSCILLATOR_TYPE
+} as const;
+
+// --- VBM Audio Documentation ---
+export const VBM_AUDIO_DOC = {
+  purpose: 'VBM Audio Sequence - Plays the A432 sequence as modulated tones',
+  sequence: 'Uses canonical A432 sequence: [0, 3, 6, 9, 1, 2, 4, 8, 7, 5, 1]',
+  trinity: 'Trinity digits (3, 6, 9) use frequencyForDigit(): 432, 864, 1296 Hz',
+  nonTrinity: 'Non-trinity digits use digital root scaling: baseFreq * (dr / 9)',
+  zero: 'Zero digit uses base frequency: 432 Hz',
+  duration: 'Each tone plays for 0.18 seconds with fade-out',
+  oscillator: 'Uses sine wave oscillator for pure harmonic tones',
+  volume: 'Starts at 30% volume with exponential fade-out'
+} as const;
+
+// --- VBM Audio Utility Functions ---
+export function getVBMFrequencyForDigit(digit: number): number {
+  return generateVBMFrequency(digit);
+}
+
+export function getVBMAudioSequence(): readonly number[] {
+  return VBM_SEQUENCE;
+}
+
+export function getVBMAudioFrequencies(): number[] {
+  return VBM_SEQUENCE.map(digit => generateVBMFrequency(digit));
+}
+
+// --- Example Usage Function ---
+export async function playVBMAudioSequence(): Promise<void> {
+  const player = createVBMAudioPlayer();
+  await player.playSequence();
+}