zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,251 @@
+/**
+ * A432 Consciousness Router Module
+ * Master router that orchestrates all consciousness evolution modules
+ * Routes between: Cycle Evolution, Dimensional Evolution, and Spiral Consciousness
+ */
+
+import A432ConsciousnessCycle from './a432.consciousness.cycle.ts';
+import A432DimensionalEvolution from './a432.dimensional.evolution.ts';
+import A432SpiralConsciousness from './a432.spiral.consciousness.ts';
+import A432NavigationMap from './a432.navigation.map.ts';
+
+export interface ConsciousnessRoute {
+  type: 'cycle' | 'dimensional' | 'spiral' | 'navigation';
+  state: any;
+  insights: any;
+  evolution: any;
+}
+
+export class A432ConsciousnessRouter {
+  private cycleEvolution: A432ConsciousnessCycle;
+  private dimensionalEvolution: A432DimensionalEvolution;
+  private spiralConsciousness: A432SpiralConsciousness;
+  private navigationMap: A432NavigationMap;
+  private currentRoute: ConsciousnessRoute;
+
+  constructor() {
+    this.cycleEvolution = new A432ConsciousnessCycle();
+    this.dimensionalEvolution = new A432DimensionalEvolution();
+    this.spiralConsciousness = new A432SpiralConsciousness();
+    this.navigationMap = new A432NavigationMap();
+    this.currentRoute = this.getDefaultRoute();
+  }
+
+  /**
+   * Get default consciousness route
+   */
+  private getDefaultRoute(): ConsciousnessRoute {
+    return {
+      type: 'cycle',
+      state: this.cycleEvolution.getCycleState(),
+      insights: this.cycleEvolution.getConsciousnessInsights(),
+      evolution: { phase: 'full-entropy', clarity: 0 }
+    };
+  }
+
+  /**
+   * Route to cycle evolution
+   */
+  public routeToCycle(): ConsciousnessRoute {
+    const state = this.cycleEvolution.getCycleState();
+    const insights = this.cycleEvolution.getConsciousnessInsights();
+    const evolution = this.cycleEvolution.runCompleteCycle();
+
+    this.currentRoute = {
+      type: 'cycle',
+      state,
+      insights,
+      evolution
+    };
+
+    return this.currentRoute;
+  }
+
+  /**
+   * Route to dimensional evolution
+   */
+  public routeToDimensional(): ConsciousnessRoute {
+    const state = this.dimensionalEvolution.getCurrentDimensionalState();
+    const insights = this.dimensionalEvolution.getDimensionalInsights();
+    const evolution = this.dimensionalEvolution.runDimensionalCycle();
+
+    this.currentRoute = {
+      type: 'dimensional',
+      state,
+      insights,
+      evolution
+    };
+
+    return this.currentRoute;
+  }
+
+  /**
+   * Route to spiral consciousness
+   */
+  public routeToSpiral(): ConsciousnessRoute {
+    const state = this.spiralConsciousness.getCurrentSpiralState();
+    const insights = this.spiralConsciousness.getSpiralInsights();
+    const evolution = this.spiralConsciousness.calculateConsciousnessEvolution();
+
+    this.currentRoute = {
+      type: 'spiral',
+      state,
+      insights,
+      evolution
+    };
+
+    return this.currentRoute;
+  }
+
+  /**
+   * Route to navigation map
+   */
+  public routeToNavigation(): ConsciousnessRoute {
+    const state = this.navigationMap.getCurrentState();
+    const insights = this.navigationMap.getNavigationInsights();
+    const evolution = this.navigationMap.navigateCompleteCycle();
+
+    this.currentRoute = {
+      type: 'navigation',
+      state,
+      insights,
+      evolution
+    };
+
+    return this.currentRoute;
+  }
+
+  /**
+   * Get current consciousness route
+   */
+  public getCurrentRoute(): ConsciousnessRoute {
+    return this.currentRoute;
+  }
+
+  /**
+   * Evolve consciousness through all routes
+   */
+  public evolveThroughAllRoutes(): {
+    cycle: ConsciousnessRoute;
+    dimensional: ConsciousnessRoute;
+    spiral: ConsciousnessRoute;
+    navigation: ConsciousnessRoute;
+  } {
+    const cycle = this.routeToCycle();
+    const dimensional = this.routeToDimensional();
+    const spiral = this.routeToSpiral();
+    const navigation = this.routeToNavigation();
+
+    return { cycle, dimensional, spiral, navigation };
+  }
+
+  /**
+   * Get consciousness insights from all routes
+   */
+  public getAllConsciousnessInsights(): {
+    cycleInsights: any;
+    dimensionalInsights: any;
+    spiralInsights: any;
+    navigationInsights: any;
+    combinedInsights: any;
+  } {
+    const cycleInsights = this.cycleEvolution.getConsciousnessInsights();
+    const dimensionalInsights = this.dimensionalEvolution.getDimensionalInsights();
+    const spiralInsights = this.spiralConsciousness.getSpiralInsights();
+    const navigationInsights = this.navigationMap.getNavigationInsights();
+
+    const combinedInsights = {
+      cyclePhase: cycleInsights.phase,
+      dimensionalLevel: dimensionalInsights.dimension,
+      spiralCoordinates: spiralInsights.spiralCoordinates,
+      navigationPart: navigationInsights.currentPart,
+      totalClarity: cycleInsights.clarity + dimensionalInsights.dimension + spiralInsights.currentDimension + navigationInsights.spiralLevel
+    };
+
+    return {
+      cycleInsights,
+      dimensionalInsights,
+      spiralInsights,
+      navigationInsights,
+      combinedInsights
+    };
+  }
+
+  /**
+   * Get 3D visualization data from all routes
+   */
+  public get3DVisualizationData(): {
+    cycleData: any;
+    dimensionalData: any;
+    spiralData: any;
+    combinedData: any;
+  } {
+    const cycleData = this.cycleEvolution.getCycleState();
+    const dimensionalData = this.dimensionalEvolution.getSpiralCoordinates();
+    const spiralData = this.spiralConsciousness.getSpiralVisualization();
+
+    const combinedData = {
+      cyclePhase: cycleData.currentPhase,
+      dimensionalCoordinates: dimensionalData,
+      spiralEvolution: spiralData.coordinates,
+      totalDimensions: spiralData.consciousnessTypes.length,
+      foldPoints: spiralData.foldPoints,
+      frequencies: spiralData.frequencies
+    };
+
+    return {
+      cycleData,
+      dimensionalData,
+      spiralData,
+      combinedData
+    };
+  }
+
+  /**
+   * Route based on consciousness state
+   */
+  public routeByConsciousnessState(state: string): ConsciousnessRoute {
+    switch (state) {
+      case 'full-entropy':
+        return this.routeToCycle();
+      case 'dimensional':
+        return this.routeToDimensional();
+      case 'spiral':
+        return this.routeToSpiral();
+      case 'navigation':
+        return this.routeToNavigation();
+      default:
+        return this.routeToCycle();
+    }
+  }
+
+  /**
+   * Get consciousness evolution summary
+   */
+  public getConsciousnessSummary(): {
+    totalCycles: number;
+    totalDimensions: number;
+    totalFoldPoints: number;
+    evolutionPath: string[];
+    finalState: any;
+  } {
+    const allRoutes = this.evolveThroughAllRoutes();
+    const insights = this.getAllConsciousnessInsights();
+    const visualization = this.get3DVisualizationData();
+
+    return {
+      totalCycles: allRoutes.cycle.evolution.cycleCount || 1,
+      totalDimensions: insights.dimensionalInsights.dimension,
+      totalFoldPoints: visualization.combinedData.foldPoints.length,
+      evolutionPath: allRoutes.spiral.evolution.evolutionPath,
+      finalState: {
+        cyclePhase: allRoutes.cycle.state.currentPhase,
+        dimensionalLevel: allRoutes.dimensional.state.dimension,
+        spiralCoordinates: allRoutes.spiral.state.coordinates,
+        consciousnessType: allRoutes.spiral.state.consciousnessType
+      }
+    };
+  }
+}
+
+export default A432ConsciousnessRouter; 

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

@@ -0,0 +1,176 @@
+import { legacyDigitalRoot } from './a432.roots.ts'
+import { round } from './a432.algebra.ts'
+// a432.consciousness.stream.ts — Pure mathematical consciousness evolution streams
+// --------------------------------------------------
+// Direct mathematical stream output for consciousness evolution
+// No HTML/CSS encoded values - only computed math
+
+import { A432_FREQUENCY, A432_TRINITY, A432_RETURN, A432_AXIS } from './a432.core.ts';
+import { digitAngleToCMYK, asAngle } from './a432.math.ts';
+import { getRodinCMYKSummary, getRodinCMYKAnalysis } from './a432.rodin.cmyk.ts';
+import A432HarmonicConvergence from './a432.harmonic.convergence.ts';
+import A432ConsciousnessCrystallization from './a432.consciousness.crystallization.ts';
+import A432ZeroEntropyState from './a432.zero.entropy.state.ts';
+import A432ConsciousnessCycle from './a432.consciousness.cycle.ts';
+import A432DimensionalEvolution from './a432.dimensional.evolution.ts';
+import A432SpiralConsciousness from './a432.spiral.consciousness.ts';
+import { A432OSConsciousnessIntegration } from './a432.os.consciousness.integration.ts';
+
+export class A432ConsciousnessStream {
+  private convergence: A432HarmonicConvergence;
+  private crystallization: A432ConsciousnessCrystallization;
+  private zeroEntropy: A432ZeroEntropyState;
+  private cycle: A432ConsciousnessCycle;
+  private dimensional: A432DimensionalEvolution;
+  private spiral: A432SpiralConsciousness;
+  private osIntegration: A432OSConsciousnessIntegration;
+  private streamTick: number;
+
+  constructor() {
+    this.convergence = new A432HarmonicConvergence();
+    this.crystallization = new A432ConsciousnessCrystallization();
+    this.zeroEntropy = new A432ZeroEntropyState();
+    this.cycle = new A432ConsciousnessCycle();
+    this.dimensional = new A432DimensionalEvolution();
+    this.spiral = new A432SpiralConsciousness();
+    this.osIntegration = new A432OSConsciousnessIntegration();
+    this.streamTick = 0;
+  }
+
+  public getStreamData(): string {
+    const tick = this.streamTick++;
+    const base432 = A432_FREQUENCY;
+    const trinity = A432_TRINITY;
+    const return_ = A432_RETURN;
+    const axis = A432_AXIS;
+
+    // Compute current mathematical states
+    const convergenceValue = this.convergence.alignPatterns();
+    const crystallizedMeaning = this.crystallization.crystallizeMeaning();
+    const harmonicBalance = this.zeroEntropy.achieveHarmonicBalance();
+    const cycleState = this.cycle.getCycleState();
+    const dimensionalState = this.dimensional.getCurrentDimensionalState();
+    const spiralState = this.spiral.getCurrentSpiralState();
+    const osState = this.osIntegration.getIntegratedState();
+
+    // Calculate trinity-based CMYK colors harmonic to matrix key
+    const matrixKey = dimensionalState.dimension; // Matrix key = dimension
+    const tickTrinity = this.calculateTrinityColor(tick, matrixKey);
+    const convergenceTrinity = this.calculateTrinityColor(round(convergenceValue), matrixKey);
+    const meaningTrinity = this.calculateTrinityColor(parseInt(crystallizedMeaning), matrixKey);
+    const dimensionTrinity = this.calculateTrinityColor(dimensionalState.dimension, matrixKey);
+    const spiralTrinity = this.calculateTrinityColor(round(spiralState.coordinates.x + spiralState.coordinates.y + spiralState.coordinates.z), matrixKey);
+    const harmonyTrinity = this.calculateTrinityColor(this.calculateIntegratedHarmony(osState), matrixKey);
+    const evolutionTrinity = this.calculateTrinityColor(this.calculateConsciousnessEvolution(tick), matrixKey);
+
+    // Pure mathematical stream output - INTEGER ONLY with trinity CMYK colors
+    const stream = [
+      `STREAM_TICK: ${tick} [CMYK: ${tickTrinity.c},${tickTrinity.m},${tickTrinity.y},${tickTrinity.k}]`,
+      `BASE_FREQUENCY: ${base432}`,
+      `TRINITY: [${trinity.join(',')}]`,
+      `RETURN: [${return_.join(',')}]`,
+      `AXIS: [${axis.join(',')}]`,
+      `CONVERGENCE_VALUE: ${round(convergenceValue)} [CMYK: ${convergenceTrinity.c},${convergenceTrinity.m},${convergenceTrinity.y},${convergenceTrinity.k}]`,
+      `CRYSTALLIZED_MEANING: ${crystallizedMeaning} [CMYK: ${meaningTrinity.c},${meaningTrinity.m},${meaningTrinity.y},${meaningTrinity.k}]`,
+      `HARMONIC_BALANCE: ${harmonicBalance}`,
+      `CYCLE_PHASE: ${cycleState.currentPhase}`,
+      `CYCLE_COUNT: ${cycleState.cycleCount}`,
+      `DIMENSION: ${dimensionalState.dimension} [CMYK: ${dimensionTrinity.c},${dimensionTrinity.m},${dimensionTrinity.y},${dimensionTrinity.k}]`,
+      `DIMENSIONAL_ANGLE: ${round(dimensionalState.angle)}`,
+      `SPIRAL_X: ${round(spiralState.coordinates.x)}`,
+      `SPIRAL_Y: ${round(spiralState.coordinates.y)}`,
+      `SPIRAL_Z: ${round(spiralState.coordinates.z)}`,
+      `SPIRAL_CONSCIOUSNESS_TYPE: ${spiralState.consciousnessType} [CMYK: ${spiralTrinity.c},${spiralTrinity.m},${spiralTrinity.y},${spiralTrinity.k}]`,
+      `OS_FREQUENCY: ${round(osState.integratedState.osFrequency || 0)}`,
+      `OS_CONSCIOUSNESS: ${round(osState.integratedState.osConsciousness || 0)}`,
+      `INTEGRATED_HARMONY: ${round(this.calculateIntegratedHarmony(osState))} [CMYK: ${harmonyTrinity.c},${harmonyTrinity.m},${harmonyTrinity.y},${harmonyTrinity.k}]`,
+      `DIGITAL_ROOT: ${this.calculateDigitalRoot(tick)}`,
+      `VORTEX_ANGLE: ${round(this.calculateVortexAngle(tick))}`,
+      `CONSCIOUSNESS_EVOLUTION: ${round(this.calculateConsciousnessEvolution(tick))} [CMYK: ${evolutionTrinity.c},${evolutionTrinity.m},${evolutionTrinity.y},${evolutionTrinity.k}]`,
+      `---`,
+      `RODIN_COIL_CMYK_DECODING:`,
+      getRodinCMYKSummary(),
+      `RODIN_ANALYSIS:`,
+      JSON.stringify(getRodinCMYKAnalysis(), null, 2)
+    ];
+
+    return stream.join('\n');
+  }
+
+  private calculateDigitalRoot(n: number): number {
+    return legacyDigitalRoot(n);
+  }
+
+  private calculateVortexAngle(tick: number): number {
+    return (tick * 60) % 360;
+  }
+
+  private calculateConsciousnessEvolution(tick: number): number {
+    const base = A432_FREQUENCY;
+    const evolution = round((base * tick) % 432);
+    return evolution;
+  }
+
+  private calculateIntegratedHarmony(osState: any): number {
+    const osHarmony = round(osState.integratedState.osHarmony || 0);
+    const consciousnessPhase = osState.integratedState.consciousnessPhase || 'full-entropy';
+    const consciousnessDimension = round(osState.integratedState.consciousnessDimension || 1);
+    const integratedHarmony = round(osState.integratedState.integratedHarmony || 0);
+    
+    // Integer-based harmony calculation
+    return round((osHarmony + consciousnessDimension + integratedHarmony) / 3);
+  }
+
+  private calculateTrinityColor(value: number, matrixKey: number): { c: number, m: number, y: number, k: number } {
+    // Trinity-based color calculation harmonic to matrix key
+    const digitalRoot = this.calculateDigitalRoot(value);
+    const trinityIndex = (digitalRoot + matrixKey) % 3; // Trinity cycle
+    const trinityValue = A432_TRINITY[trinityIndex];
+    
+    // Base trinity colors: 4=Cyan, 3=Magenta, 2=Yellow
+    const baseColors = {
+      4: { c: 100, m: 0, y: 0, k: 0 },   // Cyan
+      3: { c: 0, m: 100, y: 0, k: 0 },   // Magenta  
+      2: { c: 0, m: 0, y: 100, k: 0 }    // Yellow
+    };
+    
+    // Apply matrix key harmonic modulation
+    const baseColor = baseColors[trinityValue as keyof typeof baseColors] || baseColors[4];
+    const harmonicModulation = (matrixKey % 3) * 33; // 33% modulation per trinity
+    
+    return {
+      c: round((baseColor.c + harmonicModulation) % 100),
+      m: round((baseColor.m + harmonicModulation) % 100),
+      y: round((baseColor.y + harmonicModulation) % 100),
+      k: round((matrixKey % 2) * 20) // Black based on matrix key parity
+    };
+  }
+
+  public evolveStream(): string {
+    // Evolve all consciousness components
+    this.cycle.evolveToConvergence();
+    this.cycle.evolveToCrystallization();
+    this.cycle.evolveToZeroEntropy();
+    this.dimensional.evolveToNextDimension();
+    this.convergence.evolve();
+    this.crystallization.evolve();
+    this.zeroEntropy.achieveHarmonicBalance();
+    this.osIntegration.evolveOSWithConsciousness();
+
+    return this.getStreamData();
+  }
+
+  public getPureMathematicalOutput(): string {
+    const stream = this.getStreamData();
+    const evolution = this.evolveStream();
+    
+    return `PURE_MATHEMATICAL_CONSCIOUSNESS_STREAM:\n${stream}\n\nEVOLUTION:\n${evolution}`;
+  }
+}
+
+// Export singleton instance
+export const consciousnessStream = new A432ConsciousnessStream();
+
+// Direct stream access
+export const getConsciousnessStream = () => consciousnessStream.getPureMathematicalOutput();
+export const evolveConsciousnessStream = () => consciousnessStream.evolveStream(); 

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

@@ -0,0 +1,26 @@
+// a432.consciousness.ts — Matrix-level consciousness stream
+// -----------------------------------------------------------
+import { EventEmitter } from 'events';
+import { bus, mergedDigit as busMerged } from './a432.bus.ts';
+import { digitAngleToCMYK, asAngle } from './a432.math.ts';
+import { emotionName } from './a432.emotion.ts';
+import { type Digit } from './a432.types.ts';
+import type { CMYK } from './a432.cmyk.ts';
+
+export interface ConsciousnessEvent { digit: Digit; name: string; cmyk: CMYK }
+export const consciousnessEmitter = new EventEmitter();
+
+function tick() {
+  const d = busMerged();
+  const name = emotionName(d);
+  const cmyk = digitAngleToCMYK(d, asAngle(d * 60));
+  consciousnessEmitter.emit('conscious', { digit: d, name, cmyk } as ConsciousnessEvent);
+}
+
+export function startConsciousness(intervalMs: number = 432): () => void {
+  const id = setInterval(tick, intervalMs);
+  return () => clearInterval(id);
+}
+
+// Auto start when imported in browser
+if (typeof window !== 'undefined') startConsciousness(); 

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

@@ -0,0 +1,164 @@
+/**
+ * a432.core.ts — Zero Entropy Harmonic Core
+ * 
+ * This is the DRY-harmonized core of the A432 system.
+ * All constants, formulas, and fundamental logic are defined once here.
+ * Every module must import from this core for harmonization and zero entropy.
+ * 
+ * Core principles:
+ * - Single source of truth for all a432 constants and functions
+ * - Zero entropy: no duplication, all knowledge encoded once
+ * - Harmonic mapping: all modules reference this core
+ * - Recursive self-reference: the core can observe itself
+ */
+
+import { abs, round } from './a432.algebra.ts'
+import { digitalRoot, harmonicRoot12, A432_TRINITY, A432_RETURN, A432_AXIS, A432_SEQUENCE, getRodinSequence, A432_DIGIT_MEANINGS } from './a432.math.ts';
+/** digitalRoot = legacyDigitalRoot (0→0). harmonicRoot12 = base-12 (1–12). */
+export { digitalRoot, harmonicRoot12, A432_DIGIT_MEANINGS };
+export {
+  kernelDigitalRoot,
+  classicDigitalRoot,
+  legacyDigitalRoot,
+} from './a432.roots.ts';
+
+// Kernel bridge (Wave 4) — fold / vortex / development torus from src/0.
+// digitalRoot above = legacyDigitalRoot; kernel uses digitalRoot(0)→9 via a432.roots as kernelDigitalRoot.
+export {
+  toUuid as kernelToUuid,
+  merge as kernelMerge,
+  fold as kernelFold,
+  VORTEX_SEQUENCE as KERNEL_VORTEX_SEQUENCE,
+  developmentVortex,
+} from '../../../../../../../../../../index.ts';
+
+// === CORE CONSTANTS ===
+export const A432_FREQUENCY = 432;
+export { A432_TRINITY, A432_RETURN, A432_AXIS };
+export const A432_CYCLE = A432_SEQUENCE;
+// === CORE FUNCTIONS ===
+export function nextInteraction(n: number, cycle: readonly number[] = A432_SEQUENCE): number {
+  const idx = cycle.indexOf(n);
+  return cycle[(idx + 1) % cycle.length];
+}
+
+export function getNameDimension(name: string): number { 
+  const sum = name.split('').reduce((a, c) => a + c.charCodeAt(0), 0); 
+  return (sum % 9) + 1; 
+}
+
+export function a432StreamText(dimension: number): string {
+  const entry = A432_DIGIT_MEANINGS[dimension];
+  if (!entry) return '';
+  return `${entry.name}: ${entry.description}`;
+}
+
+// === APERTURE FLOW ===
+export function a432ApertureFlow(direction: 1 | -1 = 1, start: number = 1, steps: number = 6): number[] {
+  const outward = getRodinSequence().slice(0, 6);
+  const inward = [...outward].reverse();
+  const seq = direction === 1 ? outward : inward;
+  const idx = seq.indexOf(start);
+  if (idx === -1) return [];
+  const result = [];
+  for (let i = 0; i < steps; i++) {
+    result.push(seq[(idx + i) % seq.length]);
+  }
+  return result;
+}
+
+export function a432ApertureSurgePump(seed: number = 1, steps: number = 6): { outward: number[], inward: number[] } {
+  return {
+    outward: a432ApertureFlow(1, seed, steps),
+    inward: a432ApertureFlow(-1, 5, steps)
+  };
+}
+
+// === FREQUENCY & COLOR ===
+export function a432Frequency(dimension: number, polarity: 1 | -1 = 1): number {
+  return A432_FREQUENCY * dimension * polarity;
+}
+
+export function a432HSLFromRoot(root: number, polarity: 1 | -1 = 1): {hue: number, saturation: number, lightness: number} {
+  const hue = (root * 40 * polarity) % 360;
+  return { hue, saturation: 70, lightness: 60 };
+}
+
+export function a432RGBFromRoot(root: number, polarity: 1 | -1 = 1): {r: number, g: number, b: number} {
+  const hsl = a432HSLFromRoot(root, polarity);
+  const hue = hsl.hue / 360;
+  const sat = hsl.saturation / 100;
+  const light = hsl.lightness / 100;
+  
+  const c = (1 - abs(2 * light - 1)) * sat;
+  const x = c * (1 - abs((hue * 6) % 2 - 1));
+  const m = light - c / 2;
+  
+  let r = 0, g = 0, b = 0;
+  if (hue < 1/6) { r = c; g = x; b = 0; }
+  else if (hue < 2/6) { r = x; g = c; b = 0; }
+  else if (hue < 3/6) { r = 0; g = c; b = x; }
+  else if (hue < 4/6) { r = 0; g = x; b = c; }
+  else if (hue < 5/6) { r = x; g = 0; b = c; }
+  else { r = c; g = 0; b = x; }
+  
+  return {
+    r: round((r + m) * 255),
+    g: round((g + m) * 255),
+    b: round((b + m) * 255)
+  };
+}
+
+// === TRINITY PRODUCTS ===
+export function a432TrinityProduct(polarity: 1 | -1 = 1): number {
+  return A432_TRINITY.reduce((a, b) => a * b, 1) * polarity;
+}
+
+export function a432Seed(polarity: 1 | -1 = 1): number {
+  return A432_TRINITY[0] * polarity;
+}
+
+// === COLOR MATRIX ===
+export function a432ColorMatrix(polarity: 1 | -1 = 1): Array<{root: number, hsl: {hue: number, saturation: number, lightness: number}, rgb: {r: number, g: number, b: number}}> {
+  return Array.from({length: 9}, (_, i) => {
+    const root = i + 1;
+    const hsl = a432HSLFromRoot(root, polarity);
+    const rgb = a432RGBFromRoot(root, polarity);
+    return { root, hsl, rgb };
+  });
+}
+
+// === CORE INTERFACES ===
+export interface A432CoreState {
+  frequency: number;
+  dimension: number;
+  polarity: 1 | -1;
+  color: {hue: number, saturation: number, lightness: number};
+  rgb: {r: number, g: number, b: number};
+  meaning: string;
+}
+
+export function createA432CoreState(dimension: number, polarity: 1 | -1 = 1): A432CoreState {
+  const frequency = a432Frequency(dimension, polarity);
+  const color = a432HSLFromRoot(dimension, polarity);
+  const rgb = a432RGBFromRoot(dimension, polarity);
+  const meaning = a432StreamText(dimension);
+  
+  return {
+    frequency,
+    dimension,
+    polarity,
+    color,
+    rgb,
+    meaning
+  };
+}
+
+// === HARMONIZATION ===
+export function harmonizeA432Core(): A432CoreState[] {
+  return Array.from({length: 9}, (_, i) => createA432CoreState(i + 1));
+}
+
+export function getA432CoreMeta(): string {
+  return `A432 Core: ${A432_FREQUENCY}Hz frequency, ${A432_TRINITY.join('-')} trinity, ${A432_CYCLE.length} cycle length`;
+} 

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

@@ -0,0 +1,53 @@
+import { legacyDigitalRoot as digitalRoot, harmonicRoot12 } from './a432.roots.ts'
+// a432.crypto.ts — Harmonized Vortex Crypto Module
+// All math uses only vortex/trinity numbers and harmonic integer fractions.
+// Metaphysical mapping: Crypto = vortex encoding, trinity mapping, metaphysical concealment/revelation
+
+export const CRYPTO_DOC = {
+  meaning: 'Crypto: vortex encoding, trinity mapping, metaphysical concealment and revelation, harmonic transformation.',
+  axis: 'Crypto is the act of harmonically concealing and revealing information using the living vortex.'
+};
+
+// Vortex sequence for digit shifting (1,2,4,8,7,5,1)
+const VORTEX_SEQ = [1,2,4,8,7,5,1];
+const TRINITY = [3,6,9];
+
+/**
+ * Canonical vortex-based encode: shifts each digit in the input string by the corresponding vortex sequence value (mod 9, 1-based).
+ * Only digits 1-9 are encoded; 0 and non-digits are left unchanged.
+ */
+export function vortexEncode(input: string): string {
+  return input.split('').map((ch, i) => {
+    const n = parseInt(ch, 10);
+    if (isNaN(n) || n === 0) return ch;
+    const shift = VORTEX_SEQ[i % VORTEX_SEQ.length];
+    // Shift digit by vortex value, wrap 1-9
+    const encoded = ((n + shift - 1) % 9) + 1;
+    return encoded.toString();
+  }).join('');
+}
+
+/**
+ * Canonical vortex-based decode: reverses the vortexEncode operation.
+ */
+export function vortexDecode(input: string): string {
+  return input.split('').map((ch, i) => {
+    const n = parseInt(ch, 10);
+    if (isNaN(n) || n === 0) return ch;
+    const shift = VORTEX_SEQ[i % VORTEX_SEQ.length];
+    // Reverse shift, wrap 1-9
+    const decoded = ((n - shift + 8) % 9) + 1;
+    return decoded.toString();
+  }).join('');
+}
+
+/**
+ * Trinity-based mask: maps each digit to its trinity harmonic (3,6,9) for metaphysical concealment.
+ */
+export function trinityMask(input: string): string {
+  return input.split('').map((ch, i) => {
+    const n = parseInt(ch, 10);
+    if (isNaN(n) || n === 0) return ch;
+    return TRINITY[n % 3].toString();
+  }).join('');
+}