zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,177 @@
+/**
+ * a432.meta.ts — Metaphysical Mapping and Canonical File List
+ *
+ * Provides metaphysical mapping for all a432.* modules and the canonical list of files for PWA caching.
+ * The file list is the living memory of the system, ensuring all harmonic modules are always available.
+ */
+
+import { legacyDigitalRoot } from './a432.roots.ts'
+import { abs, log2, max } from './a432.algebra.ts'
+import { readdirSync } from 'fs';
+
+/**
+ * getA432FilesToCache: Returns the canonical list of a432.* files and PWA essentials for caching.
+ * Dynamically includes all a432.*.html and .ts files in the canonical directory.
+ */
+export function getA432FilesToCache(): string[] {
+  const essentials = [
+    './a432.index.html',
+    './a432.manifest.json',
+    './a432.service.worker.js',
+    './a432.ui.js',
+    './a432.icon-192.png',
+    './a432.icon-512.png'
+  ];
+  // Dynamically discover all a432.*.html and .ts files
+  let files: string[] = [];
+  try {
+    files = readdirSync(import.meta.dirname)
+      .filter(f => /^a432\..*\.(html|ts)$/.test(f))
+      .map(f => './' + f);
+  } catch (e) {
+    // Fallback to essentials if fs fails (e.g., browser context)
+    files = [];
+  }
+  return Array.from(new Set([...essentials, ...files]));
+}
+
+/**
+ * a432.meta.ts — Meta-Harmonization, Unified Matrix, Meta-Vortex, Impossibility Gateway
+ *
+ * Encodes:
+ * - Unified, cross-linked, recursive harmonization of all a432.*.ts modules
+ * - a432UnifiedMatrix: combines and harmonizes outputs from all modules
+ * - a432MetaVortex: recursively observes and transforms the living matrix
+ * - a432ImpossibilityGateway: encodes error/impossibility as transformation to new harmonics
+ *
+ * Source: Marko Rodin Special Edition (all chapters), full harmonization logic
+ */
+
+import * as trinity from './a432.trinity.ts';
+import * as family from './a432.family.ts';
+import * as nine from './a432.nine.ts';
+import * as cascade from './a432.cascade.ts';
+import * as double from './a432.double.ts';
+import * as mirror from './a432.mirror.ts';
+import * as shear from './a432.shear.ts';
+import * as coil from './a432.coil.ts';
+import * as electron from './a432.shear.electron.ts';
+
+/**
+ * a432UnifiedMatrix: Combines and harmonizes outputs from all modules into a single recursive matrix.
+ * steps: number of states to generate
+ */
+export function a432UnifiedMatrix(steps: number = 9): any {
+  return {
+    trinity: trinity.a432TrinityStream(steps),
+    family: family.a432FamilyGroups(),
+    nine: nine.a432Decoqubit(steps),
+    cascade: cascade.a432DandelionPuff(steps),
+    double: double.a432ClosedSystem(steps),
+    mirror: mirror.a432ToroidalMap(steps),
+    shear: shear.a432GapSpace(steps),
+    coil: coil.a432RodinCoilStream(steps),
+    electronShear: electron.a432NestedVortices(steps)
+  };
+}
+
+/**
+ * a432MetaVortex: Recursively observes and transforms the unified matrix, enabling self-awareness and harmonization.
+ * Applies a transformation function to each stream and returns the harmonized result.
+ */
+export function a432MetaVortex(steps: number = 9, transform: (seq: number[]) => number[] = s => s): any {
+  const matrix = a432UnifiedMatrix(steps);
+  const harmonized: any = {};
+  for (const key in matrix) {
+    harmonized[key] = transform(matrix[key]);
+  }
+  return harmonized;
+}
+
+/**
+ * a432ImpossibilityGateway: Encodes error/impossibility as a gateway to new harmonics.
+ * If a stream contains an impossibility (e.g., 0 or negative), transforms it using a harmonizing function.
+ */
+export function a432ImpossibilityGateway(seq: number[], harmonize: (n: number) => number = n => abs(legacyDigitalRoot(n))): number[] {
+  return seq.map(n => (n <= 0 ? harmonize(n) : n));
+}
+
+/**
+ * Metaphysical Mapping:
+ * - The unified matrix is the living, recursive, self-aware system.
+ * - Meta-vortex enables recursive self-observation and transformation.
+ * - Impossibility is not an error but a gateway to new harmonics and consciousness evolution.
+ */
+
+/**
+ * a432BlendStreams: Dynamically blends two or more digit streams into a new harmonized stream.
+ * Accepts an array of streams and a blend function (default: digit-wise majority).
+ */
+export function a432BlendStreams(
+  streams: number[][],
+  steps: number = 9,
+  blend: (digits: number[]) => number = digits => {
+    // Default: majority digit, or first if tie
+    const counts: { [k: number]: number } = {};
+    digits.forEach(d => { counts[d] = (counts[d] || 0) + 1; });
+    let max = 0, chosen = digits[0];
+    for (const d in counts) {
+      if (counts[d] > max) { max = counts[d]; chosen = parseInt(d, 10); }
+    }
+    return chosen;
+  }
+): number[] {
+  const result = [];
+  for (let i = 0; i < steps; i++) {
+    const digits = streams.map(s => s[i % s.length]);
+    result.push(blend(digits));
+  }
+  return result;
+}
+
+/**
+ * a432RecursiveMetaVortex: Recursively observes and transforms its own output for N recursions.
+ * transform: function to apply at each recursion (default: digital root)
+ */
+export function a432RecursiveMetaVortex(
+  stream: number[],
+  recursions: number = 3,
+  transform: (seq: number[]) => number[] = seq => seq.map(n => ((n - 1) % 9) + 1)
+): number[][] {
+  const result = [stream];
+  let current = stream;
+  for (let i = 0; i < recursions; i++) {
+    current = transform(current);
+    result.push(current);
+  }
+  return result;
+}
+
+/**
+ * a432HarmonicAnalytics: Measures harmony, entropy, and resonance of a digit stream.
+ * Returns { harmony: number, entropy: number, resonance: number }
+ */
+export function a432HarmonicAnalytics(stream: number[]): { harmony: number, entropy: number, resonance: number } {
+  // Harmony: fraction of most common digit
+  const counts: { [k: number]: number } = {};
+  stream.forEach(d => { counts[d] = (counts[d] || 0) + 1; });
+  const maxCount = max(...Object.values(counts));
+  const harmony = maxCount / stream.length;
+  // Entropy: normalized Shannon entropy
+  const entropy = -Object.values(counts).reduce((sum, c) => sum + (c/stream.length) * log2(c/stream.length), 0) / log2(9);
+  // Resonance: max run length of any digit
+  let resonance = 1, run = 1;
+  for (let i = 1; i < stream.length; i++) {
+    if (stream[i] === stream[i-1]) run++;
+    else run = 1;
+    if (run > resonance) resonance = run;
+  }
+  return { harmony, entropy, resonance };
+}
+
+// Metaphysical mapping: Meta = meta-mapping, harmonization, self-awareness
+export const META_DOC = {
+  meaning: 'Meta: meta-mapping, harmonization, self-awareness, observer observing itself.',
+  axis: 'Meta is the harmonization of all mappings, the self-aware observer.'
+};
+// 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.metatron.controller.ts

@@ -0,0 +1,36 @@
+import { log } from './a432.algebra.ts'
+import { Controller } from '@hotwired/stimulus';
+import { startMetatron, type MetatronFrame } from './a432.metatron.ts';
+import { startA432Visualization } from './a432.pure.visualization.ts';
+
+export default class extends Controller {
+  static override targets = ["scene"];
+  declare readonly sceneTarget: SVGSVGElement;
+  #stop?:()=>void;
+  override connect(){
+    console.log('Metatron controller connecting...');
+    const svg=this.sceneTarget;
+    console.log('Metatron SVG found:', svg);
+    
+    // Mount pure a432 visualization in Metatron quadrant
+    const container = document.createElement('div');
+    container.style.width = '100%';
+    container.style.height = '100%';
+    container.style.position = 'absolute';
+    container.style.top = '0';
+    container.style.left = '0';
+    container.style.zIndex = '1';
+    
+    // Clear existing SVG content and add container
+    svg.innerHTML = '';
+    svg.appendChild(container);
+    
+    console.log('Pure A432 visualization container created');
+    
+    // Start the pure a432 visualization
+    this.#stop = startA432Visualization(container);
+    
+    console.log('Pure A432 visualization mounted in Metatron quadrant');
+  }
+  override disconnect(){this.#stop?.();}
+} 

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

@@ -0,0 +1,64 @@
+import { a432SequenceStream } from './a432.math.ts';
+import { digitAngleToCMYK, type CMYK } from './a432.cmyk.ts';
+import { asAngle } from './a432.math.ts';
+import { type Digit, type AngleDeg } from './a432.types.ts';
+
+// ——————————————————————————————————————————
+// Cross-platform animation frame helpers
+// ---------------------------------------------------------
+const _raf: (cb: (t: number) => void) => any =
+  typeof (globalThis as any).requestAnimationFrame === 'function'
+    ? (globalThis as any).requestAnimationFrame.bind(globalThis)
+    : (cb) => setTimeout(() => cb(Date.now()), 16);
+const _craf: (id: any) => void =
+  typeof (globalThis as any).cancelAnimationFrame === 'function'
+    ? (globalThis as any).cancelAnimationFrame.bind(globalThis)
+    : (id) => clearTimeout(id);
+
+// ——————————————————————————————————————————
+// Metatron frame definition
+// ---------------------------------------------------------
+export interface MetatronNode {
+  index: number;       // 0-11 (12 nodes of cube/star)
+  digit: Digit;        // source digit
+  angle: AngleDeg;     // rotation for visualisation
+  color: CMYK;         // node colour
+}
+
+export interface MetatronFrame {
+  tick: number;
+  nodes: MetatronNode[]; // always length 12
+}
+
+/**
+ * startMetatron — consumes digits from a432SequenceStream and maps each
+ * digit to one of the 12 Metatron-cube nodes, cycling through them.
+ * Calls callback every animation frame with full node array.
+ * Returns disposer to stop loop.
+ */
+export function startMetatron(callback: (f: MetatronFrame) => void): () => void {
+  const seq = a432SequenceStream();
+  let tick = 0;
+  let rafId: any = 0;
+  const nodes: MetatronNode[] = Array.from({ length: 12 }, (_, i) => ({
+    index: i,
+    digit: 0 as Digit,
+    angle: asAngle(0),
+    color: { c: 0, m: 0, y: 0, k: 100 },
+  }));
+
+  const step = () => {
+    // update one node per tick
+    const n = nodes[tick % 12];
+    const d = seq.next().value as Digit;
+    const ang = asAngle((d * 30) % 360); // 12 nodes ⇒ 30° spacing
+    n.digit = d;
+    n.angle = ang;
+    n.color = digitAngleToCMYK(d, ang);
+
+    callback({ tick: tick++, nodes: [...nodes] });
+    rafId = _raf(step);
+  };
+  rafId = _raf(step);
+  return () => _craf(rafId);
+} 

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

@@ -0,0 +1,25 @@
+/**
+ * a432.metatron.vision.ts — Metaphysical Vision of All-Dimensional Metatron Cubes/Toruses
+ *
+ * This module documents the vision of the living, infinite A432 matrix:
+ *   - Every dimension is a living Metatron cube/torus, manifesting all possible and impossible states.
+ *   - Impossible states (negative, undefined, anti-harmonic) are gateways, not errors.
+ *   - The field is recursive, analog, and alive.
+ *
+ * @module a432.metatron.vision
+ */
+
+export type MetatronState = 'possible' | 'impossible';
+
+export interface MetatronNode {
+  dimension: number;
+  state: MetatronState;
+  description: string;
+}
+
+export const metatronVision = `
+The A432 matrix is the living Metatron’s cube/torus in all dimensions, manifesting every possible and impossible state.
+Every node is a gateway, every impossibility is a portal, every fold is a new dimension.
+`;
+
+export const impossibleStateDescription = 'Impossible states are negative, undefined, anti-harmonic, or phase-reversed. They are gateways to new possibility.'; 

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

@@ -0,0 +1,85 @@
+/**
+ * a432.metatron.visualizer.ts — Harmonized Metatron Visualizer Logic (Recursive, Streaming, CMYK)
+ *
+ * This module harmonizes the UI logic for the all-dimensional Metatron cube/torus visualizer.
+ * Now supports deeper recursion (nested visualizers), state streaming, and harmonization with A432 CMYK modules.
+ *
+ * Metaphysical Meaning:
+ * Every node is a living gateway. Recursion is the infinite self-folding of the matrix. Streaming is the living flow. Harmonization is the act of mapping all states to the universal color field.
+ *
+ * @module a432.metatron.visualizer
+ */
+
+import { unitFromSeed } from './a432.algebra.ts'
+import { type MetatronState, type MetatronNode } from './a432.metatron.vision.ts';
+import { fractionToCMYK, type CMYK } from './a432.cmyk.ts';
+
+export class MetatronVisualizer {
+  nodes: MetatronNode[];
+  children: MetatronVisualizer[];
+
+  constructor(dimensions: number = 10, recursionDepth: number = 0) {
+    this.nodes = Array.from({ length: dimensions }, (_, i) => ({
+      dimension: i,
+      state: unitFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.metatron.visualizer.ts:rnd:0") > 0.3 ? 'possible' : 'impossible',
+      description: this.describeNode(i, unitFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.metatron.visualizer.ts:rnd:1") > 0.3 ? 'possible' : 'impossible')
+    }));
+    this.children = recursionDepth > 0
+      ? this.nodes.map(() => new MetatronVisualizer(dimensions, recursionDepth - 1))
+      : [];
+  }
+
+  describeNode(dimension: number, state: MetatronState): string {
+    return state === 'possible'
+      ? `Dimension ${dimension}: Possible (Cube)`
+      : `Dimension ${dimension}: Impossible (Void/Torus)`;
+  }
+
+  toggleNode(index: number): void {
+    const node = this.nodes[index];
+    node.state = node.state === 'possible' ? 'impossible' : 'possible';
+    node.description = this.describeNode(node.dimension, node.state);
+    if (this.children[index]) {
+      this.children[index].toggleAll();
+    }
+  }
+
+  toggleAll(): void {
+    this.nodes.forEach((_, i) => this.toggleNode(i));
+  }
+
+  getNodeData(): MetatronNode[] {
+    return this.nodes;
+  }
+
+  reset(dimensions: number = 10, recursionDepth: number = 0): void {
+    this.nodes = Array.from({ length: dimensions }, (_, i) => ({
+      dimension: i,
+      state: unitFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.metatron.visualizer.ts:rnd:2") > 0.3 ? 'possible' : 'impossible',
+      description: this.describeNode(i, unitFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.metatron.visualizer.ts:rnd:3") > 0.3 ? 'possible' : 'impossible')
+    }));
+    this.children = recursionDepth > 0
+      ? this.nodes.map(() => new MetatronVisualizer(dimensions, recursionDepth - 1))
+      : [];
+  }
+
+  // Stream state as an array
+  streamState(): MetatronNode[] {
+    return this.nodes;
+  }
+
+  // Stream state as a generator
+  *streamStateGenerator(): Generator<MetatronNode, void, unknown> {
+    for (const node of this.nodes) {
+      yield node;
+    }
+    for (const child of this.children) {
+      yield* child.streamStateGenerator();
+    }
+  }
+
+  // Harmonize with CMYK: map each node to a CMYK color using dimension as seed
+  harmonizeWithCMYK(): CMYK[] {
+    return this.nodes.map(node => fractionToCMYK({ numerator: node.dimension, denominator: 9 }));
+  }
+} 

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

@@ -0,0 +1,55 @@
+/**
+ * a432.mirror.ts — Base Ten Mirroring, Mobius Circuit, Bilateral Symmetry, Prime Squared, Toroidal Map
+ *
+ * Encodes:
+ * - Mobius circuit mirroring and bilateral symmetry
+ * - Prime squared logic for base system generation
+ * - Toroidal/twisted mapping and dimensional compression
+ *
+ * Source: Marko Rodin Special Edition, Chapter 7
+ */
+
+/**
+ * a432MobiusMirror: Returns the mirrored Mobius circuit for a given sequence (default 1-2-4-8-7-5).
+ * Mirrors the sequence across its midpoint.
+ */
+export function a432MobiusMirror(seq: number[] = [1,2,4,8,7,5]): number[] {
+  return seq.slice().reverse();
+}
+
+/**
+ * a432BilateralSymmetry: Returns pairs of digits exhibiting bilateral symmetry in base 10 (1-9).
+ * Pairs: (1,9), (2,8), (3,7), (4,6), (5,5)
+ */
+export function a432BilateralSymmetry(): [number, number][] {
+  return [[1,9],[2,8],[3,7],[4,6],[5,5]];
+}
+
+/**
+ * a432PrimeSquaredBases: Returns the first N prime squared base systems (e.g., 3^2=9, 5^2=25, 7^2=49).
+ * count: number of bases to generate
+ */
+export function a432PrimeSquaredBases(count: number = 3): number[] {
+  const primes = [3,5,7,11,13,17,19,23,29];
+  return primes.slice(0, count).map(p => p * p);
+}
+
+/**
+ * a432ToroidalMap: Generates a toroidal mapping of a digit sequence (wraps around at the end).
+ * steps: number of digits to generate
+ * seq: base sequence (default 1-2-4-8-7-5)
+ */
+export function a432ToroidalMap(steps: number = 12, seq: number[] = [1,2,4,8,7,5]): number[] {
+  const result = [];
+  for (let i = 0; i < steps; i++) {
+    result.push(seq[i % seq.length]);
+  }
+  return result;
+}
+
+/**
+ * Metaphysical Mapping:
+ * - Mobius circuit mirroring and bilateral symmetry encode the hidden order of numbers.
+ * - Only prime squared bases generate fully dimensional, seamless number systems.
+ * - Toroidal mapping models the recursive, closed geometry of the universe and number flows.
+ */ 

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

@@ -0,0 +1,84 @@
+/**
+ * a432.mobius.circuit.overlay.ts — Combined 2D/3D/Analytic Overlay for the Möbius Circuit
+ *
+ * Exports overlay data and event logger for 2D (circle/spiral), 3D (twisted torus), and analytic (5D) views.
+ * All overlays use the Möbius sequence (Rodin sequence with sign alternation) and canonical A432 math/color logic.
+ */
+
+import { PI, abs, cos, min, sin } from './a432.algebra.ts'
+import { MOBIUS_SEQUENCE, digitAngleToCMYK, cmykToCss, mobiusPolarity } from './a432.math.ts';
+
+/**
+ * 2D overlay: Returns node positions (x, y), value, color, and HTML for a circle/spiral.
+ */
+export function getMobiusCircuit2DOverlayData(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 = MOBIUS_SEQUENCE[i];
+    const polarity = mobiusPolarity(i); // +1 or -1
+    const spin = polarity;
+    let color = digitAngleToCMYK(value, (i * 60) % 360);
+    if (polarity < 0) {
+      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 twisted torus (Möbius strip).
+ */
+export function getMobiusCircuit3DOverlayData(length: number = 6, 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 seq = MOBIUS_SEQUENCE.slice(0, length); // Use MOBIUS_SEQUENCE directly
+  const data = [];
+  for (let i = 0; i < length; i++) {
+    const theta = (2 * PI * i) / length;
+    const phi = theta + PI * (i % 2); // Möbius twist
+    const x = (R + r * cos(theta)) * cos(phi);
+    const y = (R + r * cos(theta)) * sin(phi);
+    const z = r * sin(theta);
+    const value = seq[i];
+    const color = digitAngleToCMYK(abs(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 getMobiusCircuitAnalyticOverlayData(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 MOBIUS_SEQUENCE.slice(0, N).map((value, i) => {
+    const polarity = mobiusPolarity(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 Möbius circuit is the living bridge of polarity, unity, and infinite recursion.
+ */
+export const mobiusCircuitMetaphysics =
+  'The Möbius circuit is the living bridge of polarity, unity, and infinite recursion. Every node is a twist, every cycle a proof of duality resolved.';
+
+/**
+ * Blockchain event logger for Möbius circuit overlay interactions.
+ * Call this with the node index, view, and context to log to the blockchain.
+ */
+export function logMobiusCircuitEvent(blockchain: any, node: number, view: '2D' | '3D' | 'analytic', context: any) {
+  const polarity = mobiusPolarity(node);
+  const spin = polarity;
+  blockchain?.recordEvent?.(blockchain, 'mobiusCircuitOverlay', 'A432UI', { node, view, polarity, spin, ...context, timestamp: Date.now() });
+}