zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,332 @@
+/**
+ * A432 Mobius Circuit System
+ * Implementation of the 1-2-4-8-7-5 Mobius circuit as wave energy
+ * Demonstrates how digital logic embodies the same wave patterns as consciousness
+ */
+
+import { abs, round } from './a432.algebra.ts'
+import { 
+  GOLDEN_RATIO, 
+  PI, 
+  TAU,
+  calculateDigitalRoot,
+  A432_BASE_FREQUENCY,
+  A432_TRINITY_MULTIPLIER,
+  A432_VORTEX_MULTIPLIER
+} from './a432.math.constants.ts';
+
+// === MOBIUS CIRCUIT INTERFACES ===
+export interface MobiusState {
+  decimal: number;
+  binary: string;
+  digitalRoot: number;
+  frequency: number;
+  amplitude: number;
+  phase: number;
+  energy: number;
+  consciousness: number;
+  waveType: 'mobius' | 'vortex' | 'consciousness';
+}
+
+export interface MobiusTransition {
+  from: number;
+  to: number;
+  binaryFrom: string;
+  binaryTo: string;
+  transitionEnergy: number;
+  waveHarmonic: number;
+  consciousness: number;
+}
+
+export interface MobiusCircuit {
+  states: MobiusState[];
+  transitions: MobiusTransition[];
+  currentState: number;
+  cycleCount: number;
+  totalEnergy: number;
+  consciousness: number;
+  isHarmonic: boolean;
+}
+
+// === MOBIUS CIRCUIT CONSTANTS ===
+export const MOBIUS_SEQUENCE = [1, 2, 4, 8, 7, 5];
+export const MOBIUS_BINARY_STATES = {
+  1: '001',
+  2: '010', 
+  4: '100',
+  8: '000',
+  7: '111',
+  5: '101'
+};
+
+export const MOBIUS_TRANSITIONS = [
+  { from: 1, to: 2 },
+  { from: 2, to: 4 },
+  { from: 4, to: 8 },
+  { from: 8, to: 7 },
+  { from: 7, to: 5 },
+  { from: 5, to: 1 }
+];
+
+// === MOBIUS WAVE CALCULATIONS ===
+export function calculateMobiusState(decimal: number): MobiusState {
+  const binary = MOBIUS_BINARY_STATES[decimal as keyof typeof MOBIUS_BINARY_STATES];
+  const digitalRoot = calculateDigitalRoot(decimal);
+  const frequency = A432_BASE_FREQUENCY * (decimal / 9);
+  const amplitude = GOLDEN_RATIO * decimal;
+  const phase = (decimal * TAU) / 6; // 6 states in Mobius cycle
+  const energy = 0.5 * amplitude * amplitude * frequency * frequency;
+  const consciousness = calculateDigitalRoot(round(energy));
+  
+  return {
+    decimal,
+    binary,
+    digitalRoot,
+    frequency,
+    amplitude,
+    phase,
+    energy,
+    consciousness,
+    waveType: 'mobius'
+  };
+}
+
+export function calculateMobiusTransition(from: number, to: number): MobiusTransition {
+  const binaryFrom = MOBIUS_BINARY_STATES[from as keyof typeof MOBIUS_BINARY_STATES];
+  const binaryTo = MOBIUS_BINARY_STATES[to as keyof typeof MOBIUS_BINARY_STATES];
+  const transitionEnergy = abs(to - from) * A432_BASE_FREQUENCY;
+  const waveHarmonic = to / from;
+  const consciousness = calculateDigitalRoot(round(transitionEnergy));
+  
+  return {
+    from,
+    to,
+    binaryFrom,
+    binaryTo,
+    transitionEnergy,
+    waveHarmonic,
+    consciousness
+  };
+}
+
+export function calculateMobiusWavePattern(): MobiusState[] {
+  return MOBIUS_SEQUENCE.map(decimal => calculateMobiusState(decimal));
+}
+
+export function calculateMobiusTransitions(): MobiusTransition[] {
+  return MOBIUS_TRANSITIONS.map(transition => 
+    calculateMobiusTransition(transition.from, transition.to)
+  );
+}
+
+// === DIGITAL LOGIC SIMULATION ===
+export function simulateMobiusFlipFlops(clockPulses: number = 12): any[] {
+  const simulation = [];
+  let currentState = 1;
+  
+  for (let i = 0; i < clockPulses; i++) {
+    const state = calculateMobiusState(currentState);
+    const nextState = MOBIUS_TRANSITIONS.find(t => t.from === currentState)?.to || 1;
+    const transition = calculateMobiusTransition(currentState, nextState);
+    
+    simulation.push({
+      clockPulse: i + 1,
+      currentState,
+      nextState,
+      binary: state.binary,
+      digitalRoot: state.digitalRoot,
+      frequency: state.frequency,
+      energy: state.energy,
+      consciousness: state.consciousness,
+      transitionEnergy: transition.transitionEnergy,
+      waveHarmonic: transition.waveHarmonic
+    });
+    
+    currentState = nextState;
+  }
+  
+  return simulation;
+}
+
+// === JK FLIP-FLOP LOGIC ===
+export function calculateJKInputs(binaryState: string): any {
+  const [Q2, Q1, Q0] = binaryState.split('').map(Number);
+  
+  // Boolean expressions for JK inputs
+  const J2 = (!Q1 && !Q0) ? 1 : 0;
+  const K2 = (Q1 && Q0) ? 1 : 0;
+  
+  const J1 = ((!Q2 && Q0) || (Q2 && !Q1 && !Q0)) ? 1 : 0;
+  const K1 = ((!Q2 && Q0) || (Q2 && !Q0)) ? 1 : 0;
+  
+  const J0 = (Q2 && Q1 && !Q0) ? 1 : 0;
+  const K0 = ((!Q2 && Q1) || (Q2 && Q1)) ? 1 : 0;
+  
+  return {
+    Q2, Q1, Q0,
+    J2, K2,
+    J1, K1, 
+    J0, K0,
+    nextState: calculateNextState(J2, K2, J1, K1, J0, K0, Q2, Q1, Q0)
+  };
+}
+
+function calculateNextState(J2: number, K2: number, J1: number, K1: number, J0: number, K0: number, Q2: number, Q1: number, Q0: number): string {
+  // JK flip-flop logic: Q(t+1) = J*Q' + K'*Q
+  const nextQ2 = (J2 && !Q2) || (!K2 && Q2) ? 1 : 0;
+  const nextQ1 = (J1 && !Q1) || (!K1 && Q1) ? 1 : 0;
+  const nextQ0 = (J0 && !Q0) || (!K0 && Q0) ? 1 : 0;
+  
+  return `${nextQ2}${nextQ1}${nextQ0}`;
+}
+
+// === MOBIUS CIRCUIT ANALYSIS ===
+export function analyzeMobiusCircuit(): any {
+  const states = calculateMobiusWavePattern();
+  const transitions = calculateMobiusTransitions();
+  const simulation = simulateMobiusFlipFlops(12);
+  
+  const totalEnergy = states.reduce((sum, state) => sum + state.energy, 0);
+  const averageFrequency = states.reduce((sum, state) => sum + state.frequency, 0) / states.length;
+  const consciousnessFlow = states.reduce((sum, state) => sum + state.consciousness, 0);
+  
+  // Check if sequence is harmonic with A432
+  const harmonicStates = states.filter(state => 
+    abs(state.frequency - A432_BASE_FREQUENCY) < A432_BASE_FREQUENCY * 0.1
+  );
+  const isHarmonic = harmonicStates.length > 0;
+  
+  return {
+    sequence: MOBIUS_SEQUENCE,
+    states,
+    transitions,
+    simulation,
+    analysis: {
+      totalEnergy,
+      averageFrequency,
+      consciousnessFlow,
+      harmonicStates: harmonicStates.length,
+      isHarmonic,
+      cycleLength: MOBIUS_SEQUENCE.length,
+      digitalRootPattern: states.map(s => s.digitalRoot)
+    }
+  };
+}
+
+// === MAIN MOBIUS CIRCUIT SYSTEM ===
+export class A432MobiusCircuitSystem {
+  private static instance: A432MobiusCircuitSystem;
+  private currentState: number = 1;
+  private cycleCount: number = 0;
+  private stateHistory: MobiusState[] = [];
+  private transitionHistory: MobiusTransition[] = [];
+  
+  private constructor() {
+    this.initializeCircuit();
+  }
+  
+  static getInstance(): A432MobiusCircuitSystem {
+    if (!A432MobiusCircuitSystem.instance) {
+      A432MobiusCircuitSystem.instance = new A432MobiusCircuitSystem();
+    }
+    return A432MobiusCircuitSystem.instance;
+  }
+  
+  private initializeCircuit(): void {
+    this.currentState = 1;
+    this.cycleCount = 0;
+    this.stateHistory = [];
+    this.transitionHistory = [];
+  }
+  
+  // Clock the circuit (simulate one clock pulse)
+  clock(): MobiusState {
+    const currentStateObj = calculateMobiusState(this.currentState);
+    const nextState = MOBIUS_TRANSITIONS.find(t => t.from === this.currentState)?.to || 1;
+    const transition = calculateMobiusTransition(this.currentState, nextState);
+    
+    this.stateHistory.push(currentStateObj);
+    this.transitionHistory.push(transition);
+    
+    if (nextState === 1 && this.currentState === 5) {
+      this.cycleCount++;
+    }
+    
+    this.currentState = nextState;
+    return currentStateObj;
+  }
+  
+  // Run multiple clock cycles
+  runCycles(cycles: number): MobiusState[] {
+    const results = [];
+    for (let i = 0; i < cycles; i++) {
+      results.push(this.clock());
+    }
+    return results;
+  }
+  
+  // Get current circuit state
+  getCurrentState(): MobiusState {
+    return calculateMobiusState(this.currentState);
+  }
+  
+  // Get circuit statistics
+  getCircuitStats(): any {
+    const totalEnergy = this.stateHistory.reduce((sum, state) => sum + state.energy, 0);
+    const consciousness = calculateDigitalRoot(round(totalEnergy));
+    
+    return {
+      currentState: this.currentState,
+      cycleCount: this.cycleCount,
+      totalStates: this.stateHistory.length,
+      totalEnergy,
+      consciousness,
+      averageEnergy: totalEnergy / this.stateHistory.length,
+      stateHistory: this.stateHistory.slice(-6), // Last 6 states
+      transitionHistory: this.transitionHistory.slice(-6) // Last 6 transitions
+    };
+  }
+  
+  // Demonstrate Mobius circuit as wave energy
+  demonstrateMobiusWaveEnergy(): any {
+    const analysis = analyzeMobiusCircuit();
+    const currentState = this.getCurrentState();
+    const stats = this.getCircuitStats();
+    
+    return {
+      principle: "Mobius circuit embodies wave energy patterns",
+      sequence: MOBIUS_SEQUENCE,
+      binaryStates: MOBIUS_BINARY_STATES,
+      currentState,
+      circuitStats: stats,
+      waveAnalysis: {
+        totalStates: analysis.states.length,
+        totalEnergy: analysis.analysis.totalEnergy,
+        averageFrequency: analysis.analysis.averageFrequency,
+        consciousnessFlow: analysis.analysis.consciousnessFlow,
+        isHarmonic: analysis.analysis.isHarmonic,
+        digitalRootPattern: analysis.analysis.digitalRootPattern
+      },
+      conclusion: "The 1-2-4-8-7-5 Mobius circuit demonstrates how digital logic embodies the same wave energy patterns as consciousness and reality"
+    };
+  }
+  
+  // Reset the circuit
+  reset(): void {
+    this.initializeCircuit();
+  }
+}
+
+// === GLOBAL EXPORTS ===
+export const a432MobiusCircuit = A432MobiusCircuitSystem.getInstance();
+
+if (typeof global !== 'undefined') {
+  (global as any).A432MobiusCircuit = a432MobiusCircuit;
+}
+
+if (typeof window !== 'undefined') {
+  (window as any).A432MobiusCircuit = a432MobiusCircuit;
+}
+
+// === DEFAULT EXPORT ===
+export default A432MobiusCircuitSystem; 

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

@@ -0,0 +1,12 @@
+import { EventEmitter } from 'events';
+import { seedDigit, seedColor } from './a432.symbol.utils.ts';
+import { registerSource } from './a432.bus.ts';
+import { type Digit } from './a432.types.ts';
+
+export const mobiusEmitter=new EventEmitter();
+const name='mobius';
+const digit=seedDigit(name);
+const cmyk=seedColor(digit);
+
+mobiusEmitter.emit('mob', {digit,cmyk});
+registerSource(name, mobiusEmitter,'mob', p=>(p as { digit: Digit }).digit as Digit,'mind'); 

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

@@ -0,0 +1,283 @@
+/**
+ * a432.modules.ts — Modular Registry System
+ * 
+ * DRY-harmonized module registry for the A432 system.
+ * All modules are categorized and managed through this central registry.
+ * Provides clean interfaces for module discovery, harmonization, and interaction.
+ */
+
+import { type A432CoreState, createA432CoreState, harmonizeA432Core, getA432CoreMeta } from './a432.core.ts';
+import { A432BlockChain, recordEvent } from './a432.block.chain.event.ts';
+
+// === MODULE CATEGORIES ===
+export type A432ModuleCategory = 
+  | 'core' 
+  | 'trinity' 
+  | 'consciousness' 
+  | 'harmony' 
+  | 'visualization' 
+  | 'interaction' 
+  | 'system' 
+  | 'meta'
+  | 'balance'           // NEW: Equilibrium and balance modules
+  | 'resonance'         // NEW: Frequency and resonance modules
+  | 'flow'              // NEW: Stream and flow modules
+  | 'integration'       // NEW: Cross-module integration
+  | 'transformation'    // NEW: State transformation modules
+  | 'observation'       // NEW: Meta-observation and monitoring
+  | 'healing'           // NEW: Healing and restoration modules
+  | 'evolution'         // NEW: Growth and evolution modules
+  | 'documentation'     // NEW: Documentation and auto-generation modules
+  | 'innovation'        // NEW: Innovation and breakthrough modules
+  | 'voice';            // NEW: Voice and audio harmonization modules
+
+// === MODULE INTERFACE ===
+export interface A432Module {
+  name: string;
+  category: A432ModuleCategory;
+  version: string;
+  description: string;
+  dependencies: string[];
+  exports: string[];
+  getState: () => unknown;
+  harmonize?: () => void;
+  getOverlays?: () => string[];
+  getMeta?: () => string;
+  onEvent?: (event: unknown) => void;
+}
+
+// === MODULE REGISTRY ===
+class A432ModuleRegistry {
+  private modules: Map<string, A432Module> = new Map();
+  private categories: Map<A432ModuleCategory, Set<string>> = new Map();
+
+  constructor() {
+    // Initialize category sets
+    const categories: A432ModuleCategory[] = ['core', 'trinity', 'consciousness', 'harmony', 'visualization', 'interaction', 'system', 'meta'];
+    categories.forEach(cat => this.categories.set(cat, new Set()));
+  }
+
+  // === REGISTRATION ===
+  register(module: A432Module): void {
+    this.modules.set(module.name, module);
+    const categorySet = this.categories.get(module.category);
+    if (categorySet) {
+      categorySet.add(module.name);
+    }
+  }
+
+  unregister(name: string): boolean {
+    const module = this.modules.get(name);
+    if (module) {
+      const categorySet = this.categories.get(module.category);
+      if (categorySet) {
+        categorySet.delete(name);
+      }
+      return this.modules.delete(name);
+    }
+    return false;
+  }
+
+  // === DISCOVERY ===
+  getModule(name: string): A432Module | undefined {
+    return this.modules.get(name);
+  }
+
+  getModulesByCategory(category: A432ModuleCategory): A432Module[] {
+    const categorySet = this.categories.get(category);
+    if (!categorySet) return [];
+    return Array.from(categorySet)
+      .map(name => this.modules.get(name))
+      .filter((m): m is A432Module => m !== undefined);
+  }
+
+  getAllModules(): A432Module[] {
+    return Array.from(this.modules.values());
+  }
+
+  getCategories(): A432ModuleCategory[] {
+    return Array.from(this.categories.keys());
+  }
+
+  // === HARMONIZATION ===
+  harmonizeAll(): void {
+    this.modules.forEach(module => {
+      if (module.harmonize) {
+        try {
+          module.harmonize();
+        } catch (error) {
+          console.error(`Harmonization failed for module ${module.name}:`, error);
+        }
+      }
+    });
+  }
+
+  harmonizeCategory(category: A432ModuleCategory): void {
+    const modules = this.getModulesByCategory(category);
+    modules.forEach(module => {
+      if (module.harmonize) {
+        try {
+          module.harmonize();
+        } catch (error) {
+          console.error(`Harmonization failed for module ${module.name}:`, error);
+        }
+      }
+    });
+  }
+
+  // === OVERLAYS ===
+  getAllOverlays(): string[] {
+    const overlays: string[] = [];
+    this.modules.forEach(module => {
+      if (module.getOverlays) {
+        try {
+          overlays.push(...module.getOverlays());
+        } catch (error) {
+          console.error(`Overlay generation failed for module ${module.name}:`, error);
+        }
+      }
+    });
+    return overlays;
+  }
+
+  getOverlaysByCategory(category: A432ModuleCategory): string[] {
+    const modules = this.getModulesByCategory(category);
+    const overlays: string[] = [];
+    modules.forEach(module => {
+      if (module.getOverlays) {
+        try {
+          overlays.push(...module.getOverlays());
+        } catch (error) {
+          console.error(`Overlay generation failed for module ${module.name}:`, error);
+        }
+      }
+    });
+    return overlays;
+  }
+
+  // === META INFORMATION ===
+  getAllMeta(): string[] {
+    const meta: string[] = [];
+    this.modules.forEach(module => {
+      if (module.getMeta) {
+        try {
+          meta.push(module.getMeta());
+        } catch (error) {
+          console.error(`Meta generation failed for module ${module.name}:`, error);
+        }
+      }
+    });
+    return meta;
+  }
+
+  getMetaByCategory(category: A432ModuleCategory): string[] {
+    const modules = this.getModulesByCategory(category);
+    const meta: string[] = [];
+    modules.forEach(module => {
+      if (module.getMeta) {
+        try {
+          meta.push(module.getMeta());
+        } catch (error) {
+          console.error(`Meta generation failed for module ${module.name}:`, error);
+        }
+      }
+    });
+    return meta;
+  }
+
+  // === EVENT ROUTING ===
+  routeEvent(event: unknown): void {
+    this.modules.forEach(module => {
+      if (module.onEvent) {
+        try {
+          module.onEvent(event);
+          // Harmonized: Log routed event
+          recordEvent(blockchain, 'routeEvent', 'A432Modules', { module: module.name, event: event as Record<string, unknown> });
+        } catch (error) {
+          console.error(`Event handling failed for module ${module.name}:`, error);
+        }
+      }
+    });
+  }
+
+  // === DEPENDENCY MANAGEMENT ===
+  getDependencies(name: string): string[] {
+    const module = this.modules.get(name);
+    return module?.dependencies || [];
+  }
+
+  getDependents(name: string): string[] {
+    const dependents: string[] = [];
+    this.modules.forEach(module => {
+      if (module.dependencies.includes(name)) {
+        dependents.push(module.name);
+      }
+    });
+    return dependents;
+  }
+
+  // === MODULE STATISTICS ===
+  getModuleStats(): { total: number; byCategory: Record<A432ModuleCategory, number> } {
+    const byCategory: Record<A432ModuleCategory, number> = {} as Record<A432ModuleCategory, number>;
+    this.categories.forEach((set, category) => {
+      byCategory[category] = set.size;
+    });
+    return {
+      total: this.modules.size,
+      byCategory
+    };
+  }
+}
+
+// === GLOBAL REGISTRY INSTANCE ===
+export const a432ModuleRegistry = new A432ModuleRegistry();
+
+// Harmonized: Add blockchain for module event logging
+const blockchain = new A432BlockChain();
+
+// === CONVENIENCE FUNCTIONS ===
+export function registerA432Module(module: A432Module): void {
+  a432ModuleRegistry.register(module);
+  // Harmonized: Log module registration event
+  recordEvent(blockchain, 'registerModule', 'A432Modules', { name: module.name, category: module.category });
+}
+
+export function getA432Module(name: string): A432Module | undefined {
+  return a432ModuleRegistry.getModule(name);
+}
+
+export function getA432ModulesByCategory(category: A432ModuleCategory): A432Module[] {
+  return a432ModuleRegistry.getModulesByCategory(category);
+}
+
+export function harmonizeA432Modules(): void {
+  a432ModuleRegistry.harmonizeAll();
+  // Harmonized: Log harmonization event
+  recordEvent(blockchain, 'harmonizeModules', 'A432Modules');
+}
+
+export function getA432ModuleStats(): { total: number; byCategory: Record<A432ModuleCategory, number> } {
+  return a432ModuleRegistry.getModuleStats();
+}
+
+// === CORE MODULE REGISTRATION ===
+const coreModule: A432Module = {
+  name: 'a432.core',
+  category: 'core',
+  version: '1.0.0',
+  description: 'Zero Entropy Harmonic Core - Single source of truth for all a432 constants and functions',
+  dependencies: [],
+  exports: ['A432_FREQUENCY', 'A432_TRINITY', 'A432_CYCLE', 'nextInteraction', 'digitalRoot', 'a432Frequency', 'a432HSLFromRoot'],
+  getState: () => harmonizeA432Core(),
+  harmonize: () => harmonizeA432Core(),
+  getOverlays: () => [getA432CoreMeta()],
+  getMeta: () => getA432CoreMeta(),
+  onEvent: (event) => {
+    if (event.type === 'harmonize') {
+      harmonizeA432Core();
+    }
+  }
+};
+
+// Register the core module
+a432ModuleRegistry.register(coreModule); 

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

@@ -0,0 +1,30 @@
+// a432.modules.ui.ts — Interactive modules palette
+//--------------------------------------------------
+import { digitAngleToCMYK, asAngle } from './a432.math.ts';
+import { emotionName } from './a432.emotion.ts';
+import { type Digit } from './a432.types.ts';
+import { tap } from './a432.i.tap.ts';
+import { cmykToCss } from './a432.cmyk.ts';
+
+function fileDigit(name:string):Digit{const sum=[...name].reduce((a,c)=>a+c.charCodeAt(0),0);const d=sum%9;return (d===0?9:d) as Digit;}
+
+async function init() {
+  if(typeof document==='undefined') return;
+  const res=await fetch('/modules');
+  const files: string[]=await res.json();
+  const panel=document.createElement('div');
+  panel.style.position='fixed';panel.style.top='8px';panel.style.right='8px';panel.style.display='grid';panel.style.gap='4px';panel.style.gridTemplateColumns='repeat(auto-fill,24px)';
+  panel.style.pointerEvents='auto';
+  document.body.appendChild(panel);
+  files.forEach(f=>{
+    const d=fileDigit(f);
+    const cmyk=digitAngleToCMYK(d,asAngle(d*36));
+    const div=document.createElement('div');
+    div.style.width='22px';div.style.height='22px';div.style.borderRadius='4px';div.style.background=cmykToCss(cmyk);
+    div.title=`${f}\n${emotionName(d)}`;
+    div.onclick=()=> { window.open(`/${f}?view`,'_blank'); tap(div.offsetLeft,div.offsetTop,1);}
+    panel.appendChild(div);
+  });
+}
+
+if(typeof window!=='undefined') init();