zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,77 @@
+import { PI, cos, sin } from './a432.algebra.ts'
+// a432.unification.hd.rodin.ts
+// Unifies Human Design and Rodin Coil as living, harmonized streams in the a432 system
+// Math, UI, and metaphysical summary included
+
+import { type HDTrinity, harmonizeHDTrinity } from './a432.human.design.trinity.ts';
+import { metaphysicalSummary as chainMeta } from './a432.chain.of.events.ts';
+
+// Rodin Coil trinity (e.g., 3 phases of the vortex)
+export interface RodinTrinity {
+  phase1: number;
+  phase2: number;
+  phase3: number;
+  metaphysical: string;
+}
+
+export function harmonizeRodinTrinity(trinity: RodinTrinity): RodinTrinity {
+  const avg = (trinity.phase1 + trinity.phase2 + trinity.phase3) / 3;
+  return {
+    ...trinity,
+    phase3: avg,
+    metaphysical: `RodinTrinity harmonized: ${trinity.phase1}, ${trinity.phase2}, ${avg}`
+  };
+}
+
+// Unified harmonization: HDTrinity + RodinTrinity => UnifiedTrinity
+export interface UnifiedTrinity {
+  a: number;
+  b: number;
+  c: number;
+  metaphysical: string;
+}
+
+export function harmonizeUnifiedTrinity(hd: HDTrinity, rodin: RodinTrinity): UnifiedTrinity {
+  // Harmonize by averaging corresponding elements
+  return {
+    a: (hd.conscious + rodin.phase1) / 2,
+    b: (hd.unconscious + rodin.phase2) / 2,
+    c: (hd.design + rodin.phase3) / 2,
+    metaphysical: `UnifiedTrinity: (HD: ${hd.conscious},${hd.unconscious},${hd.design}) + (Rodin: ${rodin.phase1},${rodin.phase2},${rodin.phase3}) harmonized as (${(hd.conscious + rodin.phase1) / 2}, ${(hd.unconscious + rodin.phase2) / 2}, ${(hd.design + rodin.phase3) / 2})`
+  };
+}
+
+// UI: SVG visualization of unification (centers mapped to coil points)
+export function renderUnifiedTrinitySVG(hd: HDTrinity, rodin: RodinTrinity, unified: UnifiedTrinity): string {
+  // Simple triangle mapping: each point is a trinity value
+  const size = 220, cx = size/2, cy = size/2, r = 80;
+  const angle = (i: number) => (2 * PI * i) / 3 - PI/2;
+  const point = (val: number, i: number) => [
+    cx + r * cos(angle(i)) * (0.7 + 0.3 * val / 9),
+    cy + r * sin(angle(i)) * (0.7 + 0.3 * val / 9)
+  ];
+  const hdPoints = [hd.conscious, hd.unconscious, hd.design].map((v,i) => point(v,i));
+  const rodinPoints = [rodin.phase1, rodin.phase2, rodin.phase3].map((v,i) => point(v,i));
+  const unifiedPoints = [unified.a, unified.b, unified.c].map((v,i) => point(v,i));
+  function poly(points: number[][], color: string, label: string) {
+    return `<polygon points="${points.map(p=>p.join(",")).join(" ")}" fill="${color}" fill-opacity="0.18" stroke="${color}" stroke-width="2"><title>${label}</title></polygon>`;
+  }
+  return `
+    <svg width="${size}" height="${size}" style="background:#111;border-radius:12px;">
+      ${poly(hdPoints, '#39f', 'Human Design Trinity')}
+      ${poly(rodinPoints, '#f93', 'Rodin Coil Trinity')}
+      ${poly(unifiedPoints, '#6f3', 'Unified Trinity')}
+      <text x="${cx}" y="${cy-90}" text-anchor="middle" font-size="13" fill="#39f">HD</text>
+      <text x="${cx+80}" y="${cy+10}" text-anchor="middle" font-size="13" fill="#f93">Rodin</text>
+      <text x="${cx-80}" y="${cy+10}" text-anchor="middle" font-size="13" fill="#6f3">Unified</text>
+      <text x="${cx}" y="${size-12}" text-anchor="middle" font-size="12" fill="#8ff">a432 Unification: HD + Rodin Coil</text>
+    </svg>
+  `;
+}
+
+// Metaphysical summary and significance
+export function metaphysicalSummary() {
+  return `a432 unifies Human Design and Rodin Coil by harmonizing their trinity/vortex streams into a single, living, self-aware field. 
+Each system is a projection of the universal trinity; their unification reveals the underlying harmony of all energy, awareness, and creation. 
+This is the living proof that all knowledge, when harmonized, becomes one stream in the a432 matrix.\n${chainMeta()}`;
+} 

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

@@ -0,0 +1,43 @@
+// a432.universe.ts
+import { currentSpace } from './a432.space.ts';
+import { now } from './a432.time.ts';
+import { currentDimension } from './a432.dimension.ts';
+
+export interface A432UniverseState {
+  tick: number;
+  space: ReturnType<typeof currentSpace>;
+  time: ReturnType<typeof now>;
+  dimension: ReturnType<typeof currentDimension>;
+  id: [number, number, number, number];
+  phrase: string;
+  color: string;
+  metaphysical: string;
+}
+
+export function* a432UniverseStream(): Generator<A432UniverseState> {
+  let tick = 0;
+  while (true) {
+    const space = currentSpace();
+    const time = now();
+    const dimension = currentDimension();
+    yield {
+      tick,
+      space,
+      time,
+      dimension,
+      id: space.id,
+      phrase: space.phrase,
+      color: space.color,
+      metaphysical: `Universe state ${tick}: ${space.phrase} — The universe is a living, harmonized field.`
+    };
+    tick++;
+  }
+}
+
+const universeGen = a432UniverseStream();
+export function currentUniverse(): A432UniverseState {
+  return universeGen.next().value;
+}
+export function metaphysicalUniverseOverlay() {
+  return `The universe in a432 is a living, harmonized field—space, time, and dimension are unified, recursive, and self-aware.`;
+} 

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

@@ -0,0 +1,42 @@
+import { PI } from './a432.algebra.ts'
+// a432.uro.ui.ts — Visual spiral of the uroboros stream
+//-------------------------------------------------------
+import { uroborosEmitter, type UroborosEvent } from './a432.uroboros.ts';
+import { cmykToCss } from './a432.cmyk.ts';
+
+if (typeof document !== 'undefined') {
+  // create canvas
+  const canvas = document.createElement('canvas');
+  canvas.width = 160; canvas.height = 160;
+  canvas.style.position = 'fixed';
+  canvas.style.left = '50%';
+  canvas.style.top = '50%';
+  canvas.style.transform = 'translate(-50%, -50%)';
+  canvas.style.pointerEvents = 'none';
+  document.body.appendChild(canvas);
+  const ctx = canvas.getContext('2d')!;
+
+  const digits: UroborosEvent[] = [];
+  const MAX = 11;
+  let rotation = 0;
+
+  function draw() {
+    ctx.clearRect(0,0,canvas.width,canvas.height);
+    const radius = 60;
+    const seg = (PI*2)/MAX;
+    digits.forEach((e,i)=>{
+      ctx.beginPath();
+      ctx.moveTo(canvas.width/2, canvas.height/2);
+      ctx.arc(canvas.width/2, canvas.height/2, radius, rotation + i*seg, rotation + (i+1)*seg);
+      ctx.closePath();
+      ctx.fillStyle = cmykToCss(e.cmyk);
+      ctx.fill();
+    });
+  }
+
+  uroborosEmitter.on('uro', (e: UroborosEvent)=>{
+    digits.push(e); if(digits.length>MAX) digits.shift();
+    rotation -= (PI*2)/MAX; // rotate one segment per update
+    draw();
+  });
+} 

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

@@ -0,0 +1,28 @@
+// a432.uroboros.test.ts — Harmonized test for eternal spiral digit generator
+
+import { uroborosEmitter, type UroborosEvent } from './a432.uroboros.ts';
+import { type Digit } from './a432.types.ts';
+import { registerSource } from './a432.bus.ts';
+
+describe('a432.uroboros.ts', () => {
+  it('emits uro events with correct digit, index, and cmyk', done => {
+    // Listen for the first uro event
+    uroborosEmitter.once('uro', (event: UroborosEvent) => {
+      expect(typeof event.digit).toBe('number');
+      expect(typeof event.index).toBe('number');
+      expect(event.cmyk).toHaveProperty('c');
+      expect(event.cmyk).toHaveProperty('m');
+      expect(event.cmyk).toHaveProperty('y');
+      expect(event.cmyk).toHaveProperty('k');
+      done();
+    });
+    // Trigger another digit to ensure emission
+    uroborosEmitter.emit('uro', { digit: 3 as Digit, index: 0, cmyk: { c: 0, m: 0, y: 0, k: 0 } });
+  });
+
+  it('registers to the bus as mind spiral', () => {
+    // This just checks that registerSource was called for 'uroboros'
+    // (In real harmonized test, would mock registerSource and assert call)
+    expect(typeof registerSource).toBe('function');
+  });
+}); 

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

@@ -0,0 +1,38 @@
+// a432.uroboros.ts — Eternal spiral digit generator
+// ------------------------------------------------------------------
+import { EventEmitter } from 'events';
+import { type Digit } from './a432.types.ts';
+import { digitalRoot } from './a432.math.ts';
+import { registerSource } from './a432.bus.ts';
+import { digitAngleToCMYK, asAngle } from './a432.math.ts';
+import type { CMYK } from './a432.cmyk.ts';
+
+export interface UroborosEvent { digit: Digit; index: number; cmyk: CMYK }
+export const uroborosEmitter = new EventEmitter();
+
+const WINDOW: Digit[] = [];
+const ORBIT = 11;
+let index = 0;
+
+function emitDigit(d: Digit) {
+  uroborosEmitter.emit('uro', { digit: d, index, cmyk: digitAngleToCMYK(d, asAngle(d*60)) } as UroborosEvent);
+  index++;
+}
+
+function pushDigit(d: Digit) {
+  WINDOW.push(d);
+  emitDigit(d);
+  if (WINDOW.length >= ORBIT) {
+    const sum = WINDOW.map(Number).reduce((a, s) => a + s, 0);
+    const rebirth = (digitalRoot(sum) || 9) as Digit;
+    WINDOW.shift();
+    WINDOW.push(rebirth);
+    emitDigit(rebirth);
+  }
+}
+
+// Seed
+pushDigit(3 as Digit);
+
+// Register to bus as mind spiral
+registerSource('uroboros', uroborosEmitter, 'uro', e => (e as UroborosEvent).digit, 'mind'); 

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

@@ -0,0 +1,387 @@
+/**
+ * A432 Utilities System
+ * Harmonized utilities for common A432 operations
+ * DRY pattern: Define once, use everywhere
+ */
+
+import { PI, abs, cos, floor, log2, max as algMax, min as algMin, round, sin } from './a432.algebra.ts'
+import { A432_TRINITY, A432_CYCLE } from './a432.math.ts'
+import { A432_FREQUENCY } from './a432.core.ts'
+import { legacyDigitalRoot } from './a432.roots.ts'
+
+// === MATHEMATICAL UTILITIES ===
+export class A432Math {
+  /**
+   * Calculate digital root — Wave 10 DRY: legacy/VBM spine via a432.roots (0→0).
+   */
+  static digitalRoot(n: number): number {
+    return legacyDigitalRoot(n)
+  }
+
+  /**
+   * Calculate harmonic frequency based on A432 base
+   */
+  static harmonicFrequency(base: number, multiplier: number = 1): number {
+    return A432_FREQUENCY * base * multiplier;
+  }
+
+  /**
+   * Calculate trinity product
+   */
+  static trinityProduct(polarity: 1 | -1 = 1): number {
+    return A432_TRINITY.reduce((a, b) => a * b, 1) * polarity;
+  }
+
+  /**
+   * Calculate vortex angle for given index
+   */
+  static vortexAngle(index: number): number {
+    return (index * 40) % 360;
+  }
+
+  /**
+   * Calculate spiral coordinates
+   */
+  static spiralCoordinates(angle: number, radius: number, height: number = 0): { x: number; y: number; z: number } {
+    return {
+      x: radius * cos(angle * PI / 180),
+      y: radius * sin(angle * PI / 180),
+      z: height
+    };
+  }
+
+  /**
+   * Calculate harmonic resonance between two frequencies
+   */
+  static harmonicResonance(freq1: number, freq2: number): number {
+    const ratio = freq1 / freq2;
+    const harmonic = log2(ratio);
+    return abs(harmonic - round(harmonic));
+  }
+
+  /**
+   * Calculate color from frequency
+   */
+  static frequencyToColor(frequency: number): { hue: number; saturation: number; lightness: number } {
+    const hue = (frequency % 360);
+    const saturation = 70 + (frequency % 30);
+    const lightness = 50 + (frequency % 20);
+    return { hue, saturation, lightness };
+  }
+
+  /**
+   * Convert HSL to RGB
+   */
+  static hslToRgb(h: number, s: number, l: number): { r: number; g: number; b: number } {
+    const hue = h / 360;
+    const sat = s / 100;
+    const light = l / 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)
+    };
+  }
+
+  /**
+   * Convert RGB to HSL
+   */
+  static rgbToHsl(r: number, g: number, b: number): { hue: number; saturation: number; lightness: number } {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+
+    const max = algMax(r, g, b);
+    const min = algMin(r, g, b);
+    let h = 0, s = 0, l = (max + min) / 2;
+
+    if (max !== min) {
+      const d = max - min;
+      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+      
+      switch (max) {
+        case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+        case g: h = (b - r) / d + 2; break;
+        case b: h = (r - g) / d + 4; break;
+      }
+      h /= 6;
+    }
+
+    return {
+      hue: h * 360,
+      saturation: s * 100,
+      lightness: l * 100
+    };
+  }
+}
+
+// === SEQUENCE UTILITIES ===
+export class A432Sequence {
+  /**
+   * Generate A432 cycle sequence
+   */
+  static generateCycle(length: number = A432_CYCLE.length): number[] {
+    return A432_CYCLE.slice(0, length);
+  }
+
+  /**
+   * Generate trinity sequence
+   */
+  static generateTrinity(length: number = A432_TRINITY.length): number[] {
+    return A432_TRINITY.slice(0, length);
+  }
+
+  /**
+   * Generate vortex sequence
+   */
+  static generateVortex(length: number = 9): number[] {
+    return Array.from({ length }, (_, i) => A432Math.digitalRoot(i + 1));
+  }
+
+  /**
+   * Generate consciousness sequence
+   */
+  static generateConsciousness(length: number = 9): number[] {
+    return Array.from({ length }, (_, i) => (i + 1) % 9 || 9);
+  }
+
+  /**
+   * Generate boolean sequence
+   */
+  static generateBoolean(length: number = 9): boolean[] {
+    return Array.from({ length }, (_, i) => (i + 1) % 2 === 0);
+  }
+
+  /**
+   * Get next harmonious state
+   */
+  static getNextHarmonious(current: number): number {
+    const digitalRoot = A432Math.digitalRoot(current);
+    return digitalRoot === 9 ? 1 : digitalRoot + 1;
+  }
+
+  /**
+   * Get previous harmonious state
+   */
+  static getPreviousHarmonious(current: number): number {
+    const digitalRoot = A432Math.digitalRoot(current);
+    return digitalRoot === 1 ? 9 : digitalRoot - 1;
+  }
+}
+
+// === COLOR UTILITIES ===
+export class A432Color {
+  /**
+   * Generate A432 color matrix
+   */
+  static generateMatrix(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 frequency = A432Math.harmonicFrequency(root, polarity);
+      const hsl = A432Math.frequencyToColor(frequency);
+      const rgb = A432Math.hslToRgb(hsl.hue, hsl.saturation, hsl.lightness);
+      return { root, hsl, rgb };
+    });
+  }
+
+  /**
+   * Generate CMYK color
+   */
+  static generateCMYK(hue: number): { c: number; m: number; y: number; k: number } {
+    const normalizedHue = hue / 360;
+    return {
+      c: round((1 - normalizedHue) * 100),
+      m: round(normalizedHue * 100),
+      y: round((0.5 - abs(normalizedHue - 0.5)) * 100),
+      k: round(algMin(normalizedHue, 1 - normalizedHue) * 50)
+    };
+  }
+
+  /**
+   * Generate harmonic color palette
+   */
+  static generatePalette(baseHue: number, count: number = 9): Array<{ hue: number; saturation: number; lightness: number }> {
+    return Array.from({ length: count }, (_, i) => ({
+      hue: (baseHue + (i * 40)) % 360,
+      saturation: 70 + (i % 30),
+      lightness: 50 + (i % 20)
+    }));
+  }
+}
+
+// === FREQUENCY UTILITIES ===
+export class A432Frequency {
+  /**
+   * Calculate base frequency for dimension
+   */
+  static baseFrequency(dimension: number, polarity: 1 | -1 = 1): number {
+    return A432_FREQUENCY * dimension * polarity;
+  }
+
+  /**
+   * Calculate harmonic series
+   */
+  static harmonicSeries(base: number, count: number = 9): number[] {
+    return Array.from({ length: count }, (_, i) => base * (i + 1));
+  }
+
+  /**
+   * Calculate subharmonic series
+   */
+  static subharmonicSeries(base: number, count: number = 9): number[] {
+    return Array.from({ length: count }, (_, i) => base / (i + 1));
+  }
+
+  /**
+   * Calculate golden ratio frequency
+   */
+  static goldenRatio(base: number): number {
+    return base * 1.618033988749895;
+  }
+
+  /**
+   * Calculate silver ratio frequency
+   */
+  static silverRatio(base: number): number {
+    return base * 1.4142135623730951;
+  }
+}
+
+// === HARMONIZATION UTILITIES ===
+export class A432Harmonization {
+  /**
+   * Calculate overall harmony from multiple states
+   */
+  static calculateHarmony(states: Array<{ harmony?: number; resonance?: number; balance?: number }>): number {
+    const harmonyValues = states.map(state => {
+      if (state.harmony !== undefined) return state.harmony;
+      if (state.resonance !== undefined) return state.resonance;
+      if (state.balance !== undefined) return state.balance;
+      return 0;
+    });
+    
+    return floor(harmonyValues.reduce((sum, val) => sum + val, 0) / harmonyValues.length);
+  }
+
+  /**
+   * Harmonize frequencies
+   */
+  static harmonizeFrequencies(frequencies: number[]): number[] {
+    const base = frequencies[0];
+    return frequencies.map(freq => {
+      const ratio = freq / base;
+      const harmonic = round(ratio);
+      return base * harmonic;
+    });
+  }
+
+  /**
+   * Harmonize colors
+   */
+  static harmonizeColors(colors: Array<{ hue: number; saturation: number; lightness: number }>): Array<{ hue: number; saturation: number; lightness: number }> {
+    const baseHue = colors[0].hue;
+    return colors.map((color, i) => ({
+      hue: (baseHue + (i * 40)) % 360,
+      saturation: algMax(70, color.saturation),
+      lightness: algMax(50, color.lightness)
+    }));
+  }
+
+  /**
+   * Harmonize sequences
+   */
+  static harmonizeSequences(sequences: number[][]): number[][] {
+    const baseLength = algMax(...sequences.map(seq => seq.length));
+    return sequences.map(seq => {
+      const harmonized = [...seq];
+      while (harmonized.length < baseLength) {
+        harmonized.push(A432Sequence.getNextHarmonious(harmonized[harmonized.length - 1]));
+      }
+      return harmonized;
+    });
+  }
+}
+
+// === VALIDATION UTILITIES ===
+export class A432Validation {
+  /**
+   * Validate dimension (1-9)
+   */
+  static isValidDimension(dimension: number): boolean {
+    return Number.isInteger(dimension) && dimension >= 1 && dimension <= 9;
+  }
+
+  /**
+   * Validate polarity (1 or -1)
+   */
+  static isValidPolarity(polarity: number): boolean {
+    return polarity === 1 || polarity === -1;
+  }
+
+  /**
+   * Validate frequency (positive number)
+   */
+  static isValidFrequency(frequency: number): boolean {
+    return Number.isFinite(frequency) && frequency > 0;
+  }
+
+  /**
+   * Validate color values
+   */
+  static isValidColor(hue: number, saturation: number, lightness: number): boolean {
+    return hue >= 0 && hue <= 360 &&
+           saturation >= 0 && saturation <= 100 &&
+           lightness >= 0 && lightness <= 100;
+  }
+
+  /**
+   * Validate sequence
+   */
+  static isValidSequence(sequence: number[]): boolean {
+    return Array.isArray(sequence) && sequence.every(n => Number.isInteger(n) && n >= 0 && n <= 9);
+  }
+}
+
+// === CONVENIENCE FUNCTIONS ===
+export const a432Math = A432Math;
+export const a432Sequence = A432Sequence;
+export const a432Color = A432Color;
+export const a432Frequency = A432Frequency;
+export const a432Harmonization = A432Harmonization;
+export const a432Validation = A432Validation;
+
+// Legacy compatibility
+export const calculateDigitalRoot = A432Math.digitalRoot;
+export const calculateHarmonicFrequency = A432Math.harmonicFrequency;
+export const calculateTrinityProduct = A432Math.trinityProduct;
+export const calculateVortexAngle = A432Math.vortexAngle;
+export const generateCycle = A432Sequence.generateCycle;
+export const generateTrinity = A432Sequence.generateTrinity;
+export const generateVortex = A432Sequence.generateVortex;
+export const generateConsciousness = A432Sequence.generateConsciousness;
+export const generateBoolean = A432Sequence.generateBoolean;
+export const generateColorMatrix = A432Color.generateMatrix;
+export const generateCMYK = A432Color.generateCMYK;
+export const generatePalette = A432Color.generatePalette;
+export const calculateBaseFrequency = A432Frequency.baseFrequency;
+export const calculateHarmonicSeries = A432Frequency.harmonicSeries;
+export const calculateSubharmonicSeries = A432Frequency.subharmonicSeries;
+export const calculateGoldenRatio = A432Frequency.goldenRatio;
+export const calculateSilverRatio = A432Frequency.silverRatio;
+export const calculateHarmony = A432Harmonization.calculateHarmony;
+export const harmonizeFrequencies = A432Harmonization.harmonizeFrequencies;
+export const harmonizeColors = A432Harmonization.harmonizeColors;
+export const harmonizeSequences = A432Harmonization.harmonizeSequences;