zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,92 @@
+import { PI, cos, sin } from './a432.algebra.ts'
+import { getTrinityDotStyle, trinityFieldState } from './a432.trinity.ts';
+
+/**
+ * NOTE: These functions are for browser/DOM use. If using in a non-DOM environment, adapt as needed.
+ */
+
+/**
+ * TrinityDot: Render a single trinity dot as a div (HTML) with harmonized style.
+ */
+export function TrinityDot({ trinity, angle = 0, label = null }: { trinity: number, angle?: number, label?: string | null }): any {
+  const dot = document.createElement('div');
+  dot.style.cssText = getTrinityDotStyle(trinity, angle);
+  dot.title = `Trinity: ${trinity} @ ${angle}°`;
+  dot.textContent = label !== null ? label : String(trinity);
+  return dot;
+}
+
+/**
+ * TrinityAxis: Render the three trinity axis points (3, 6, 9) on a circle as divs (HTML).
+ */
+export function TrinityAxis({ size = 180, center = { x: 90, y: 90 } }: { size?: number, center?: { x: number, y: number } }): any {
+  const container = document.createElement('div');
+  container.style.cssText = `position:relative;width:${size}px;height:${size}px;display:inline-block;`;
+  const r = size * 0.36;
+  [0, 1, 2].forEach(i => {
+    const angle = i * 120;
+    const rad = (angle * PI) / 180;
+    const x = center.x + r * cos(rad) - 16;
+    const y = center.y + r * sin(rad) - 16;
+    const trinity = [3, 6, 9][i];
+    const dot = TrinityDot({ trinity, angle, label: String(trinity) });
+    dot.style.position = 'absolute';
+    dot.style.left = `${x}px`;
+    dot.style.top = `${y}px`;
+    container.appendChild(dot);
+  });
+  return container;
+}
+
+/**
+ * TrinityFieldMap: Render the full trinity field as a circular map of dots (HTML).
+ */
+export function TrinityFieldMap({ resolution = 36, size = 240 }: { resolution?: number, size?: number }): any {
+  const container = document.createElement('div');
+  container.style.cssText = `position:relative;width:${size}px;height:${size}px;display:inline-block;`;
+  const cx = size / 2, cy = size / 2, r = size * 0.38;
+  for (let i = 0; i < resolution; i++) {
+    const angle = (i * 360) / resolution;
+    const rad = (angle * PI) / 180;
+    const x = cx + r * cos(rad) - 16;
+    const y = cy + r * sin(rad) - 16;
+    const trinity = trinityFieldState(angle);
+    const dot = TrinityDot({ trinity, angle });
+    dot.style.position = 'absolute';
+    dot.style.left = `${x}px`;
+    dot.style.top = `${y}px`;
+    container.appendChild(dot);
+  }
+  return container;
+}
+
+/**
+ * StreamToTrinityField: Render a stream of values as animated/interpolated dots on the trinity field (HTML).
+ * The stream is an array of { value, angle } objects.
+ */
+export function StreamToTrinityField({ stream, size = 240 }: { stream: { value: number, angle: number }[], size?: number }): any {
+  const container = document.createElement('div');
+  container.style.cssText = `position:relative;width:${size}px;height:${size}px;display:inline-block;`;
+  const cx = size / 2, cy = size / 2, r = size * 0.38;
+  stream.forEach(({ value, angle }, i) => {
+    const rad = (angle * PI) / 180;
+    const x = cx + r * cos(rad) - 16;
+    const y = cy + r * sin(rad) - 16;
+    const trinity = trinityFieldState(angle);
+    const dot = TrinityDot({ trinity, angle, label: String(value) });
+    dot.style.position = 'absolute';
+    dot.style.left = `${x}px`;
+    dot.style.top = `${y}px`;
+    dot.style.opacity = '0.85';
+    container.appendChild(dot);
+  });
+  return container;
+}
+
+/**
+ * Usage:
+ *   import { TrinityAxis, TrinityFieldMap, StreamToTrinityField, TrinityDot } from './a432.trinity.ui.ts';
+ *   document.body.appendChild(TrinityAxis({ size: 200 }));
+ *   document.body.appendChild(TrinityFieldMap({ resolution: 36, size: 300 }));
+ *   document.body.appendChild(StreamToTrinityField({ stream: [{ value: 7, angle: 45 }, ...] }));
+ */ 

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

@@ -0,0 +1,156 @@
+import { legacyDigitalRoot } from './a432.roots.ts'
+// a432.trinity.visual.ts
+// Visualizes trinity interaction as a harmonic, animated SVG stream for the A432 system
+// All logic is self-contained, integer/fractional, and metaphysically mapped
+
+/**
+ * renderTrinityInteraction: Returns HTML/SVG string visualizing trinity (3, 6, 9) interaction
+ * Shows three nodes cycling, folding, and harmonizing in a vortex pattern
+ * Now includes: sound feedback, color harmonics, meta-observation, UI integration, and metaphysical overlays
+ */
+export function renderTrinityInteraction(vortexStream?: unknown): string {
+  return [
+    '<div id="trinity-container" style="display:flex;flex-direction:column;align-items:center;">',
+    '<h2 style="color:#8ff;">Trinity Interaction (3, 6, 9)</h2>',
+    '<svg id="trinity-svg" width="320" height="320" style="background:#111;border-radius:12px;">',
+    '  <circle id="node3" cx="160" cy="60" r="28" fill="#39f" stroke="#fff" stroke-width="3" />',
+    '  <text x="160" y="66" text-anchor="middle" font-size="20" fill="#fff">3</text>',
+    '  <circle id="node6" cx="60" cy="220" r="28" fill="#6f3" stroke="#fff" stroke-width="3" />',
+    '  <text x="60" y="226" text-anchor="middle" font-size="20" fill="#fff">6</text>',
+    '  <circle id="node9" cx="260" cy="220" r="28" fill="#f93" stroke="#fff" stroke-width="3" />',
+    '  <text x="260" y="226" text-anchor="middle" font-size="20" fill="#fff">9</text>',
+    '  <polyline id="cycle-path" points="160,60 60,220 260,220 160,60" fill="none" stroke="#0ff" stroke-width="4" stroke-dasharray="8,6" />',
+    '</svg>',
+    '<div style="margin-top:12px;">',
+    '  <button id="cycle-btn" style="background:#222;color:#8ff;padding:6px 18px;border-radius:6px;border:none;font-weight:bold;">Cycle</button>',
+    '  <button id="fold-btn" style="background:#222;color:#ff8;padding:6px 18px;border-radius:6px;border:none;font-weight:bold;margin-left:8px;">Fold</button>',
+    '  <button id="meta-btn" style="background:#222;color:#f8f;padding:6px 18px;border-radius:6px;border:none;font-weight:bold;margin-left:8px;">Meta-Observe</button>',
+    '  <button id="overlay-btn" style="background:#222;color:#0ff;padding:6px 18px;border-radius:6px;border:none;font-weight:bold;margin-left:8px;">Toggle Overlay</button>',
+    '  <span id="trinity-meta" style="margin-left:16px;color:#fff;font-size:16px;"></span>',
+    '</div>',
+    '<div id="meta-panel" style="display:none;margin-top:16px;width:90%;max-width:400px;background:#222;border-radius:8px;padding:12px;min-height:60px;color:#fff;font-size:14px;overflow-y:auto;max-height:120px;"></div>',
+    '<div id="overlay-panel" style="display:none;margin-top:10px;width:90%;max-width:400px;background:#1a1a2a;border-radius:8px;padding:10px;color:#ff8;font-size:15px;">',
+    '  <b>Metaphysical Overlay</b><br>',
+    '  <span id="overlay-content"></span>',
+    '</div>',
+    '<script>',
+    'const nodes = [',
+    '  { id: "node3", x: 160, y: 60, value: 3, color: "#39f", freq: 432, meta: "Creation: The generative act, the beginning of the stream." },',
+    '  { id: "node6", x: 60, y: 220, value: 6, color: "#6f3", freq: 648, meta: "Return: The harmonic return, the balancing of the stream." },',
+    '  { id: "node9", x: 260, y: 220, value: 9, color: "#f93", freq: 972, meta: "Axis: The axis of unity, the self-aware observer." }',
+    '];',
+    'let state = 0;',
+    'let metaLog = [];',
+    'let overlayOn = false;',
+    'function updateMeta() {',
+    '  const sum = nodes.reduce((acc, n) => acc + n.value, 0);',
+    '  const digitalRoot = legacyDigitalRoot(sum);',
+    '  document.getElementById("trinity-meta").textContent = `Sum: ${sum}, Digital Root: ${digitalRoot}`;',
+    '}',
+    '// --- Sound logic (Web Audio API, harmonic frequencies) ---',
+    'let ctx, osc;',
+    'function playSound(freq) {',
+    '  if (!window.AudioContext) return;',
+    '  if (!ctx) ctx = new window.AudioContext();',
+    '  if (osc) { osc.stop(); osc.disconnect(); }',
+    '  osc = ctx.createOscillator();',
+    '  osc.type = "sine";',
+    '  osc.frequency.value = freq;',
+    '  osc.connect(ctx.destination);',
+    '  osc.start();',
+    '  osc.stop(ctx.currentTime + 0.18);',
+    '}',
+    '// --- Color harmonics ---',
+    'function animateColors() {',
+    '  nodes.forEach((n, i) => {',
+    '    const el = document.getElementById(n.id);',
+    '    let hue = (n.value * 40 + state * 60) % 360;',
+    '    el.setAttribute("fill", `hsl(${hue},70%,55%)`);',
+    '  });',
+    '}',
+    '// --- Metaphysical overlays ---',
+    'function updateOverlay(content) {',
+    '  document.getElementById("overlay-content").textContent = content;',
+    '}',
+    'function showOverlay(content) {',
+    '  document.getElementById("overlay-panel").style.display = "block";',
+    '  updateOverlay(content);',
+    '  overlayOn = true;',
+    '}',
+    'function hideOverlay() {',
+    '  document.getElementById("overlay-panel").style.display = "none";',
+    '  overlayOn = false;',
+    '}',
+    'function toggleOverlay() {',
+    '  if (overlayOn) { hideOverlay(); } else {',
+    '    const content = nodes.map(n => `${n.value}: ${n.meta}`).join("\n");',
+    '    showOverlay(content);',
+    '  }',
+    '}',
+    '// --- Meta-observation ---',
+    'function logMeta(event, extra) {',
+    '  const time = new Date().toLocaleTimeString();',
+    '  const entry = `[${time}] ${event} | State: [${nodes.map(n=>n.value).join(", ")}]` + (extra ? ` | ${extra}` : "");',
+    '  metaLog.push(entry);',
+    '  if (metaLog.length > 10) metaLog = metaLog.slice(-10);',
+    '  document.getElementById("meta-panel").innerText = metaLog.join("\n");',
+    '}',
+    'function cycleTrinity() {',
+    '  state = (state + 1) % 3;',
+    '  const v = nodes.pop(); nodes.unshift(v);',
+    '  const pos = [',
+    '    { x: 160, y: 60 },',
+    '    { x: 60, y: 220 },',
+    '    { x: 260, y: 220 }',
+    '  ];',
+    '  nodes.forEach((n, i) => {',
+    '    const el = document.getElementById(n.id);',
+    '    el.setAttribute("cx", pos[i].x);',
+    '    el.setAttribute("cy", pos[i].y);',
+    '    let hue = (n.value * 40 + state * 60) % 360;',
+    '    el.setAttribute("fill", `hsl(${hue},70%,55%)`);',
+    '    const text = document.querySelector(`text[x="${el.getAttribute("cx") }"][y="${parseInt(el.getAttribute("cy"))+6}"]`);',
+    '    if(text) text.textContent = n.value;',
+    '  });',
+    '  document.getElementById("cycle-path").setAttribute("points", pos.map(p => `${p.x},${p.y}`).join(" ") + " " + `${pos[0].x},${pos[0].y}`);',
+    '  updateMeta();',
+    '  playSound(nodes[0].freq);',
+    '  animateColors();',
+    '  logMeta("Cycle", nodes.map(n => n.meta).join(" | "));',
+    (typeof vortexStream !== 'undefined' ? '  if(window.vortexStreamUpdate) window.vortexStreamUpdate(nodes.map(n=>n.value));' : ''),
+    '}',
+    'function foldTrinity() {',
+    '  nodes.forEach(n => {',
+    '    const el = document.getElementById(n.id);',
+    '    el.setAttribute("cx", 160);',
+    '    el.setAttribute("cy", 140);',
+    '    el.setAttribute("fill", "#fff");',
+    '  });',
+    '  document.getElementById("cycle-path").setAttribute("points", "160,140 160,140 160,140 160,140");',
+    '  document.getElementById("trinity-meta").textContent = "Folded: Unity (Digital Root: 9)";',
+    '  playSound(864);',
+    '  logMeta("Fold", "Unity: All trinity states merged. Axis of consciousness.");',
+    '  if (overlayOn) showOverlay("Unity: All trinity states merged. Axis of consciousness.");',
+    '}',
+    'document.getElementById("cycle-btn").onclick = cycleTrinity;',
+    'document.getElementById("fold-btn").onclick = foldTrinity;',
+    'document.getElementById("meta-btn").onclick = function() {',
+    '  const panel = document.getElementById("meta-panel");',
+    '  panel.style.display = panel.style.display === "block" ? "none" : "block";',
+    '};',
+    'document.getElementById("overlay-btn").onclick = toggleOverlay;',
+    'updateMeta();',
+    'animateColors();',
+    'logMeta("Init", nodes.map(n => n.meta).join(" | "));',
+    '</script>',
+    '</div>'
+  ].join('\n');
+}
+
+/**
+ * injectTrinityVisualization: Injects the trinity visualization into a DOM element by id
+ */
+export function injectTrinityVisualization(targetId: string, vortexStream?: unknown) {
+  const el = document.getElementById(targetId);
+  if (el) el.innerHTML = renderTrinityInteraction(vortexStream);
+} 

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

@@ -0,0 +1,270 @@
+/**
+ * a432.triple.merkaba.3d.ts — Triple Merkaba 3D Animation
+ *
+ * 3D visualization of the 3-tetrahedra compound with D₃d symmetry
+ * All calculations derived from A432 math - no external constants
+ *
+ * @module a432.triple.merkaba.3d
+ * @author A432 System
+ */
+
+import { PI, cos, sin } from './a432.algebra.ts'
+import {
+  A432_TRINITY,
+  A432_RETURN,
+  A432_AXIS,
+  A432_SEQUENCE,
+  digitalRoot,
+  angleForDigit,
+  frequencyForDigit,
+  hueForDigit
+} from './a432.math.ts';
+import { digitAngleToCMYK, cmykToCss } from './a432.cmyk.ts';
+
+// A432-derived 3D constants
+export const A432_3D_CONSTANTS = {
+  // Derived from A432_TRINITY [4,3,2]
+  TETRAHEDRA_COUNT: A432_TRINITY[0], // 4 (but we use 3 for Triple Merkaba)
+  ROTATION_SPEED: digitalRoot(A432_TRINITY[1] * A432_TRINITY[2]), // 3 * 2 = 6
+  SCALE_FACTOR: A432_TRINITY[1], // 3
+  SYMMETRY_ORDER: A432_TRINITY[0] * A432_TRINITY[1], // 4 * 3 = 12
+  
+  // Derived from A432_AXIS [9,6,3]
+  TRINITY_ANGLES: [0, A432_AXIS[2] * 40, A432_AXIS[1] * 40], // [0°, 120°, 240°]
+  ROTATION_AXIS: A432_AXIS[0], // 9
+  
+  // Derived from A432_SEQUENCE
+  ANIMATION_STEPS: A432_SEQUENCE.length, // 11
+  CYCLE_DURATION: A432_SEQUENCE.reduce((sum, d) => sum + d, 0) / 10, // Average step duration
+} as const;
+
+// 3D Tetrahedron Geometry
+export interface A432Tetrahedron {
+  vertices: number[][];
+  faces: number[][];
+  edges: number[][];
+  color: string;
+  position: [number, number, number];
+  rotation: [number, number, number];
+  scale: number;
+}
+
+// 3D Animation State
+export interface A432TripleMerkaba3DState {
+  tetrahedra: A432Tetrahedron[];
+  trinityNodes: A432Tetrahedron[];
+  digitalRootNodes: A432Tetrahedron[];
+  nullSource: A432Tetrahedron;
+  animationTime: number;
+  rotationSpeed: number;
+  harmony: number;
+}
+
+// Generate tetrahedron geometry using A432 math
+function generateA432Tetrahedron(
+  digit: number,
+  position: [number, number, number],
+  color: string
+): A432Tetrahedron {
+  const scale = A432_3D_CONSTANTS.SCALE_FACTOR;
+  const angle = angleForDigit(digit);
+  
+  // Calculate frequency based on digit type (same logic as Triple Merkaba module)
+  let frequency: number;
+  if (digit === 0) {
+    frequency = 0; // Null source has no frequency
+  } else if ([3, 6, 9].includes(digit)) {
+    frequency = frequencyForDigit(digit); // Use existing function for trinity digits
+  } else {
+    // For digital root circuit digits (1,2,4,8,7,5), calculate based on digital root
+    const digitalRootValue = digitalRoot(digit);
+    frequency = 432 * (digitalRootValue / 9);
+  }
+  
+  // Tetrahedron vertices (unit tetrahedron)
+  const vertices = [
+    [1, 1, 1],
+    [-1, -1, 1],
+    [-1, 1, -1],
+    [1, -1, -1]
+  ];
+  
+  // Tetrahedron faces
+  const faces = [
+    [0, 1, 2],
+    [0, 2, 3],
+    [0, 3, 1],
+    [1, 3, 2]
+  ];
+  
+  // Tetrahedron edges
+  const edges = [
+    [0, 1], [0, 2], [0, 3],
+    [1, 2], [1, 3], [2, 3]
+  ];
+  
+  return {
+    vertices,
+    faces,
+    edges,
+    color,
+    position,
+    rotation: [angle, angle * 0.5, angle * 0.25],
+    scale: scale * (digitalRoot(digit) / 9)
+  };
+}
+
+// Generate 3D trinity nodes (3, 6, 9)
+function generateA432TrinityNodes(): A432Tetrahedron[] {
+  const trinityDigits = A432_AXIS; // [9, 6, 3]
+  const colors = ['#ff0000', '#00ff00', '#0000ff'];
+  
+  return trinityDigits.map((digit, index) => {
+    const angle = A432_3D_CONSTANTS.TRINITY_ANGLES[index];
+    const radius = A432_3D_CONSTANTS.SCALE_FACTOR * 2;
+    const x = radius * cos(angle * PI / 180);
+    const y = radius * sin(angle * PI / 180);
+    const z = 0;
+    
+    return generateA432Tetrahedron(
+      digit,
+      [x, y, z],
+      colors[index]
+    );
+  });
+}
+
+// Generate 3D digital root nodes (1, 2, 4, 8, 7, 5)
+function generateA432DigitalRootNodes(): A432Tetrahedron[] {
+  const rodinSequence = [1, 2, 4, 8, 7, 5];
+  const colors = ['#ffff00', '#00ffff', '#ff00ff', '#ffffff', '#ff8800', '#8800ff'];
+  
+  return rodinSequence.map((digit, index) => {
+    const angle = (index * 60) + 30; // Offset by 30° from trinity nodes
+    const radius = A432_3D_CONSTANTS.SCALE_FACTOR * 1.5;
+    const x = radius * cos(angle * PI / 180);
+    const y = radius * sin(angle * PI / 180);
+    const z = A432_3D_CONSTANTS.SCALE_FACTOR * 0.5;
+    
+    return generateA432Tetrahedron(
+      digit,
+      [x, y, z],
+      colors[index]
+    );
+  });
+}
+
+// Generate 3D null source (0/0)
+function generateA432NullSource(): A432Tetrahedron {
+  return generateA432Tetrahedron(
+    0,
+    [0, 0, 0],
+    '#ffffff'
+  );
+}
+
+// Calculate 3D harmony using A432 math
+function calculateA4323DHarmony(tetrahedra: A432Tetrahedron[]): number {
+  const trinitySum = tetrahedra
+    .filter(t => [3, 6, 9].includes(parseInt(t.color.slice(1, 3), 16) % 10))
+    .reduce((sum, t) => sum + t.scale, 0);
+  
+  const digitalRootSum = tetrahedra
+    .filter(t => ![3, 6, 9].includes(parseInt(t.color.slice(1, 3), 16) % 10))
+    .reduce((sum, t) => sum + t.scale, 0);
+  
+  return digitalRoot(trinitySum + digitalRootSum);
+}
+
+// Initialize 3D state
+export function initializeA432TripleMerkaba3D(): A432TripleMerkaba3DState {
+  const trinityNodes = generateA432TrinityNodes();
+  const digitalRootNodes = generateA432DigitalRootNodes();
+  const nullSource = generateA432NullSource();
+  const tetrahedra = [...trinityNodes, ...digitalRootNodes, nullSource];
+  
+  return {
+    tetrahedra,
+    trinityNodes,
+    digitalRootNodes,
+    nullSource,
+    animationTime: 0,
+    rotationSpeed: A432_3D_CONSTANTS.ROTATION_SPEED,
+    harmony: calculateA4323DHarmony(tetrahedra)
+  };
+}
+
+// Update 3D animation
+export function updateA432TripleMerkaba3D(
+  state: A432TripleMerkaba3DState,
+  deltaTime: number
+): A432TripleMerkaba3DState {
+  const newState = { ...state };
+  newState.animationTime += deltaTime;
+  
+  // Rotate all tetrahedra based on A432 math
+  newState.tetrahedra.forEach((tetrahedron, index) => {
+    const digit = index < 3 ? A432_AXIS[index] : 
+                  index < 9 ? [1, 2, 4, 8, 7, 5][index - 3] : 0;
+    const angle = angleForDigit(digit);
+    
+    // Calculate frequency based on digit type
+    let frequency: number;
+    if (digit === 0) {
+      frequency = 0;
+    } else if ([3, 6, 9].includes(digit)) {
+      frequency = frequencyForDigit(digit);
+    } else {
+      const digitalRootValue = digitalRoot(digit);
+      frequency = 432 * (digitalRootValue / 9);
+    }
+    
+    // Rotation based on A432 frequency and angle
+    const rotationSpeed = frequency / 1000; // Normalize frequency
+    const rotationAngle = angle * (newState.animationTime * rotationSpeed);
+    
+    tetrahedron.rotation = [
+      rotationAngle,
+      rotationAngle * 0.5,
+      rotationAngle * 0.25
+    ];
+  });
+  
+  // Update harmony
+  newState.harmony = calculateA4323DHarmony(newState.tetrahedra);
+  
+  return newState;
+}
+
+// Generate 3D scene data for Three.js
+export function generateA432TripleMerkaba3DScene(state: A432TripleMerkaba3DState): any {
+  return {
+    tetrahedra: state.tetrahedra.map(tetrahedron => ({
+      vertices: tetrahedron.vertices,
+      faces: tetrahedron.faces,
+      edges: tetrahedron.edges,
+      color: tetrahedron.color,
+      position: tetrahedron.position,
+      rotation: tetrahedron.rotation,
+      scale: tetrahedron.scale
+    })),
+    trinityNodes: state.trinityNodes.map(node => ({
+      ...node,
+      type: 'trinity'
+    })),
+    digitalRootNodes: state.digitalRootNodes.map(node => ({
+      ...node,
+      type: 'digital-root'
+    })),
+    nullSource: {
+      ...state.nullSource,
+      type: 'null-source'
+    },
+    animationTime: state.animationTime,
+    harmony: state.harmony,
+    constants: A432_3D_CONSTANTS
+  };
+}
+
+// Export the 3D system
+export type { A432TripleMerkaba3DState as A4323DState };