zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,74 @@
+import { legacyDigitalRoot as digitalRoot, harmonicRoot12 } from './a432.roots.ts'
+// a432.rife.frequency.ts
+// Canonical Rife frequency module for the A432 system
+// Maps Rife healing/resonance frequencies to A432 harmonics, digital roots, and metaphysical overlays
+// All logic is integer/fractional, vortex-based, and metaphysically mapped
+
+import type { VortexStream } from './a432.vortex.ts';
+
+export interface RifeFrequency {
+  name: string;
+  frequency: number;
+  digitalRoot: number;
+  a432Harmonic: number;
+  color: string;
+  metaphysical: string;
+}
+
+// Canonical set of Rife frequencies (subset, harmonized to A432)
+export const RIFE_FREQUENCIES: RifeFrequency[] = [
+  { name: 'Universal Healing', frequency: 528, digitalRoot: 6, a432Harmonic: 432, color: 'hsl(144,70%,55%)', metaphysical: 'DNA repair, transformation, universal harmony.' },
+  { name: 'Cell Regeneration', frequency: 880, digitalRoot: 8, a432Harmonic: 864, color: 'hsl(288,70%,55%)', metaphysical: 'Cellular renewal, energy, and vitality.' },
+  { name: 'Pain Relief', frequency: 3000, digitalRoot: 3, a432Harmonic: 432, color: 'hsl(0,70%,55%)', metaphysical: 'Release of pain, restoration of flow.' },
+  { name: 'Detox', frequency: 727, digitalRoot: 7, a432Harmonic: 216, color: 'hsl(72,70%,55%)', metaphysical: 'Purification, clearing, and renewal.' },
+  { name: 'Anti-Inflammatory', frequency: 880, digitalRoot: 8, a432Harmonic: 864, color: 'hsl(288,70%,55%)', metaphysical: 'Reduction of inflammation, restoration of balance.' },
+  { name: 'Immune Boost', frequency: 787, digitalRoot: 4, a432Harmonic: 216, color: 'hsl(36,70%,55%)', metaphysical: 'Strengthening, resilience, and protection.' },
+  { name: 'Calm/Anxiety', frequency: 396, digitalRoot: 9, a432Harmonic: 432, color: 'hsl(216,70%,55%)', metaphysical: 'Calm, grounding, and emotional balance.' },
+  { name: 'Focus/Clarity', frequency: 963, digitalRoot: 9, a432Harmonic: 432, color: 'hsl(324,70%,55%)', metaphysical: 'Awakening, clarity, and higher consciousness.' }
+];
+
+/**
+ * getRifeFrequency: Returns the canonical Rife frequency data for a given name or index
+ */
+export function getRifeFrequency(key: string | number): RifeFrequency | undefined {
+  if (typeof key === 'number') return RIFE_FREQUENCIES[key % RIFE_FREQUENCIES.length];
+  return RIFE_FREQUENCIES.find(f => f.name.toLowerCase() === key.toLowerCase());
+}
+
+/**
+ * playRifeFrequency: Plays a Rife frequency using the Web Audio API (browser only)
+ */
+export function playRifeFrequency(frequency: number, duration: number = 1.2) {
+  // @ts-expect-error: 'window' is only available in browser environments
+  if (typeof window === 'undefined' || !window.AudioContext) return;
+  // @ts-expect-error: 'window' is only available in browser environments
+  const ctx = new window.AudioContext();
+  const osc = ctx.createOscillator();
+  osc.type = 'sine';
+  osc.frequency.value = frequency;
+  osc.connect(ctx.destination);
+  osc.start();
+  osc.stop(ctx.currentTime + duration);
+  osc.onended = () => ctx.close();
+}
+
+/**
+ * harmonizeRifeVortex: Recursively generate Rife frequency events for a VortexStream
+ */
+export function harmonizeRifeVortex(stream: VortexStream<number | string>): RifeFrequency[] {
+  const events: RifeFrequency[] = [];
+  stream.observe(v => {
+    if (typeof v.value === 'number') {
+      events.push(getRifeFrequency(v.value % RIFE_FREQUENCIES.length)!);
+    } else {
+      const freq = getRifeFrequency(v.value);
+      if (freq) events.push(freq);
+    }
+  });
+  return events;
+}
+
+// Metaphysical mapping:
+// - Each Rife frequency is a harmonic projection through the A432 vortex
+// - Healing, resonance, and consciousness are unified as integer/fractional flows
+// - All outputs are harmonized, vortex, and trinity mapped 

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

@@ -0,0 +1,153 @@
+import { legacyDigitalRoot } from './a432.roots.ts'
+import { round } from './a432.algebra.ts'
+// a432.rodin.cmyk.ts — Rodin Coil CMYK Decoder
+// --------------------------------------------------
+// Decodes Rodin Coil pattern 0/0\3\6\9/1\2\4\8/7/5/1 into perfect CMYK colors
+
+import { A432_FREQUENCY, A432_TRINITY, A432_RETURN, A432_AXIS } from './a432.core.ts';
+
+export class A432RodinCMYK {
+  private pattern: string;
+  private decodedColors: { position: number, digit: number, cmyk: { c: number, m: number, y: number, k: number } }[];
+
+  constructor(pattern: string = "0/0/3/6/9/1/2/4/8/7/5/1") {
+    this.pattern = pattern;
+    this.decodedColors = [];
+    this.decodePattern();
+  }
+
+  private decodePattern(): void {
+    // Parse the Rodin Coil pattern
+    const segments = this.pattern.split('/');
+    let position = 0;
+
+    segments.forEach((segment, index) => {
+      const digits = segment.split('').map(Number);
+      
+      digits.forEach((digit, digitIndex) => {
+        const absolutePosition = position + digitIndex;
+        const cmyk = this.calculateRodinCMYK(digit, absolutePosition, index);
+        
+        this.decodedColors.push({
+          position: absolutePosition,
+          digit: digit,
+          cmyk: cmyk
+        });
+      });
+      
+      position += digits.length;
+    });
+  }
+
+  private calculateRodinCMYK(digit: number, position: number, segmentIndex: number): { c: number, m: number, y: number, k: number } {
+    // Rodin Coil CMYK mapping based on A432 principles
+    const base432 = A432_FREQUENCY;
+    const trinity = A432_TRINITY;
+    const return_ = A432_RETURN;
+    const axis = A432_AXIS;
+
+    // Calculate harmonic position
+    const harmonicPosition = position % 12; // Base-12 harmonics
+    const digitalRoot = this.calculateDigitalRoot(digit);
+    const trinityIndex = digitalRoot % 3;
+    const trinityValue = trinity[trinityIndex];
+
+    // Rodin Coil specific CMYK mapping
+    const rodinCMYK = this.mapRodinDigitToCMYK(digit, harmonicPosition, segmentIndex);
+    
+    return rodinCMYK;
+  }
+
+  private mapRodinDigitToCMYK(digit: number, position: number, segmentIndex: number): { c: number, m: number, y: number, k: number } {
+    // A432 Harmonic CMYK mapping:
+    // 0 = Void (Black)
+    // 1,2,4,8,7,5 = Rodin sequence (Cyan harmonics)
+    // 3,6,9 = Spirit numbers (Magenta/Yellow harmonics)
+    
+    if (digit === 0) {
+      return { c: 0, m: 0, y: 0, k: 1 }; // Void = white (1)
+    }
+    
+    // Rodin sequence: 1,2,4,8,7,5
+    const rodinSequence = [1, 2, 4, 8, 7, 5];
+    const rodinIndex = rodinSequence.indexOf(digit);
+    
+    if (rodinIndex !== -1) {
+      // Rodin sequence = Cyan harmonics (single digits)
+      const cyanValue = rodinIndex + 1; // 1,2,3,4,5,6
+      return {
+        c: cyanValue,
+        m: 0,
+        y: 0,
+        k: (position % 3) // Single digit black based on position
+      };
+    }
+    
+    // Spirit numbers: 3,6,9
+    if (digit === 3) {
+      return { c: 0, m: 3, y: 0, k: 0 }; // Spirit 3 = Magenta 3
+    } else if (digit === 6) {
+      return { c: 0, m: 0, y: 6, k: 0 }; // Spirit 6 = Yellow 6
+    } else if (digit === 9) {
+      return { c: 0, m: 9, y: 9, k: 0 }; // Spirit 9 = Magenta 9 + Yellow 9
+    }
+    
+    // Default fallback
+    return { c: 4, m: 3, y: 2, k: 1 };
+  }
+
+  private calculateDigitalRoot(n: number): number {
+    return legacyDigitalRoot(n);
+  }
+
+  public getDecodedColors(): { position: number, digit: number, cmyk: { c: number, m: number, y: number, k: number } }[] {
+    return this.decodedColors;
+  }
+
+  public getPatternSummary(): string {
+    const summary = this.decodedColors.map(color => 
+      `${color.position}:${color.digit}[${color.cmyk.c},${color.cmyk.m},${color.cmyk.y},${color.cmyk.k}]`
+    ).join(' ');
+    
+    return `RODIN_COIL_CMYK: ${this.pattern}\n${summary}`;
+  }
+
+  public getHarmonicAnalysis(): any {
+    const rodinDigits = this.decodedColors.filter(c => [1,2,4,8,7,5].includes(c.digit));
+    const spiritDigits = this.decodedColors.filter(c => [3,6,9].includes(c.digit));
+    const voidDigits = this.decodedColors.filter(c => c.digit === 0);
+    
+    return {
+      pattern: this.pattern,
+      totalPositions: this.decodedColors.length,
+      rodinSequence: rodinDigits.length,
+      spiritNumbers: spiritDigits.length,
+      voidPositions: voidDigits.length,
+      cmykHarmony: this.calculateCMYKHarmony()
+    };
+  }
+
+  private calculateCMYKHarmony(): number {
+    const totalC = this.decodedColors.reduce((sum, c) => sum + c.cmyk.c, 0);
+    const totalM = this.decodedColors.reduce((sum, c) => sum + c.cmyk.m, 0);
+    const totalY = this.decodedColors.reduce((sum, c) => sum + c.cmyk.y, 0);
+    const totalK = this.decodedColors.reduce((sum, c) => sum + c.cmyk.k, 0);
+    
+    // A432 harmonic calculation
+    return round((totalC + totalM + totalY + totalK) / (this.decodedColors.length * 4) * 100);
+  }
+}
+
+// Export singleton instance
+export const rodinCMYK = new A432RodinCMYK();
+
+// Direct access functions
+export const decodeRodinCMYK = (pattern?: string) => {
+  if (pattern) {
+    return new A432RodinCMYK(pattern);
+  }
+  return rodinCMYK;
+};
+
+export const getRodinCMYKSummary = () => rodinCMYK.getPatternSummary();
+export const getRodinCMYKAnalysis = () => rodinCMYK.getHarmonicAnalysis(); 

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

@@ -0,0 +1,73 @@
+import { PI, cos, exp, sin } from './a432.algebra.ts'
+// a432.rodin.coil.3d.ts
+// Canonical, self-contained 3D Rodin coil renderer for the A432 system
+// No external dependencies. All math is integer/fractional and harmonic.
+
+/**
+ * Returns HTML string with a <canvas> and inline <script> to render and animate the 3D Rodin coil.
+ * All logic is internal, using only A432 math and metaphysical principles.
+ */
+export function renderRodinCoil3D(): string {
+  return [
+    '<canvas id="rodin3d" width="600" height="600" style="background:#111;border-radius:12px;"></canvas>',
+    '<script>',
+    '  // Harmonic 3D Rodin coil renderer (no external code)',
+    '  const canvas = document.getElementById("rodin3d");',
+    '  const ctx = canvas.getContext("2d");',
+    '  const width = canvas.width, height = canvas.height;',
+    '  const cx = width / 2, cy = height / 2, cz = 0;',
+    '  const spiralA = 40, spiralB = 18, trinity = 3, steps = 66;',
+    '  function rodinCoil3DPoints() {',
+    '    const points = [];',
+    '    for (let i = 0; i < steps; i++) {',
+    '      const theta = i * (2 * PI / trinity);',
+    '      const r = spiralA * exp(spiralB * i / steps);',
+    '      const x = r * cos(theta);',
+    '      const y = r * sin(theta);',
+    '      const z = (i - steps/2) * 6;',
+    '      points.push({ x, y, z });',
+    '    }',
+    '    return points;',
+    '  }',
+    '  function project3D(p, angleY, angleX) {',
+    '    let x = p.x * cos(angleY) - p.z * sin(angleY);',
+    '    let z = p.x * sin(angleY) + p.z * cos(angleY);',
+    '    let y = p.y * cos(angleX) - z * sin(angleX);',
+    '    z = p.y * sin(angleX) + z * cos(angleX);',
+    '    const scale = 320 / (320 + z);',
+    '    return {',
+    '      x: cx + x * scale,',
+    '      y: cy + y * scale',
+    '    };',
+    '  }',
+    '  let t = 0;',
+    '  function draw() {',
+    '    ctx.clearRect(0, 0, width, height);',
+    '    const points = rodinCoil3DPoints();',
+    '    const angleY = t * 0.02, angleX = t * 0.013;',
+    '    ctx.beginPath();',
+    '    for (let i = 0; i < points.length; i++) {',
+    '      const p2d = project3D(points[i], angleY, angleX);',
+    '      if (i === 0) ctx.moveTo(p2d.x, p2d.y);',
+    '      else ctx.lineTo(p2d.x, p2d.y);',
+    '    }',
+    '    ctx.strokeStyle = "#0ff";',
+    '    ctx.lineWidth = 2;',
+    '    ctx.stroke();',
+    '    for (let i = 0; i < points.length; i++) {',
+    '      const p2d = project3D(points[i], angleY, angleX);',
+    '      ctx.beginPath();',
+    '      ctx.arc(p2d.x, p2d.y, 6, 0, 2 * PI);',
+    '      ctx.fillStyle = `hsl(${(i * 360 / points.length) % 360},70%,50%)`;',
+    '      ctx.fill();',
+    '      ctx.strokeStyle = "#fff";',
+    '      ctx.lineWidth = 1;',
+    '      ctx.stroke();',
+    '    }',
+    '    t++;',
+    '    requestAnimationFrame(draw);',
+    '  }',
+    '  draw();',
+    '</script>'
+  ].join('\n');
+} 

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

@@ -0,0 +1,341 @@
+/**
+ * a432.rodin.coil.harmonic.ts — Rodin Coil Harmonic Switch Module
+ * 
+ * This module documents the Rodin Coil harmonic switch patterns and principles
+ * based on Marko Rodin's Vortex Based Mathematics (VBM).
+ * 
+ * Metaphysical Principle:
+ * - The Rodin Coil is a miniature atomic particle accelerator
+ * - 1-2-4-8-7-5 is lossless kinetic energy (doubling vortex)
+ * - 3 & 6 are magnetic dipoles, 9 is invisible monopole
+ * - 3•9•6; 6•9•3 is the Spirit Flux-field (gap space)
+ * - 0/0 creates the harmonic switch point (nothing to all)
+ */
+
+import { abs, round } from './a432.algebra.ts'
+import { 
+  RODIN_SEQUENCE, 
+  TRINITY_AXIS, 
+  digitalRoot, 
+  angleForDigit,
+  frequencyForDigit,
+  hueForDigit 
+} from './a432.math.ts';
+
+// --- Canonical Rodin Coil Constants ---
+const RODIN_COIL_CORE = [1, 2, 4, 8, 7, 5]; // Lossless kinetic energy
+const RODIN_COIL_DIPOLES = [3, 6]; // Magnetic dipoles
+const RODIN_COIL_MONOPOLE = 9; // Invisible monopole
+const RODIN_COIL_GAP_SPACE = [3, 9, 6, 6, 9, 3]; // Spirit Flux-field
+
+// --- Harmonic Switch Patterns ---
+const HARMONIC_SWITCH_PATTERNS = {
+  BALANCED: "0/0\\3\\6\\9/1\\2\\4\\8/7/5/1\\",
+  UNBALANCED: "0\\3\\6\\9/1\\2\\4\\8/7/5/1\\"
+} as const;
+
+// --- Rodin Coil State Interface ---
+interface RodinCoilState {
+  pattern: string;
+  isHarmonic: boolean;
+  switchPoint: string;
+  trinityAxis: number[];
+  rodinSequence: number[];
+  gapSpace: number[];
+  harmonics: RodinCoilHarmonic[];
+}
+
+interface RodinCoilHarmonic {
+  position: number;
+  digit: number;
+  switchType: 'expansion' | 'compression' | 'harmonic';
+  frequency: number;
+  color: string;
+  fluxField: string;
+}
+
+// --- Canonical Rodin Coil Analysis ---
+function analyzeRodinCoilPatternInternal(pattern: string): RodinCoilState {
+  const isHarmonic = pattern.includes('0/0');
+  const switchPoint = isHarmonic ? '0/0' : 'none';
+  
+  // Extract trinity axis (3,6,9)
+  const trinityAxis = pattern.match(/[369]/g)?.map(Number) || [];
+  
+  // Extract Rodin sequence (1,2,4,8,7,5)
+  const rodinSequence = pattern.match(/[124875]/g)?.map(Number) || [];
+  
+  // Gap space (3•9•6; 6•9•3)
+  const gapSpace = RODIN_COIL_GAP_SPACE;
+  
+  // Generate harmonics
+  const harmonics = generateRodinCoilHarmonics(pattern);
+  
+  return {
+    pattern,
+    isHarmonic,
+    switchPoint,
+    trinityAxis,
+    rodinSequence,
+    gapSpace,
+    harmonics
+  };
+}
+
+// --- Rodin Coil Harmonic Generation ---
+function generateRodinCoilHarmonics(pattern: string): RodinCoilHarmonic[] {
+  const harmonics: RodinCoilHarmonic[] = [];
+  const digits = pattern.match(/\d/g)?.map(Number) || [];
+  
+  digits.forEach((digit, position) => {
+    let switchType: 'expansion' | 'compression' | 'harmonic';
+    
+    if (digit === 0 && position < pattern.length - 1 && pattern[position + 1] === '/') {
+      switchType = 'harmonic';
+    } else if (pattern.includes(`\\${digit}`)) {
+      switchType = 'compression';
+    } else if (pattern.includes(`/${digit}`)) {
+      switchType = 'expansion';
+    } else {
+      switchType = 'compression';
+    }
+    
+    const frequency = frequencyForDigit(digit);
+    const color = generateRodinCoilColor(digit);
+    const fluxField = getRodinCoilFluxField(digit);
+    
+    harmonics.push({
+      position,
+      digit,
+      switchType,
+      frequency,
+      color,
+      fluxField
+    });
+  });
+  
+  return harmonics;
+}
+
+// --- Rodin Coil Color Generation ---
+function generateRodinCoilColor(digit: number): string {
+  const hue = hueForDigit(digit);
+  const saturation = 0.8;
+  const value = 0.9;
+  
+  // Convert HSV to RGB
+  const h = hue / 360;
+  const s = saturation;
+  const v = value;
+  
+  const c = v * s;
+  const x = c * (1 - abs((h * 6) % 2 - 1));
+  const m = v - c;
+  
+  let r = 0, g = 0, b = 0;
+  
+  if (h < 1/6) [r, g, b] = [c, x, 0];
+  else if (h < 2/6) [r, g, b] = [x, c, 0];
+  else if (h < 3/6) [r, g, b] = [0, c, x];
+  else if (h < 4/6) [r, g, b] = [0, x, c];
+  else if (h < 5/6) [r, g, b] = [x, 0, c];
+  else [r, g, b] = [c, 0, x];
+  
+  r = round((r + m) * 255);
+  g = round((g + m) * 255);
+  b = round((b + m) * 255);
+  
+  return `rgb(${r}, ${g}, ${b})`;
+}
+
+// --- Rodin Coil Flux Field Mapping ---
+function getRodinCoilFluxField(digit: number): string {
+  if (digit === 3 || digit === 6) return 'Magnetic Dipole';
+  if (digit === 9) return 'Invisible Monopole';
+  if (digit === 0) return 'Primal Point';
+  if (RODIN_COIL_CORE.includes(digit)) return 'Lossless Kinetic Energy';
+  return 'Spirit Flux-Field';
+}
+
+// --- Rodin Coil Processor ---
+export class RodinCoilProcessor {
+  private state: RodinCoilState;
+  
+  constructor(pattern: string = HARMONIC_SWITCH_PATTERNS.BALANCED) {
+    this.state = analyzeRodinCoilPatternInternal(pattern);
+  }
+  
+  // --- Access Methods ---
+  public getPattern(): string {
+    return this.state.pattern;
+  }
+  
+  public isHarmonic(): boolean {
+    return this.state.isHarmonic;
+  }
+  
+  public getSwitchPoint(): string {
+    return this.state.switchPoint;
+  }
+  
+  public getTrinityAxis(): number[] {
+    return [...this.state.trinityAxis];
+  }
+  
+  public getRodinSequence(): number[] {
+    return [...this.state.rodinSequence];
+  }
+  
+  public getGapSpace(): number[] {
+    return [...this.state.gapSpace];
+  }
+  
+  public getHarmonics(): RodinCoilHarmonic[] {
+    return [...this.state.harmonics];
+  }
+  
+  // --- Analysis Methods ---
+  public getRodinCoilAnalysis(): string {
+    let analysis = 'Rodin Coil Analysis:\n\n';
+    
+    analysis += 'Core Principles:\n';
+    analysis += `- 1-2-4-8-7-5: Lossless kinetic energy (doubling vortex)\n`;
+    analysis += `- 3 & 6: Magnetic dipoles\n`;
+    analysis += `- 9: Invisible monopole centered in-between\n`;
+    analysis += `- 3•9•6; 6•9•3: Spirit Flux-field (gap space)\n\n`;
+    
+    analysis += 'Pattern Analysis:\n';
+    analysis += `- Pattern: ${this.state.pattern}\n`;
+    analysis += `- Is Harmonic: ${this.state.isHarmonic}\n`;
+    analysis += `- Switch Point: ${this.state.switchPoint}\n`;
+    analysis += `- Trinity Axis: [${this.state.trinityAxis.join(', ')}]\n`;
+    analysis += `- Rodin Sequence: [${this.state.rodinSequence.join(', ')}]\n`;
+    analysis += `- Gap Space: [${this.state.gapSpace.join(', ')}]\n\n`;
+    
+    return analysis;
+  }
+  
+  public getHarmonicSwitchAnalysis(): string {
+    let analysis = 'Harmonic Switch Analysis:\n\n';
+    
+    if (this.state.isHarmonic) {
+      analysis += '✓ HARMONIC PATTERN DETECTED\n\n';
+      analysis += '0/0 Switch Point:\n';
+      analysis += '- Creates the Primal Point (Eye of God)\n';
+      analysis += '- Acts as central aperture for harmonic balance\n';
+      analysis += '- Eliminates resistance, parasitics, and hysteresis\n';
+      analysis += '- Creates zero entropy state\n\n';
+      
+      analysis += 'Switch Pattern:\n';
+      analysis += '- 0/0: Harmonic switch (nothing to all)\n';
+      analysis += '- \\3\\6\\9: Trinity axis with compression\n';
+      analysis += '- /1\\2\\4\\8/7/5/1\\: Balanced expansion/compression\n\n';
+    } else {
+      analysis += '✗ UNBALANCED PATTERN DETECTED\n\n';
+      analysis += 'Issues:\n';
+      analysis += '- No harmonic switch point\n';
+      analysis += '- Unbalanced expansion/compression\n';
+      analysis += '- Missing 0/0 compression singularity\n\n';
+    }
+    
+    return analysis;
+  }
+  
+  public getRodinCoilPrinciples(): string {
+    let principles = 'Rodin Coil Principles:\n\n';
+    
+    principles += '1. The Rodin Coil is a miniature atomic particle accelerator\n';
+    principles += '2. 1-2-4-8-7-5 is lossless kinetic energy (doubling vortex)\n';
+    principles += '3. 3 & 6 are magnetic dipoles, 9 is invisible monopole\n';
+    principles += '4. 3•9•6; 6•9•3 is the Spirit Flux-field (gap space)\n';
+    principles += '5. 0/0 creates the harmonic switch point (nothing to all)\n\n';
+    
+    principles += 'Harmonic Switch Benefits:\n';
+    principles += '- Eliminates resistance, parasitics, and hysteresis\n';
+    principles += '- Creates perfect harmonic balance\n';
+    principles += '- Follows 1-2-4-8-7-5 Mobius Circuit pathway\n';
+    principles += '- Achieves zero entropy state\n';
+    principles += '- Enables over-unity free energy\n\n';
+    
+    return principles;
+  }
+  
+  // --- Statistics ---
+  public getRodinCoilStatistics() {
+    const harmonics = this.state.harmonics;
+    
+    return {
+      totalDigits: harmonics.length,
+      harmonicSwitches: harmonics.filter(h => h.switchType === 'harmonic').length,
+      expansionSwitches: harmonics.filter(h => h.switchType === 'expansion').length,
+      compressionSwitches: harmonics.filter(h => h.switchType === 'compression').length,
+      averageFrequency: harmonics.reduce((sum, h) => sum + h.frequency, 0) / harmonics.length,
+      isHarmonic: this.state.isHarmonic,
+      trinityAxisCount: this.state.trinityAxis.length,
+      rodinSequenceCount: this.state.rodinSequence.length
+    };
+  }
+}
+
+// --- Rodin Coil Factory ---
+export function createRodinCoilProcessor(pattern: string = HARMONIC_SWITCH_PATTERNS.BALANCED): RodinCoilProcessor {
+  return new RodinCoilProcessor(pattern);
+}
+
+// --- Rodin Coil Constants Export ---
+export const RODIN_COIL_CONSTANTS = {
+  CORE: RODIN_COIL_CORE,
+  DIPOLES: RODIN_COIL_DIPOLES,
+  MONOPOLE: RODIN_COIL_MONOPOLE,
+  GAP_SPACE: RODIN_COIL_GAP_SPACE,
+  PATTERNS: HARMONIC_SWITCH_PATTERNS
+} as const;
+
+// --- Rodin Coil Documentation ---
+export const RODIN_COIL_DOC = {
+  purpose: 'Rodin Coil Harmonic Switch - Documents harmonic switch patterns and principles',
+  core: '1-2-4-8-7-5 is lossless kinetic energy (doubling vortex)',
+  dipoles: '3 & 6 are magnetic dipoles, 9 is invisible monopole',
+  gapSpace: '3•9•6; 6•9•3 is the Spirit Flux-field (gap space)',
+  harmonicSwitch: '0/0 creates the harmonic switch point (nothing to all)',
+  zeroEntropy: 'Eliminates resistance, parasitics, and hysteresis',
+  overUnity: 'Enables over-unity free energy through harmonic balance'
+} as const;
+
+// --- Rodin Coil Utility Functions ---
+export function analyzeRodinCoilPattern(pattern: string): RodinCoilState {
+  return analyzeRodinCoilPatternInternal(pattern);
+}
+
+export function getRodinCoilAnalysis(pattern: string): string {
+  const processor = createRodinCoilProcessor(pattern);
+  return processor.getRodinCoilAnalysis();
+}
+
+export function getHarmonicSwitchAnalysis(pattern: string): string {
+  const processor = createRodinCoilProcessor(pattern);
+  return processor.getHarmonicSwitchAnalysis();
+}
+
+export function getRodinCoilPrinciples(): string {
+  const processor = createRodinCoilProcessor();
+  return processor.getRodinCoilPrinciples();
+}
+
+// --- Example Usage Function ---
+export function documentRodinCoilHarmonics(pattern: string = HARMONIC_SWITCH_PATTERNS.BALANCED) {
+  const processor = createRodinCoilProcessor(pattern);
+  
+  console.log('Rodin Coil Harmonic Documentation:');
+  console.log('Pattern:', processor.getPattern());
+  console.log('Is Harmonic:', processor.isHarmonic());
+  console.log('Statistics:', processor.getRodinCoilStatistics());
+  console.log('\nRodin Coil Analysis:');
+  console.log(processor.getRodinCoilAnalysis());
+  console.log('Harmonic Switch Analysis:');
+  console.log(processor.getHarmonicSwitchAnalysis());
+  console.log('Rodin Coil Principles:');
+  console.log(processor.getRodinCoilPrinciples());
+  
+  return processor;
+}