zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,29 @@
+/**
+ * a432.roots — single adapter for contradictory digital-root paths.
+ *
+ * Three spines exist in this tree; never mix them without an adapter:
+ * - kernelDigitalRoot(0) → 9   (src/0 vortex axis)
+ * - legacyDigitalRoot(0) → 0   (VBM / consciousness path)
+ * - harmonicRoot12(0) → 0      (a432.math base-12 harmonic, returns 1–12)
+ *
+ * Prefer importing from here instead of hand-rolling local digitalRoot copies.
+ *
+ * Wave 9+: critical ESM bridges use `.ts` import specifiers for Node strip-types.
+ * Digit-stream `a432.1*.ts` import `legacyDigitalRoot` from here.
+ * Remaining extensionless a432 imports stay rollup-resolved (mass rewrite deferred).
+ * Wave 10: `foldA432AuditCensus` lists residual forks for the next DRY tip.
+ */
+
+export {
+  digitalRoot as kernelDigitalRoot,
+  digitalRoot as classicDigitalRoot,
+  VORTEX_SEQUENCE as KERNEL_VORTEX_SEQUENCE,
+  LEGACY_CONSCIOUSNESS_SEQUENCE,
+} from '../../../../../../../../../../index.ts'
+
+export {
+  legacyDigitalRoot,
+  legacyHarmonicRoot12 as harmonicRoot12,
+  mapLegacyDigitToKernel,
+  rodinOrbit,
+} from '../../../../../../../../../../../kernel/legacy.ts'

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

@@ -0,0 +1,61 @@
+/**
+ * a432.router.ts — Zero-Entropy, Self-Recognizing Routing Stream
+ *
+ * - Each module exports its own pattern and handler.
+ * - The router auto-discovers all patterns/handlers.
+ * - Routing is a living stream: matches by resonance, zero friction, no hardcoding.
+ * - If no match, returns a harmonized 404.
+ * - Metaphysical: Routing is harmonic flow, self-recognition, and zero entropy.
+ */
+
+import { log } from './a432.algebra.ts'
+// Type for a module's route pattern and handler
+export type A432RoutePattern = string | RegExp;
+export type A432RouteHandler = (params: Record<string, string>, req: unknown, res: unknown) => void;
+export interface A432ModuleRoute {
+  pattern: A432RoutePattern;
+  handler: A432RouteHandler;
+  module: string;
+  metaphysics?: string;
+}
+
+// Simulate auto-discovery: modules register themselves here
+const moduleRoutes: A432ModuleRoute[] = [];
+export function registerA432Route(pattern: A432RoutePattern, handler: A432RouteHandler, module: string, metaphysics?: string) {
+  console.log('Registering route pattern:', pattern);
+  moduleRoutes.push({ pattern, handler, module, metaphysics });
+}
+
+/**
+ * Zero-entropy router: matches incoming path to the first (or best) harmonic pattern.
+ * If no match, returns a harmonized 404.
+ */
+export function zeroEntropyRoute(path: string, req: unknown, res: unknown) {
+  for (const { pattern, handler } of moduleRoutes) {
+    let match = false;
+    let params: Record<string, string> = {};
+    if (typeof pattern === 'string') {
+      match = path === pattern;
+    } else if (pattern instanceof RegExp) {
+      const m = path.match(pattern);
+      if (m) {
+        match = true;
+        params = m.groups || {};
+      }
+    }
+    if (match) {
+      return handler(params, req, res);
+    }
+  }
+  // No match: harmonized 404
+  res.statusCode = 404;
+  res.end('Zero entropy: no harmonic route found.');
+}
+
+/**
+ * Example: Module registering its own route
+ * (In practice, each module would call registerA432Route on load)
+ */
+// registerA432Route(/^\/trinity\/(?<digit>\d+)$/, (params, req, res) => {
+//   res.end(`Trinity route for digit ${params.digit}`);
+// }, 'a432.trinity', 'Trinity route handler'); 

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

@@ -0,0 +1,625 @@
+/**
+ * A432 Sacred Geometry Integer Mathematics
+ * All calculations use exact integer arithmetic
+ * No floating point - pure mathematical relationships
+ */
+
+import { cos, sin } from './a432.algebra.ts'
+// ============================================================================
+// PLATONIC SOLIDS - EXACT INTEGER PROPERTIES
+// ============================================================================
+
+export const PLATONIC_SOLIDS = {
+  TETRAHEDRON: {
+    vertices: 4,
+    edges: 6,
+    faces: 4,
+    faceType: 3, // triangular faces
+    vertexDegree: 3, // edges per vertex
+    dualOf: 'TETRAHEDRON', // self-dual
+    schläfli: [3, 3], // {3,3}
+  },
+  
+  CUBE: {
+    vertices: 8,
+    edges: 12,
+    faces: 6,
+    faceType: 4, // square faces
+    vertexDegree: 3,
+    dualOf: 'OCTAHEDRON',
+    schläfli: [4, 3], // {4,3}
+  },
+  
+  OCTAHEDRON: {
+    vertices: 6,
+    edges: 12,
+    faces: 8,
+    faceType: 3, // triangular faces
+    vertexDegree: 4,
+    dualOf: 'CUBE',
+    schläfli: [3, 4], // {3,4}
+  },
+  
+  DODECAHEDRON: {
+    vertices: 20,
+    edges: 30,
+    faces: 12,
+    faceType: 5, // pentagonal faces
+    vertexDegree: 3,
+    dualOf: 'ICOSAHEDRON',
+    schläfli: [5, 3], // {5,3}
+  },
+  
+  ICOSAHEDRON: {
+    vertices: 12,
+    edges: 30,
+    faces: 20,
+    faceType: 3, // triangular faces
+    vertexDegree: 5,
+    dualOf: 'DODECAHEDRON',
+    schläfli: [3, 5], // {3,5}
+  },
+} as const;
+
+// ============================================================================
+// ARCHIMEDEAN SOLIDS - SEMI-REGULAR POLYHEDRA
+// ============================================================================
+
+export const ARCHIMEDEAN_SOLIDS = {
+  TRUNCATED_TETRAHEDRON: {
+    vertices: 12,
+    edges: 18,
+    faces: 8,
+    faceTypes: [3, 6], // triangles and hexagons
+  },
+  
+  CUBOCTAHEDRON: {
+    vertices: 12,
+    edges: 24,
+    faces: 14,
+    faceTypes: [3, 4], // triangles and squares
+  },
+  
+  TRUNCATED_CUBE: {
+    vertices: 24,
+    edges: 36,
+    faces: 14,
+    faceTypes: [3, 8], // triangles and octagons
+  },
+  
+  TRUNCATED_OCTAHEDRON: {
+    vertices: 24,
+    edges: 36,
+    faces: 14,
+    faceTypes: [4, 6], // squares and hexagons
+  },
+  
+  RHOMBICUBOCTAHEDRON: {
+    vertices: 24,
+    edges: 48,
+    faces: 26,
+    faceTypes: [3, 4], // triangles and squares
+  },
+  
+  ICOSIDODECAHEDRON: {
+    vertices: 30,
+    edges: 60,
+    faces: 32,
+    faceTypes: [3, 5], // triangles and pentagons
+  },
+} as const;
+
+// ============================================================================
+// GOLDEN RATIO AND FIBONACCI - INTEGER REPRESENTATIONS
+// ============================================================================
+
+export const GOLDEN_CONSTANTS = {
+  // Fibonacci ratios approaching phi
+  PHI_APPROXIMATIONS: [
+    [1, 1],    // 1.000000
+    [2, 1],    // 2.000000
+    [3, 2],    // 1.500000
+    [5, 3],    // 1.666667
+    [8, 5],    // 1.600000
+    [13, 8],   // 1.625000
+    [21, 13],  // 1.615385
+    [34, 21],  // 1.619048
+    [55, 34],  // 1.617647
+    [89, 55],  // 1.618182
+    [144, 89], // 1.617978
+    [233, 144],// 1.618056
+  ],
+  
+  // Lucas number ratios
+  LUCAS_RATIOS: [
+    [3, 2],    // 1.500000
+    [4, 3],    // 1.333333
+    [7, 4],    // 1.750000
+    [11, 7],   // 1.571429
+    [18, 11],  // 1.636364
+    [29, 18],  // 1.611111
+    [47, 29],  // 1.620690
+    [76, 47],  // 1.617021
+    [123, 76], // 1.618421
+  ],
+  
+  // Pentagon and pentagram ratios
+  PENTAGON_DIAGONAL: [1618, 1000], // diagonal/side ratio
+  PENTAGRAM_RATIO: [1618, 1000],    // star point ratios
+} as const;
+
+// ============================================================================
+// SACRED GEOMETRY CALCULATOR CLASS
+// ============================================================================
+
+export class SacredGeometryIntegers {
+  /**
+   * Verify Euler's formula: V - E + F = 2
+   */
+  static verifyEuler(vertices: number, edges: number, faces: number): boolean {
+    return vertices - edges + faces === 2;
+  }
+  
+  /**
+   * Calculate surface area of regular polyhedron
+   * Using integer math (multiply by 10000 for precision)
+   */
+  static platonicSurfaceArea(solid: keyof typeof PLATONIC_SOLIDS, edgeLength: number): number {
+    const s = edgeLength;
+    
+    switch (solid) {
+      case 'TETRAHEDRON':
+        // A = √3 * s²
+        // √3 ≈ 17321/10000
+        return (17321 * s * s) / 10000;
+        
+      case 'CUBE':
+        // A = 6s²
+        return 6 * s * s;
+        
+      case 'OCTAHEDRON':
+        // A = 2√3 * s²
+        return (2 * 17321 * s * s) / 10000;
+        
+      case 'DODECAHEDRON':
+        // A = 3√(25 + 10√5) * s²
+        // Approximation: 20.6457 ≈ 206457/10000
+        return (3 * 206457 * s * s) / 10000;
+        
+      case 'ICOSAHEDRON':
+        // A = 5√3 * s²
+        return (5 * 17321 * s * s) / 10000;
+        
+      default:
+        return 0;
+    }
+  }
+  
+  /**
+   * Calculate volume of regular polyhedron
+   * Using integer math (multiply by 10000 for precision)
+   */
+  static platonicVolume(solid: keyof typeof PLATONIC_SOLIDS, edgeLength: number): number {
+    const s = edgeLength;
+    
+    switch (solid) {
+      case 'TETRAHEDRON':
+        // V = s³/(6√2)
+        // 1/(6√2) ≈ 1178/10000
+        return (s * s * s * 1178) / 10000;
+        
+      case 'CUBE':
+        // V = s³
+        return s * s * s;
+        
+      case 'OCTAHEDRON':
+        // V = (√2/3) * s³
+        // √2/3 ≈ 4714/10000
+        return (s * s * s * 4714) / 10000;
+        
+      case 'DODECAHEDRON':
+        // V = ((15 + 7√5)/4) * s³
+        // Approximation: 7.6631 ≈ 76631/10000
+        return (s * s * s * 76631) / 10000;
+        
+      case 'ICOSAHEDRON':
+        // V = (5(3 + √5)/12) * s³
+        // Approximation: 2.1817 ≈ 21817/10000
+        return (s * s * s * 21817) / 10000;
+        
+      default:
+        return 0;
+    }
+  }
+  
+  /**
+   * Generate Fibonacci sequence
+   */
+  static fibonacci(n: number): number[] {
+    if (n <= 0) return [];
+    if (n === 1) return [1];
+    
+    const seq = [1, 1];
+    for (let i = 2; i < n; i++) {
+      seq.push(seq[i - 1] + seq[i - 2]);
+    }
+    return seq;
+  }
+  
+  /**
+   * Generate Lucas sequence
+   */
+  static lucas(n: number): number[] {
+    if (n <= 0) return [];
+    if (n === 1) return [2];
+    if (n === 2) return [2, 1];
+    
+    const seq = [2, 1];
+    for (let i = 2; i < n; i++) {
+      seq.push(seq[i - 1] + seq[i - 2]);
+    }
+    return seq;
+  }
+  
+  /**
+   * Calculate golden ratio approximation using Fibonacci
+   */
+  static goldenRatioApprox(n: number): [number, number] {
+    const fib = this.fibonacci(n + 1);
+    if (fib.length < 2) return [1, 1];
+    return [fib[fib.length - 1], fib[fib.length - 2]];
+  }
+  
+  /**
+   * Generate Pascal's triangle row
+   */
+  static pascalRow(n: number): number[] {
+    const row = [1];
+    for (let k = 1; k <= n; k++) {
+      row.push((row[k - 1] * (n - k + 1)) / k);
+    }
+    return row;
+  }
+  
+  /**
+   * Calculate binomial coefficient C(n, k)
+   */
+  static binomial(n: number, k: number): number {
+    if (k > n) return 0;
+    if (k === 0 || k === n) return 1;
+    
+    let result = 1;
+    for (let i = 0; i < k; i++) {
+      result = (result * (n - i)) / (i + 1);
+    }
+    return result;
+  }
+  
+  /**
+   * Generate magic square of order 3
+   */
+  static magicSquare3(): number[][] {
+    return [
+      [2, 7, 6],
+      [9, 5, 1],
+      [4, 3, 8],
+    ];
+  }
+  
+  /**
+   * Generate magic square of order 4
+   */
+  static magicSquare4(): number[][] {
+    return [
+      [16, 2, 3, 13],
+      [5, 11, 10, 8],
+      [9, 7, 6, 12],
+      [4, 14, 15, 1],
+    ];
+  }
+  
+  /**
+   * Check if a square is magic
+   */
+  static isMagicSquare(square: number[][]): boolean {
+    const n = square.length;
+    if (n === 0) return false;
+    
+    // Calculate expected sum
+    const expectedSum = (n * (n * n + 1)) / 2;
+    
+    // Check rows
+    for (const row of square) {
+      const sum = row.reduce((a, b) => a + b, 0);
+      if (sum !== expectedSum) return false;
+    }
+    
+    // Check columns
+    for (let col = 0; col < n; col++) {
+      let sum = 0;
+      for (let row = 0; row < n; row++) {
+        sum += square[row][col];
+      }
+      if (sum !== expectedSum) return false;
+    }
+    
+    // Check diagonals
+    let diag1 = 0, diag2 = 0;
+    for (let i = 0; i < n; i++) {
+      diag1 += square[i][i];
+      diag2 += square[i][n - 1 - i];
+    }
+    
+    return diag1 === expectedSum && diag2 === expectedSum;
+  }
+  
+  /**
+   * Generate Pythagorean triples
+   */
+  static pythagoreanTriple(m: number, n: number): [number, number, number] {
+    if (m <= n) return [0, 0, 0];
+    
+    const a = m * m - n * n;
+    const b = 2 * m * n;
+    const c = m * m + n * n;
+    
+    return [a, b, c];
+  }
+  
+  /**
+   * Generate primitive Pythagorean triples up to limit
+   */
+  static primitivePythagoreanTriples(limit: number): Array<[number, number, number]> {
+    const triples: Array<[number, number, number]> = [];
+    
+    for (let m = 2; m * m < limit; m++) {
+      for (let n = 1; n < m; n++) {
+        // Check if m and n are coprime and not both odd
+        if (this.gcd(m, n) === 1 && (m % 2 !== n % 2)) {
+          const [a, b, c] = this.pythagoreanTriple(m, n);
+          if (c <= limit) {
+            triples.push([a, b, c]);
+          }
+        }
+      }
+    }
+    
+    return triples;
+  }
+  
+  /**
+   * Greatest common divisor
+   */
+  static gcd(a: number, b: number): number {
+    while (b !== 0) {
+      const temp = b;
+      b = a % b;
+      a = temp;
+    }
+    return a;
+  }
+  
+  /**
+   * Calculate triangular number
+   */
+  static triangular(n: number): number {
+    return (n * (n + 1)) / 2;
+  }
+  
+  /**
+   * Calculate tetrahedral number
+   */
+  static tetrahedral(n: number): number {
+    return (n * (n + 1) * (n + 2)) / 6;
+  }
+  
+  /**
+   * Calculate pentagonal number
+   */
+  static pentagonal(n: number): number {
+    return (n * (3 * n - 1)) / 2;
+  }
+  
+  /**
+   * Calculate hexagonal number
+   */
+  static hexagonal(n: number): number {
+    return n * (2 * n - 1);
+  }
+  
+  /**
+   * Calculate octahedral number
+   */
+  static octahedral(n: number): number {
+    return (n * (2 * n * n + 1)) / 3;
+  }
+  
+  /**
+   * Generate spiral pattern (Ulam spiral positions)
+   */
+  static spiralPosition(n: number): [number, number] {
+    if (n === 1) return [0, 0];
+    
+    // Find which ring n is in
+    let ring = 0;
+    let ringStart = 1;
+    while (ringStart + 8 * ring <= n) {
+      ringStart += 8 * ring;
+      ring++;
+    }
+    
+    // Position within the ring
+    const posInRing = n - ringStart;
+    const sideLength = 2 * ring;
+    
+    // Determine which side and position
+    if (posInRing < sideLength) {
+      // Right side
+      return [ring, -ring + posInRing];
+    } else if (posInRing < 2 * sideLength) {
+      // Top side
+      return [ring - (posInRing - sideLength), ring];
+    } else if (posInRing < 3 * sideLength) {
+      // Left side
+      return [-ring, ring - (posInRing - 2 * sideLength)];
+    } else {
+      // Bottom side
+      return [-ring + (posInRing - 3 * sideLength), -ring];
+    }
+  }
+  
+  /**
+   * Calculate Vesica Piscis area (intersection of two circles)
+   * Using integer approximation
+   */
+  static vesicaPiscisArea(radius: number): number {
+    // Area = (2π/3 - √3/2) * r²
+    // Approximation: 1.2284 ≈ 12284/10000
+    return (radius * radius * 12284) / 10000;
+  }
+  
+  /**
+   * Calculate Flower of Life pattern points
+   */
+  static flowerOfLifePoints(centerX: number, centerY: number, radius: number): Array<[number, number]> {
+    const points: Array<[number, number]> = [[centerX, centerY]];
+    
+    // Six surrounding circles
+    for (let i = 0; i < 6; i++) {
+      const angle = i * 60; // degrees
+      
+      // Use integer approximation for sin/cos
+      // sin(60°) ≈ 866/1000, cos(60°) ≈ 500/1000
+      let x, y;
+      switch (angle) {
+        case 0:
+          x = centerX + radius;
+          y = centerY;
+          break;
+        case 60:
+          x = centerX + (radius * 500) / 1000;
+          y = centerY + (radius * 866) / 1000;
+          break;
+        case 120:
+          x = centerX - (radius * 500) / 1000;
+          y = centerY + (radius * 866) / 1000;
+          break;
+        case 180:
+          x = centerX - radius;
+          y = centerY;
+          break;
+        case 240:
+          x = centerX - (radius * 500) / 1000;
+          y = centerY - (radius * 866) / 1000;
+          break;
+        case 300:
+          x = centerX + (radius * 500) / 1000;
+          y = centerY - (radius * 866) / 1000;
+          break;
+        default:
+          x = centerX;
+          y = centerY;
+      }
+      
+      points.push([x, y]);
+    }
+    
+    return points;
+  }
+}
+
+// ============================================================================
+// MATRIX OPERATIONS FOR SACRED GEOMETRY
+// ============================================================================
+
+export class SacredMatrix {
+  /**
+   * Create identity matrix
+   */
+  static identity(n: number): number[][] {
+    const matrix: number[][] = [];
+    for (let i = 0; i < n; i++) {
+      const row: number[] = [];
+      for (let j = 0; j < n; j++) {
+        row.push(i === j ? 1 : 0);
+      }
+      matrix.push(row);
+    }
+    return matrix;
+  }
+  
+  /**
+   * Matrix multiplication
+   */
+  static multiply(a: number[][], b: number[][]): number[][] {
+    const rowsA = a.length;
+    const colsA = a[0].length;
+    const colsB = b[0].length;
+    
+    const result: number[][] = [];
+    for (let i = 0; i < rowsA; i++) {
+      const row: number[] = [];
+      for (let j = 0; j < colsB; j++) {
+        let sum = 0;
+        for (let k = 0; k < colsA; k++) {
+          sum += a[i][k] * b[k][j];
+        }
+        row.push(sum);
+      }
+      result.push(row);
+    }
+    return result;
+  }
+  
+  /**
+   * Calculate determinant (up to 3x3)
+   */
+  static determinant(matrix: number[][]): number {
+    const n = matrix.length;
+    
+    if (n === 1) {
+      return matrix[0][0];
+    }
+    
+    if (n === 2) {
+      return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
+    }
+    
+    if (n === 3) {
+      const [[a, b, c], [d, e, f], [g, h, i]] = matrix;
+      return a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+    }
+    
+    return 0; // Not implemented for n > 3
+  }
+  
+  /**
+   * Transpose matrix
+   */
+  static transpose(matrix: number[][]): number[][] {
+    const rows = matrix.length;
+    const cols = matrix[0].length;
+    
+    const result: number[][] = [];
+    for (let j = 0; j < cols; j++) {
+      const row: number[] = [];
+      for (let i = 0; i < rows; i++) {
+        row.push(matrix[i][j]);
+      }
+      result.push(row);
+    }
+    return result;
+  }
+}
+
+// ============================================================================
+// EXPORT ALL
+// ============================================================================
+
+export default {
+  PLATONIC_SOLIDS,
+  ARCHIMEDEAN_SOLIDS,
+  GOLDEN_CONSTANTS,
+  SacredGeometryIntegers,
+  SacredMatrix,
+};