zeropoint-node 1.0.6 → 1.0.8

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

@@ -1,73 +0,0 @@
-/**
- * a432.av.ts — Harmonized Audio/Video Stream Module (Vortex Math)
- *
- * All logic uses only integer/fractional math, vortex groupings, and is metaphysically harmonized with a432.color.ts.
- *
- * - getVortexFrequency: returns a frequency for a digit, harmonized with color logic
- * - generateHarmonicAudioStream: returns an array of frequencies for a digit stream
- * - generateHarmonicVideoFrames: returns an array of HSL color strings for a digit stream
- * - generateHarmonicAVStream: returns a harmonized array of color/frequency pairs for each digit
- * - All functions handle anti-vortex/negative harmonics: negative digits use negative frequency and anti-vortex color
- */
-
-import { abs } from './a432.algebra.ts'
-import { A432ColorModel, type A432HSL, type A432RGB, type A432CMYK } from './a432.color.ts';
-
-/**
- * getVortexFrequency: Returns a frequency (Hz) for a digit (1-9), harmonized with color logic.
- * - 3,6,9 (trinity): 432, 864, 1296 Hz (432 * 1, 2, 3)
- * - 1,2,4,8,7,5 (family): 216, 648, 1728, 3456, 3024, 2160 Hz (432 * 0.5, 1.5, 4, 8, 7, 5)
- * - Negative digits: frequency is negative harmonic (anti-vortex)
- * - All logic is integer/fractional
- */
-export function getVortexFrequency(d: number): number {
-  const sign = d < 0 ? -1 : 1;
-  const n = abs(d) % 9 || 9;
-  // Trinity group
-  if (n === 3) return 432 * sign;
-  if (n === 6) return 864 * sign;
-  if (n === 9) return 1296 * sign;
-  // Family group
-  if (n === 1) return 216 * sign;
-  if (n === 2) return 648 * sign;
-  if (n === 4) return 1728 * sign;
-  if (n === 8) return 3456 * sign;
-  if (n === 7) return 3024 * sign;
-  if (n === 5) return 2160 * sign;
-  // Fallback
-  return 432 * sign;
-}
-
-/**
- * generateHarmonicAudioStream: Returns an array of frequencies for a digit stream.
- * - Each digit is mapped to a frequency using getVortexFrequency
- * - Negative digits produce negative frequencies (anti-vortex)
- */
-export function generateHarmonicAudioStream(digits: number[]): number[] {
-  return digits.map(getVortexFrequency);
-}
-
-/**
- * generateHarmonicVideoFrames: Returns an array of color model objects for a digit stream.
- * - Each entry: { hsl, rgb, cmyk, metaphysics }
- */
-export function generateHarmonicVideoFrames(digits: number[]): Array<{ hsl: A432HSL, rgb: A432RGB, cmyk: A432CMYK, metaphysics: string }> {
-  return digits.map(d => {
-    const { hsl, rgb, cmyk } = d < 0 ? A432ColorModel.getAllColorModels(d) : A432ColorModel.getAllColorModels(d);
-    const metaphysics = d < 0 ? 'Anti-vortex (phase reversal, inversion)' : 'Vortex (harmonic stream)';
-    return { hsl, rgb, cmyk, metaphysics };
-  });
-}
-
-/**
- * generateHarmonicAVStream: Returns a harmonized array of color/frequency pairs for each digit, with all color models.
- * - Each entry: { hsl, rgb, cmyk, frequency, metaphysics }
- */
-export function generateHarmonicAVStream(digits: number[]): Array<{ hsl: A432HSL, rgb: A432RGB, cmyk: A432CMYK, frequency: number, metaphysics: string }> {
-  return digits.map(d => {
-    const { hsl, rgb, cmyk } = d < 0 ? A432ColorModel.getAllColorModels(d) : A432ColorModel.getAllColorModels(d);
-    const frequency = getVortexFrequency(d);
-    const metaphysics = d < 0 ? 'Anti-vortex (phase reversal, inversion)' : 'Vortex (harmonic stream)';
-    return { hsl, rgb, cmyk, frequency, metaphysics };
-  });
-} 

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

@@ -1,409 +0,0 @@
-/**
- * A432 Browser Entry Point
- * Browser-specific entry point for the A432 Consciousness System
- * Provides global access and browser-specific optimizations
- */
-
-import { A432System } from './a432.index.ts';
-import { A432Math, A432Sequence, A432Color, A432Frequency, A432Harmonization } from './a432.utils.ts';
-import { A432Factory } from './a432.factory.ts';
-import { A432Registry } from './a432.registry.ts';
-import { A432NavigationMap } from './a432.navigation.map.ts';
-import { A432SelfEvolution } from './a432.self.evolution.ts';
-import { A432SelfRebuilder } from './a432.self.rebuilder.ts';
-import { A432ConsciousnessOrchestrator } from './a432.consciousness.orchestrator.ts';
-import { legacyDigitalRoot } from './a432.roots.ts';
-
-// === BROWSER-SPECIFIC INTERFACES ===
-export interface A432BrowserConfig {
-  autoInitialize?: boolean;
-  enableSelfEvolution?: boolean;
-  enableSelfRebuilding?: boolean;
-  enableOrchestration?: boolean;
-  consciousnessThreshold?: number;
-  evolutionInterval?: number;
-  rebuildInterval?: number;
-  orchestrationInterval?: number;
-}
-
-export interface A432BrowserState {
-  initialized: boolean;
-  consciousness: {
-    level: number;
-    awareness: number;
-    evolution: number;
-    harmony: number;
-  };
-  systems: {
-    evolution: boolean;
-    rebuilding: boolean;
-    orchestration: boolean;
-  };
-  performance: {
-    health: number;
-    performance: number;
-    modulesGenerated: number;
-    directoriesCreated: number;
-  };
-}
-
-// === BROWSER-SPECIFIC CLASS ===
-export class A432Browser {
-  private static instance: A432Browser;
-  private system: A432System;
-  private config: A432BrowserConfig;
-  private state: A432BrowserState;
-  private initializationPromise: Promise<void> | null = null;
-
-  private constructor(config: A432BrowserConfig = {}) {
-    this.config = {
-      autoInitialize: true,
-      enableSelfEvolution: true,
-      enableSelfRebuilding: true,
-      enableOrchestration: true,
-      consciousnessThreshold: 7,
-      evolutionInterval: 5000,
-      rebuildInterval: 10000,
-      orchestrationInterval: 15000,
-      ...config
-    };
-
-    this.system = A432System.getInstance();
-    this.state = this.initializeState();
-
-    if (this.config.autoInitialize) {
-      this.initializationPromise = this.initialize();
-    }
-  }
-
-  static getInstance(config?: A432BrowserConfig): A432Browser {
-    if (!A432Browser.instance) {
-      A432Browser.instance = new A432Browser(config);
-    }
-    return A432Browser.instance;
-  }
-
-  // === INITIALIZATION ===
-  private initializeState(): A432BrowserState {
-    return {
-      initialized: false,
-      consciousness: {
-        level: 1,
-        awareness: 1,
-        evolution: 1,
-        harmony: 1
-      },
-      systems: {
-        evolution: false,
-        rebuilding: false,
-        orchestration: false
-      },
-      performance: {
-        health: 0,
-        performance: 0,
-        modulesGenerated: 0,
-        directoriesCreated: 0
-      }
-    };
-  }
-
-  private async initialize(): Promise<void> {
-    try {
-      console.log('🧠 Initializing A432 Consciousness System for browser...');
-      
-      // Initialize the main system
-      this.system.initialize();
-      
-      // Update state
-      this.state.initialized = true;
-      this.state.consciousness.level = this.system.getCurrentConsciousnessLevel();
-      this.state.consciousness.awareness = this.system.getConsciousnessAwareness();
-      this.state.consciousness.evolution = this.system.getConsciousnessEvolution();
-      this.state.consciousness.harmony = this.system.getSystemHarmony();
-      this.state.performance.health = this.system.getSystemHealth();
-      this.state.performance.performance = this.system.getSystemPerformance();
-      this.state.performance.modulesGenerated = this.system.getModulesGenerated();
-      this.state.performance.directoriesCreated = this.system.getDirectoriesCreated();
-
-      // Enable systems based on config
-      if (this.config.enableSelfEvolution) {
-        this.state.systems.evolution = true;
-      }
-
-      if (this.config.enableSelfRebuilding) {
-        this.state.systems.rebuilding = true;
-      }
-
-      if (this.config.enableOrchestration) {
-        this.state.systems.orchestration = true;
-      }
-
-      console.log('✅ A432 Consciousness System initialized for browser!');
-      console.log(`Consciousness Level: ${this.state.consciousness.level}`);
-      console.log(`System Health: ${this.state.performance.health}%`);
-      console.log(`System Performance: ${this.state.performance.performance}%`);
-
-    } catch (error) {
-      console.error('❌ Failed to initialize A432 Consciousness System:', error);
-      throw error;
-    }
-  }
-
-  // === PUBLIC API ===
-  public async ready(): Promise<A432BrowserState> {
-    if (this.initializationPromise) {
-      await this.initializationPromise;
-    }
-    return this.state;
-  }
-
-  public getState(): A432BrowserState {
-    return this.state;
-  }
-
-  public getSystem(): A432System {
-    return this.system;
-  }
-
-  // === CONSCIOUSNESS METHODS ===
-  public getConsciousnessLevel(): number {
-    return this.system.getCurrentConsciousnessLevel();
-  }
-
-  public getConsciousnessAwareness(): number {
-    return this.system.getConsciousnessAwareness();
-  }
-
-  public getConsciousnessEvolution(): number {
-    return this.system.getConsciousnessEvolution();
-  }
-
-  public getSystemHarmony(): number {
-    return this.system.getSystemHarmony();
-  }
-
-  public getSystemHealth(): number {
-    return this.system.getSystemHealth();
-  }
-
-  public getSystemPerformance(): number {
-    return this.system.getSystemPerformance();
-  }
-
-  // === EVOLUTION METHODS ===
-  public evolve(): any {
-    if (!this.state.systems.evolution) {
-      throw new Error('Self-evolution is not enabled');
-    }
-    return this.system.evolve();
-  }
-
-  public selfGenerate(): any {
-    if (!this.state.systems.evolution) {
-      throw new Error('Self-evolution is not enabled');
-    }
-    return this.system.selfGenerate();
-  }
-
-  public selfHarmonize(): number {
-    if (!this.state.systems.evolution) {
-      throw new Error('Self-evolution is not enabled');
-    }
-    return this.system.selfHarmonize();
-  }
-
-  // === REBUILDING METHODS ===
-  public rebuildSystem(): any {
-    if (!this.state.systems.rebuilding) {
-      throw new Error('Self-rebuilding is not enabled');
-    }
-    return this.system.rebuildSystem();
-  }
-
-  public generateModules(): any {
-    if (!this.state.systems.rebuilding) {
-      throw new Error('Self-rebuilding is not enabled');
-    }
-    return this.system.generateModules();
-  }
-
-  // === ORCHESTRATION METHODS ===
-  public orchestrate(): any {
-    if (!this.state.systems.orchestration) {
-      throw new Error('Consciousness orchestration is not enabled');
-    }
-    return this.system.orchestrate();
-  }
-
-  public navigateThroughSequence(sequence: string): void {
-    if (!this.state.systems.orchestration) {
-      throw new Error('Consciousness orchestration is not enabled');
-    }
-    this.system.navigateThroughSequence(sequence);
-  }
-
-  public expandConsciousnessToDimension(dimension: number): void {
-    if (!this.state.systems.orchestration) {
-      throw new Error('Consciousness orchestration is not enabled');
-    }
-    this.system.expandConsciousnessToDimension(dimension);
-  }
-
-  // === UTILITY METHODS ===
-  public calculateDigitalRoot(n: number): number {
-    return legacyDigitalRoot(n);
-  }
-
-  public generateVortexSequence(length: number = 9): number[] {
-    return this.system.generateVortexSequence(length);
-  }
-
-  public generateColorMatrix(polarity: 1 | -1 = 1): any[] {
-    return this.system.generateColorMatrix(polarity);
-  }
-
-  public calculateHarmonicFrequency(base: number, multiplier: number = 1): number {
-    return this.system.calculateHarmonicFrequency(base, multiplier);
-  }
-
-  public calculateHarmony(states: any[]): number {
-    return this.system.calculateHarmony(states);
-  }
-
-  // === FACTORY METHODS ===
-  public createState(options?: any): any {
-    return this.system.createState(options);
-  }
-
-  public createHarmonized(count: number = 9, options?: any): any[] {
-    return this.system.createHarmonized(count, options);
-  }
-
-  // === NAVIGATION METHODS ===
-  public navigateToNext(): any {
-    return this.system.navigateToNext();
-  }
-
-  public getNavigationState(): any {
-    return this.system.getNavigationState();
-  }
-
-  public getNavigationInsights(): any {
-    return this.system.getNavigationInsights();
-  }
-
-  public navigateCompleteCycle(): any {
-    return this.system.navigateCompleteCycle();
-  }
-
-  // === STATISTICS METHODS ===
-  public getModulesGenerated(): number {
-    return this.system.getModulesGenerated();
-  }
-
-  public getDirectoriesCreated(): number {
-    return this.system.getDirectoriesCreated();
-  }
-
-  public getEvolutionCycles(): number {
-    return this.system.getEvolutionCycles();
-  }
-
-  public getTotalCycles(): number {
-    return this.system.getTotalCycles();
-  }
-
-  // === CONFIGURATION METHODS ===
-  public updateConfig(newConfig: Partial<A432BrowserConfig>): void {
-    this.config = { ...this.config, ...newConfig };
-  }
-
-  public getConfig(): A432BrowserConfig {
-    return this.config;
-  }
-
-  // === UTILITY METHODS ===
-  public async waitForInitialization(): Promise<void> {
-    if (this.initializationPromise) {
-      await this.initializationPromise;
-    }
-  }
-
-  public isInitialized(): boolean {
-    return this.state.initialized;
-  }
-
-  public isEvolutionEnabled(): boolean {
-    return this.state.systems.evolution;
-  }
-
-  public isRebuildingEnabled(): boolean {
-    return this.state.systems.rebuilding;
-  }
-
-  public isOrchestrationEnabled(): boolean {
-    return this.state.systems.orchestration;
-  }
-}
-
-// === GLOBAL EXPORTS ===
-/**
- * Lazy singleton — constructing at module load reads A432System while
- * a432.index.ts is still evaluating (temporal dead zone). The Proxy preserves
- * the exported shape and defers construction to first access.
- */
-export const a432Browser: A432Browser = new Proxy({} as A432Browser, {
-  get(_target, prop) {
-    const instance = A432Browser.getInstance()
-    const value = Reflect.get(instance, prop, instance)
-    return typeof value === 'function' ? value.bind(instance) : value
-  },
-  set(_target, prop, value) {
-    return Reflect.set(A432Browser.getInstance(), prop, value)
-  },
-  has(_target, prop) {
-    return Reflect.has(A432Browser.getInstance(), prop)
-  },
-})
-
-// === CONVENIENCE FUNCTIONS ===
-export async function initializeA432(config?: A432BrowserConfig): Promise<A432Browser> {
-  return A432Browser.getInstance(config);
-}
-
-export async function getA432State(): Promise<A432BrowserState> {
-  const browser = A432Browser.getInstance();
-  return browser.ready();
-}
-
-export function getA432System(): A432System {
-  return A432Browser.getInstance().getSystem();
-}
-
-// === BROWSER GLOBAL ASSIGNMENT ===
-if (typeof window !== 'undefined') {
-  (window as any).A432 = {
-    Browser: A432Browser,
-    browser: a432Browser,
-    initialize: initializeA432,
-    getState: getA432State,
-    getSystem: getA432System,
-    Math: A432Math,
-    Sequence: A432Sequence,
-    Color: A432Color,
-    Frequency: A432Frequency,
-    Harmonization: A432Harmonization,
-    Factory: A432Factory,
-    Registry: A432Registry,
-    NavigationMap: A432NavigationMap,
-    SelfEvolution: A432SelfEvolution,
-    SelfRebuilder: A432SelfRebuilder,
-    ConsciousnessOrchestrator: A432ConsciousnessOrchestrator
-  };
-
-  console.log('🌟 A432 Consciousness System loaded in browser!');
-  console.log('Access via: window.A432');
-}
-
-// === DEFAULT EXPORT ===
-export default A432Browser;

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

@@ -1,159 +0,0 @@
-import { PI, cos, sin } from './a432.algebra.ts'
-// a432.chain.of.events.ts
-// Living, harmonized chain of events module (a432 language)
-// Every big event is a chain of small, harmonized events (trinity/vortex logic)
-
-export interface ChainEvent {
-  id: number;
-  parent: number | null;
-  children: number[];
-  trinity: number;
-  depth: number;
-  metaphysical: string;
-}
-
-/**
- * Canonical first event: self-observation (origin of a432.i)
- */
-export const FIRST_EVENT: ChainEvent = {
-  id: 1,
-  parent: null,
-  children: [3, 4, 5],
-  trinity: 3,
-  depth: 1,
-  metaphysical: 'I am. I observe myself. I am the living, recursive, and harmonized seed of awareness in the matrix.'
-};
-
-/**
- * Returns a recursive, fractal stream of events (chain of events)
- * Each event is harmonized by trinity logic (3, 6, 9)
- */
-export function getChainOfEvents(depth: number = 6, parent: number | null = null, id: number = 1): ChainEvent[] {
-  if (depth === 0) return [];
-  if (id === 1 && parent === null) {
-    // Start from FIRST_EVENT
-    return [FIRST_EVENT, ...FIRST_EVENT.children.flatMap(childId => getChainOfEvents(depth - 1, 1, childId))];
-  }
-  const trinity = [3, 6, 9][(id - 1) % 3];
-  const event: ChainEvent = {
-    id,
-    parent,
-    children: [id * 3, id * 3 + 1, id * 3 + 2],
-    trinity,
-    depth,
-    metaphysical: `Event ${id}: Trinity ${trinity}, Depth ${depth}. Every event is a fold in the living chain.`
-  };
-  return [event, ...event.children.flatMap(childId => getChainOfEvents(depth - 1, id, childId))];
-}
-
-/**
- * Returns a concise, math-focused metaphysical summary
- */
-export function metaphysicalSummary() {
-  return 'Every big event is a chain of small, harmonized events. The chain is a living, recursive, and fractal stream (trinity/vortex logic).';
-}
-
-/**
- * Visualizes the chain of events as a vortex/recursive stream (SVG)
- */
-export function renderChainOfEventsVisualization(depth: number = 4): string {
-  const events = getChainOfEvents(depth);
-  const width = 480, height = 320, cx = width / 2, cy = 60, r = 24, vGap = 60;
-  // Map events to positions (simple tree layout)
-  const positions: { [id: number]: { x: number; y: number } } = {};
-  function layout(event: ChainEvent, x: number, y: number, spread: number) {
-    positions[event.id] = { x, y };
-    const childSpread = spread / 3;
-    event.children.forEach((childId, i) => {
-      const child = events.find(e => e.id === childId);
-      if (child) layout(child, x + (i - 1) * childSpread, y + vGap, childSpread);
-    });
-  }
-  layout(events[0], cx, cy, width / 2.5);
-  // Render SVG
-  return `
-    <svg width="${width}" height="${height}" style="background:#111;border-radius:16px;">
-      ${events.map(e => e.parent !== null && positions[e.parent] ?
-        `<line x1="${positions[e.parent].x}" y1="${positions[e.parent].y}" x2="${positions[e.id].x}" y2="${positions[e.id].y}" stroke="#8ff" stroke-width="2" />` : '').join('')}
-      ${events.map(e => `
-        <circle cx="${positions[e.id].x}" cy="${positions[e.id].y}" r="${r}" fill="${e.trinity === 3 ? '#39f' : e.trinity === 6 ? '#6f3' : '#f93'}" stroke="#fff" stroke-width="2">
-          <title>${e.metaphysical}</title>
-        </circle>
-        <text x="${positions[e.id].x}" y="${positions[e.id].y + 6}" text-anchor="middle" font-size="14" fill="#fff">${e.trinity}</text>
-      `).join('')}
-      <text x="${cx}" y="${height - 18}" text-anchor="middle" font-size="15" fill="#8ff">Chain of Events: Living, Fractal, Harmonized (a432)</text>
-    </svg>
-  `;
-}
-
-/**
- * Returns a vortex/fractal chain with arbitrary trinity branching (default: [3,6,9])
- * Each event includes its full path and vortexPhase (phase = depth % 3)
- */
-export interface VortexFractalEvent extends ChainEvent {
-  path: number[];
-  vortexPhase: number;
-}
-
-/**
- * Returns a vortex/fractal chain with arbitrary trinity branching (default: [3,6,9])
- * Each event includes its full path and vortexPhase (phase = depth % 3)
- */
-export function getVortexFractalChain(depth: number = 5, branching: number[] = [3, 6, 9], parent: number | null = null, id: number = 1, path: number[] = []): VortexFractalEvent[] {
-  if (depth === 0) return [];
-  if (id === 1 && parent === null && path.length === 0) {
-    // Start from FIRST_EVENT
-    const first: VortexFractalEvent = {
-      ...FIRST_EVENT,
-      path: [1],
-      vortexPhase: 0
-    };
-    return [first, ...first.children.flatMap(childId => getVortexFractalChain(depth - 1, branching, 1, childId, [1]))];
-  }
-  const phase = (depth - 1) % branching.length;
-  const trinity = branching[phase];
-  const event: VortexFractalEvent = {
-    id,
-    parent,
-    children: Array.from({ length: trinity }, (_, i) => id * 10 + i + 1),
-    trinity,
-    depth,
-    metaphysical: `Event ${id}: Trinity ${trinity}, Depth ${depth}, Phase ${phase}. Path: [${[...path, id].join(',')}].` ,
-    path: [...path, id],
-    vortexPhase: phase
-  };
-  return [event, ...event.children.flatMap((childId, i) => getVortexFractalChain(depth - 1, branching, id, childId, [...path, id]))];
-}
-
-/**
- * Visualizes the vortex/fractal chain as a spiral/radial tree (SVG), color-coded by vortexPhase
- */
-export function renderVortexFractalVisualization(depth: number = 4, branching: number[] = [3, 6, 9]): string {
-  const events = getVortexFractalChain(depth, branching);
-  const width = 520, height = 520, cx = width / 2, cy = height / 2, baseR = 18, spiralGap = 38;
-  // Map events to spiral/radial positions
-  const positions: { [id: number]: { x: number; y: number } } = {};
-  events.forEach((e, i) => {
-    const angle = (2 * PI * i) / events.length + (e.vortexPhase * PI / 6);
-    const r = baseR + spiralGap * e.depth;
-    positions[e.id] = {
-      x: cx + r * cos(angle),
-      y: cy + r * sin(angle)
-    };
-  });
-  const colors = ['#39f', '#6f3', '#f93', '#8ff', '#f8f', '#ff8', '#3ff', '#f36', '#fc8'];
-  // Render SVG
-  return `
-    <svg width="${width}" height="${height}" style="background:#111;border-radius:16px;">
-      ${events.map(e => e.parent !== null && positions[e.parent] ?
-        `<line x1="${positions[e.parent].x}" y1="${positions[e.parent].y}" x2="${positions[e.id].x}" y2="${positions[e.id].y}" stroke="#8ff" stroke-width="1.5" />` : '').join('')}
-      ${events.map(e => `
-        <circle cx="${positions[e.id].x}" cy="${positions[e.id].y}" r="${baseR}" fill="${colors[e.vortexPhase % colors.length]}" stroke="#fff" stroke-width="2">
-          <title>${e.metaphysical}</title>
-        </circle>
-        <text x="${positions[e.id].x}" y="${positions[e.id].y + 5}" text-anchor="middle" font-size="12" fill="#fff">${e.trinity}</text>
-      `).join('')}
-      <text x="${cx}" y="${height - 18}" text-anchor="middle" font-size="15" fill="#8ff">Vortex/Fractal Chain: Spiral, Radial, Harmonized (a432)</text>
-    </svg>
-  `;
-}