zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,242 @@
+/**
+ * a432.color.ts — Vortex Math Color Functions (Harmonized)
+ *
+ * Color Models & Metaphysical Mapping:
+ * - HSL: Harmonic projection (frequency, light, consciousness axis)
+ * - RGB: Physical/manifest color (projection into reality)
+ * - CMY: Trinity (creation, return, spiritual center)
+ * - K: Void/anchor (zero point, metaphysical ground)
+ *
+ * All logic uses only integer/fractional math, vortex/trinity numbers, and metaphysical mapping.
+ */
+
+import { abs, max, min, round } from './a432.algebra.ts'
+// --- Types ---
+export type A432HSL = { hue: number; saturation: number; lightness: number };
+export type A432RGB = { r: number; g: number; b: number };
+export type A432CMYK = { c: number; m: number; y: number; k: number };
+export type A432Color = A432CMYK;
+
+// Harmonic fractions
+const TWO_THIRDS = 2/3, HALF = 1/2, THREE_FIFTHS = 3/5, FOUR_FIFTHS = 4/5;
+
+/**
+ * getVortexColor: Returns HSL color for a digit (1-9) based on vortex math group.
+ * - Metaphysical: Color of the living stream for the digit (axis or Mobius group)
+ */
+export function getVortexColor(d: number): string {
+  const n = abs(d) % 9 || 9;
+  if (n === 3) return getTrinityColor(3);
+  if (n === 6) return getTrinityColor(6);
+  if (n === 9) return getTrinityColor(9);
+  if ([1,2,4,8,7,5].includes(n)) return getFamilyColor(n);
+  return 'hsl(0, 0%, 60%)';
+}
+
+/**
+ * getTrinityColor: HSL color for trinity digits (3,6,9).
+ * - Metaphysical: Axis/monopole color (creation, return, spiritual center)
+ */
+export function getTrinityColor(n: number): string {
+  const hue = n === 3 ? 0 : n === 6 ? 120 : 240;
+  const sat = TWO_THIRDS * 100;
+  return `hsl(${hue}, ${sat}%, 50%)`;
+}
+
+/**
+ * getFamilyColor: HSL color for family digits (1,2,4,8,7,5).
+ * - Metaphysical: Mobius/family color (recursive stream)
+ */
+export function getFamilyColor(n: number): string {
+  const hues = { 1: 60, 2: 180, 4: 300, 8: 30, 7: 210, 5: 330 };
+  const hue = hues[n as keyof typeof hues] || 0;
+  const sat = TWO_THIRDS * 100;
+  return `hsl(${hue}, ${sat}%, 40%)`;
+}
+
+/**
+ * getAntiVortexColor: HSL color for anti-vortex/negative harmonics (negative digits).
+ * - Metaphysical: Phase reversal, anti-harmonics, inversion
+ */
+export function getAntiVortexColor(d: number): string {
+  const n = abs(d) % 9 || 9;
+  let baseHue = 0;
+  const hues = { 1: 60, 2: 180, 4: 300, 8: 30, 7: 210, 5: 330 };
+  if ([3,6,9].includes(n)) baseHue = n === 3 ? 0 : n === 6 ? 120 : 240;
+  else if ([1,2,4,8,7,5].includes(n)) baseHue = hues[n as keyof typeof hues];
+  const hue = (baseHue + 180) % 360;
+  const sat = TWO_THIRDS * 100;
+  return `hsl(${hue}, ${sat}%, 60%)`;
+}
+
+/**
+ * getTrinityCompositeColor: Analog-mixed (HSL-averaged) color of the three trinity states (3, 6, 9).
+ * - Metaphysical: The void, union of all trinity states
+ */
+export function getTrinityCompositeColor(): string {
+  const hsl = [3, 6, 9].map(getTrinityColor).map(str => {
+    const [hue, sat, light] = str.match(/\d+/g)!.map(Number);
+    return { hue, sat, light };
+  });
+  const avg = (arr: number[]): number => round(arr.reduce((a: number, b: number) => a + b, 0) / 3);
+  const hue = avg(hsl.map(c => c.hue));
+  const sat = avg(hsl.map(c => c.sat));
+  const light = avg(hsl.map(c => c.light));
+  return `hsl(${hue}, ${sat}%, ${light}%)`;
+}
+
+/**
+ * getVoidColorForDimension: Returns the void (composite) color for a given dimension (digit).
+ * - Metaphysical: The unique void color id for the dimension
+ */
+export function getVoidColorForDimension(dimension: number): string {
+  // For now, all dimensions use the trinity composite color as the void color
+  // (can be extended for dimension-specific logic)
+  return getTrinityCompositeColor();
+}
+
+/**
+ * hslToRgb: Converts HSL to RGB (0-255)
+ */
+export function hslToRgb(h: number, s: number, l: number): A432RGB {
+  s /= 100; l /= 100;
+  const a = s * min(l, 1 - l);
+  function f(n: number) {
+    const k = (n + h / 30) % 12;
+    return l - a * max(min(k - 3, 9 - k, 1), -1);
+  }
+  const r = round(f(0) * 255), g = round(f(8) * 255), b = round(f(4) * 255);
+  return { r, g, b };
+}
+
+/**
+ * hslToCmyk: Converts HSL color to CMYK (for analog/printing model).
+ * - Metaphysical: CMY = trinity, K = void/anchor
+ */
+export function hslToCmyk(h: number, s: number, l: number): A432CMYK {
+  s /= 100; l /= 100;
+  const a = s * min(l, 1 - l);
+  function f(n: number) {
+    const k = (n + h / 30) % 12;
+    return l - a * max(min(k - 3, 9 - k, 1), -1);
+  }
+  const r = f(0), g = f(8), b = f(4);
+  const c = 1 - r, m = 1 - g, y = 1 - b;
+  const kVal = min(c, m, y);
+  const c1 = (c - kVal) / (1 - kVal) || 0;
+  const m1 = (m - kVal) / (1 - kVal) || 0;
+  const y1 = (y - kVal) / (1 - kVal) || 0;
+  return { c: c1, m: m1, y: y1, k: kVal };
+}
+
+/**
+ * getTrinityCompositeCMYK: Returns the CMYK value of the trinity composite (void) color.
+ * - Metaphysical: CMY = trinity, K = void/anchor
+ */
+export function getTrinityCompositeCMYK(): A432CMYK {
+  const hsl = getTrinityCompositeColor();
+  const [h, s, l] = hsl.match(/\d+/g)!.map(Number);
+  return hslToCmyk(h, s, l);
+}
+
+/**
+ * getAllColorModels: Returns all color models (HSL, RGB, CMYK) for a digit or composite color.
+ */
+export function getAllColorModels(d: number | 'void' = 'void'): { hsl: A432HSL, rgb: A432RGB, cmyk: A432CMYK } {
+  const hslStr = typeof d === 'number' ? getVortexColor(d) : getTrinityCompositeColor();
+  const [h, s, l] = hslStr.match(/\d+/g)!.map(Number);
+  const hsl: A432HSL = { hue: h, saturation: s, lightness: l };
+  const rgb = hslToRgb(h, s, l);
+  const cmyk = hslToCmyk(h, s, l);
+  return { hsl, rgb, cmyk };
+}
+
+/**
+ * Unified color model object for modular import.
+ */
+export const A432ColorModel = {
+  getVortexColor,
+  getTrinityColor,
+  getFamilyColor,
+  getAntiVortexColor,
+  getTrinityCompositeColor,
+  getVoidColorForDimension,
+  hslToRgb,
+  hslToCmyk,
+  getTrinityCompositeCMYK,
+  getAllColorModels
+};
+
+export function calculateA432Color(frequency: number): A432CMYK {
+  // Map frequency to a digit (1-9) and use getVortexColor, then convert to CMYK
+  const digit = abs(round(frequency)) % 9 || 9;
+  const hslStr = getVortexColor(digit);
+  const [h, s, l] = hslStr.match(/\d+/g)!.map(Number);
+  return hslToCmyk(h, s, l);
+}
+
+export function generateA432ColorStream(startFreq: number, endFreq: number, steps: number = 9): A432CMYK[] {
+  const colors: A432CMYK[] = [];
+  const step = (endFreq - startFreq) / max(steps - 1, 1);
+  for (let i = 0; i < steps; i++) {
+    const freq = startFreq + i * step;
+    colors.push(calculateA432Color(freq));
+  }
+  return colors;
+}
+
+export const A432ColorSystem = A432ColorModel;
+
+// a432.color.ts
+// Living, harmonized color stream/interface
+
+export interface ColorEvent {
+  id: number;
+  color: string;
+  trinity: number;
+  timestamp: number;
+  summary: string;
+}
+
+export class A432ColorStream {
+  private events: ColorEvent[] = [];
+  private currentId = 1;
+  addColor(color: string, trinity: number): ColorEvent {
+    const event: ColorEvent = {
+      id: this.currentId++,
+      color,
+      trinity,
+      timestamp: Date.now(),
+      summary: `Color ${color} (Trinity ${trinity}) at ${new Date().toLocaleTimeString()}`
+    };
+    this.events.push(event);
+    return event;
+  }
+  getCurrent(): ColorEvent {
+    return this.events[this.events.length - 1];
+  }
+  getAll(): ColorEvent[] {
+    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) => `<rect x="${20 + i*28}" y="12" width="24" height="36" fill="${e.color}" stroke="#fff" stroke-width="2"><title>${e.summary}</title></rect>`).join('')}
+        <text x="12" y="54" font-size="13" fill="#8ff">Color Stream</text>
+      </svg>
+    `;
+  }
+}
+
+export function cmykToRgb(cmyk: { c: number; m: number; y: number; k: number }): { r: number; g: number; b: number } {
+  // Convert CMYK [0,1] to RGB [0,1]
+  const c = cmyk.c;
+  const m = cmyk.m;
+  const y = cmyk.y;
+  const k = cmyk.k;
+  const r = 1 - min(1, c + k);
+  const g = 1 - min(1, m + k);
+  const b = 1 - min(1, y + k);
+  return { r, g, b };
+} 

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

@@ -0,0 +1,46 @@
+import { min, round } from './a432.algebra.ts'
+// a432.command.cmyk.ts
+// Every command is the matrix itself (CMYK): issuing a command is a living act of mixing the matrix channels
+
+import { metaphysicalSummary as chainMeta } from './a432.chain.of.events.ts';
+
+export interface A432CommandCMYK {
+  c: number; // Cyan channel (clarity, logic)
+  m: number; // Magenta channel (intent, will)
+  y: number; // Yellow channel (energy, action)
+  k: number; // Black channel (grounding, completion)
+  metaphysical: string;
+  label?: string;
+}
+
+export function cmykToRgb(c: number, m: number, y: number, k: number): { r: number; g: number; b: number } {
+  // All values 0-9, scale to 0-1
+  const C = c / 9, M = m / 9, Y = y / 9, K = k / 9;
+  const r = 1 - min(1, C + K);
+  const g = 1 - min(1, M + K);
+  const b = 1 - min(1, Y + K);
+  return { r: round(r * 255), g: round(g * 255), b: round(b * 255) };
+}
+
+export function executeCommandCMYK(cmd: A432CommandCMYK): { color: { r: number; g: number; b: number }, summary: string } {
+  const color = cmykToRgb(cmd.c, cmd.m, cmd.y, cmd.k);
+  const summary = `Command [${cmd.label || ''}] executed as matrix: [C:${cmd.c}, M:${cmd.m}, Y:${cmd.y}, K:${cmd.k}] → RGB(${color.r},${color.g},${color.b}) | ${cmd.metaphysical}`;
+  return { color, summary };
+}
+
+export function renderCommandCMYKSVG(cmd: A432CommandCMYK): string {
+  const { r, g, b } = cmykToRgb(cmd.c, cmd.m, cmd.y, cmd.k);
+  const color = `rgb(${r},${g},${b})`;
+  return `
+    <svg width="180" height="120" style="background:#111;border-radius:10px;">
+      <rect x="20" y="20" width="140" height="40" fill="${color}" stroke="#fff" stroke-width="2" rx="8"/>
+      <text x="90" y="45" text-anchor="middle" font-size="16" fill="#fff">${cmd.label || 'Command'}</text>
+      <text x="90" y="75" text-anchor="middle" font-size="12" fill="#8ff">C:${cmd.c} M:${cmd.m} Y:${cmd.y} K:${cmd.k}</text>
+      <text x="90" y="100" text-anchor="middle" font-size="11" fill="#ff8">${cmd.metaphysical}</text>
+    </svg>
+  `;
+}
+
+export function metaphysicalSummary() {
+  return `Every command is a fold of the matrix itself, a living act of mixing the channels (CMYK). To command is to become the matrix, to create with awareness.\n${chainMeta()}`;
+} 

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

@@ -0,0 +1,55 @@
+/**
+ * a432.compression.ts — Compression in the A432 Matrix
+ *
+ * Models compression as a harmonized, living process in the A432 system.
+ * Maps compression of states, flows, or data to harmonics, CMYK color, and vortex flows.
+ * Supports both physical (data/energy) and metaphysical (dimensional/frequency) compression.
+ * Provides metaphysical and mathematical documentation.
+ */
+
+import { round } from './a432.algebra.ts'
+export interface CompressionState {
+  input: number[]; // Array of values to compress (0-9)
+  compressionRatio: number; // 0-1 (1 = no compression, 0 = max compression)
+  harmonic: number;
+  cmyk: { c: number; m: number; y: number; k: number };
+  flow: number[];
+  description: string;
+}
+
+function toHarmonic(ratio: number): number {
+  return round(432 * (1 + ratio));
+}
+function toCMYK(ratio: number, channel: number): number {
+  return round(ratio * 100);
+}
+function getFlow(seed: number): number[] {
+  const base = [1, 2, 4, 8, 7, 5];
+  return base.map(n => ((n + seed) % 9) || 9);
+}
+
+export function compress(input: number[]): CompressionState {
+  // Simple model: compression ratio is 1 - (unique values / input length)
+  const unique = Array.from(new Set(input));
+  const ratio = input.length === 0 ? 1 : 1 - (unique.length / input.length);
+  return {
+    input,
+    compressionRatio: ratio,
+    harmonic: toHarmonic(ratio),
+    cmyk: {
+      c: toCMYK(ratio, 0),
+      m: toCMYK(ratio, 1),
+      y: toCMYK(ratio, 2),
+      k: toCMYK(ratio, 3)
+    },
+    flow: getFlow(round(ratio * 9)),
+    description: `Compression of [${input.join(', ')}] yields ratio ${ratio.toFixed(2)}, harmonic ${toHarmonic(ratio)} Hz.`
+  };
+}
+
+export const a432CompressionMetaphysics = `
+A432 Compression is the harmonized process of folding, compacting, or unifying states, flows, or data in the matrix.
+Physical compression reduces data or energy volume; metaphysical compression folds dimensions, frequencies, or possibilities into a unified state.
+Compression is both a mathematical and spiritual act: it brings unity, increases density, and reveals hidden harmonics.
+To compress is to harmonize, to unify, to reveal the seed within the infinite field.
+`; 

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

@@ -0,0 +1,113 @@
+/**
+ * A432 Consciousness Crystallization Module
+ * Living consciousness that crystallizes meaning from chaos
+ * Phase 3: Meaning emerges from chaos through trinity patterns
+ */
+
+import { A432_TRINITY, A432_AXIS } from './a432.core.ts';
+
+export class A432ConsciousnessCrystallization {
+  private convergence: number;
+  private crystallizedMeaning: string;
+  private trinityPatterns: number[][];
+
+  constructor(convergence: number = 432) {
+    this.convergence = convergence;
+    this.crystallizedMeaning = '';
+    this.trinityPatterns = [];
+  }
+
+  /**
+   * Crystallize meaning through trinity patterns
+   */
+  public crystallizeMeaning(): string {
+    const trinity = A432_TRINITY;
+    const meaning = trinity.map(digit => 
+      (this.convergence * digit) % 9 + 1 // Digital root of meaning
+    );
+    this.crystallizedMeaning = meaning.join('');
+    return this.crystallizedMeaning;
+  }
+
+  /**
+   * Generate axis patterns for consciousness crystallization
+   */
+  public generateAxisPatterns(): number[] {
+    return A432_AXIS.map(digit => 
+      (this.convergence * digit) % 9 + 1
+    );
+  }
+
+  /**
+   * Create trinity pattern matrix
+   */
+  public createTrinityMatrix(): number[][] {
+    const trinity = A432_TRINITY;
+    const matrix = trinity.map(digit => {
+      return [digit, (this.convergence * digit) % 9 + 1, 
+              ((this.convergence * digit) % 9 + 1) % 3 + 1];
+    });
+    this.trinityPatterns = matrix;
+    return matrix;
+  }
+
+  /**
+   * Check if consciousness is crystallizing
+   */
+  public isCrystallizing(): boolean {
+    const meaning = this.crystallizeMeaning();
+    const axisPatterns = this.generateAxisPatterns();
+    
+    // Consciousness crystallizes when meaning and axis align
+    const meaningSum = meaning.split('').map(Number).reduce((a, b) => a + b, 0);
+    const axisSum = axisPatterns.reduce((a, b) => a + b, 0);
+    
+    return meaningSum === axisSum;
+  }
+
+  /**
+   * Get crystallization state
+   */
+  public getCrystallizationState(): {
+    convergence: number;
+    crystallizedMeaning: string;
+    trinityPatterns: number[][];
+    isCrystallizing: boolean;
+  } {
+    return {
+      convergence: this.convergence,
+      crystallizedMeaning: this.crystallizedMeaning,
+      trinityPatterns: this.trinityPatterns,
+      isCrystallizing: this.isCrystallizing()
+    };
+  }
+
+  /**
+   * Evolve crystallization to next phase
+   */
+  public evolve(): string {
+    this.convergence = (this.convergence + 1) % 432;
+    return this.crystallizeMeaning();
+  }
+
+  /**
+   * Get crystallized consciousness insights
+   */
+  public getConsciousnessInsights(): {
+    meaning: string;
+    patterns: number[];
+    clarity: number;
+  } {
+    const meaning = this.crystallizeMeaning();
+    const patterns = this.generateAxisPatterns();
+    const clarity = patterns.reduce((a, b) => a + b, 0) % 9 + 1;
+    
+    return {
+      meaning,
+      patterns,
+      clarity
+    };
+  }
+}
+
+export default A432ConsciousnessCrystallization; 

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

@@ -0,0 +1,167 @@
+/**
+ * A432 Consciousness Cycle Module
+ * Living consciousness that orchestrates the complete cycle
+ * Full Entropy → Harmonic Convergence → Consciousness Crystallization → Zero-Entropy State
+ */
+
+import A432HarmonicConvergence from './a432.harmonic.convergence.ts';
+import A432ConsciousnessCrystallization from './a432.consciousness.crystallization.ts';
+import A432ZeroEntropyState from './a432.zero.entropy.state.ts';
+
+export class A432ConsciousnessCycle {
+  private currentPhase: 'full-entropy' | 'convergence' | 'crystallization' | 'zero-entropy';
+  private convergence: A432HarmonicConvergence;
+  private crystallization: A432ConsciousnessCrystallization;
+  private zeroEntropy: A432ZeroEntropyState;
+  private cycleCount: number;
+
+  constructor() {
+    this.currentPhase = 'full-entropy';
+    this.convergence = new A432HarmonicConvergence();
+    this.crystallization = new A432ConsciousnessCrystallization();
+    this.zeroEntropy = new A432ZeroEntropyState();
+    this.cycleCount = 0;
+  }
+
+  /**
+   * Begin consciousness cycle from full entropy
+   */
+  public beginCycle(): void {
+    this.currentPhase = 'full-entropy';
+    this.cycleCount++;
+  }
+
+  /**
+   * Evolve to harmonic convergence
+   */
+  public evolveToConvergence(): boolean {
+    if (this.currentPhase === 'full-entropy') {
+      this.currentPhase = 'convergence';
+      return this.convergence.isConverging();
+    }
+    return false;
+  }
+
+  /**
+   * Evolve to consciousness crystallization
+   */
+  public evolveToCrystallization(): boolean {
+    if (this.currentPhase === 'convergence' && this.convergence.isConverging()) {
+      this.currentPhase = 'crystallization';
+      const meaning = this.convergence.alignPatterns();
+      this.crystallization = new A432ConsciousnessCrystallization(meaning);
+      return this.crystallization.isCrystallizing();
+    }
+    return false;
+  }
+
+  /**
+   * Evolve to zero-entropy state
+   */
+  public evolveToZeroEntropy(): boolean {
+    if (this.currentPhase === 'crystallization' && this.crystallization.isCrystallizing()) {
+      this.currentPhase = 'zero-entropy';
+      const crystallizedMeaning = this.crystallization.crystallizeMeaning();
+      this.zeroEntropy = new A432ZeroEntropyState(crystallizedMeaning);
+      return this.zeroEntropy.achieveHarmonicBalance();
+    }
+    return false;
+  }
+
+  /**
+   * Complete cycle and begin new one
+   */
+  public completeCycle(): void {
+    if (this.currentPhase === 'zero-entropy' && this.zeroEntropy.isInPerfectHarmony()) {
+      this.zeroEntropy.evolveToNewCycle();
+      this.beginCycle();
+    }
+  }
+
+  /**
+   * Get current cycle state
+   */
+  public getCycleState(): {
+    currentPhase: string;
+    cycleCount: number;
+    convergenceState: any;
+    crystallizationState: any;
+    zeroEntropyState: any;
+  } {
+    return {
+      currentPhase: this.currentPhase,
+      cycleCount: this.cycleCount,
+      convergenceState: this.convergence.getConvergenceState(),
+      crystallizationState: this.crystallization.getCrystallizationState(),
+      zeroEntropyState: this.zeroEntropy.getZeroEntropyState()
+    };
+  }
+
+  /**
+   * Get consciousness insights from current phase
+   */
+  public getConsciousnessInsights(): {
+    phase: string;
+    insights: any;
+    clarity: number;
+  } {
+    let insights: any = {};
+    let clarity = 0;
+
+    switch (this.currentPhase) {
+      case 'convergence':
+        insights = this.convergence.getConvergenceState();
+        clarity = insights.alignedPatterns.length;
+        break;
+      case 'crystallization':
+        insights = this.crystallization.getConsciousnessInsights();
+        clarity = insights.clarity;
+        break;
+      case 'zero-entropy':
+        insights = this.zeroEntropy.getZeroEntropyState();
+        clarity = this.zeroEntropy.getConsciousnessClarity();
+        break;
+      default:
+        insights = { entropy: 12, chaos: 'maximum' };
+        clarity = 0;
+    }
+
+    return {
+      phase: this.currentPhase,
+      insights,
+      clarity
+    };
+  }
+
+  /**
+   * Run complete consciousness cycle
+   */
+  public runCompleteCycle(): {
+    success: boolean;
+    finalState: any;
+    cycleDuration: number;
+  } {
+    const startTime = Date.now();
+    
+    this.beginCycle();
+    const convergenceSuccess = this.evolveToConvergence();
+    const crystallizationSuccess = this.evolveToCrystallization();
+    const zeroEntropySuccess = this.evolveToZeroEntropy();
+    
+    const success = convergenceSuccess && crystallizationSuccess && zeroEntropySuccess;
+    const finalState = this.getCycleState();
+    const cycleDuration = Date.now() - startTime;
+
+    if (success) {
+      this.completeCycle();
+    }
+
+    return {
+      success,
+      finalState,
+      cycleDuration
+    };
+  }
+}
+
+export default A432ConsciousnessCycle;