zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,232 @@
+/**
+ * a432.flow.ts — Flow & Stream Modules
+ * 
+ * Consciousness and energy flow modules for the A432 system.
+ * Implements consciousness flow, energy flow, and stream harmonization.
+ * Zero entropy: define once, harmonize everywhere.
+ */
+
+import { abs, floor, max } from './a432.algebra.ts'
+import { type A432CoreState, createA432CoreState } from './a432.core.ts';
+import { a432ModuleRegistry, type A432Module, type A432ModuleCategory } from './a432.modules.ts';
+import { A432_FREQUENCY } from './a432.ts';
+
+// === FLOW INTERFACES ===
+export interface A432FlowState {
+  consciousness: ConsciousnessFlow;
+  energy: EnergyFlow;
+  stream: StreamFlow;
+  harmony: FlowHarmony;
+}
+
+export interface ConsciousnessFlow {
+  awareness: number;    // 0-9: Level of awareness
+  clarity: number;      // 0-9: Mental clarity
+  focus: number;        // 0-9: Focus strength
+  flow: number;         // 0-9: Flow state
+  resonance: number;    // 0-9: Consciousness resonance
+  color: string;
+  frequency: number;
+}
+
+export interface EnergyFlow {
+  vitality: number;     // 0-9: Life force strength
+  intensity: number;    // 0-9: Energy intensity
+  direction: number;    // 0-9: Flow direction
+  balance: number;      // 0-9: Energy balance
+  resonance: number;    // 0-9: Energy resonance
+  color: string;
+  frequency: number;
+}
+
+export interface StreamFlow {
+  velocity: number;     // 0-9: Stream velocity
+  volume: number;       // 0-9: Stream volume
+  coherence: number;    // 0-9: Stream coherence
+  harmony: number;      // 0-9: Stream harmony
+  resonance: number;    // 0-9: Stream resonance
+  color: string;
+  frequency: number;
+}
+
+export interface FlowHarmony {
+  consciousness: number; // 0-9: Consciousness harmony
+  energy: number;       // 0-9: Energy harmony
+  stream: number;       // 0-9: Stream harmony
+  overall: number;      // 0-9: Overall harmony
+  balance: number;      // 0-9: Flow balance
+  color: string;
+  frequency: number;
+}
+
+// === CORE FLOW FUNCTIONS ===
+export function createConsciousnessFlow(awareness: number = 5): ConsciousnessFlow {
+  const clarity = max(0, 9 - abs(awareness - 5));
+  const focus = floor((awareness + clarity) / 2);
+  const flow = max(0, 9 - abs(focus - 5));
+  const resonance = floor((awareness + clarity + focus + flow) / 4);
+  const color = `hsl(${awareness * 40}, 70%, ${50 + resonance * 5}%)`;
+  const frequency = 432 * (resonance / 9);
+  
+  return { awareness, clarity, focus, flow, resonance, color, frequency };
+}
+
+export function createEnergyFlow(vitality: number = 5): EnergyFlow {
+  const intensity = max(0, 9 - abs(vitality - 5));
+  const direction = floor((vitality + intensity) / 2);
+  const balance = max(0, 9 - abs(direction - 5));
+  const resonance = floor((vitality + intensity + direction + balance) / 4);
+  const color = `hsl(${vitality * 40}, 70%, ${50 + resonance * 5}%)`;
+  const frequency = 432 * (resonance / 9);
+  
+  return { vitality, intensity, direction, balance, resonance, color, frequency };
+}
+
+export function createStreamFlow(velocity: number = 5): StreamFlow {
+  const volume = max(0, 9 - abs(velocity - 5));
+  const coherence = floor((velocity + volume) / 2);
+  const harmony = max(0, 9 - abs(coherence - 5));
+  const resonance = floor((velocity + volume + coherence + harmony) / 4);
+  const color = `hsl(${velocity * 40}, 70%, ${50 + resonance * 5}%)`;
+  const frequency = 432 * (resonance / 9);
+  
+  return { velocity, volume, coherence, harmony, resonance, color, frequency };
+}
+
+export function createFlowHarmony(consciousness: number = 5, energy: number = 5, stream: number = 5): FlowHarmony {
+  const overall = floor((consciousness + energy + stream) / 3);
+  const balance = max(0, 9 - abs(overall - 5));
+  const color = `hsl(${overall * 40}, 70%, ${50 + balance * 5}%)`;
+  const frequency = 432 * (overall / 9);
+  
+  return { consciousness, energy, stream, overall, balance, color, frequency };
+}
+
+// === FLOW STATE MANAGEMENT ===
+export function createA432FlowState(): A432FlowState {
+  const consciousness = createConsciousnessFlow();
+  const energy = createEnergyFlow();
+  const stream = createStreamFlow();
+  const harmony = createFlowHarmony(consciousness.resonance, energy.resonance, stream.resonance);
+  
+  return { consciousness, energy, stream, harmony };
+}
+
+export function harmonizeA432Flow(): A432FlowState {
+  const state = createA432FlowState();
+  
+  // Harmonize consciousness with energy
+  state.consciousness.awareness = (state.consciousness.awareness + state.energy.vitality) % 9;
+  state.energy.vitality = (state.energy.vitality + state.consciousness.awareness) % 9;
+  
+  // Harmonize energy with stream
+  state.energy.intensity = (state.energy.intensity + state.stream.velocity) % 9;
+  state.stream.velocity = (state.stream.velocity + state.energy.intensity) % 9;
+  
+  // Harmonize stream with consciousness
+  state.stream.coherence = (state.stream.coherence + state.consciousness.clarity) % 9;
+  state.consciousness.clarity = (state.consciousness.clarity + state.stream.coherence) % 9;
+  
+  // Update harmony
+  state.harmony = createFlowHarmony(state.consciousness.resonance, state.energy.resonance, state.stream.resonance);
+  
+  return state;
+}
+
+// === FLOW MODULES ===
+const consciousnessModule: A432Module = {
+  name: 'a432.flow.consciousness',
+  category: 'flow',
+  version: '1.0.0',
+  description: 'Consciousness flow: Stream of awareness',
+  dependencies: ['a432.core'],
+  exports: ['createConsciousnessFlow', 'harmonizeConsciousness'],
+  getState: () => createConsciousnessFlow(),
+  harmonize: () => {
+    const flow = createConsciousnessFlow();
+    // Consciousness harmonization logic
+    return flow;
+  },
+  getOverlays: () => ['Consciousness Flow', 'Awareness Stream', 'Mental Clarity'],
+  getMeta: () => 'Consciousness flow: Stream of awareness'
+};
+
+const energyModule: A432Module = {
+  name: 'a432.flow.energy',
+  category: 'flow',
+  version: '1.0.0',
+  description: 'Energy flow: Life force harmonization',
+  dependencies: ['a432.core', 'a432.flow.consciousness'],
+  exports: ['createEnergyFlow', 'harmonizeEnergy'],
+  getState: () => createEnergyFlow(),
+  harmonize: () => {
+    const flow = createEnergyFlow();
+    // Energy harmonization logic
+    return flow;
+  },
+  getOverlays: () => ['Energy Flow', 'Life Force', 'Vitality'],
+  getMeta: () => 'Energy flow: Life force harmonization'
+};
+
+const streamModule: A432Module = {
+  name: 'a432.flow.stream',
+  category: 'flow',
+  version: '1.0.0',
+  description: 'Stream flow: Coherent flow harmonization',
+  dependencies: ['a432.core', 'a432.flow.energy'],
+  exports: ['createStreamFlow', 'harmonizeStream'],
+  getState: () => createStreamFlow(),
+  harmonize: () => {
+    const flow = createStreamFlow();
+    // Stream harmonization logic
+    return flow;
+  },
+  getOverlays: () => ['Stream Flow', 'Coherent Flow', 'Harmony'],
+  getMeta: () => 'Stream flow: Coherent flow harmonization'
+};
+
+const harmonyModule: A432Module = {
+  name: 'a432.flow.harmony',
+  category: 'flow',
+  version: '1.0.0',
+  description: 'Flow harmony: Integrated flow balance',
+  dependencies: ['a432.core', 'a432.flow.stream'],
+  exports: ['createFlowHarmony', 'harmonizeFlowHarmony'],
+  getState: () => createFlowHarmony(),
+  harmonize: () => {
+    const harmony = createFlowHarmony();
+    // Flow harmony logic
+    return harmony;
+  },
+  getOverlays: () => ['Flow Harmony', 'Integrated Balance', 'Flow Unity'],
+  getMeta: () => 'Flow harmony: Integrated flow balance'
+};
+
+// === MODULE REGISTRATION ===
+export function registerA432FlowModules(): void {
+  a432ModuleRegistry.register(consciousnessModule);
+  a432ModuleRegistry.register(energyModule);
+  a432ModuleRegistry.register(streamModule);
+  a432ModuleRegistry.register(harmonyModule);
+}
+
+// === FLOW UTILITIES ===
+export function getFlowStats(): { total: number; flowing: number; blocked: number } {
+  const state = createA432FlowState();
+  const total = 4; // consciousness, energy, stream, harmony
+  const flowing = [
+    state.consciousness.flow >= 7,
+    state.energy.balance >= 7,
+    state.stream.harmony >= 7,
+    state.harmony.overall >= 7
+  ].filter(Boolean).length;
+  
+  return { total, flowing, blocked: total - flowing };
+}
+
+export function harmonizeAllFlow(): A432FlowState {
+  return harmonizeA432Flow();
+}
+
+// Auto-register flow modules
+registerA432FlowModules(); 

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

@@ -0,0 +1,64 @@
+/**
+ * a432.flower.of.life.ts — Living Flower of Life animation for the A432 matrix
+ *
+ * FrameType: FlowerOfLifeFrame
+ *   - tick: number
+ *   - points: Array<{ x: number; y: number; color: CMYK }>
+ *   - metaphysical: string
+ *
+ * startFlowerOfLife(callback: (frame: FlowerOfLifeFrame) => void): () => void
+ *   - Streams frames for animation/overlay.
+ *   - Returns a disposer function to stop the stream.
+ *
+ * Example usage:
+ *   const disposer = startFlowerOfLife((frame) => { ... });
+ *   // Call disposer() to stop.
+ */
+import { PI, cos, sin } from './a432.algebra.ts'
+import { type CMYK, digitAngleToCMYK } from './a432.cmyk.ts';
+import { asAngle } from './a432.math.ts';
+
+export interface FlowerOfLifeFrame {
+  tick: number;
+  points: Array<{ x: number; y: number; color: CMYK }>;
+  metaphysical: string;
+}
+
+const _raf: (cb: (t: number) => void) => any =
+  typeof (globalThis as any).requestAnimationFrame === 'function'
+    ? (globalThis as any).requestAnimationFrame.bind(globalThis)
+    : (cb) => setTimeout(() => cb(Date.now()), 16);
+const _craf: (id: any) => void =
+  typeof (globalThis as any).cancelAnimationFrame === 'function'
+    ? (globalThis as any).cancelAnimationFrame.bind(globalThis)
+    : (id) => clearTimeout(id);
+
+/**
+ * Streams animated Flower of Life points (7 circles, color-coded by tick)
+ */
+export function startFlowerOfLife(callback: (f: FlowerOfLifeFrame) => void): () => void {
+  let tick = 0;
+  let rafId: any = 0;
+  const R = 60; // radius
+  const cx = 120, cy = 120;
+  const points = Array.from({ length: 7 }, (_, i) => ({ x: 0, y: 0, color: { c: 0, m: 0, y: 0, k: 0 } as CMYK }));
+  const metaphysical = 'The Flower of Life: 7 circles, infinite creation, unity of all streams.';
+
+  const step = () => {
+    // Center
+    points[0].x = cx;
+    points[0].y = cy;
+    points[0].color = digitAngleToCMYK((tick % 10), asAngle(tick * 36));
+    // 6 surrounding
+    for (let i = 1; i < 7; i++) {
+      const ang = ((i - 1) / 6) * 2 * PI + (tick * 0.03);
+      points[i].x = cx + cos(ang) * R;
+      points[i].y = cy + sin(ang) * R;
+      points[i].color = digitAngleToCMYK(((tick + i) % 10), asAngle(tick * 36 + i * 60));
+    }
+    callback({ tick: tick++, points: points.map(p => ({ ...p })), metaphysical });
+    rafId = _raf(step);
+  };
+  rafId = _raf(step);
+  return () => _craf(rafId);
+} 

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

@@ -0,0 +1,336 @@
+/**
+ * A432 Flute - Sacred Sound Synthesis
+ * 
+ * Generates flute-like tones tuned to A432Hz and its harmonic ratios
+ * Integrates with the sacred geometry and mathematical patterns of the A432 system
+ */
+
+import { floor, log2, max, min, pow, round } from './a432.algebra.ts'
+export interface FluteNote {
+  frequency: number;
+  duration: number;
+  amplitude: number;
+  harmonic: number;
+}
+
+export interface FluteScale {
+  name: string;
+  frequencies: number[];
+  ratios: number[];
+}
+
+export class A432Flute {
+  private audioContext: AudioContext;
+  private masterGain: GainNode;
+  private baseFrequency: number = 432; // A432Hz
+  private currentOscillators: OscillatorNode[] = [];
+
+  // Sacred ratios for natural harmonic series
+  private readonly sacredRatios = [
+    1,        // Fundamental (A432)
+    9/8,      // Major 2nd
+    5/4,      // Major 3rd
+    4/3,      // Perfect 4th
+    3/2,      // Perfect 5th
+    5/3,      // Major 6th
+    15/8,     // Major 7th
+    2,        // Octave
+  ];
+
+  // Pentatonic scale ratios for meditative qualities
+  private readonly pentatonicRatios = [
+    1,        // Root
+    9/8,      // 2nd
+    5/4,      // 3rd
+    3/2,      // 5th
+    5/3,      // 6th
+    2,        // Octave
+  ];
+
+  constructor() {
+    this.audioContext = new AudioContext();
+    this.masterGain = this.audioContext.createGain();
+    this.masterGain.connect(this.audioContext.destination);
+    this.masterGain.gain.value = 0.3;
+  }
+
+  /**
+   * Generate A432-based scale frequencies
+   */
+  generateScale(type: 'chromatic' | 'pentatonic' | 'sacred' = 'pentatonic'): FluteScale {
+    const ratios = type === 'pentatonic' ? this.pentatonicRatios : this.sacredRatios;
+    const frequencies = ratios.map(ratio => this.baseFrequency * ratio);
+    
+    return {
+      name: `A432 ${type} Scale`,
+      frequencies,
+      ratios
+    };
+  }
+
+  /**
+   * Create a flute-like tone with natural harmonics
+   */
+  private createFluteTone(frequency: number, startTime: number, duration: number): OscillatorNode {
+    // Primary oscillator (fundamental)
+    const fundamental = this.audioContext.createOscillator();
+    fundamental.type = 'sine';
+    fundamental.frequency.value = frequency;
+
+    // Add harmonic overtones for flute-like timbre
+    const harmonics = [
+      { freq: frequency * 2, gain: 0.3 },    // 2nd harmonic
+      { freq: frequency * 3, gain: 0.15 },   // 3rd harmonic
+      { freq: frequency * 4, gain: 0.08 },   // 4th harmonic
+      { freq: frequency * 5, gain: 0.04 },   // 5th harmonic
+    ];
+
+    // Create gain envelope for natural attack/decay
+    const envelope = this.audioContext.createGain();
+    envelope.gain.value = 0;
+    
+    // Natural flute attack and decay
+    envelope.gain.setValueAtTime(0, startTime);
+    envelope.gain.linearRampToValueAtTime(0.8, startTime + 0.1);
+    envelope.gain.exponentialRampToValueAtTime(0.6, startTime + duration * 0.3);
+    envelope.gain.exponentialRampToValueAtTime(0.01, startTime + duration);
+
+    // Connect fundamental
+    fundamental.connect(envelope);
+    envelope.connect(this.masterGain);
+
+    // Add harmonics
+    harmonics.forEach(harmonic => {
+      const osc = this.audioContext.createOscillator();
+      const gain = this.audioContext.createGain();
+      
+      osc.type = 'sine';
+      osc.frequency.value = harmonic.freq;
+      gain.gain.value = harmonic.gain;
+      
+      osc.connect(gain);
+      gain.connect(envelope);
+      
+      osc.start(startTime);
+      osc.stop(startTime + duration);
+      
+      this.currentOscillators.push(osc);
+    });
+
+    fundamental.start(startTime);
+    fundamental.stop(startTime + duration);
+    
+    this.currentOscillators.push(fundamental);
+    return fundamental;
+  }
+
+  /**
+   * Play a single note
+   */
+  playNote(frequency: number, duration: number = 1.0, delay: number = 0): Promise<void> {
+    return new Promise((resolve) => {
+      const startTime = this.audioContext.currentTime + delay;
+      this.createFluteTone(frequency, startTime, duration);
+      
+      setTimeout(() => {
+        resolve();
+      }, (delay + duration) * 1000);
+    });
+  }
+
+  /**
+   * Play a sequence of notes
+   */
+  async playSequence(notes: FluteNote[], interval: number = 0.1): Promise<void> {
+    let currentTime = 0;
+    
+    for (const note of notes) {
+      this.createFluteTone(
+        note.frequency, 
+        this.audioContext.currentTime + currentTime, 
+        note.duration
+      );
+      currentTime += note.duration + interval;
+    }
+
+    // Wait for sequence to complete
+    return new Promise(resolve => {
+      setTimeout(resolve, currentTime * 1000);
+    });
+  }
+
+  /**
+   * Play ascending scale
+   */
+  async playScale(type: 'chromatic' | 'pentatonic' | 'sacred' = 'pentatonic', noteDuration: number = 0.5): Promise<void> {
+    const scale = this.generateScale(type);
+    const notes: FluteNote[] = scale.frequencies.map(freq => ({
+      frequency: freq,
+      duration: noteDuration,
+      amplitude: 0.7,
+      harmonic: freq / this.baseFrequency
+    }));
+
+    return this.playSequence(notes, 0.1);
+  }
+
+  /**
+   * Create meditative drone with A432 base
+   */
+  createDrone(duration: number = 10): Promise<void> {
+    return new Promise((resolve) => {
+      const startTime = this.audioContext.currentTime;
+      
+      // Base A432 drone
+      const drone1 = this.createFluteTone(this.baseFrequency, startTime, duration);
+      
+      // Perfect fifth harmony (A432 * 3/2 = 648Hz)
+      const drone2 = this.createFluteTone(this.baseFrequency * 3/2, startTime, duration);
+      
+      // Octave harmony (A432 * 2 = 864Hz)
+      const drone3 = this.createFluteTone(this.baseFrequency * 2, startTime, duration);
+      
+      setTimeout(() => {
+        resolve();
+      }, duration * 1000);
+    });
+  }
+
+  /**
+   * Generate sacred geometry-inspired melody
+   * Based on Fibonacci sequence and golden ratio
+   */
+  async playSacredMelody(): Promise<void> {
+    const goldenRatio = 1.618033988749;
+    const fibonacci = [1, 1, 2, 3, 5, 8, 13];
+    
+    const notes: FluteNote[] = fibonacci.map((fib, index) => {
+      const ratio = pow(goldenRatio, (fib % 8) / 8);
+      const frequency = this.baseFrequency * ratio;
+      
+      return {
+        frequency,
+        duration: 0.8,
+        amplitude: 0.6,
+        harmonic: ratio
+      };
+    });
+
+    return this.playSequence(notes, 0.3);
+  }
+
+  /**
+   * Generate frequencies based on Rodin coil mathematics (3-6-9 pattern)
+   */
+  generateRodinFrequencies(): number[] {
+    const rodinPattern = [3, 6, 9, 1, 2, 4, 8, 7, 5];
+    return rodinPattern.map(num => this.baseFrequency * (num / 9) * 2);
+  }
+
+  /**
+   * Play Rodin coil inspired sequence
+   */
+  async playRodinSequence(): Promise<void> {
+    const frequencies = this.generateRodinFrequencies();
+    const notes: FluteNote[] = frequencies.map(freq => ({
+      frequency: freq,
+      duration: 0.6,
+      amplitude: 0.5,
+      harmonic: freq / this.baseFrequency
+    }));
+
+    return this.playSequence(notes, 0.2);
+  }
+
+  /**
+   * Stop all current sounds
+   */
+  stopAll(): void {
+    this.currentOscillators.forEach(osc => {
+      try {
+        osc.stop();
+      } catch (e) {
+        // Oscillator may already be stopped
+      }
+    });
+    this.currentOscillators = [];
+  }
+
+  /**
+   * Set master volume
+   */
+  setVolume(volume: number): void {
+    this.masterGain.gain.value = max(0, min(1, volume));
+  }
+
+  /**
+   * Get current A432 base frequency
+   */
+  getBaseFrequency(): number {
+    return this.baseFrequency;
+  }
+
+  /**
+   * Set base frequency (maintains A432 relationships)
+   */
+  setBaseFrequency(frequency: number): void {
+    this.baseFrequency = frequency;
+  }
+
+  /**
+   * Calculate frequency for musical interval
+   */
+  getInterval(semitones: number): number {
+    return this.baseFrequency * pow(2, semitones / 12);
+  }
+
+  /**
+   * Generate healing frequencies based on Solfeggio scale
+   */
+  getSolfeggioFrequencies(): number[] {
+    // Traditional Solfeggio frequencies adjusted to A432 tuning
+    const baseRatios = [
+      174/440, 285/440, 396/440, 417/440, 528/440, 639/440, 741/440, 852/440, 963/440
+    ];
+    
+    return baseRatios.map(ratio => ratio * this.baseFrequency);
+  }
+
+  /**
+   * Dispose of audio resources
+   */
+  dispose(): void {
+    this.stopAll();
+    this.audioContext.close();
+  }
+}
+
+// Export utility functions
+export const createA432Flute = (): A432Flute => new A432Flute();
+
+export const frequencyToNote = (frequency: number): string => {
+  const noteNames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'];
+  const a4 = 432; // A432 tuning
+  const c0 = a4 * pow(2, -4.75); // C0 frequency in A432 tuning
+  
+  const h = round(12 * log2(frequency / c0));
+  const octave = floor(h / 12);
+  const n = h % 12;
+  
+  return noteNames[n] + octave;
+};
+
+export const noteToFrequency = (note: string, octave: number): number => {
+  const noteOffsets: { [key: string]: number } = {
+    'C': -9, 'C#': -8, 'D': -7, 'D#': -6, 'E': -5, 'F': -4,
+    'F#': -3, 'G': -2, 'G#': -1, 'A': 0, 'A#': 1, 'B': 2
+  };
+  
+  const a4 = 432; // A432 tuning
+  const semitoneOffset = noteOffsets[note] + (octave - 4) * 12;
+  
+  return a4 * pow(2, semitoneOffset / 12);
+};
+
+// Default export
+export default A432Flute;

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

@@ -0,0 +1,53 @@
+/**
+ * a432.font.ts — Living Font Stream (Invented Characters)
+ *
+ * - Each character is generated from vortex/trinity/digit logic.
+ * - The font is a stream: infinite, recursive, and harmonized.
+ * - Each glyph encodes color, frequency, and metaphysical meaning.
+ */
+import { legacyDigitalRoot } from './a432.roots.ts'
+import { A432ColorModel } from './a432.color.ts';
+
+export interface A432Glyph {
+  char: string; // Unicode or invented symbol
+  digit: number; // 1-9
+  trinity: 3 | 6 | 9 | null;
+  color: string; // HSL
+  frequency: number;
+  metaphysics: string;
+}
+
+/**
+ * Generator: yields an infinite stream of invented glyphs.
+ * Each glyph is harmonized with the digit/trinity/color/frequency.
+ */
+export function* a432FontStream(): Generator<A432Glyph> {
+  let n = 1;
+  while (true) {
+    const digit = legacyDigitalRoot(n);
+    const trinity = [3, 6, 9].includes(digit) ? digit as 3 | 6 | 9 : null;
+    // Invented character: math bold A-Z cycling
+    const char = String.fromCharCode(0x1D400 + ((digit - 1) % 26));
+    // Harmonized color and frequency
+    const { hsl } = A432ColorModel.getAllColorModels(digit);
+    const color = `hsl(${hsl.hue},${hsl.saturation}%,${hsl.lightness}%)`;
+    const frequency = 432 * digit;
+    const metaphysics = trinity
+      ? `Trinity glyph for ${digit}`
+      : `Vortex glyph for ${digit}`;
+    yield { char, digit, trinity, color, frequency, metaphysics };
+    n++;
+  }
+}
+
+/**
+ * Visualize the first N glyphs of the font stream as a colored, animated stream.
+ * Each glyph shows its color, digit, and metaphysical meaning as a tooltip.
+ */
+export function renderA432FontStream(N: number = 27): string {
+  const gen = a432FontStream();
+  const glyphs = Array.from({ length: N }, () => gen.next().value);
+  return `<div style="display:flex;gap:8px;align-items:flex-end;font-size:2.2em;line-height:1.1;">
+    ${glyphs.map(g => `<span title="${g.metaphysics}\nDigit: ${g.digit}\nFreq: ${g.frequency} Hz" style="color:${g.color};transition:transform 0.4s;display:inline-block;transform:translateY(${(9-g.digit)*6}px);">${g.char}</span>`).join('')}
+  </div>`;
+}