zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,187 @@
+/**
+ * a432.rodin.coil.omnidimension.ts — A432 Rodin Coil Omni-Dimension
+ *
+ * Models Mobius circuit pairs and gap space for each prime-squared base.
+ * Encodes the gap space as a non-conductive, vortex-activating region.
+ * Validates that only prime-squared bases are allowed.
+ * Throws an error or returns a catastrophic state for invalid (non-prime-squared) bases.
+ * Visualizes the compacted coil and gap space structure.
+ *
+ * Metaphysical meaning: The gap space is the Omni-dimensional fold, the invisible
+ * higher-dimensional flux-field (one part Spirit, two parts magnetism) that allows
+ * the nested vortices to activate. Only prime-squared bases create a perfect,
+ * compacted, omni-dimensional hypersphere (torus). Any other base tears the torus skin.
+ */
+
+import { max, round, sqrt as algSqrt } from './a432.algebra.ts'
+import { type Fraction, type CMYK } from './a432.cmyk.ts';
+
+export interface MobiusCircuitPair {
+  pairId: string;
+  base: number;
+  isPrimeSquared: boolean;
+  gapSpace: GapSpace;
+  status: 'valid' | 'catastrophic';
+  description: string;
+}
+
+export interface GapSpace {
+  gapId: string;
+  length: number;
+  width: number;
+  isConductive: boolean;
+  activatesVortex: boolean;
+  description: string;
+}
+
+export interface RodinCoilOmniDimensionState {
+  base: number;
+  numPairs: number;
+  gapSpace: GapSpace;
+  status: 'valid' | 'catastrophic';
+  description: string;
+}
+
+/**
+ * Utility: Check if n is a prime number
+ */
+function isPrime(n: number): boolean {
+  if (n < 2) return false;
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false;
+  }
+  return true;
+}
+
+/**
+ * Utility: Check if n is a prime squared (n = p^2, p prime)
+ */
+function isPrimeSquared(n: number): boolean {
+  const sqrt = algSqrt(n);
+  return Number.isInteger(sqrt) && isPrime(sqrt);
+}
+
+/**
+ * Get number of Mobius circuit pairs for a given base
+ * (Base 10: 1 pair, 26: 2, 50: 3, 122: 4, ...)
+ */
+function getNumPairs(base: number): number {
+  // For known prime-squared bases
+  switch (base) {
+    case 10: return 1;
+    case 26: return 2;
+    case 50: return 3;
+    case 122: return 4;
+    default: return max(1, round(algSqrt(base) / 2));
+  }
+}
+
+/**
+ * Get gap space length for a given base
+ * (Increases with base, width is constant)
+ */
+function getGapSpaceLength(base: number): number {
+  return base * 2; // Arbitrary: proportional to base
+}
+
+/**
+ * Get gap space width (always 1)
+ */
+function getGapSpaceWidth(): number {
+  return 1;
+}
+
+/**
+ * Create Mobius circuit pairs and gap space for a base
+ */
+export function createRodinCoilOmniDimension(base: number): RodinCoilOmniDimensionState {
+  const isValid = isPrimeSquared(base);
+  const numPairs = isValid ? getNumPairs(base) : 0;
+  const gapLength = isValid ? getGapSpaceLength(base) : 0;
+  const gapWidth = getGapSpaceWidth();
+
+  const gapSpace: GapSpace = {
+    gapId: `gap.${base}`,
+    length: gapLength,
+    width: gapWidth,
+    isConductive: false,
+    activatesVortex: isValid,
+    description: isValid
+      ? `Non-conductive, vortex-activating gap space for base ${base}`
+      : `Catastrophic: gap space torn, torus skin broken for base ${base}`
+  };
+
+  return {
+    base,
+    numPairs,
+    gapSpace,
+    status: isValid ? 'valid' : 'catastrophic',
+    description: isValid
+      ? `Base ${base} is a prime-squared base. ${numPairs} Mobius circuit pair(s) with a single gap space (length ${gapLength}, width ${gapWidth}). Higher dimensions compacted into the gap space.`
+      : `Base ${base} is NOT a prime-squared base. Catastrophic: torus skin torn, X/Y/Z great circles broken.`
+  };
+}
+
+/**
+ * Visualize the compacted coil and gap space structure as HTML
+ */
+export function generateRodinCoilOmniDimensionHtml(state: RodinCoilOmniDimensionState): string {
+  const { base, numPairs, gapSpace, status, description } = state;
+  const pairsHtml = status === 'valid'
+    ? Array.from({ length: numPairs }, (_, i) => `<div class="mobius-pair">Mobius Circuit Pair ${i + 1}</div>`).join('')
+    : '';
+  const gapHtml = `<div class="gap-space" style="width:${gapSpace.length * 5}px;">${gapSpace.description}</div>`;
+
+  return `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>A432 Rodin Coil Omni-Dimension</title>
+  <style>
+    body { background: #000; color: #0ff; font-family: 'Courier New', monospace; padding: 20px; }
+    .header { text-align: center; font-size: 28px; color: #0ff; margin-bottom: 20px; }
+    .meta { text-align: center; font-size: 14px; color: #888; margin-bottom: 30px; }
+    .coil-structure { display: flex; align-items: center; justify-content: center; gap: 20px; margin-bottom: 30px; }
+    .mobius-pair { background: #111; border: 2px solid #0ff; border-radius: 8px; padding: 20px 30px; margin: 0 10px; font-size: 18px; box-shadow: 0 0 8px #0ff; }
+    .gap-space { background: #222; border: 2px dashed #ff0; border-radius: 8px; padding: 20px 30px; margin: 0 10px; font-size: 18px; color: #ff0; box-shadow: 0 0 8px #ff0; min-width: 80px; text-align: center; }
+    .catastrophic { color: #f00; font-weight: bold; text-align: center; font-size: 22px; margin-top: 30px; }
+    .desc { margin-top: 20px; color: #aaa; font-size: 15px; text-align: center; }
+  </style>
+</head>
+<body>
+  <div class="header">A432 Rodin Coil Omni-Dimension</div>
+  <div class="meta">
+    Models Mobius circuit pairs and gap space for each prime-squared base.<br>
+    Gap space is non-conductive, vortex-activating. Only prime-squared bases are valid.<br>
+    Invalid bases tear the torus skin and break the X/Y/Z great circles.
+  </div>
+  <div class="coil-structure">
+    ${pairsHtml}
+    ${gapHtml}
+    ${pairsHtml}
+  </div>
+  ${status === 'catastrophic' ? `<div class="catastrophic">CATASTROPHIC: Torus skin torn, X/Y/Z great circles broken!</div>` : ''}
+  <div class="desc">${description}</div>
+</body>
+</html>
+  `;
+}
+
+/**
+ * A432 Rodin Coil Omni-Dimension Metaphysics
+ */
+export const a432RodinCoilOmniDimensionMetaphysics = `
+The gap space is the Omni-dimensional fold, the invisible higher-dimensional flux-field
+(one part Spirit, two parts magnetism) that allows the underpinning nested vortices to activate.
+This gap space is always left empty—no copper wire conductor is ever placed there in the Rodin Coil.
+
+For each prime-squared base (10, 26, 50, 122, ...), the system forms Mobius circuit pairs with a single gap space.
+The gap space length increases with the base, but its width remains constant. All higher dimensions above the 3rd
+are compacted, compressed, and folded together into this one Omni-dimension.
+
+Only prime-squared base number counting systems create a perfect, compacted, omni-dimensional hypersphere (torus).
+If any number other than a prime is squared, the result is catastrophic: a tear in the torus skin, and the great circles
+of the X, Y, Z axes are broken. The system must validate and protect against such states, ensuring only Divine, prime-squared
+bases are used for true Rodin Coil Omni-Dimensional harmonization.
+`; 

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

@@ -0,0 +1,86 @@
+/**
+ * a432.rodin.coil.overlay.ts — Combined 2D/3D/Analytic Overlay for the Rodin Coil
+ *
+ * Exports overlay data and event logger for 2D (circle/spiral), 3D (torus), and analytic (5D) views.
+ * All overlays use canonical A432 math, sequence, and color logic.
+ */
+
+import { PI, cos, min, sin } from './a432.algebra.ts'
+import { RODIN_SEQUENCE, digitAngleToCMYK, cmykToCss, rodinPolarity } from './a432.math.ts';
+
+/**
+ * 2D overlay: Returns node positions (x, y), value, color, and HTML for a circle/spiral.
+ */
+export function getRodinCoil2DOverlayData(radius: number = 120, centerX: number = 0, centerY: number = 0): Array<{ x: number; y: number; value: number; color: { c: number; m: number; y: number; k: number }; html: string; polarity: number; spin: number }> {
+  const N = 6;
+  const data = [];
+  for (let i = 0; i < N; i++) {
+    const angle = (2 * PI * i) / N;
+    const x = centerX + radius * cos(angle);
+    const y = centerY + radius * sin(angle);
+    const value = RODIN_SEQUENCE[i];
+    const polarity = rodinPolarity(i); // +1 or -1
+    const spin = polarity; // For Rodin, spin = polarity
+    let color = digitAngleToCMYK(value, (i * 60) % 360);
+    if (polarity < 0) {
+      // Phase-invert color for negative polarity
+      color = { c: color.m, m: color.c, y: color.y, k: color.k };
+    }
+    const html = `<div style="width:48px;height:48px;background:${cmykToCss(color)};display:flex;align-items:center;justify-content:center;font-size:1.2em;color:#fff;border-radius:10px;position:absolute;left:${x}px;top:${y}px;">${value}</div>`;
+    data.push({ x, y, value, color, html, polarity, spin });
+  }
+  return data;
+}
+
+/**
+ * 3D overlay: Returns node positions (x, y, z), value, color for a torus.
+ * Use with Three.js or similar for rendering.
+ */
+export function getRodinCoil3DOverlayData(R: number = 100, r: number = 40): Array<{ x: number; y: number; z: number; value: number; color: { c: number; m: number; y: number; k: number } }> {
+  const N = 6;
+  const data = [];
+  for (let i = 0; i < N; i++) {
+    const theta = (2 * PI * i) / N;
+    const phi = (2 * PI * i) / N;
+    const x = (R + r * cos(theta)) * cos(phi);
+    const y = (R + r * cos(theta)) * sin(phi);
+    const z = r * sin(theta);
+    const value = RODIN_SEQUENCE[i];
+    const color = digitAngleToCMYK(value, (i * 60) % 360);
+    data.push({ x, y, z, value, color });
+  }
+  return data;
+}
+
+/**
+ * Analytic/5D overlay: Returns node data with extra analytic/metaphysical dimensions (e.g., resonance, event count).
+ */
+export function getRodinCoilAnalyticOverlayData(events: Array<{ value: number; timestamp: number }>): Array<{ value: number; color: { c: number; m: number; y: number; k: number }; resonance: number; eventCount: number; html: string; polarity: number; spin: number }> {
+  const N = 6;
+  const now = Date.now();
+  return RODIN_SEQUENCE.slice(0, N).map((value, i) => {
+    const polarity = rodinPolarity(i);
+    const spin = polarity;
+    const color = digitAngleToCMYK(value, (i * 60) % 360);
+    const eventCount = events.filter(e => e.value === value).length;
+    const resonance = eventCount > 0 ? min(1, (now - events.filter(e => e.value === value).slice(-1)[0]?.timestamp) / 10000) : 0;
+    const html = `<div style="width:48px;height:48px;background:${cmykToCss(color)};display:flex;align-items:center;justify-content:center;font-size:1.2em;color:#fff;border-radius:10px;box-shadow:0 0 ${8 + 24 * resonance}px #0ff;">${value}<br><span style='font-size:0.7em;'>${eventCount}</span></div>`;
+    return { value, color, resonance, eventCount, html, polarity, spin };
+  });
+}
+
+/**
+ * Metaphysical meaning: The Rodin coil is the living torus of unity, recursion, and harmonic flow.
+ */
+export const rodinCoilMetaphysics =
+  'The Rodin coil is the living torus of unity, recursion, and harmonic flow. Every node is a gateway, every cycle a proof of infinite possibility.';
+
+/**
+ * Blockchain event logger for Rodin coil overlay interactions.
+ * Call this with the node index, view, and context to log to the blockchain.
+ */
+export function logRodinCoilEvent(blockchain: any, node: number, view: '2D' | '3D' | 'analytic', context: any) {
+  const polarity = rodinPolarity(node);
+  const spin = polarity;
+  blockchain?.recordEvent?.(blockchain, 'rodinCoilOverlay', 'A432UI', { node, view, polarity, spin, ...context, timestamp: Date.now() });
+} 

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

@@ -0,0 +1,185 @@
+import { PI, cos, exp, sin } from './a432.algebra.ts'
+// Canonical Rodin Coil Math for the A432 System
+// All Rodin coil logic must be imported from this file only.
+
+/**
+ * a432.rodin.coil.ts — harmonized with canonical A432 math
+ * All Rodin sequence logic uses RODIN_SEQUENCE from a432.math.ts
+ */
+import { RODIN_SEQUENCE, rodinAngle } from './a432.math.ts';
+
+/**
+ * rodinVortexCycle: Returns n cycles of the Rodin sequence (forward or reverse)
+ * @param n - number of cycles
+ * @param polarity - +1 (forward, default), -1 (reverse)
+ */
+export function rodinVortexCycle(n: number, polarity: 1 | -1 = 1): number[] {
+  const seq = polarity === 1 ? RODIN_SEQUENCE : [...RODIN_SEQUENCE].reverse();
+  const result = [];
+  for (let i = 0; i < n; i++) result.push(...seq);
+  return result;
+}
+
+/**
+ * rodinPosition: Returns the value at a given index in the Rodin sequence (with polarity)
+ * @param index - position in the cycle
+ * @param polarity - +1 (forward, default), -1 (reverse)
+ */
+export function rodinPosition(index: number, polarity: 1 | -1 = 1): number {
+  const seq = polarity === 1 ? RODIN_SEQUENCE : [...RODIN_SEQUENCE].reverse();
+  return seq[index % seq.length];
+}
+
+/**
+ * RodinCoilStep: Represents a step in the Rodin coil pattern, with harmonic properties
+ */
+export interface RodinCoilStep {
+  position: number;
+  value: number;
+  digitalRoot: number;
+  angle: number; // (360 / 6) * (position % 6) for visualization
+}
+
+/**
+ * rodinCoilPattern: Returns an array of RodinCoilStep for n cycles, with angle and digitalRoot
+ * @param n - number of cycles
+ * @param polarity - +1 (forward, default), -1 (reverse)
+ */
+export function rodinCoilPattern(n: number, polarity: 1 | -1 = 1): RodinCoilStep[] {
+  const pattern = rodinVortexCycle(n, polarity);
+  const N = RODIN_SEQUENCE.length - 1; // 6 unique steps per cycle
+  return pattern.map((value, i) => ({
+    position: i,
+    value,
+    digitalRoot: ((value - 1) % 9) + 1,
+    angle: rodinAngle(i)
+  }));
+}
+
+/**
+ * Metaphysical context:
+ * - The Rodin coil is the mathematical and metaphysical bridge between the torus, Mobius circuit, and the Most Great Name of God.
+ * - Its sequence encodes the living, recursive, zero-entropy flow of consciousness and energy.
+ * - The coil’s field is poloidal, not toroidal, and is responsible for unique harmonic and energetic properties.
+ *
+ * Extension points:
+ * - Add harmonic mapping (color, frequency, field) as needed.
+ * - Implement advanced pattern analysis, visualization, or metaphysical logic here.
+ */
+// All Rodin coil math for the A432 system must use these canonical exports.
+
+/**
+ * rodinCoilStream: Canonical stream function for the Rodin coil
+ * When no parameters given: uses π-based stream from a432.pi.ts
+ * When parameters provided: uses Rodin coil pattern
+ * @param cycles - number of cycles (optional)
+ * @param polarity - +1 (forward, default), -1 (reverse) (optional)
+ * @param length - length for π stream (default: 10)
+ */
+export function rodinCoilStream(cycles?: number, polarity?: 1 | -1, length: number = 10) {
+  // Always use Rodin coil pattern as default
+  const cycleCount = cycles || 2;
+  const polarityValue = polarity || 1;
+  const pattern = rodinCoilPattern(cycleCount, polarityValue);
+  return {
+    source: 'a432.rodin.coil.ts',
+    cycles: cycleCount,
+    polarity: polarityValue,
+    sequence: RODIN_SEQUENCE,
+    pattern: pattern
+  };
+}
+
+/**
+ * RodinCoilStreamData: Represents the data structure returned by rodinCoilStream
+ */
+export interface RodinCoilStreamData {
+  source: string;
+  cycles: number;
+  polarity: 1 | -1;
+  sequence: number[];
+  pattern: RodinCoilStep[];
+}
+
+/**
+ * Point: Extends RodinCoilStep with x and y coordinates for visualization
+ */
+interface Point extends RodinCoilStep {
+  x: number;
+  y: number;
+}
+
+/**
+ * renderRodinCoilStreamHtml: Canonical HTML rendering for Rodin coil stream
+ * @param streamData - The result from rodinCoilStream()
+ * @returns HTML string for visualization
+ */
+export function renderRodinCoilStreamHtml(streamData: RodinCoilStreamData): string {
+  // Always render the Rodin coil pattern spiral
+  // Parameters
+  const width = 600, height = 600, cx = width/2, cy = height/2;
+  const spiralA = 60; // base radius
+  const spiralB = 18; // growth rate (logarithmic)
+  const trinity = 3;
+  const steps = streamData.pattern.length;
+  // Calculate spiral points
+  const points = streamData.pattern.map((step: RodinCoilStep, i: number): Point => {
+    // Logarithmic trinity spiral: r = a * exp(b * theta), theta = i * 2π/3 (trinity)
+    const theta = i * (2 * PI / trinity);
+    const r = spiralA * exp(spiralB * i / steps);
+    const x = cx + r * cos(theta);
+    const y = cy + r * sin(theta);
+    return { x, y, ...step };
+  });
+  // SVG path for spiral
+  const pathD = points.map((p: Point, i: number) => (i === 0 ? `M${p.x},${p.y}` : `L${p.x},${p.y}`)).join(' ');
+  // SVG circles for steps
+  const circles = points.map((p: Point, i: number) => `
+    <circle cx="${p.x}" cy="${p.y}" r="16" fill="hsl(${(p.angle * 360 / 360) % 360},70%,50%)" stroke="#fff" stroke-width="2">
+      <title>Step ${i}: Value ${p.value}, Root ${p.digitalRoot}, Angle ${p.angle.toFixed(1)}°</title>
+    </circle>
+    <text x="${p.x}" y="${p.y-22}" text-anchor="middle" font-size="10" fill="#eee">${p.value}</text>
+  `).join('');
+  // --- Trinity/Axis Overlay (3, 6, 9 and 0) ---
+  // Place 3, 6, 9 as triangle vertices, 0 as center
+  const axisRadius = spiralA * 0.7;
+  const axisPoints = [0, 1, 2].map(i => {
+    const theta = i * (2 * PI / 3);
+    return {
+      x: cx + axisRadius * cos(theta),
+      y: cy + axisRadius * sin(theta),
+      label: [3, 6, 9][i]
+    };
+  });
+  const axisTriangle = `M${axisPoints[0].x},${axisPoints[0].y} L${axisPoints[1].x},${axisPoints[1].y} L${axisPoints[2].x},${axisPoints[2].y} Z`;
+  // Scaffold for animated dot, controls, metaphysical overlays, and sound (to be extended)
+  return `
+    <svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" style="background:#111;">
+      <path d="${pathD}" fill="none" stroke="#0ff" stroke-width="3"/>
+      ${circles}
+      <path d="${axisTriangle}" fill="none" stroke="#ff8" stroke-width="2" stroke-dasharray="6,4"/>
+      ${axisPoints.map(p => `<text x="${p.x}" y="${p.y-10}" text-anchor="middle" font-size="14" fill="#ff8">${p.label}</text>`).join('')}
+      <circle cx="${cx}" cy="${cy}" r="10" fill="#fff" stroke="#ff8" stroke-width="2"/>
+      <text x="${cx}" y="${cy+5}" text-anchor="middle" font-size="12" fill="#111">0</text>
+    </svg>
+  `;
+}
+
+/**
+ * getNextRodinValue: Returns the next value in the canonical Rodin sequence, cycling as needed
+ * @param digit - current digit (1,2,4,8,7,5)
+ * @returns next digit in the sequence (cycles back to 1 after 5)
+ *
+ * Example:
+ *   getNextRodinValue(1) // 2 (1/1 → 2)
+ */
+// export function getNextRodinValue(digit: number): number {
+//   const idx = RODIN_SEQUENCE.indexOf(digit);
+//   if (idx === -1) throw new Error(`Digit ${digit} not in Rodin sequence`);
+//   return RODIN_SEQUENCE[(idx + 1) % RODIN_SEQUENCE.length];
+// }
+
+// Metaphysical mapping: Rodin Coil = vortex, axis, Tesla, infinite field
+// Reference canonical metaphysical documentation:
+// See RODIN_VORTEX_DOC in a432.rodin.ts for all metaphysical meaning and documentation.
+// All math in this module uses only vortex/trinity numbers and harmonic integer fractions.

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

@@ -0,0 +1,46 @@
+/**
+ * a432.rodin.matrix.overlay.ts — Canonical Rodin Matrix Overlay/Analytic
+ *
+ * Provides overlay data, metaphysical meaning, and blockchain event logging for the Rodin matrix.
+ * Uses only canonical A432 math, sequence, and color logic.
+ */
+
+import { RODIN_SEQUENCE, digitAngleToCMYK, cmykToCss } from './a432.math.ts';
+
+/**
+ * Returns overlay data for a 7x7 Rodin matrix grid.
+ * Each cell: value, color, HTML.
+ */
+export function getRodinMatrixOverlayData(): Array<Array<{ value: number; color: { c: number; m: number; y: number; k: number }; html: string }>> {
+  const grid: Array<Array<{ value: number; color: { c: number; m: number; y: number; k: number }; html: string }>> = [];
+  for (let row = 0; row < 7; row++) {
+    const rowArr = [];
+    for (let col = 0; col < 7; col++) {
+      // Canonical: value is RODIN_SEQUENCE[(row + col) % 6] (cycle 1-2-4-8-7-5)
+      const idx = (row + col) % 6;
+      const value = RODIN_SEQUENCE[idx];
+      const color = digitAngleToCMYK(value, (idx * 60) % 360);
+      const html = `<div style="width:48px;height:48px;background:${cmykToCss(color)};display:flex;align-items:center;justify-content:center;font-size:1.2em;color:#fff;border-radius:10px;">${value}</div>`;
+      rowArr.push({ value, color, html });
+    }
+    grid.push(rowArr);
+  }
+  return grid;
+}
+
+/**
+ * Metaphysical meaning: The Rodin matrix is the living map of vortex flow, unity, and recursion.
+ */
+export const rodinMatrixMetaphysics =
+  'The Rodin matrix is the living, recursive map of vortex flow, unity, and consciousness. Every cell is a gateway, every cycle a proof of zero-entropy harmony.';
+
+/**
+ * Blockchain event logger for Rodin matrix overlay interactions.
+ * Call this with the cell position and context to log to the blockchain.
+ */
+export function logRodinMatrixEvent(blockchain: unknown, row: number, col: number, context: unknown) {
+  if (typeof blockchain === 'object' && blockchain !== null && 'recordEvent' in blockchain) {
+    const contextObj = typeof context === 'object' && context !== null ? context : {};
+    (blockchain as { recordEvent: Function }).recordEvent(blockchain, 'rodinMatrixOverlay', 'A432UI', { row, col, ...contextObj, timestamp: Date.now() });
+  }
+} 

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

@@ -0,0 +1,58 @@
+import { PI, cos, sin } from './a432.algebra.ts'
+// a432.rodin.matrix.ts
+// Canonical 3D Rodin matrix visualization logic
+// Imports matrix math, trinity overlays, and toroidal mapping helpers
+
+import { rodinMatrix7x7, getTrinityIndices, mapMatrixToTorus } from './a432.matrix.ts';
+import { RODIN_SEQUENCE } from './a432.math.ts';
+
+/**
+ * a432.rodin.matrix.ts — harmonized with canonical A432 math
+ * All Rodin sequence logic uses RODIN_SEQUENCE from a432.math.ts
+ */
+
+/**
+ * getRodinMatrixTorusCoords: Returns 3D toroidal coordinates for the 7x7 Rodin matrix.
+ * @param R - major radius
+ * @param r - minor radius
+ * @returns Array of {x, y, z, value, row, col}
+ */
+export function getRodinMatrixTorusCoords(R: number, r: number) {
+  const matrix = rodinMatrix7x7();
+  return mapMatrixToTorus(matrix, R, r);
+}
+
+/**
+ * getRodinTrinityCoords: Returns 3D toroidal coordinates for all trinity/axis points (3,6,9) in the matrix.
+ * @param R - major radius
+ * @param r - minor radius
+ * @returns Array of {x, y, z, value, row, col}
+ */
+export function getRodinTrinityCoords(R: number, r: number) {
+  const matrix = rodinMatrix7x7();
+  const trinityIndices = getTrinityIndices();
+  return trinityIndices.map(({row, col, value}) => {
+    const theta = (row / 7) * 2 * PI;
+    const phi = (col / 7) * 2 * PI;
+    const x = (R + r * cos(phi)) * cos(theta);
+    const y = (R + r * cos(phi)) * sin(theta);
+    const z = r * sin(phi);
+    return {x, y, z, value, row, col};
+  });
+}
+
+/**
+ * getRodinMatrixFieldLines: Scaffold for generating field line overlays for the matrix on the torus.
+ * @param R - major radius
+ * @param r - minor radius
+ * @returns Array of field line paths (to be extended)
+ */
+export function getRodinMatrixFieldLines(R: number, r: number) {
+  // Placeholder: implement field line logic (e.g., diagonals, flows)
+  return [];
+}
+
+/**
+ * Documentation: This module provides canonical 3D mapping and overlay helpers for Rodin matrix visualization.
+ * Extend with: animation, interactive overlays, and metaphysical flows.
+ */ 

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

@@ -0,0 +1,111 @@
+import { log } from './a432.algebra.ts'
+// @ts-nocheck
+/**
+ * a432.rodin.ts — Science & Math extraction from the Rodin book
+ * -----------------------------------------------------------------
+ * This module scans every plain-text chapter chunk under the project
+ * (directories like src/<n>/chunks/<file>.txt) and extracts lines that look
+ * mathematical: ones containing numbers, equations, ratios, degrees,
+ * frequency references, etc.  The goal is to keep the raw science/math
+ * content handy for further analysis while avoiding manual copy-paste.
+ *
+ * Usage
+ *   import { extractRodinMath, getRodinMathLines } from './a432.rodin.ts';
+ *   const lines = await getRodinMathLines();
+ *   console.log(lines.slice(0, 20));
+ *
+ * Run directly:
+ *   npx ts-node src/.../a432.rodin.ts > rodin-math.txt
+ *
+ * Notes
+ * • Uses only Node built-ins (fs, path) to stay dependency-free.
+ * • Filtering heuristic: a line is considered mathematical if it
+ *   contains a digit OR one of the symbols: %,°,=,+,-,*,/,^.
+ * • You can post-process the returned lines with regex, a432.math helpers, etc.
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+/** Root directory of the repository (assumed two levels up from this file). */
+const PROJECT_ROOT = path.resolve(import.meta.dirname, '..', '..', '..', '..', '..', '..', '..', '..', '..', '..', '..');
+
+/** True when executed directly via `ts-node a432.rodin.ts` */
+const IS_CLI = require.main === module;
+
+/** Regex flagging a line as math/science (contains digits or math symbols). */
+const MATH_REGEX = /[0-9]|[%°=+\-*/^]/;
+
+/**
+ * Recursively walk a directory collecting .txt files inside a `chunks` folder.
+ */
+async function collectChunkFiles(dir: string): Promise<string[]> {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const files: string[] = [];
+  for (const entry of entries) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      // Only recurse if still within reasonable depth
+      files.push(...await collectChunkFiles(p));
+    } else if (entry.isFile() && entry.name.endsWith('.txt') && (dir.includes('chunks') || dir.includes('rodin-knowledge'))) {
+      files.push(p);
+    }
+  }
+  return files;
+}
+
+/**
+ * Read a file and return the lines that satisfy MATH_REGEX.
+ */
+async function extractMathLinesFromFile(file: string): Promise<string[]> {
+  const raw = await fs.readFile(file, 'utf8');
+  return raw.split(/\r?\n/).filter(line => MATH_REGEX.test(line));
+}
+
+/**
+ * Returns a flat array of all math/science lines across every chunk file.
+ */
+export async function getRodinMathLines(): Promise<string[]> {
+  const chunkFiles = await collectChunkFiles(PROJECT_ROOT + '/src');
+  const all: string[] = [];
+  for (const f of chunkFiles) {
+    const lines = await extractMathLinesFromFile(f);
+    all.push(...lines.map(l => l.trim()));
+  }
+  return all;
+}
+
+/**
+ * Groups the math lines by their originating file for easier context.
+ */
+export interface FileMath {
+  file: string;
+  lines: string[];
+}
+
+export async function extractRodinMath(): Promise<FileMath[]> {
+  const chunkFiles = await collectChunkFiles(PROJECT_ROOT + '/src');
+  const result: FileMath[] = [];
+  for (const f of chunkFiles) {
+    const lines = await extractMathLinesFromFile(f);
+    if (lines.length) result.push({ file: path.relative(PROJECT_ROOT, f), lines });
+  }
+  return result;
+}
+
+// ------------------------------------------------------------------
+// CLI: print all math lines (with source file headers) to stdout
+// ------------------------------------------------------------------
+if (IS_CLI) {
+  (async () => {
+    const grouped = await extractRodinMath();
+    for (const g of grouped) {
+      console.log(`# ${g.file}`);
+      g.lines.forEach(ln => console.log(ln));
+      console.log();
+    }
+  })().catch(err => {
+    console.error(err);
+    process.exit(1);
+  });
+}