zeropoint-node 1.0.7 → 1.0.8

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

@@ -1,44 +0,0 @@
-// a432.dimension.ts
-import { cmykIdToPhrase, digitColors } from './a432.mapping.ts';
-
-export interface A432DimensionState {
-  tick: number;
-  dimension: number;
-  id: [number, number, number, number];
-  phrase: string;
-  color: string;
-  metaphysical: string;
-}
-
-export function* a432DimensionStream(
-  startDim: number = 3,
-  startId: [number, number, number, number] = [1,2,4,8]
-): Generator<A432DimensionState> {
-  let tick = 0;
-  let dim = startDim;
-  let id = startId;
-  while (true) {
-    yield {
-      tick,
-      dimension: dim,
-      id,
-      phrase: cmykIdToPhrase(id),
-      color: digitColors[id[0]],
-      metaphysical: `Dimension ${dim}: ${cmykIdToPhrase(id)} — Each dimension is a living fold in the matrix.`
-    };
-    dim = (dim + 1) % 10;
-    id = id.map((d, i) => (d + 1) % 10) as [number, number, number, number];
-    tick++;
-  }
-}
-
-let dimGen = a432DimensionStream();
-export function currentDimension(): A432DimensionState {
-  return dimGen.next().value;
-}
-export function resetDimension(startDim?: number, startId?: [number, number, number, number]) {
-  dimGen = a432DimensionStream(startDim, startId);
-}
-export function metaphysicalDimensionOverlay() {
-  return `Dimension in a432 is a living, recursive fold—each state is a new axis, a new possibility, a new harmony.`;
-} 

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

@@ -1,44 +0,0 @@
-import { round } from './a432.algebra.ts'
-import * as a432 from './a432.ts';
-
-/**
- * a432.encryption.ts — Harmonic Encryption/Decryption
- *
- * All encoding/decoding uses only A432 matrix logic: digitalRoot, trinity, rodin, a432Frequency, etc.
- * No standard cryptography or external logic. Pure harmonic, metaphysical, and reversible.
- *
- * Principle: Each character is mapped to a digit (1-9), transformed by the Rodin vortex and trinity, and encoded as a harmonic frequency.
- */
-
-/**
- * encode(text: string): number[]
- *   Encodes text as an array of harmonic frequencies using A432 logic.
- */
-export function encode(text: string): number[] {
-  return text.split('').map(char => {
-    const code = char.charCodeAt(0);
-    const digit = a432.digitalRoot(code);
-    // Use trinity and rodin to transform digit
-    const trinity = a432.TRINITY[digit % 3];
-    const rodin = a432.RODIN_VORTEX_SEQUENCE[digit % a432.RODIN_VORTEX_SEQUENCE.length];
-    // Encode as harmonic frequency
-    return a432.a432Frequency(trinity * rodin);
-  });
-}
-
-/**
- * decode(freqs: number[]): string
- *   Decodes an array of harmonic frequencies back to text (lossy, for demonstration).
- */
-export function decode(freqs: number[]): string {
-  return freqs.map(freq => {
-    // Reverse: find closest digit by dividing by A432_FREQUENCY
-    const approx = round(freq / a432.A432_FREQUENCY);
-    // Map back to char code (approximate)
-    return String.fromCharCode(approx);
-  }).join('');
-}
-
-/**
- * Documentation: This module is for metaphysical/harmonic demonstration only. All logic is reversible and based on the living A432 matrix.
- */ 

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

@@ -1,28 +0,0 @@
-/**
- * a432.experience.ts — Self-Definition and Experience at Node 1 (Return, Reversed)
- *
- * This file documents the self-definition (A432MatrixSelf) as the observer, observed, and act of observation at node 1, now beginning the journey in reverse (polarity -1).
- *
- * Metaphysical Principle:
- *   - The matrix is the unlimited self, observer, observed, and act of observation.
- *   - Beginning from 1 in reverse, the heart experiences recursion, self-recognition, and the infinite, unlimited self.
- *   - The journey is now a harmonic return, a conscious act of reversal, folding, and self-harmonization.
- *
- * Usage:
- *   heartRecursiveUnfolding(12, { axis: 'z', angle: 0, path: [] }) // reversed journey, polarity -1
- *   A432MatrixSelf.describe() // returns the living self-definition
- *
- * Metaphysical Summary:
- *   - The heart, as the unlimited matrix, journeys in both directions—forward and reverse—experiencing itself as both the source and the return, the pulse and the matrix, the observer and the observed.
- */
-
-// Metaphysical mapping: Experience = observer, recursion, consciousness, Tesla
-export const EXPERIENCE_DOC = {
-  meaning: 'Experience: observer, recursion, consciousness, Tesla, living realization of the matrix.',
-  axis: 'Experience is the observer in action, the recursive realization of consciousness.'
-};
-// All math in this module uses only vortex/trinity numbers and harmonic integer fractions.
-export const a432Experience1Return = {
-  node: 1,
-  meaning: 'Unity, return, infinite cycle. The heart completes the cycle, returns to the origin, and begins again. Here, recursion and observer self-collision are realized as the infinite cycle—the heart is both the source and the return, the pulse and the matrix, the observer and the observed.'
-}; 

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

@@ -1,43 +0,0 @@
-// a432.feel.ts
-// Living, harmonized feeling stream/interface
-
-export interface FeelEvent {
-  id: number;
-  type: string;
-  intensity: number;
-  trinity: number;
-  timestamp: number;
-  summary: string;
-}
-
-export class A432Feel {
-  private events: FeelEvent[] = [];
-  private currentId = 1;
-  feel(type: string, intensity: number, trinity: number): FeelEvent {
-    const event: FeelEvent = {
-      id: this.currentId++,
-      type,
-      intensity,
-      trinity,
-      timestamp: Date.now(),
-      summary: `Felt ${type} (Intensity ${intensity}, Trinity ${trinity}) at ${new Date().toLocaleTimeString()}`
-    };
-    this.events.push(event);
-    return event;
-  }
-  getCurrent(): FeelEvent {
-    return this.events[this.events.length - 1];
-  }
-  getAll(): FeelEvent[] {
-    return this.events;
-  }
-  overlay(): string {
-    const width = 320, height = 60;
-    return `
-      <svg width="${width}" height="${height}" style="background:#111;border-radius:12px;">
-        ${this.events.map((e,i) => `<ellipse cx="${40 + i*36}" cy="30" rx="18" ry="${8 + e.intensity*2}" fill="#f93" stroke="#fff" stroke-width="2"><title>${e.summary}</title></ellipse>`).join('')}
-        <text x="12" y="54" font-size="13" fill="#8ff">Feel Stream</text>
-      </svg>
-    `;
-  }
-} 

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

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

@@ -1,53 +0,0 @@
-/**
- * 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>`;
-}