zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,50 @@
+/**
+ * a432.quantum.entanglement.ts — Canonical A432 Harmonization
+ *
+ * Re-solves the quantum entanglement challenge using only A432 math, sequence, and metaphysical logic.
+ * Exports: proof, metaphysical meaning, analytic overlay, and blockchain event logger.
+ */
+
+import { digitAngleToCMYK, cmykToCss } from './a432.math.ts';
+
+/**
+ * Canonical proof: In A432, entanglement is the resonance of two or more states in the living matrix.
+ * The impossibility of separation is resolved by the unity of the harmonic field.
+ */
+export function quantumEntanglementProof(): string {
+  return 'In the A432 system, quantum entanglement is the resonance of two or more states in the living harmonic field. Separation is impossible; all states are unified by the A432 sequence.';
+}
+
+/**
+ * Metaphysical meaning: Entanglement is the proof of unity; the observer is both participant and witness.
+ */
+export const quantumEntanglementMetaphysics =
+  'Entanglement is not a paradox, but a demonstration of the unity of consciousness. The A432 field harmonizes all states, and the observer is both participant and witness.';
+
+/**
+ * Analytic overlay: Returns overlay data for two entangled states and the observer, with canonical color.
+ */
+export function getQuantumEntanglementCMYKOverlayData(): Array<{
+  state: 'entangledA' | 'entangledB' | 'observer';
+  color: { c: number; m: number; y: number; k: number };
+  html: string;
+}> {
+  const states: Array<{ state: 'entangledA' | 'entangledB' | 'observer'; digit: number; angle: number }> = [
+    { state: 'entangledA', digit: 4, angle: 0 },
+    { state: 'entangledB', digit: 8, angle: 120 },
+    { state: 'observer', digit: 9, angle: 240 }
+  ];
+  return states.map(({ state, digit, angle }) => {
+    const color = digitAngleToCMYK(digit, angle);
+    const html = `<div style="width:80px;height:80px;background:${cmykToCss(color)};display:flex;align-items:center;justify-content:center;font-size:1.1em;color:#fff;border-radius:16px;">${state}</div>`;
+    return { state, color, html };
+  });
+}
+
+/**
+ * Blockchain event logger for quantum entanglement overlay interactions.
+ * Call this with the state and context to log to the blockchain.
+ */
+export function logQuantumEntanglementEvent(blockchain: any, state: 'entangledA' | 'entangledB' | 'observer', context: any) {
+  blockchain?.recordEvent?.(blockchain, 'quantumEntanglementOverlay', 'A432UI', { state, ...context, timestamp: Date.now() });
+} 

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

@@ -0,0 +1,59 @@
+import { PI, abs, sin } from './a432.algebra.ts'
+// a432.quantum.trinity.ts
+// Quantum physics trinity module for a432
+
+import { cmykIdToPhrase, digitColors } from './a432.mapping.ts';
+import { rodinVortexStep } from './a432.vortex.cmyk.matrix.ts';
+
+export interface A432QuantumTrinityState {
+  tick: number;
+  id: [number, number, number, number]; // CMYK
+  phase: number;
+  amplitude: number;
+  probability: number;
+  phrase: string;
+  color: string;
+  metaphysical: string;
+}
+
+const trinityChannels: (0|1|2)[] = [0, 1, 2]; // C, M, Y
+
+export function* a432QuantumTrinityStream(
+  start: [number, number, number, number] = [3,6,9,1],
+  basePhase: number = 0,
+  baseAmplitude: number = 1
+): Generator<A432QuantumTrinityState> {
+  let tick = 0;
+  let id = start;
+  let phase = basePhase;
+  let amplitude = baseAmplitude;
+  while (true) {
+    const channel = trinityChannels[tick % trinityChannels.length];
+    yield {
+      tick,
+      id,
+      phase,
+      amplitude,
+      probability: abs(sin(phase)),
+      phrase: cmykIdToPhrase(id),
+      color: digitColors[id[0]],
+      metaphysical: `Quantum trinity state ${tick}: ${cmykIdToPhrase(id)} — Phase: ${phase.toFixed(2)}, Amplitude: ${amplitude.toFixed(2)}, Probability: ${abs(sin(phase)).toFixed(2)}. The quantum trinity is a living, harmonized stream.`
+    };
+    id = rodinVortexStep(id, channel);
+    phase += PI / 3; // 60-degree shift
+    amplitude = 1 + 0.5 * sin(phase); // Example: amplitude oscillates
+    tick++;
+  }
+}
+
+let quantumTrinityGen = a432QuantumTrinityStream();
+export function currentQuantumTrinityState(): A432QuantumTrinityState {
+  return quantumTrinityGen.next().value;
+}
+export function resetQuantumTrinity(start?: [number, number, number, number], basePhase?: number, baseAmplitude?: number) {
+  quantumTrinityGen = a432QuantumTrinityStream(start, basePhase, baseAmplitude);
+}
+
+export function metaphysicalQuantumTrinityOverlay() {
+  return `Quantum physics in a432 is a living, harmonized trinity—each state is a unique, non-colliding fold in the CMYK matrix. Phase, amplitude, and probability are all recursive, harmonized flows. The quantum trinity never stops, never collides, always harmonizes.`;
+} 

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

@@ -0,0 +1,27 @@
+import { linearStream, vortexStream } from './a432.matrix.ts';
+import { asDigit } from './a432.types.ts';
+import { digitAngleToCMYK } from './a432.cmyk.ts';
+import { TRINITY_POLARITY, asAngle } from './a432.math.ts';
+
+export interface QState { energy: number; spin: number; angle: number; color: ReturnType<typeof digitAngleToCMYK>; }
+
+function* qStream() {
+  const e = linearStream();
+  const s = vortexStream();
+  while (true) yield { ψ: e.next().value, σ: s.next().value };
+}
+
+function nextEnergy(ψ:number,σ:number): number { return asDigit((ψ ^ σ) % 10); }
+
+export function* quantumSolver() {
+  const it = qStream();
+  for (const {ψ,σ} of it) {
+    const energy = nextEnergy(ψ,σ);
+    let spin = σ;
+    if (TRINITY_POLARITY[σ]===0) spin = [3,6,9][energy%3];
+    const angle = asAngle(spin*60%360);
+    const color = digitAngleToCMYK(spin, angle);
+    const state:QState={energy:energy, spin, angle, color};
+    yield state;
+  }
+} 

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

@@ -0,0 +1,470 @@
+/**
+ * A432 Registry System
+ * Harmonized registry for A432 modules, components, and services
+ * DRY pattern: Register once, discover everywhere
+ */
+
+import { type A432Module, type A432ModuleCategory } from './a432.modules.ts';
+import { type A432FactoryState, createA432State } from './a432.factory.ts';
+import { A432Validation } from './a432.utils.ts';
+
+// === REGISTRY INTERFACES ===
+export interface A432RegistryEntry<T = any> {
+  id: string;
+  name: string;
+  type: string;
+  category: string;
+  component: T;
+  metadata: {
+    version: string;
+    description: string;
+    tags: string[];
+    dependencies: string[];
+    created: Date;
+    updated: Date;
+  };
+  stats: {
+    usage: number;
+    lastUsed: Date;
+    performance: number;
+  };
+}
+
+export interface A432RegistryOptions {
+  autoDiscover?: boolean;
+  cacheEnabled?: boolean;
+  validationEnabled?: boolean;
+  performanceTracking?: boolean;
+}
+
+export interface A432RegistryStats {
+  totalEntries: number;
+  byType: Record<string, number>;
+  byCategory: Record<string, number>;
+  cacheHitRate: number;
+  averagePerformance: number;
+  lastUpdated: Date;
+}
+
+// === HARMONIZED REGISTRY ===
+export class A432Registry {
+  private static instance: A432Registry;
+  private entries: Map<string, A432RegistryEntry> = new Map();
+  private cache: Map<string, any> = new Map();
+  private options: A432RegistryOptions;
+
+  private constructor(options: A432RegistryOptions = {}) {
+    this.options = {
+      autoDiscover: true,
+      cacheEnabled: true,
+      validationEnabled: true,
+      performanceTracking: true,
+      ...options
+    };
+  }
+
+  static getInstance(options?: A432RegistryOptions): A432Registry {
+    if (!A432Registry.instance) {
+      A432Registry.instance = new A432Registry(options);
+    }
+    return A432Registry.instance;
+  }
+
+  /**
+   * Register a component
+   */
+  register<T>(
+    id: string,
+    name: string,
+    type: string,
+    category: string,
+    component: T,
+    metadata: Partial<A432RegistryEntry['metadata']> = {}
+  ): A432RegistryEntry<T> {
+    if (this.options.validationEnabled) {
+      this.validateRegistration(id, name, type, category);
+    }
+
+    const entry: A432RegistryEntry<T> = {
+      id,
+      name,
+      type,
+      category,
+      component,
+      metadata: {
+        version: '1.0.0',
+        description: '',
+        tags: [],
+        dependencies: [],
+        created: new Date(),
+        updated: new Date(),
+        ...metadata
+      },
+      stats: {
+        usage: 0,
+        lastUsed: new Date(),
+        performance: 0
+      }
+    };
+
+    this.entries.set(id, entry);
+    return entry;
+  }
+
+  /**
+   * Get a component by ID
+   */
+  get<T>(id: string): T | undefined {
+    const entry = this.entries.get(id);
+    if (!entry) return undefined;
+
+    // Update usage stats
+    if (this.options.performanceTracking) {
+      entry.stats.usage++;
+      entry.stats.lastUsed = new Date();
+    }
+
+    // Check cache
+    if (this.options.cacheEnabled && this.cache.has(id)) {
+      return this.cache.get(id);
+    }
+
+    // Cache the component
+    if (this.options.cacheEnabled) {
+      this.cache.set(id, entry.component);
+    }
+
+    return entry.component as T;
+  }
+
+  /**
+   * Get all components by type
+   */
+  getByType<T>(type: string): T[] {
+    const components: T[] = [];
+    for (const entry of this.entries.values()) {
+      if (entry.type === type) {
+        components.push(entry.component as T);
+      }
+    }
+    return components;
+  }
+
+  /**
+   * Get all components by category
+   */
+  getByCategory<T>(category: string): T[] {
+    const components: T[] = [];
+    for (const entry of this.entries.values()) {
+      if (entry.category === category) {
+        components.push(entry.component as T);
+      }
+    }
+    return components;
+  }
+
+  /**
+   * Get all components by tag
+   */
+  getByTag<T>(tag: string): T[] {
+    const components: T[] = [];
+    for (const entry of this.entries.values()) {
+      if (entry.metadata.tags.includes(tag)) {
+        components.push(entry.component as T);
+      }
+    }
+    return components;
+  }
+
+  /**
+   * Get all entries
+   */
+  getAllEntries(): A432RegistryEntry[] {
+    return Array.from(this.entries.values());
+  }
+
+  /**
+   * Get all IDs
+   */
+  getAllIds(): string[] {
+    return Array.from(this.entries.keys());
+  }
+
+  /**
+   * Check if component exists
+   */
+  has(id: string): boolean {
+    return this.entries.has(id);
+  }
+
+  /**
+   * Remove a component
+   */
+  remove(id: string): boolean {
+    const removed = this.entries.delete(id);
+    if (removed && this.options.cacheEnabled) {
+      this.cache.delete(id);
+    }
+    return removed;
+  }
+
+  /**
+   * Update component metadata
+   */
+  updateMetadata(id: string, metadata: Partial<A432RegistryEntry['metadata']>): boolean {
+    const entry = this.entries.get(id);
+    if (!entry) return false;
+
+    entry.metadata = { ...entry.metadata, ...metadata, updated: new Date() };
+    return true;
+  }
+
+  /**
+   * Get registry statistics
+   */
+  getStats(): A432RegistryStats {
+    const byType: Record<string, number> = {};
+    const byCategory: Record<string, number> = {};
+    let totalPerformance = 0;
+    let performanceCount = 0;
+
+    for (const entry of this.entries.values()) {
+      byType[entry.type] = (byType[entry.type] || 0) + 1;
+      byCategory[entry.category] = (byCategory[entry.category] || 0) + 1;
+      
+      if (entry.stats.performance > 0) {
+        totalPerformance += entry.stats.performance;
+        performanceCount++;
+      }
+    }
+
+    const cacheHitRate = this.options.cacheEnabled ? 
+      (this.cache.size / this.entries.size) * 100 : 0;
+
+    return {
+      totalEntries: this.entries.size,
+      byType,
+      byCategory,
+      cacheHitRate,
+      averagePerformance: performanceCount > 0 ? totalPerformance / performanceCount : 0,
+      lastUpdated: new Date()
+    };
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  /**
+   * Clear all entries
+   */
+  clear(): void {
+    this.entries.clear();
+    this.cache.clear();
+  }
+
+  /**
+   * Export registry to JSON
+   */
+  export(): string {
+    const exportData = {
+      entries: Array.from(this.entries.entries()),
+      stats: this.getStats(),
+      options: this.options,
+      exported: new Date()
+    };
+    return JSON.stringify(exportData, null, 2);
+  }
+
+  /**
+   * Import registry from JSON
+   */
+  import(jsonData: string): boolean {
+    try {
+      const importData = JSON.parse(jsonData);
+      
+      // Clear existing entries
+      this.clear();
+      
+      // Import entries
+      for (const [id, entry] of importData.entries) {
+        this.entries.set(id, entry);
+      }
+      
+      return true;
+    } catch (error) {
+      console.error('Failed to import registry:', error);
+      return false;
+    }
+  }
+
+  // === PRIVATE METHODS ===
+  private validateRegistration(id: string, name: string, type: string, category: string): void {
+    if (!id || typeof id !== 'string') {
+      throw new Error('Invalid ID: must be a non-empty string');
+    }
+    
+    if (!name || typeof name !== 'string') {
+      throw new Error('Invalid name: must be a non-empty string');
+    }
+    
+    if (!type || typeof type !== 'string') {
+      throw new Error('Invalid type: must be a non-empty string');
+    }
+    
+    if (!category || typeof category !== 'string') {
+      throw new Error('Invalid category: must be a non-empty string');
+    }
+    
+    if (this.entries.has(id)) {
+      throw new Error(`Component with ID '${id}' already exists`);
+    }
+  }
+}
+
+// === SPECIALIZED REGISTRIES ===
+export class A432ModuleRegistry extends A432Registry {
+  constructor() {
+    super({ autoDiscover: true, validationEnabled: true });
+  }
+
+  /**
+   * Register A432 module
+   */
+  registerModule(module: A432Module): A432RegistryEntry<A432Module> {
+    return this.register(
+      module.name,
+      module.name,
+      'module',
+      module.category,
+      module,
+      {
+        description: module.description,
+        tags: module.tags || [],
+        dependencies: module.dependencies || []
+      }
+    );
+  }
+
+  /**
+   * Get modules by category
+   */
+  getModulesByCategory(category: A432ModuleCategory): A432Module[] {
+    return this.getByCategory<A432Module>(category);
+  }
+
+  /**
+   * Get all modules
+   */
+  getAllModules(): A432Module[] {
+    return this.getByType<A432Module>('module');
+  }
+}
+
+export class A432StateRegistry extends A432Registry {
+  constructor() {
+    super({ cacheEnabled: true, performanceTracking: true });
+  }
+
+  /**
+   * Register A432 state
+   */
+  registerState(id: string, state: A432FactoryState): A432RegistryEntry<A432FactoryState> {
+    return this.register(
+      id,
+      `State-${id}`,
+      'state',
+      'factory',
+      state,
+      {
+        description: `A432 factory state for ${id}`,
+        tags: ['state', 'factory', 'a432']
+      }
+    );
+  }
+
+  /**
+   * Get states by dimension
+   */
+  getStatesByDimension(dimension: number): A432FactoryState[] {
+    return this.getByTag<A432FactoryState>('dimension-' + dimension);
+  }
+
+  /**
+   * Get states by polarity
+   */
+  getStatesByPolarity(polarity: 1 | -1): A432FactoryState[] {
+    return this.getByTag<A432FactoryState>('polarity-' + polarity);
+  }
+}
+
+// === CONVENIENCE FUNCTIONS ===
+export const a432Registry = A432Registry.getInstance();
+export const a432ModuleRegistry = new A432ModuleRegistry();
+export const a432StateRegistry = new A432StateRegistry();
+
+export function registerA432Component<T>(
+  id: string,
+  name: string,
+  type: string,
+  category: string,
+  component: T,
+  metadata?: Partial<A432RegistryEntry['metadata']>
+): A432RegistryEntry<T> {
+  return a432Registry.register(id, name, type, category, component, metadata);
+}
+
+export function getA432Component<T>(id: string): T | undefined {
+  return a432Registry.get<T>(id);
+}
+
+export function getA432ComponentsByType<T>(type: string): T[] {
+  return a432Registry.getByType<T>(type);
+}
+
+export function getA432ComponentsByCategory<T>(category: string): T[] {
+  return a432Registry.getByCategory<T>(category);
+}
+
+export function getA432ComponentsByTag<T>(tag: string): T[] {
+  return a432Registry.getByTag<T>(tag);
+}
+
+export function registerA432Module(module: A432Module): A432RegistryEntry<A432Module> {
+  return a432ModuleRegistry.registerModule(module);
+}
+
+export function getA432ModulesByCategory(category: A432ModuleCategory): A432Module[] {
+  return a432ModuleRegistry.getModulesByCategory(category);
+}
+
+export function getAllA432Modules(): A432Module[] {
+  return a432ModuleRegistry.getAllModules();
+}
+
+export function registerA432State(id: string, state: A432FactoryState): A432RegistryEntry<A432FactoryState> {
+  return a432StateRegistry.registerState(id, state);
+}
+
+export function getA432State(id: string): A432FactoryState | undefined {
+  return a432StateRegistry.get<A432FactoryState>(id);
+}
+
+export function getA432RegistryStats(): A432RegistryStats {
+  return a432Registry.getStats();
+}
+
+export function clearA432RegistryCache(): void {
+  a432Registry.clearCache();
+}
+
+export function exportA432Registry(): string {
+  return a432Registry.export();
+}
+
+export function importA432Registry(jsonData: string): boolean {
+  return a432Registry.import(jsonData);
+}

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

@@ -0,0 +1,99 @@
+/**
+ * a432.renderer.webgl.ts — minimal public-domain WebGL2 renderer for A432 snapshots.
+ * No external dependencies; ~200 SLOC.
+ */
+
+import { PI, hypot, tan } from './a432.algebra.ts'
+import { getRodinSnapshot, TrinityTorusSnapshot } from './a432.adapters.ts';
+
+const VSH = `#version 300 es
+in vec3 position;
+uniform mat4 mvp;
+void main(){ gl_Position = mvp * vec4(position,1.0); }
+`;
+const FSH = `#version 300 es
+precision highp float;
+uniform vec3 uColor;
+out vec4 outColor;
+void main(){ outColor = vec4(uColor,1.0);} 
+`;
+
+function compile(gl: WebGL2RenderingContext, type: number, src: string) {
+  const sh = gl.createShader(type)!; gl.shaderSource(sh, src); gl.compileShader(sh);
+  if(!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) throw new Error(gl.getShaderInfoLog(sh)??'shader err');
+  return sh;
+}
+
+function link(gl: WebGL2RenderingContext, vs: WebGLShader, fs: WebGLShader){
+  const p = gl.createProgram()!; gl.attachShader(p,vs); gl.attachShader(p,fs); gl.linkProgram(p);
+  if(!gl.getProgramParameter(p, gl.LINK_STATUS)) throw new Error(gl.getProgramInfoLog(p)??'link err');
+  return p;
+}
+
+export function startRenderer(canvas: HTMLCanvasElement){
+  const gl = canvas.getContext('webgl2');
+  if(!gl) throw new Error('WebGL2 required');
+  
+  // After null check, gl is guaranteed to be non-null
+  const glContext = gl as WebGL2RenderingContext;
+  
+  const vs=compile(glContext, glContext.VERTEX_SHADER, VSH);
+  const fs=compile(glContext, glContext.FRAGMENT_SHADER, FSH);
+  const prog=link(glContext,vs,fs);
+  const posLoc = glContext.getAttribLocation(prog,'position');
+  const mvpLoc = glContext.getUniformLocation(prog,'mvp');
+  const colLoc = glContext.getUniformLocation(prog,'uColor');
+
+  const rod = getRodinSnapshot(3);
+  const vbo = glContext.createBuffer(); glContext.bindBuffer(glContext.ARRAY_BUFFER,vbo);
+  const verts = new Float32Array(rod.vertices.flatMap(v=>[v.x,v.y,v.z]));
+  glContext.bufferData(glContext.ARRAY_BUFFER, verts, glContext.STATIC_DRAW);
+
+  glContext.enableVertexAttribArray(posLoc);
+  glContext.vertexAttribPointer(posLoc,3,glContext.FLOAT,false,0,0);
+
+  const proj = mat4Perspective(45, canvas.width/canvas.height, 0.1, 100);
+
+  function frame(time:number){
+    glContext.clearColor(0,0,0,1); glContext.clear(glContext.COLOR_BUFFER_BIT|glContext.DEPTH_BUFFER_BIT);
+    glContext.useProgram(prog);
+    const view = mat4LookAt({x:0,y:10,z:20},{x:0,y:5,z:0});
+    const mvp = mat4Multiply(proj, view);
+    glContext.uniformMatrix4fv(mvpLoc,false,mvp);
+    glContext.uniform3f(colLoc,1,1,1);
+    glContext.drawArrays(glContext.LINE_STRIP,0,rod.vertices.length);
+    requestAnimationFrame(frame);
+  }
+  requestAnimationFrame(frame);
+}
+
+// minimal 4x4 matrix helpers
+function mat4Perspective(fov:number,aspect:number,near:number,far:number){
+  const f=1/tan(fov*PI/360); const nf=1/(near-far);
+  return new Float32Array([
+    f/aspect,0,0,0,
+    0,f,0,0,
+    0,0,(far+near)*nf,-1,
+    0,0,(2*far*near)*nf,0
+  ]);
+}
+interface V3{ x:number;y:number;z:number; }
+function mat4LookAt(eye:V3, center:V3){
+  const zx=eye.x-center.x, zy=eye.y-center.y, zz=eye.z-center.z; const zl=hypot(zx,zy,zz);
+  const zxN=zx/zl, zyN=zy/zl, zzN=zz/zl;
+  const ux=0, uy=1, uz=0;
+  const sx=uy*zzN-uz*zyN, sy=uz*zxN-ux*zzN, sz=ux*zyN-uy*zxN; const sl=hypot(sx,sy,sz);
+  const sxN=sx/sl, syN=sy/sl, szN=sz/sl;
+  const ux2=zyN*szN-zzN*syN, uy2=zzN*sxN-zxN*szN, uz2=zxN*syN-zyN*sxN;
+  return new Float32Array([
+    sxN, uy2, zxN, 0,
+    syN, uy2, zyN, 0,
+    szN, uz2, zzN, 0,
+    -(sxN*eye.x+syN*eye.y+szN*eye.z), -(ux2*eye.x+uy2*eye.y+uz2*eye.z), -(zxN*eye.x+zyN*eye.y+zzN*eye.z), 1
+  ]);
+}
+function mat4Multiply(a:Float32Array,b:Float32Array){
+  const out=new Float32Array(16);
+  for(let i=0;i<4;i++) for(let j=0;j<4;j++) out[i*4+j]=a[i*4+0]*b[0*4+j]+a[i*4+1]*b[1*4+j]+a[i*4+2]*b[2*4+j]+a[i*4+3]*b[3*4+j];
+  return out;
+}