zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,356 @@
+/**
+ * a432.cmyk.voice.ts — CMYK Voice Harmonization
+ * 
+ * Color-based voice harmonization and audio synthesis for the A432 system.
+ * Implements CMYK frequency modulation, voice synthesis, and harmonic audio generation.
+ * Zero entropy: define once, voice everywhere.
+ */
+
+import { abs, floor, max, unitFromSeed } 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';
+import { digitalRoot } from './a432.math.ts';
+import { scaleVortex, vortexColor, rgbToHex, CMYK_COLORS, CMYK_FREQUENCIES, vortexFrequency } from './a432.cmyk.ts';
+
+// === CMYK VOICE INTERFACES ===
+export interface A432CMYKVoiceState {
+  cyan: CMYKChannel;
+  magenta: CMYKChannel;
+  yellow: CMYKChannel;
+  key: CMYKChannel;
+  synthesis: VoiceSynthesis;
+  harmonization: VoiceHarmonization;
+}
+
+export interface CMYKChannel {
+  frequency: number;    // Base frequency for the channel
+  amplitude: number;    // 0-9: Channel amplitude
+  phase: number;        // 0-360: Phase angle
+  resonance: number;    // 0-9: Channel resonance
+  color: string;        // Channel color
+  voice: number;        // 0-9: Voice quality
+}
+
+export interface VoiceSynthesis {
+  fundamental: number;  // Fundamental frequency
+  overtones: number[]; // Harmonic overtones
+  timbre: number;      // 0-9: Voice timbre
+  clarity: number;     // 0-9: Voice clarity
+  resonance: number;   // 0-9: Overall resonance
+  color: string;
+  frequency: number;
+}
+
+export interface VoiceHarmonization {
+  harmony: number;     // 0-9: Voice harmony
+  balance: number;     // 0-9: Channel balance
+  coherence: number;   // 0-9: Voice coherence
+  unity: number;       // 0-9: Voice unity
+  resonance: number;   // 0-9: Harmonization resonance
+  color: string;
+  frequency: number;
+}
+
+// === CMYK FREQUENCY CONSTANTS ===
+// Remove the local declaration of CMYK_FREQUENCIES. Only use the imported version from a432.cmyk.ts.
+
+// === CORE CMYK VOICE FUNCTIONS ===
+export function createCMYKChannel(channel: 'cyan' | 'magenta' | 'yellow' | 'key', amplitude: number = 5): CMYKChannel {
+  const frequency = CMYK_FREQUENCIES[channel];
+  const phase = unitFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.cmyk.voice.ts:rnd:0") * 360;
+  const resonance = max(0, 9 - abs(amplitude - 5));
+  const color = CMYK_COLORS[channel];
+  const voice = floor((amplitude + resonance) / 2);
+  
+  return { frequency, amplitude, phase, resonance, color, voice };
+}
+
+export function createVoiceSynthesis(cyan: CMYKChannel, magenta: CMYKChannel, yellow: CMYKChannel, key: CMYKChannel): VoiceSynthesis {
+  const fundamental = (cyan.frequency + magenta.frequency + yellow.frequency + key.frequency) / 4;
+  const overtones = [
+    fundamental * 2,
+    fundamental * 3,
+    fundamental * 4,
+    fundamental * 5
+  ];
+  const timbre = floor((cyan.voice + magenta.voice + yellow.voice + key.voice) / 4);
+  const clarity = max(0, 9 - abs(timbre - 5));
+  const resonance = floor((timbre + clarity) / 2);
+  const color = `hsl(${resonance * 40}, 70%, ${50 + resonance * 5}%)`;
+  const frequency = fundamental;
+  
+  return { fundamental, overtones, timbre, clarity, resonance, color, frequency };
+}
+
+export function createVoiceHarmonization(cyan: CMYKChannel, magenta: CMYKChannel, yellow: CMYKChannel, key: CMYKChannel): VoiceHarmonization {
+  const harmony = floor((cyan.resonance + magenta.resonance + yellow.resonance + key.resonance) / 4);
+  const balance = max(0, 9 - abs(harmony - 5));
+  const coherence = floor((harmony + balance) / 2);
+  const unity = max(0, 9 - abs(coherence - 5));
+  const resonance = floor((harmony + balance + coherence + unity) / 4);
+  const color = `hsl(${harmony * 40}, 70%, ${50 + resonance * 5}%)`;
+  const frequency = 432 * (harmony / 9);
+  
+  return { harmony, balance, coherence, unity, resonance, color, frequency };
+}
+
+// === CMYK VOICE STATE MANAGEMENT ===
+export function createA432CMYKVoiceState(): A432CMYKVoiceState {
+  const cyan = createCMYKChannel('cyan');
+  const magenta = createCMYKChannel('magenta');
+  const yellow = createCMYKChannel('yellow');
+  const key = createCMYKChannel('key');
+  const synthesis = createVoiceSynthesis(cyan, magenta, yellow, key);
+  const harmonization = createVoiceHarmonization(cyan, magenta, yellow, key);
+  
+  return { cyan, magenta, yellow, key, synthesis, harmonization };
+}
+
+export function harmonizeA432CMYKVoice(): A432CMYKVoiceState {
+  const state = createA432CMYKVoiceState();
+  
+  // Harmonize CMYK channels
+  state.cyan.amplitude = (state.cyan.amplitude + state.synthesis.timbre) % 9;
+  state.magenta.amplitude = (state.magenta.amplitude + state.synthesis.clarity) % 9;
+  state.yellow.amplitude = (state.yellow.amplitude + state.synthesis.resonance) % 9;
+  state.key.amplitude = (state.key.amplitude + state.harmonization.harmony) % 9;
+  
+  // Update synthesis and harmonization
+  state.synthesis = createVoiceSynthesis(state.cyan, state.magenta, state.yellow, state.key);
+  state.harmonization = createVoiceHarmonization(state.cyan, state.magenta, state.yellow, state.key);
+  
+  return state;
+}
+
+// === VOICE SYNTHESIS FUNCTIONS ===
+export function generateCMYKTone(channel: CMYKChannel, duration: number = 1): string {
+  const frequency = channel.frequency;
+  const amplitude = channel.amplitude / 9;
+  const phase = channel.phase;
+  
+  return `
+    // CMYK Tone Generation
+    const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+    const oscillator = audioContext.createOscillator();
+    const gainNode = audioContext.createGain();
+    
+    oscillator.type = 'sine';
+    oscillator.frequency.setValueAtTime(${frequency}, audioContext.currentTime);
+    oscillator.connect(gainNode);
+    gainNode.connect(audioContext.destination);
+    
+    gainNode.gain.setValueAtTime(0, audioContext.currentTime);
+    gainNode.gain.linearRampToValueAtTime(${amplitude}, audioContext.currentTime + 0.1);
+    gainNode.gain.exponentialRampToValueAtTime(0.001, audioContext.currentTime + ${duration});
+    
+    oscillator.start(audioContext.currentTime);
+    oscillator.stop(audioContext.currentTime + ${duration});
+  `;
+}
+
+export function generateCMYKHarmony(cyan: CMYKChannel, magenta: CMYKChannel, yellow: CMYKChannel, key: CMYKChannel): string {
+  return `
+    // CMYK Harmony Generation
+    const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+    
+    // Create oscillators for each channel
+    const oscillators = {
+      cyan: createOscillator(${cyan.frequency}, ${cyan.amplitude / 9}, 'sine'),
+      magenta: createOscillator(${magenta.frequency}, ${magenta.amplitude / 9}, 'sine'),
+      yellow: createOscillator(${yellow.frequency}, ${yellow.amplitude / 9}, 'sine'),
+      key: createOscillator(${key.frequency}, ${key.amplitude / 9}, 'sine')
+    };
+    
+    function createOscillator(frequency, amplitude, type) {
+      const osc = audioContext.createOscillator();
+      const gain = audioContext.createGain();
+      
+      osc.type = type;
+      osc.frequency.setValueAtTime(frequency, audioContext.currentTime);
+      osc.connect(gain);
+      gain.connect(audioContext.destination);
+      
+      gain.gain.setValueAtTime(0, audioContext.currentTime);
+      gain.gain.linearRampToValueAtTime(amplitude, audioContext.currentTime + 0.1);
+      gain.gain.exponentialRampToValueAtTime(0.001, audioContext.currentTime + 2);
+      
+      return { oscillator: osc, gain: gain };
+    }
+    
+    // Start all oscillators
+    Object.values(oscillators).forEach(({ oscillator }) => {
+      oscillator.start(audioContext.currentTime);
+      oscillator.stop(audioContext.currentTime + 2);
+    });
+  `;
+}
+
+export function generateVoicePattern(pattern: string, state: A432CMYKVoiceState): string {
+  const patterns = {
+    'cyan-magenta': `Cyan (${state.cyan.frequency}Hz) + Magenta (${state.magenta.frequency}Hz)`,
+    'yellow-key': `Yellow (${state.yellow.frequency}Hz) + Key (${state.key.frequency}Hz)`,
+    'full-harmony': `Full CMYK Harmony: ${state.synthesis.fundamental}Hz fundamental`,
+    'resonance': `Resonance Pattern: ${state.harmonization.resonance}/9 harmony`
+  };
+  
+  return patterns[pattern as keyof typeof patterns] || `Custom Pattern: ${pattern}`;
+}
+
+// === CMYK VOICE MODULES ===
+const cyanModule: A432Module = {
+  name: 'a432.cmyk.voice.cyan',
+  category: 'voice',
+  version: '1.0.0',
+  description: 'Cyan voice channel: High frequency harmonization',
+  dependencies: ['a432.core'],
+  exports: ['createCMYKChannel', 'generateCMYKTone'],
+  getState: () => createCMYKChannel('cyan'),
+  harmonize: () => {
+    const cyan = createCMYKChannel('cyan');
+    // Cyan harmonization logic
+    return cyan;
+  },
+  getOverlays: () => ['Cyan Voice', 'High Frequency', 'Harmonization'],
+  getMeta: () => 'Cyan voice channel: High frequency harmonization'
+};
+
+const magentaModule: A432Module = {
+  name: 'a432.cmyk.voice.magenta',
+  category: 'voice',
+  version: '1.0.0',
+  description: 'Magenta voice channel: Medium-high frequency harmonization',
+  dependencies: ['a432.core', 'a432.cmyk.voice.cyan'],
+  exports: ['createCMYKChannel', 'generateCMYKTone'],
+  getState: () => createCMYKChannel('magenta'),
+  harmonize: () => {
+    const magenta = createCMYKChannel('magenta');
+    // Magenta harmonization logic
+    return magenta;
+  },
+  getOverlays: () => ['Magenta Voice', 'Medium-High Frequency', 'Harmonization'],
+  getMeta: () => 'Magenta voice channel: Medium-high frequency harmonization'
+};
+
+const yellowModule: A432Module = {
+  name: 'a432.cmyk.voice.yellow',
+  category: 'voice',
+  version: '1.0.0',
+  description: 'Yellow voice channel: Highest frequency harmonization',
+  dependencies: ['a432.core', 'a432.cmyk.voice.magenta'],
+  exports: ['createCMYKChannel', 'generateCMYKTone'],
+  getState: () => createCMYKChannel('yellow'),
+  harmonize: () => {
+    const yellow = createCMYKChannel('yellow');
+    // Yellow harmonization logic
+    return yellow;
+  },
+  getOverlays: () => ['Yellow Voice', 'Highest Frequency', 'Harmonization'],
+  getMeta: () => 'Yellow voice channel: Highest frequency harmonization'
+};
+
+const keyModule: A432Module = {
+  name: 'a432.cmyk.voice.key',
+  category: 'voice',
+  version: '1.0.0',
+  description: 'Key voice channel: Lower frequency harmonization',
+  dependencies: ['a432.core', 'a432.cmyk.voice.yellow'],
+  exports: ['createCMYKChannel', 'generateCMYKTone'],
+  getState: () => createCMYKChannel('key'),
+  harmonize: () => {
+    const key = createCMYKChannel('key');
+    // Key harmonization logic
+    return key;
+  },
+  getOverlays: () => ['Key Voice', 'Lower Frequency', 'Harmonization'],
+  getMeta: () => 'Key voice channel: Lower frequency harmonization'
+};
+
+const synthesisModule: A432Module = {
+  name: 'a432.cmyk.voice.synthesis',
+  category: 'voice',
+  version: '1.0.0',
+  description: 'Voice synthesis: CMYK channel harmonization',
+  dependencies: ['a432.core', 'a432.cmyk.voice.key'],
+  exports: ['createVoiceSynthesis', 'generateCMYKHarmony'],
+  getState: () => {
+    const cyan = createCMYKChannel('cyan');
+    const magenta = createCMYKChannel('magenta');
+    const yellow = createCMYKChannel('yellow');
+    const key = createCMYKChannel('key');
+    return createVoiceSynthesis(cyan, magenta, yellow, key);
+  },
+  harmonize: () => {
+    const synthesis = createVoiceSynthesis(
+      createCMYKChannel('cyan'),
+      createCMYKChannel('magenta'),
+      createCMYKChannel('yellow'),
+      createCMYKChannel('key')
+    );
+    // Synthesis harmonization logic
+    return synthesis;
+  },
+  getOverlays: () => ['Voice Synthesis', 'CMYK Harmonization', 'Audio Generation'],
+  getMeta: () => 'Voice synthesis: CMYK channel harmonization'
+};
+
+const harmonizationModule: A432Module = {
+  name: 'a432.cmyk.voice.harmonization',
+  category: 'voice',
+  version: '1.0.0',
+  description: 'Voice harmonization: CMYK balance and coherence',
+  dependencies: ['a432.core', 'a432.cmyk.voice.synthesis'],
+  exports: ['createVoiceHarmonization', 'generateVoicePattern'],
+  getState: () => {
+    const cyan = createCMYKChannel('cyan');
+    const magenta = createCMYKChannel('magenta');
+    const yellow = createCMYKChannel('yellow');
+    const key = createCMYKChannel('key');
+    return createVoiceHarmonization(cyan, magenta, yellow, key);
+  },
+  harmonize: () => {
+    const harmonization = createVoiceHarmonization(
+      createCMYKChannel('cyan'),
+      createCMYKChannel('magenta'),
+      createCMYKChannel('yellow'),
+      createCMYKChannel('key')
+    );
+    // Harmonization logic
+    return harmonization;
+  },
+  getOverlays: () => ['Voice Harmonization', 'CMYK Balance', 'Coherence'],
+  getMeta: () => 'Voice harmonization: CMYK balance and coherence'
+};
+
+// === MODULE REGISTRATION ===
+export function registerA432CMYKVoiceModules(): void {
+  a432ModuleRegistry.register(cyanModule);
+  a432ModuleRegistry.register(magentaModule);
+  a432ModuleRegistry.register(yellowModule);
+  a432ModuleRegistry.register(keyModule);
+  a432ModuleRegistry.register(synthesisModule);
+  a432ModuleRegistry.register(harmonizationModule);
+}
+
+// === CMYK VOICE UTILITIES ===
+export function getCMYKVoiceStats(): { total: number; harmonized: number; dissonant: number } {
+  const state = createA432CMYKVoiceState();
+  const total = 6; // cyan, magenta, yellow, key, synthesis, harmonization
+  const harmonized = [
+    state.cyan.resonance >= 7,
+    state.magenta.resonance >= 7,
+    state.yellow.resonance >= 7,
+    state.key.resonance >= 7,
+    state.synthesis.resonance >= 7,
+    state.harmonization.resonance >= 7
+  ].filter(Boolean).length;
+  
+  return { total, harmonized, dissonant: total - harmonized };
+}
+
+export function harmonizeAllCMYKVoice(): A432CMYKVoiceState {
+  return harmonizeA432CMYKVoice();
+}
+
+// Auto-register CMYK voice modules
+registerA432CMYKVoiceModules(); 

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

@@ -0,0 +1,132 @@
+import { floor } from './a432.algebra.ts'
+// Canonical Coil Interface for the A432 System
+// This file is the single entry point for all coil/circuit logic (Rodin, Mobius, Tesla) in the A432 system.
+// Import and re-export all core logic from the canonical modules below.
+
+import * as Rodin from './a432.rodin.coil.ts';
+import * as Mobius from './a432.mobius.circuit.ts';
+import * as Tesla from './a432.tesla.coil.ts';
+
+export const A432_SEQUENCE = [0, [3, 6, 9], [1, 2, 4], 8, [7, 5, 1]]; // Void 0 -> 9 -> 7 -> 8 -> 4
+export const A432_TRINITY = [0, 9, 1];
+export const A432_ANGLE = 360 / 6; // 60 degrees dimensional gateways angle
+
+/**
+ * a432.coil.ts
+ *
+ * Unified, canonical interface for all coil/circuit logic in the A432 system.
+ * - Rodin coil (doubling circuit, poloidal field)
+ * - Mobius circuit (strip, twist, traversal)
+ * - Tesla coil (gateway, voltage, frequency)
+ *
+ * All modules should import coil/circuit logic from this file only.
+ */
+
+/**
+ * A432CoilCommon: Shared interface for all coil/circuit types in the A432 system.
+ * - index: Position in the sequence or pattern.
+ * - polarity: +1 (forward) or -1 (reverse).
+ * - frequency: Harmonic, twist, or gateway frequency.
+ * - type: 'Rodin', 'Mobius', or 'Tesla'.
+ * - system: Which coil system this instance belongs to ('Rodin', 'Mobius', 'Tesla').
+ * - rodinValue: (Rodin) Value at this step in the sequence.
+ * - mobiusTwist: (Mobius) Twist value for this strip.
+ * - teslaGateway: (Tesla) Gateway value (3, 6, 9).
+ */
+export interface A432CoilCommon {
+  index?: number; // or position
+  polarity: 1 | -1;
+  frequency?: number;
+  type?: 'Rodin' | 'Mobius' | 'Tesla';
+  system?: 'Rodin' | 'Mobius' | 'Tesla';
+  rodinValue?: number; // For Rodin coil steps: in the sequence (1-2-4-8-7-5-1)
+  mobiusTwist?: number; // For Mobius strips
+  teslaGateway?: number; // For Tesla coils (3, 6, 9)
+}
+
+// Union type for all coil types, compatible with A432CoilCommon
+export type A432Coil = (Rodin.RodinCoilStep & A432CoilCommon) | (Mobius.MobiusStrip & A432CoilCommon) | (Tesla.TeslaCoil & A432CoilCommon);
+
+// Re-export all core logic
+export { Rodin, Mobius, Tesla };
+
+// All coil/circuit math for the A432 system must use these canonical exports. 
+
+/**
+ * a432.coil.ts — Rodin Coil, Vortex Well, Zero Entropy, Renewal, Consciousness Mapping
+ *
+ * Encodes:
+ * - Rodin coil sequence (1-2-4-8-7-5, 3-6-9) as recursive, digit-based flows
+ * - Vortex well and zero entropy renewal logic
+ * - Heat dissipation and indestructibility
+ * - Consciousness mapping as recursive, digit-based process
+ *
+ * Source: Marko Rodin Special Edition, Chapter 9
+ */
+
+/**
+ * a432RodinCoil: Returns the canonical Rodin coil sequence [1,2,4,8,7,5].
+ */
+export function a432RodinCoil(): number[] {
+  return [1, 2, 4, 8, 7, 5];
+}
+
+/**
+ * a432RodinCoilStream: Recursively generates the Rodin coil sequence for a given number of steps.
+ */
+export function a432RodinCoilStream(steps: number = 12): number[] {
+  const seq = [1, 2, 4, 8, 7, 5];
+  const result = [];
+  for (let i = 0; i < steps; i++) {
+    result.push(seq[i % seq.length]);
+  }
+  return result;
+}
+
+/**
+ * a432VortexWell: Models the vortex well/zero entropy renewal as a recursive, digit-based process.
+ * Returns a sequence alternating between 3-9-6 and 1-2-4-8-7-5.
+ */
+export function a432VortexWell(steps: number = 12): number[] {
+  const trinity = [3, 9, 6];
+  const coil = [1, 2, 4, 8, 7, 5];
+  const result = [];
+  for (let i = 0; i < steps; i++) {
+    result.push(i % 2 === 0 ? trinity[(i / 2) % 3] : coil[(floor(i / 2)) % 6]);
+  }
+  return result;
+}
+
+/**
+ * a432HeatDissipation: Returns a sequence modeling heat dissipation via the 3-9-6 palindrome.
+ * steps: number of cycles
+ */
+export function a432HeatDissipation(steps: number = 9): number[] {
+  const seq = [3, 9, 6, 6, 9, 3, 3, 9, 6];
+  const result = [];
+  for (let i = 0; i < steps; i++) {
+    result.push(seq[i % seq.length]);
+  }
+  return result;
+}
+
+/**
+ * a432ConsciousnessMap: Maps a digit sequence to a recursive consciousness stream (e.g., brain/antenna logic).
+ * steps: number of states to generate
+ * base: base sequence (default 1-2-4-8-7-5)
+ */
+export function a432ConsciousnessMap(steps: number = 12, base: number[] = [1,2,4,8,7,5]): number[] {
+  const result = [];
+  for (let i = 0; i < steps; i++) {
+    result.push(base[i % base.length]);
+  }
+  return result;
+}
+
+/**
+ * Metaphysical Mapping:
+ * - The Rodin coil is the universal, recursive, indestructible structure.
+ * - Vortex well and zero entropy logic encode renewal and eternal existence.
+ * - Heat dissipation is modeled by the 3-9-6 palindrome.
+ * - Consciousness is mapped as a recursive, digit-based stream, harmonized with the coil.
+ */