zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,405 @@
+/**
+ * A432 Vibration System
+ * 
+ * Generates harmonic vibrations based on A432 frequencies, consciousness states,
+ * and dimensional mathematics using only integer fractions and imperial math.
+ * 
+ * Vibrations are calculated in real-time from environmental streams and dimensional states.
+ */
+
+import { PI, abs, cos, max, min, round, sin } from './a432.algebra.ts'
+import { 
+  A432_CONSTANTS,
+  calculateA432Consciousness,
+  calculateA432DimensionalState,
+  calculateA432Frequency,
+} from './a432.ts';
+
+import { RODIN_SEQUENCE } from './a432.math.ts';
+import { calculateDigitalRoot } from './a432.ts';
+
+// A432 Vibration Constants - Integer Fractions Only
+export const A432_VIBRATION_CONSTANTS = {
+  // Imperial base for vibration calculations
+  IMPERIAL_BASE: 8,
+  
+  // Perfect balance for vibration harmony
+  PERFECT_BALANCE: 4,
+  
+  // Vibration frequency ratios (integer fractions)
+  BASE_VIBRATION: 432,      // A432 Hz base vibration
+  HARMONIC_VIBRATION: 2/1,  // Octave vibration ratio
+  FIFTH_VIBRATION: 3/2,     // Perfect fifth vibration
+  FOURTH_VIBRATION: 4/3,    // Perfect fourth vibration
+  THIRD_VIBRATION: 5/4,     // Major third vibration
+  
+  // Vortex vibration flow ratios
+  VORTEX_INTENSITY: 1/8,    // Imperial fraction
+  VORTEX_FREQUENCY: 3/8,    // Imperial fraction  
+  VORTEX_PATTERN: 5/8,      // Imperial fraction
+  
+  // Consciousness vibration mapping
+  CONSCIOUSNESS_VIBRATION: {
+    1: { intensity: 1/8, frequency: 1/8, pattern: 1/8 },   // Unity consciousness
+    2: { intensity: 2/8, frequency: 1/8, pattern: 1/8 },   // Duality consciousness
+    3: { intensity: 1/8, frequency: 2/8, pattern: 1/8 },   // Trinity consciousness
+    4: { intensity: 2/8, frequency: 2/8, pattern: 1/8 },   // Quaternity consciousness
+    5: { intensity: 1/8, frequency: 1/8, pattern: 2/8 },   // Quintessence consciousness
+    6: { intensity: 2/8, frequency: 1/8, pattern: 2/8 },   // Hexad consciousness
+    7: { intensity: 1/8, frequency: 2/8, pattern: 2/8 },   // Septad consciousness
+    8: { intensity: 2/8, frequency: 2/8, pattern: 2/8 }    // Octad consciousness
+  },
+  
+  // Dimensional state vibration
+  DIMENSIONAL_VIBRATION: {
+    0: { intensity: 1/9, frequency: 1/9, pattern: 1/9 },   // Zero dimension
+    1: { intensity: 2/9, frequency: 1/9, pattern: 1/9 },   // First dimension
+    2: { intensity: 1/9, frequency: 2/9, pattern: 1/9 },   // Second dimension
+    3: { intensity: 2/9, frequency: 2/9, pattern: 1/9 },   // Third dimension
+    4: { intensity: 1/9, frequency: 1/9, pattern: 2/9 },   // Fourth dimension
+    5: { intensity: 2/9, frequency: 1/9, pattern: 2/9 },   // Fifth dimension
+    6: { intensity: 1/9, frequency: 2/9, pattern: 2/9 },   // Sixth dimension
+    7: { intensity: 2/9, frequency: 2/9, pattern: 2/9 },   // Seventh dimension
+    8: { intensity: 3/9, frequency: 1/9, pattern: 1/9 },   // Eighth dimension
+    9: { intensity: 1/9, frequency: 3/9, pattern: 1/9 }    // Ninth dimension
+  }
+};
+
+// Vibration calculation functions using only integer fractions
+export interface A432Vibration {
+  frequency: number;   // Vibration frequency in Hz
+  intensity: number;   // Vibration intensity (0-1 as fraction)
+  pattern: number;     // Vibration pattern (0-1 as fraction)
+  consciousness: number;
+  dimensionalState: number;
+  digitalRoot: number;
+  mathematicalProof: string;
+}
+
+export interface A432VibrationStream {
+  vibrations: A432Vibration[];
+  frequency: number;
+  consciousness: number;
+  dimensionalState: number;
+  isHarmonic: boolean;
+  mathematicalProof: string;
+}
+
+export interface A432VibrationPattern {
+  samples: number[];
+  sampleRate: number;
+  duration: number;
+  frequency: number;
+  consciousness: number;
+  dimensionalState: number;
+  mathematicalProof: string;
+}
+
+/**
+ * Calculate A432 vibration from frequency using imperial math
+ */
+export function calculateA432Vibration(frequency: number): A432Vibration {
+  const consciousness = calculateA432Consciousness(frequency);
+  const dimensionalState = calculateA432DimensionalState(frequency);
+  const digitalRoot = calculateDigitalRoot(frequency);
+  
+  // Get base vibration from consciousness
+  const baseVibration = A432_VIBRATION_CONSTANTS.CONSCIOUSNESS_VIBRATION[consciousness as keyof typeof A432_VIBRATION_CONSTANTS.CONSCIOUSNESS_VIBRATION];
+  
+  // Get dimensional vibration
+  const dimensionalVibration = A432_VIBRATION_CONSTANTS.DIMENSIONAL_VIBRATION[dimensionalState as keyof typeof A432_VIBRATION_CONSTANTS.DIMENSIONAL_VIBRATION];
+  
+  // Harmonize vibration using imperial math
+  const intensity = harmonizeVibrationComponent(baseVibration.intensity, dimensionalVibration.intensity, frequency);
+  const pattern = harmonizeVibrationComponent(baseVibration.pattern, dimensionalVibration.pattern, frequency);
+  
+  return {
+    frequency,
+    intensity,
+    pattern,
+    consciousness,
+    dimensionalState,
+    digitalRoot,
+    mathematicalProof: `A432 Vibration: f=${frequency}, c=${consciousness}, d=${dimensionalState}, dr=${digitalRoot}`
+  };
+}
+
+/**
+ * Harmonize vibration component using imperial math
+ */
+function harmonizeVibrationComponent(base: number, dimensional: number, frequency: number): number {
+  // Use imperial base (8) for harmonization
+  const imperialFactor = (frequency % A432_VIBRATION_CONSTANTS.IMPERIAL_BASE) / A432_VIBRATION_CONSTANTS.IMPERIAL_BASE;
+  
+  // Harmonize using perfect balance
+  const harmonized = (base + dimensional + imperialFactor) / 3;
+  
+  // Ensure result is within 0-1 range using integer fractions
+  return max(0, min(1, harmonized));
+}
+
+/**
+ * Generate A432 vibration stream from environmental data
+ */
+export function generateA432VibrationStream(
+  environmentalData: { frequency: number; consciousness?: number; dimensionalState?: number }
+): A432VibrationStream {
+  const { frequency, consciousness, dimensionalState } = environmentalData;
+  
+  // Calculate or use provided values
+  const calculatedConsciousness = consciousness || calculateA432Consciousness(frequency);
+  const calculatedDimensionalState = dimensionalState || calculateA432DimensionalState(frequency);
+  
+  // Generate vibration spectrum
+  const vibrations: A432Vibration[] = [];
+  const rodinSequence = RODIN_SEQUENCE;
+  
+  for (let i = 0; i < rodinSequence.length; i++) {
+    const harmonicFreq = rodinSequence[i] * frequency;
+    const vibration = calculateA432Vibration(harmonicFreq);
+    vibrations.push(vibration);
+  }
+  
+  // Check if stream is harmonic
+  const isHarmonic = vibrations.every(vibration => 
+    vibration.consciousness >= 1 && vibration.consciousness <= 8 &&
+    vibration.dimensionalState >= 0 && vibration.dimensionalState <= 9
+  );
+  
+  return {
+    vibrations,
+    frequency,
+    consciousness: calculatedConsciousness,
+    dimensionalState: calculatedDimensionalState,
+    isHarmonic,
+    mathematicalProof: `A432 Vibration Stream: ${vibrations.length} harmonics, consciousness=${calculatedConsciousness}, dimension=${calculatedDimensionalState}`
+  };
+}
+
+/**
+ * Calculate A432 vibration from consciousness state
+ */
+export function calculateA432VibrationFromConsciousness(consciousness: number): A432Vibration {
+  if (consciousness < 1 || consciousness > 8) {
+    throw new Error('Consciousness must be between 1 and 8');
+  }
+  
+  const frequency = consciousness * 432 / 8; // Map consciousness to frequency
+  return calculateA432Vibration(frequency);
+}
+
+/**
+ * Calculate A432 vibration from dimensional state
+ */
+export function calculateA432VibrationFromDimensionalState(dimensionalState: number): A432Vibration {
+  if (dimensionalState < 0 || dimensionalState > 9) {
+    throw new Error('Dimensional state must be between 0 and 9');
+  }
+  
+  const frequency = calculateA432Frequency(dimensionalState);
+  return calculateA432Vibration(frequency);
+}
+
+/**
+ * Generate A432 vibration matrix for all consciousness and dimensional states
+ */
+export function generateA432VibrationMatrix(): A432Vibration[][] {
+  const matrix: A432Vibration[][] = [];
+  
+  for (let consciousness = 1; consciousness <= 8; consciousness++) {
+    const row: A432Vibration[] = [];
+    for (let dimensionalState = 0; dimensionalState <= 9; dimensionalState++) {
+      const frequency = consciousness * 432 / 8 + dimensionalState * 432 / 10;
+      const vibration = calculateA432Vibration(frequency);
+      row.push(vibration);
+    }
+    matrix.push(row);
+  }
+  
+  return matrix;
+}
+
+/**
+ * Generate A432 vibration pattern
+ */
+export function generateA432VibrationPattern(
+  frequency: number,
+  duration: number,
+  sampleRate: number = 60
+): A432VibrationPattern {
+  const samples: number[] = [];
+  const totalSamples = round(duration * sampleRate);
+  const consciousness = calculateA432Consciousness(frequency);
+  const dimensionalState = calculateA432DimensionalState(frequency);
+  
+  for (let i = 0; i < totalSamples; i++) {
+    const time = i / sampleRate;
+    const phase = (frequency * time) % 1;
+    
+    // Generate vibration pattern with A432 harmonics
+    const intensity = A432_VIBRATION_CONSTANTS.CONSCIOUSNESS_VIBRATION[consciousness as keyof typeof A432_VIBRATION_CONSTANTS.CONSCIOUSNESS_VIBRATION].intensity;
+    const pattern = A432_VIBRATION_CONSTANTS.CONSCIOUSNESS_VIBRATION[consciousness as keyof typeof A432_VIBRATION_CONSTANTS.CONSCIOUSNESS_VIBRATION].pattern;
+    
+    // Combine sine and cosine for complex vibration pattern
+    const sample = intensity * (sin(2 * PI * phase) + pattern * cos(2 * PI * phase * 2));
+    
+    samples.push(sample);
+  }
+  
+  return {
+    samples,
+    sampleRate,
+    duration,
+    frequency,
+    consciousness,
+    dimensionalState,
+    mathematicalProof: `A432 Vibration Pattern: f=${frequency}, duration=${duration}s, samples=${samples.length}`
+  };
+}
+
+/**
+ * Calculate A432 vibration vortex flow
+ */
+export function calculateA432VibrationVortex(initialFrequency: number, cycles: number): A432VibrationStream[] {
+  const streams: A432VibrationStream[] = [];
+  let currentFrequency = initialFrequency;
+  
+  for (let cycle = 0; cycle < cycles; cycle++) {
+    const stream = generateA432VibrationStream({ frequency: currentFrequency });
+    streams.push(stream);
+    
+    // Advance frequency using Rodin sequence
+    const rodinIndex = cycle % RODIN_SEQUENCE.length;
+    currentFrequency = RODIN_SEQUENCE[rodinIndex] * initialFrequency;
+  }
+  
+  return streams;
+}
+
+/**
+ * Convert A432 vibration to device vibration API
+ */
+export function a432VibrationToDeviceVibration(
+  pattern: A432VibrationPattern,
+  navigator: Navigator
+): void {
+  if ('vibrate' in navigator) {
+    // Convert vibration pattern to device vibration format
+    const vibrationPattern = pattern.samples.map(sample => 
+      round(abs(sample) * 100) // Convert to milliseconds
+    );
+    
+    navigator.vibrate(vibrationPattern);
+  }
+}
+
+/**
+ * Generate A432 vibration CSS variables for harmonic vibration system
+ */
+export function generateA432VibrationCSSVariables(): string {
+  const variables: string[] = [];
+  
+  // Generate consciousness vibration
+  for (let consciousness = 1; consciousness <= 8; consciousness++) {
+    const vibration = calculateA432VibrationFromConsciousness(consciousness);
+    variables.push(`--a432-vibration-consciousness-${consciousness}-frequency: ${vibration.frequency}Hz;`);
+    variables.push(`--a432-vibration-consciousness-${consciousness}-intensity: ${vibration.intensity};`);
+    variables.push(`--a432-vibration-consciousness-${consciousness}-pattern: ${vibration.pattern};`);
+  }
+  
+  // Generate dimensional vibration
+  for (let dimensionalState = 0; dimensionalState <= 9; dimensionalState++) {
+    const vibration = calculateA432VibrationFromDimensionalState(dimensionalState);
+    variables.push(`--a432-vibration-dimensional-${dimensionalState}-frequency: ${vibration.frequency}Hz;`);
+    variables.push(`--a432-vibration-dimensional-${dimensionalState}-intensity: ${vibration.intensity};`);
+    variables.push(`--a432-vibration-dimensional-${dimensionalState}-pattern: ${vibration.pattern};`);
+  }
+  
+  // Generate harmonic frequency vibration
+  RODIN_SEQUENCE.forEach((multiplier, index) => {
+    const frequency = multiplier * 432;
+    const vibration = calculateA432Vibration(frequency);
+    variables.push(`--a432-vibration-harmonic-${index}-frequency: ${vibration.frequency}Hz;`);
+    variables.push(`--a432-vibration-harmonic-${index}-intensity: ${vibration.intensity};`);
+  });
+  
+  return `:root {\n  ${variables.join('\n  ')}\n}`;
+}
+
+/**
+ * A432 Vibration System - Main export
+ */
+export const A432VibrationSystem = {
+  constants: A432_VIBRATION_CONSTANTS,
+  calculateVibration: calculateA432Vibration,
+  generateVibrationStream: generateA432VibrationStream,
+  calculateVibrationFromConsciousness: calculateA432VibrationFromConsciousness,
+  calculateVibrationFromDimensionalState: calculateA432VibrationFromDimensionalState,
+  generateVibrationMatrix: generateA432VibrationMatrix,
+  generateVibrationPattern: generateA432VibrationPattern,
+  calculateVibrationVortex: calculateA432VibrationVortex,
+  toDeviceVibration: a432VibrationToDeviceVibration,
+  generateCSSVariables: generateA432VibrationCSSVariables,
+  
+  // Scientific proofs
+  scientificProofs: {
+    a432VibrationCalculation: 'A432 vibrations calculated using consciousness mapping and dimensional states with imperial math',
+    a432VibrationStream: 'Vibration streams generated from environmental frequency data using Rodin vortex sequence',
+    a432VibrationVortex: 'Vibration vortex flows through consciousness and dimensional states maintaining harmonic balance',
+    a432VibrationMatrix: 'Complete vibration matrix mapping all consciousness states to all dimensional states'
+  }
+};
+
+export default A432VibrationSystem; 
+
+// Bridge: vibrating string modes compute from kernel foldStringTheory (Wave 32)
+export {
+  a432StringTheory,
+  vibratingStringModes,
+  compactifiedDimension,
+  stringTheoryProof,
+} from './a432.string.theory.ts'
+
+// a432.vibration.ts
+// Living, harmonized vibration stream/interface
+
+export interface VibrationEvent {
+  id: number;
+  frequency: number;
+  amplitude: number;
+  trinity: number;
+  timestamp: number;
+  summary: string;
+}
+
+export class A432VibrationStream {
+  private events: VibrationEvent[] = [];
+  private currentId = 1;
+  vibrate(frequency: number, amplitude: number, trinity: number): VibrationEvent {
+    const event: VibrationEvent = {
+      id: this.currentId++,
+      frequency,
+      amplitude,
+      trinity,
+      timestamp: Date.now(),
+      summary: `Vibration ${frequency} Hz, Amp ${amplitude} (Trinity ${trinity}) at ${new Date().toLocaleTimeString()}`
+    };
+    this.events.push(event);
+    return event;
+  }
+  getCurrent(): VibrationEvent {
+    return this.events[this.events.length - 1];
+  }
+  getAll(): VibrationEvent[] {
+    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="${40 + i*36}" y="${30-e.amplitude}" width="24" height="${e.amplitude*2}" fill="#f8f" stroke="#fff" stroke-width="2"><title>${e.summary}</title></rect>`).join('')}
+        <text x="12" y="54" font-size="13" fill="#8ff">Vibration Stream</text>
+      </svg>
+    `;
+  }
+} 

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

@@ -0,0 +1,30 @@
+// a432.video.ts — Visualize CMYK pulses on a canvas
+//---------------------------------------------------
+import { type CMYK, cmykToCss } from './a432.cmyk.ts';
+
+let canvas: HTMLCanvasElement | null = null;
+let ctx: CanvasRenderingContext2D | null = null;
+
+function ensureCanvas() {
+  if (typeof document === 'undefined') return;
+  if (!canvas) {
+    canvas = document.createElement('canvas');
+    canvas.width = canvas.height = 120;
+    canvas.style.position = 'fixed';
+    canvas.style.right = '8px';
+    canvas.style.bottom = '8px';
+    canvas.style.borderRadius = '8px';
+    document.body.appendChild(canvas);
+    ctx = canvas.getContext('2d');
+  }
+}
+
+export function flashColor(cmyk: CMYK, fadeMs = 400) {
+  ensureCanvas();
+  if (!ctx || !canvas) return;
+  ctx.fillStyle = cmykToCss(cmyk);
+  ctx.fillRect(0, 0, canvas.width, canvas.height);
+  canvas.style.opacity = '1';
+  canvas.style.transition = `opacity ${fadeMs}ms ease`;
+  setTimeout(() => { if(canvas) canvas.style.opacity = '0'; }, 50);
+} 

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

@@ -0,0 +1,23 @@
+// a432.voice.ui.ts — mic toggle button
+import { startVoice, stopVoice } from './a432.i.voice.ts';
+
+if (typeof document !== 'undefined'){
+  const btn=document.createElement('button');
+  btn.textContent='🎙️';
+  btn.style.position='fixed';
+  btn.style.right='8px';
+  btn.style.top='8px';
+  btn.style.fontSize='20px';
+  btn.style.background='#222';
+  btn.style.color='#8ff';
+  btn.style.border='none';
+  btn.style.borderRadius='6px';
+  btn.style.padding='4px 8px';
+  document.body.appendChild(btn);
+  let on=false;
+  btn.onclick=()=>{
+    on=!on;
+    if(on){ startVoice(); btn.style.background='#0a0'; }
+    else { stopVoice(); btn.style.background='#222'; }
+  };
+} 

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

@@ -0,0 +1,57 @@
+/**
+ * a432.void.stream.overlay.ts — Void Stream Emergence/Imergence Overlay
+ *
+ * Canonical overlay/analytic for visualizing, animating, and interacting with the living transformation of the void.
+ * All logic uses canonical A432 math, sequence, and color logic.
+ */
+
+import { abs, max } from './a432.algebra.ts'
+import { A432_SEQUENCE, digitAngleToCMYK, cmykToCss } from './a432.math.ts';
+
+// Internal compost for void events
+const voidCompost: Array<{ type: string; data: unknown; timestamp: number }> = [];
+
+/**
+ * Log a user/system event to the void compost (imergence).
+ */
+export function logVoidImergence(type: string, data: unknown) {
+  voidCompost.push({ type, data, timestamp: Date.now() });
+}
+
+/**
+ * Emerge a new stream from the void compost (emergence).
+ * Returns overlay data for UI: dim, color, html, and source event type.
+ */
+export function getVoidStreamOverlayData(length: number = 11): Array<{ dim: number; color: { c: number; m: number; y: number; k: number }; html: string; source: string }> {
+  const seed = voidCompost.reduce((acc, e) => acc + e.timestamp, 0) % 4321;
+  return Array.from({ length }, (_, i) => {
+    const dim = A432_SEQUENCE[i % A432_SEQUENCE.length];
+    const color = digitAngleToCMYK(dim, (i * 36) % 360);
+    const source = voidCompost[i % voidCompost.length]?.type || 'void';
+    const html = `<div style="width:48px;height:48px;background:${cmykToCss(color)};display:flex;align-items:center;justify-content:center;font-size:1.1em;color:#fff;border-radius:10px;">${dim}<br><span style='font-size:0.7em;'>${source}</span></div>`;
+    return { dim, color, html, source };
+  });
+}
+
+/**
+ * Animate the transformation: returns animation frames for emergence/imergence.
+ * Each frame is an array of overlay data, showing the merging and rebirth process.
+ */
+export function animateVoidTransformation(frames: number = 20, length: number = 11): Array<Array<{ dim: number; color: { c: number; m: number; y: number; k: number }; html: string; source: string }>> {
+  const out = [];
+  for (let f = 0; f < frames; f++) {
+    out.push(getVoidStreamOverlayData(length).map((d, i) => {
+      // Animate color/opacity based on frame
+      const opacity = max(0.2, 1 - abs(f - i) / frames);
+      const html = `<div style="width:48px;height:48px;background:${cmykToCss(d.color)};opacity:${opacity};display:flex;align-items:center;justify-content:center;font-size:1.1em;color:#fff;border-radius:10px;">${d.dim}<br><span style='font-size:0.7em;'>${d.source}</span></div>`;
+      return { ...d, html };
+    }));
+  }
+  return out;
+}
+
+/**
+ * Metaphysical meaning: The void is the living gateway—streams emerge, user actions imerge, all is harmonized and reborn.
+ */
+export const voidStreamMetaphysics =
+  'The void is the living gateway—streams emerge, user actions imerge, all is harmonized and reborn as new multidimensional experience.'; 

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

@@ -0,0 +1,84 @@
+import { PI, cos, sin } from './a432.algebra.ts'
+// a432.vortex.cmyk.matrix.ts
+// Living vortex flow through the digital CMYK matrix (a432)
+
+import {
+  generateA432Matrix,
+  type A432MatrixEntry,
+  cmykIdToPhrase,
+  digitColors
+} from './a432.mapping.ts';
+import { type A432Id } from './a432.design.cmyk.ts';
+
+// Rodin vortex sequence for a single channel
+const rodinSeq = [1, 2, 4, 8, 7, 5];
+
+export function rodinVortexStep(id: A432Id, channel: 0|1|2|3): A432Id {
+  const idx = rodinSeq.indexOf(id[channel]);
+  const next = rodinSeq[(idx + 1) % rodinSeq.length];
+  const newId = [...id] as A432Id;
+  newId[channel] = next;
+  return newId;
+}
+
+export function traverseVortexMatrix(
+  start: A432Id,
+  steps: number,
+  channel: 0|1|2|3 = 0
+): A432MatrixEntry[] {
+  const matrix = generateA432Matrix();
+  let current = start;
+  const path: A432MatrixEntry[] = [];
+  for (let i = 0; i < steps; i++) {
+    const entry = matrix.find(e => e.id.every((d, j) => d === current[j]));
+    if (entry) path.push(entry);
+    current = rodinVortexStep(current, channel);
+  }
+  return path;
+}
+
+// Metaphysical overlay for shift vs. oppose
+export function metaphysicalShiftOverlay() {
+  return `<div style="margin-top:10px;font-size:13px;color:#ff8;white-space:pre-line;">
+    <b>Why Shift Lives and Opposition Kills:</b><br>
+    In the a432 and Rodin vortex, only the 60-degree shift (the next step in the living sequence) preserves the stream. Opposition (inversion, flipping) breaks the flow, collapses recursion, and leads to stasis or entropy. Shift is life, recursion, and harmony; opposition is death, stasis, and entropy. The living vortex is always shifting, never opposing.
+  </div>`;
+}
+
+export function renderVortexMatrixSVG(path: A432MatrixEntry[], highlightIndex: number = -1): string {
+  // Spiral layout
+  const size = 400, cx = size/2, cy = size/2, baseR = 40, spiralGap = 18;
+  const n = path.length;
+  const points = path.map((entry, i) => {
+    const angle = (2 * PI * i) / n * 2;
+    const r = baseR + spiralGap * i;
+    return {
+      x: cx + r * cos(angle),
+      y: cy + r * sin(angle),
+      entry
+    };
+  });
+  const nodes = points.map((p, i) => {
+    const color = digitColors[p.entry.id[0]];
+    const highlight = i === highlightIndex ? 'filter="url(#glow)"' : '';
+    return `<circle cx="${p.x}" cy="${p.y}" r="16" fill="${color}" stroke="#fff" stroke-width="2" ${highlight}>
+      <title>${p.entry.phrase}</title></circle>
+      <text x="${p.x}" y="${p.y+5}" text-anchor="middle" font-size="11" fill="#fff">${cmykIdToPhrase(p.entry.id)}</text>`;
+  }).join('');
+  // Animate a pulse along the spiral (highlight the current node)
+  const pulse = points.map((p, i) =>
+    `<circle cx="${p.x}" cy="${p.y}" r="${i === highlightIndex ? 22 : 0}" fill="#ff8" fill-opacity="0.18">
+      <animate attributeName="r" values="0;22;0" keyTimes="0;0.5;1" dur="1.2s" begin="0s" repeatCount="indefinite"/>
+    </circle>`
+  ).join('');
+  // SVG filter for glow effect
+  const glow = `<filter id="glow"><feGaussianBlur stdDeviation="4" result="coloredBlur"/><feMerge><feMergeNode in="coloredBlur"/><feMergeNode in="SourceGraphic"/></feMerge></filter>`;
+  return `
+    <svg width="${size}" height="${size}" style="background:#111;border-radius:16px;">
+      ${glow}
+      ${pulse}
+      ${nodes}
+      <text x="${cx}" y="${size-18}" text-anchor="middle" font-size="14" fill="#8ff">a432 Vortex CMYK Matrix: 60° Shift (Rodin)</text>
+    </svg>
+  `;
+}