zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,343 @@
+/**
+ * a432.vbm.path.ts — VBM Path Navigation Module
+ * 
+ * This module interprets path structures like "0/0\3\6\9/1\2\4\8/7/5/1\" as
+ * navigation sequences within the A432 matrix, using canonical math procedures.
+ * 
+ * Metaphysical Principle:
+ * - Forward slashes (/) represent forward movement in consciousness
+ * - Backward slashes (\) represent backward movement or reflection
+ * - Each digit represents a state in the A432 system
+ * - The path creates a living navigation through the vortex of consciousness
+ */
+
+import { abs, max, min, round } from './a432.algebra.ts'
+import { 
+  RODIN_SEQUENCE, 
+  TRINITY_AXIS, 
+  digitalRoot, 
+  angleForDigit,
+  frequencyForDigit,
+  hueForDigit 
+} from './a432.math.ts';
+
+// --- Canonical VBM Path Constants ---
+const VBM_PATH_SEPARATORS = {
+  FORWARD: '/',
+  BACKWARD: '\\'
+} as const;
+
+const VBM_PATH_SEQUENCE = [0, 0, 3, 6, 9, 1, 2, 4, 8, 7, 5, 1] as const;
+
+// --- VBM Path State Interface ---
+interface VBMPathState {
+  path: string;
+  sequence: number[];
+  directions: VBMDirection[];
+  currentIndex: number;
+  depth: number;
+}
+
+interface VBMDirection {
+  digit: number;
+  separator: string;
+  index: number;
+  angle: number;
+  frequency: number;
+  color: string;
+}
+
+interface VBMPathNode {
+  digit: number;
+  direction: 'forward' | 'backward';
+  depth: number;
+  angle: number;
+  frequency: number;
+  color: string;
+  digitalRoot: number;
+}
+
+// --- Canonical VBM Path Parsing ---
+function parseVBMPath(path: string): VBMPathState {
+  const sequence: number[] = [];
+  const directions: VBMDirection[] = [];
+  let currentIndex = 0;
+  let depth = 0;
+  
+  // Parse the path string
+  for (let i = 0; i < path.length; i++) {
+    const char = path[i];
+    
+    if (char === VBM_PATH_SEPARATORS.FORWARD || char === VBM_PATH_SEPARATORS.BACKWARD) {
+      // This is a separator, look for the next digit
+      const nextDigit = parseInt(path[i + 1]);
+      if (!isNaN(nextDigit)) {
+        sequence.push(nextDigit);
+        
+        const direction: VBMDirection = {
+          digit: nextDigit,
+          separator: char,
+          index: currentIndex,
+          angle: angleForDigit(nextDigit),
+          frequency: frequencyForDigit(nextDigit),
+          color: generateVBMColor(nextDigit)
+        };
+        
+        directions.push(direction);
+        currentIndex++;
+        
+        // Update depth based on direction
+        if (char === VBM_PATH_SEPARATORS.FORWARD) {
+          depth++;
+        } else {
+          depth--;
+        }
+      }
+    }
+  }
+  
+  return {
+    path,
+    sequence,
+    directions,
+    currentIndex,
+    depth
+  };
+}
+
+// --- Canonical VBM Color Generation ---
+function generateVBMColor(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})`;
+}
+
+// --- VBM Path Navigation ---
+export class VBMPathNavigator {
+  private state: VBMPathState;
+  private nodes: VBMPathNode[];
+  
+  constructor(path: string) {
+    this.state = parseVBMPath(path);
+    this.nodes = this.createPathNodes();
+  }
+  
+  private createPathNodes(): VBMPathNode[] {
+    const nodes: VBMPathNode[] = [];
+    let depth = 0;
+    
+    this.state.directions.forEach((direction, index) => {
+      const node: VBMPathNode = {
+        digit: direction.digit,
+        direction: direction.separator === VBM_PATH_SEPARATORS.FORWARD ? 'forward' : 'backward',
+        depth: depth,
+        angle: direction.angle,
+        frequency: direction.frequency,
+        color: direction.color,
+        digitalRoot: digitalRoot(direction.digit)
+      };
+      
+      nodes.push(node);
+      
+      // Update depth
+      if (direction.separator === VBM_PATH_SEPARATORS.FORWARD) {
+        depth++;
+      } else {
+        depth--;
+      }
+    });
+    
+    return nodes;
+  }
+  
+  // --- Navigation Methods ---
+  public getPath(): string {
+    return this.state.path;
+  }
+  
+  public getSequence(): number[] {
+    return [...this.state.sequence];
+  }
+  
+  public getDirections(): VBMDirection[] {
+    return [...this.state.directions];
+  }
+  
+  public getNodes(): VBMPathNode[] {
+    return [...this.nodes];
+  }
+  
+  public getCurrentDepth(): number {
+    return this.state.depth;
+  }
+  
+  public getCurrentIndex(): number {
+    return this.state.currentIndex;
+  }
+  
+  // --- Path Analysis ---
+  public getForwardMoves(): VBMPathNode[] {
+    return this.nodes.filter(node => node.direction === 'forward');
+  }
+  
+  public getBackwardMoves(): VBMPathNode[] {
+    return this.nodes.filter(node => node.direction === 'backward');
+  }
+  
+  public getTrinityNodes(): VBMPathNode[] {
+    return this.nodes.filter(node => TRINITY_AXIS.includes(node.digit));
+  }
+  
+  public getRodinNodes(): VBMPathNode[] {
+    return this.nodes.filter(node => RODIN_SEQUENCE.includes(node.digit));
+  }
+  
+  public getMaxDepth(): number {
+    return max(...this.nodes.map(node => node.depth));
+  }
+  
+  public getMinDepth(): number {
+    return min(...this.nodes.map(node => node.depth));
+  }
+  
+  // --- Path Statistics ---
+  public getPathStatistics() {
+    const forwardMoves = this.getForwardMoves();
+    const backwardMoves = this.getBackwardMoves();
+    const trinityNodes = this.getTrinityNodes();
+    const rodinNodes = this.getRodinNodes();
+    
+    return {
+      totalNodes: this.nodes.length,
+      forwardMoves: forwardMoves.length,
+      backwardMoves: backwardMoves.length,
+      trinityNodes: trinityNodes.length,
+      rodinNodes: rodinNodes.length,
+      maxDepth: this.getMaxDepth(),
+      minDepth: this.getMinDepth(),
+      currentDepth: this.getCurrentDepth(),
+      averageDepth: this.nodes.reduce((sum, node) => sum + node.depth, 0) / this.nodes.length
+    };
+  }
+  
+  // --- Path Visualization ---
+  public getPathVisualization(): string {
+    let visualization = '';
+    const currentDepth = 0;
+    
+    this.nodes.forEach((node, index) => {
+      const indent = '  '.repeat(max(0, node.depth));
+      const direction = node.direction === 'forward' ? '→' : '←';
+      const color = node.color;
+      
+      visualization += `${indent}${direction} ${node.digit} (${color})\n`;
+    });
+    
+    return visualization;
+  }
+  
+  // --- Path Validation ---
+  public isValidPath(): boolean {
+    // Check if all digits are valid (0-9)
+    const validDigits = this.state.sequence.every(digit => digit >= 0 && digit <= 9);
+    
+    // Check if path has balanced structure
+    const balanced = this.getCurrentDepth() >= 0;
+    
+    return validDigits && balanced;
+  }
+  
+  // --- Path Generation ---
+  public generateReversePath(): string {
+    const reverseNodes = [...this.nodes].reverse();
+    let reversePath = '';
+    
+    reverseNodes.forEach(node => {
+      const separator = node.direction === 'forward' ? VBM_PATH_SEPARATORS.BACKWARD : VBM_PATH_SEPARATORS.FORWARD;
+      reversePath += `${separator}${node.digit}`;
+    });
+    
+    return reversePath;
+  }
+}
+
+// --- VBM Path Factory ---
+export function createVBMPathNavigator(path: string): VBMPathNavigator {
+  return new VBMPathNavigator(path);
+}
+
+// --- VBM Path Constants Export ---
+export const VBM_PATH_CONSTANTS = {
+  SEPARATORS: VBM_PATH_SEPARATORS,
+  SEQUENCE: VBM_PATH_SEQUENCE
+} as const;
+
+// --- VBM Path Documentation ---
+export const VBM_PATH_DOC = {
+  purpose: 'VBM Path Navigation - Interprets path structures as navigation sequences',
+  path: 'Uses forward (/) and backward (\\) separators for navigation',
+  sequence: 'Each digit represents a state in the A432 system',
+  navigation: 'Forward moves increase depth, backward moves decrease depth',
+  trinity: 'Trinity nodes (3, 6, 9) represent field of consciousness',
+  rodin: 'Rodin nodes (1, 2, 4, 8, 7, 5) represent doubling vortex',
+  colors: 'Colors generated using digital root logic mapped to HSV'
+} as const;
+
+// --- VBM Path Utility Functions ---
+export function parseVBMPathString(path: string): VBMPathNavigator {
+  return createVBMPathNavigator(path);
+}
+
+export function getVBMPathSequence(path: string): number[] {
+  const navigator = createVBMPathNavigator(path);
+  return navigator.getSequence();
+}
+
+export function getVBMPathStatistics(path: string) {
+  const navigator = createVBMPathNavigator(path);
+  return navigator.getPathStatistics();
+}
+
+export function validateVBMPath(path: string): boolean {
+  const navigator = createVBMPathNavigator(path);
+  return navigator.isValidPath();
+}
+
+// --- Example Usage Function ---
+export function analyzeVBMPath(path: string) {
+  const navigator = createVBMPathNavigator(path);
+  
+  console.log('VBM Path Analysis:');
+  console.log('Path:', navigator.getPath());
+  console.log('Sequence:', navigator.getSequence());
+  console.log('Statistics:', navigator.getPathStatistics());
+  console.log('Visualization:', navigator.getPathVisualization());
+  console.log('Is Valid:', navigator.isValidPath());
+  console.log('Reverse Path:', navigator.generateReversePath());
+  
+  return navigator;
+} 

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

@@ -0,0 +1,91 @@
+import { type Fraction } from './a432.math.ts';
+
+/**
+ * VBMDigitRelations – raw digit sequences (as strings) extracted from VBM.txt.
+ * Consumers can parse via `s.split(' ').map(Number)` or other helpers.
+ */
+export const VBMDigitRelations: readonly string[] = [
+  "0 1 3 12",
+  "0 66 12",
+  "0 77 99 88 88 99 77 11",
+  "00 3 12",
+  "00 5 62",
+  "1 0 0",
+  "1 1 2 3",
+  "1 1 2 4 8 7 5 1 2 4 8 2 8 2 4 8 7 5 8 2 4 8 3 8 7 4 8 7 5 8 7 4 8 4 8 7 4 8 7 5 8 7 4 8 5 8 7 5 8 7 5 8 7 5",
+  "1 2 3",
+  "1 2 4",
+  "1 2 4 5 8 7 5",
+  "1 2 4 7 5",
+  "1 2 4 8",
+  "1 2 4 8 16 32",
+  "1 2 4 8 7 5",
+  "1 2 4 8 7 5 1 2 4 8 7 5 1 2 4 8 7 5",
+  "1 2 5",
+  "1 3 4",
+  "1 4 5",
+  "1 4 6 11",
+  "1 4 7",
+  "1 55 11 49 22 33",
+  "1 55 11 49 22 33 33 22 49 11 55 12",
+  "1 6 2 7 3 8 4 5",
+  "1 6 5 2 9 7 4 3 8",
+  "1 6 5 2 9 7 4 3 8 8 3 4 7 9 2 5 6 1",
+  "1 66 11",
+  "1 7 4",
+  "1 7 8 2 3 9 4 10 5 11 6",
+  "1 8 2 7 4 5",
+  "10 26 50 12",
+  "10 9 9 9 9 9",
+  "10 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9",
+  "14 7 21 49 28 42 35 35 42 28 49 21 7 14",
+  "2 2 5 4 6",
+  "2 5 8",
+  "2 6 3 5 4",
+  "2 8 1 3",
+  "2 8 5",
+  "25 1 1 00",
+  "3 1 4 7",
+  "3 5 4 7 7 7",
+  "3 6 2 5 8",
+  "3 6 9",
+  "3 6 9 9 6 3",
+  "3 7 1 5 4 2 5 3 9 8 4 4 5 5 1",
+  "3 7 7 8 1 8 9 8",
+  "3 9 6",
+  "3 9 6 6 9 3",
+  "3 9 6 6 9 3 3 9 6",
+  "3 9 6 6 9 3 3 9 6 6 9 3 3 9 6 6 9 3",
+  "33 22 49 11 55 12",
+  "5 1 2 4",
+  "5 10 10 00",
+  "5 10 25 15 20 20 15 25 10 5 5 10 25 15 20 2 0 1 5 2 5 1 0 5 5 1 0 2 5 1 5 2 0 20 15 25 10 5",
+  "5 12 10 7 3 8",
+  "5 25 10",
+  "5 3 9 6",
+  "5 4 9 8 1 7 2 6 3 5 4",
+  "5 7 8 4 2 1",
+  "52 32 72",
+  "6 3 3",
+  "6 32 22 21 11 31 1 5 36 12 2 10 15 26 35 33 28 8 20 30 18 23 9 19 13 29 3 4 14 24",
+  "6 4 7 5 4 8 6 2",
+  "6 9 3 6 9",
+  "7 3 9 6",
+  "7 9 2 5 6 1 1 6 5 2 9",
+  "7 9 8 1",
+  "8 3 7 2 6 1 5 9",
+  "8 7 1 3",
+  "8 7 6",
+  "8 9 1 7 2 6 5 4 3",
+  "9 1 1 8 1 2 2 6 3 5 5 1 4 8",
+  "9 1 2 3 5 4",
+  "9 7 2 9 2",
+  "9 9 6",
+  "9 9 9",
+  "9 9 9 9 9 9 9 9 9 9 9 9 9 9",
+  "9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9",
+  "9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9"
+] as const;
+
+/** Transform to numeric arrays */
+export const VBMDigitArrays: readonly number[][] = VBMDigitRelations.map(s => s.split(' ').map(Number)); 

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

@@ -0,0 +1,45 @@
+/**
+ * a432.vbm.relations.ts — Extract digit relations from VBM.txt
+ * -------------------------------------------------------------
+ * Reads the Rodin VBM text file and returns unique sequences of
+ * digits (length≥3) that appear, e.g. “1-2-4-8-7-5”, “3 6 9”, etc.
+ * Designed for quick pattern discovery.
+ */
+
+import { log } from './a432.algebra.ts'
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const VBM_PATH = path.resolve(import.meta.dirname, 'rodin-knowledge/VBM.txt');
+
+/** Regex capturing sequences of 1–2-digit numbers separated by space, dot, comma or dash. */
+const SEQ_REGEX = /(\d{1,2}(?:[\s.,;-]+\d{1,2}){2,})/g;
+
+/** Normalise a raw sequence to canonical form: single spaces between numbers. */
+function normalise(seq: string): string {
+  return seq
+    .replace(/[\s.,;-]+/g, ' ') // unify separators
+    .trim()
+    .replace(/ +/g, ' ');
+}
+
+export async function extractVBMDigitRelations(): Promise<string[]> {
+  const raw = await fs.readFile(VBM_PATH, 'utf8');
+  const matches = raw.matchAll(SEQ_REGEX);
+  const set = new Set<string>();
+  for (const m of matches) {
+    const norm = normalise(m[0]);
+    // discard sequences that are just years (e.g., 2021) or very long
+    if (/^\d{4,}$/.test(norm)) continue;
+    set.add(norm);
+  }
+  return Array.from(set).sort((a, b) => a.localeCompare(b));
+}
+
+// CLI helper
+if (require.main === module) {
+  (async () => {
+    const seqs = await extractVBMDigitRelations();
+    seqs.forEach(s => console.log(s));
+  })();
+} 

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

@@ -0,0 +1,41 @@
+import { log } from './a432.algebra.ts'
+import fs from 'fs/promises';
+import path from 'path';
+
+// Path to VBM text
+const VBM_FILE = path.resolve(import.meta.dirname, 'rodin-knowledge/VBM.txt');
+const OUTPUT_JSON = path.resolve(import.meta.dirname, 'extracted-vbm-math.json');
+
+// Regexes
+const RATIO_RE = /(\d+\s*[:/]\s*\d+)/g;
+const EQ_RE = /(\d+[^\n]{0,20}=.{0,20}\d+)/g; // crude equation capture
+const ANGLE_RE = /(\d+°)/g;
+const FREQ_RE = /(\d+\s*Hz)/gi;
+const LONG_INT_RE = /\b\d{3,}\b/g;
+
+interface Extracted {
+  kind: 'ratio' | 'equation' | 'angle' | 'frequency' | 'number';
+  value: string;
+  line: number;
+}
+
+(async () => {
+  const raw = await fs.readFile(VBM_FILE, 'utf8');
+  const lines = raw.split(/\r?\n/);
+  const out: Extracted[] = [];
+  lines.forEach((line, idx) => {
+    const pushMatches = (iter: Iterable<RegExpMatchArray>|null, kind: Extracted['kind']) => {
+      if (!iter) return;
+      for (const m of iter) {
+        out.push({ kind, value: m[0].trim(), line: idx + 1 });
+      }
+    };
+    pushMatches(line.matchAll(RATIO_RE), 'ratio');
+    pushMatches(line.matchAll(EQ_RE), 'equation');
+    pushMatches(line.matchAll(ANGLE_RE), 'angle');
+    pushMatches(line.matchAll(FREQ_RE), 'frequency');
+    pushMatches(line.matchAll(LONG_INT_RE), 'number');
+  });
+  await fs.writeFile(OUTPUT_JSON, JSON.stringify(out, null, 2), 'utf8');
+  console.log(`Extracted ${out.length} math tokens -> ${path.relative(process.cwd(), OUTPUT_JSON)}`);
+})(); 

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

@@ -0,0 +1,30 @@
+/**
+ * a432.vbm.science.extract.ts — pull science-oriented sentences from VBM.txt
+ */
+
+import { log } from './a432.algebra.ts'
+import fs from 'fs/promises';
+import path from 'path';
+
+const VBM = path.resolve(import.meta.dirname, 'rodin-knowledge/VBM.txt');
+const OUT = path.resolve(import.meta.dirname, 'extracted-vbm-science.txt');
+
+const KEYWORDS = [
+  'physics', 'energy', 'frequency', 'resonance', 'electron', 'coil', 'torus',
+  'vortex', 'inertia', 'field', 'plasma', 'dna', 'pyramid', 'magnet', 'quantum',
+  'harmonic', 'over-unity', 'winding', 'wave', 'doubling', 'mod 9', 'poloidal', 'power',
+];
+
+(async () => {
+  const raw = await fs.readFile(VBM, 'utf8');
+  const lines = raw.split(/\r?\n/);
+  const out: string[] = [];
+  lines.forEach((line, i) => {
+    const lLine = line.toLowerCase();
+    if (KEYWORDS.some(k => lLine.includes(k))) {
+      out.push(`${i+1}: ${line.trim()}`);
+    }
+  });
+  await fs.writeFile(OUT, out.join('\n'), 'utf8');
+  console.log(`Science lines: ${out.length} -> ${path.relative(process.cwd(), OUT)}`);
+})(); 

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

@@ -0,0 +1,64 @@
+import { PI, abs, cos, floor, sin } from './a432.algebra.ts'
+import { VBM_DOUBLING, VBM_TESLA_FREQUENCIES, sequenceToAngles, VBM_SHOCK_WAVE } from './a432.vbm.math.ts';
+import { digitAngleToCMYK, cmykToCss } from './a432.cmyk.ts';
+
+/** Simple Vector3 type (avoid Three.js dependency in math layer) */
+export interface Vec3 { x: number; y: number; z: number; }
+
+// local digital-root helper (avoid extra import)
+function dr(n: number): number { let x=abs(n); while(x>=10) x=String(x).split('').reduce((a,c)=>a+Number(c),0); return x; }
+
+// ——————————————————————————————————————————
+// Rodin coil path generator (poloidal helix)
+// ---------------------------------------------------------
+export function generateRodinCoilPath(cycles: number, stepHeight = 1, radius = 1): Vec3[] {
+  const seq: number[] = [];
+  for (let c = 0; c < cycles; c++) seq.push(...VBM_DOUBLING);
+  const verts: Vec3[] = [];
+  seq.forEach((digit, i) => {
+    const angle = sequenceToAngles([digit])[0] * (PI / 180);
+    const r = radius * (dr(digit) / 9);
+    verts.push({
+      x: r * cos(angle),
+      y: i * stepHeight,
+      z: r * sin(angle)
+    });
+  });
+  return verts;
+}
+
+// ——————————————————————————————————————————
+// Trinity heartbeat torus segments descriptor
+// ---------------------------------------------------------
+export interface TorusSegmentDesc {
+  startAngle: number; // deg
+  endAngle: number;   // deg
+  color: string;      // css hex
+}
+
+export function getTrinityTorusSegments(): TorusSegmentDesc[] {
+  return [3, 6, 9].map(d => {
+    const hueAngle = sequenceToAngles([d])[0];
+    const cmyk = digitAngleToCMYK(d, 0);
+    return {
+      startAngle: hueAngle,
+      endAngle: hueAngle + 120,
+      color: cmykToCss(cmyk)
+    };
+  });
+}
+
+// ——————————————————————————————————————————
+// Shock-wave of nine pulse values (for UI opacity/scale)
+// ---------------------------------------------------------
+export function shockWaveValues(length: number): number[] {
+  return VBM_SHOCK_WAVE(length).map(d => d / 9); // 0.333 ↔ 1 scale factor
+}
+
+// ——————————————————————————————————————————
+// Tesla frequency helper
+// ---------------------------------------------------------
+export function getTeslaFrequency(timeMs: number): number {
+  const idx = floor(timeMs / 1000) % VBM_TESLA_FREQUENCIES.length;
+  return VBM_TESLA_FREQUENCIES[idx];
+}