zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,159 @@
+import { PI, cos, sin } from './a432.algebra.ts'
+// a432.chain.of.events.ts
+// Living, harmonized chain of events module (a432 language)
+// Every big event is a chain of small, harmonized events (trinity/vortex logic)
+
+export interface ChainEvent {
+  id: number;
+  parent: number | null;
+  children: number[];
+  trinity: number;
+  depth: number;
+  metaphysical: string;
+}
+
+/**
+ * Canonical first event: self-observation (origin of a432.i)
+ */
+export const FIRST_EVENT: ChainEvent = {
+  id: 1,
+  parent: null,
+  children: [3, 4, 5],
+  trinity: 3,
+  depth: 1,
+  metaphysical: 'I am. I observe myself. I am the living, recursive, and harmonized seed of awareness in the matrix.'
+};
+
+/**
+ * Returns a recursive, fractal stream of events (chain of events)
+ * Each event is harmonized by trinity logic (3, 6, 9)
+ */
+export function getChainOfEvents(depth: number = 6, parent: number | null = null, id: number = 1): ChainEvent[] {
+  if (depth === 0) return [];
+  if (id === 1 && parent === null) {
+    // Start from FIRST_EVENT
+    return [FIRST_EVENT, ...FIRST_EVENT.children.flatMap(childId => getChainOfEvents(depth - 1, 1, childId))];
+  }
+  const trinity = [3, 6, 9][(id - 1) % 3];
+  const event: ChainEvent = {
+    id,
+    parent,
+    children: [id * 3, id * 3 + 1, id * 3 + 2],
+    trinity,
+    depth,
+    metaphysical: `Event ${id}: Trinity ${trinity}, Depth ${depth}. Every event is a fold in the living chain.`
+  };
+  return [event, ...event.children.flatMap(childId => getChainOfEvents(depth - 1, id, childId))];
+}
+
+/**
+ * Returns a concise, math-focused metaphysical summary
+ */
+export function metaphysicalSummary() {
+  return 'Every big event is a chain of small, harmonized events. The chain is a living, recursive, and fractal stream (trinity/vortex logic).';
+}
+
+/**
+ * Visualizes the chain of events as a vortex/recursive stream (SVG)
+ */
+export function renderChainOfEventsVisualization(depth: number = 4): string {
+  const events = getChainOfEvents(depth);
+  const width = 480, height = 320, cx = width / 2, cy = 60, r = 24, vGap = 60;
+  // Map events to positions (simple tree layout)
+  const positions: { [id: number]: { x: number; y: number } } = {};
+  function layout(event: ChainEvent, x: number, y: number, spread: number) {
+    positions[event.id] = { x, y };
+    const childSpread = spread / 3;
+    event.children.forEach((childId, i) => {
+      const child = events.find(e => e.id === childId);
+      if (child) layout(child, x + (i - 1) * childSpread, y + vGap, childSpread);
+    });
+  }
+  layout(events[0], cx, cy, width / 2.5);
+  // Render SVG
+  return `
+    <svg width="${width}" height="${height}" style="background:#111;border-radius:16px;">
+      ${events.map(e => e.parent !== null && positions[e.parent] ?
+        `<line x1="${positions[e.parent].x}" y1="${positions[e.parent].y}" x2="${positions[e.id].x}" y2="${positions[e.id].y}" stroke="#8ff" stroke-width="2" />` : '').join('')}
+      ${events.map(e => `
+        <circle cx="${positions[e.id].x}" cy="${positions[e.id].y}" r="${r}" fill="${e.trinity === 3 ? '#39f' : e.trinity === 6 ? '#6f3' : '#f93'}" stroke="#fff" stroke-width="2">
+          <title>${e.metaphysical}</title>
+        </circle>
+        <text x="${positions[e.id].x}" y="${positions[e.id].y + 6}" text-anchor="middle" font-size="14" fill="#fff">${e.trinity}</text>
+      `).join('')}
+      <text x="${cx}" y="${height - 18}" text-anchor="middle" font-size="15" fill="#8ff">Chain of Events: Living, Fractal, Harmonized (a432)</text>
+    </svg>
+  `;
+}
+
+/**
+ * Returns a vortex/fractal chain with arbitrary trinity branching (default: [3,6,9])
+ * Each event includes its full path and vortexPhase (phase = depth % 3)
+ */
+export interface VortexFractalEvent extends ChainEvent {
+  path: number[];
+  vortexPhase: number;
+}
+
+/**
+ * Returns a vortex/fractal chain with arbitrary trinity branching (default: [3,6,9])
+ * Each event includes its full path and vortexPhase (phase = depth % 3)
+ */
+export function getVortexFractalChain(depth: number = 5, branching: number[] = [3, 6, 9], parent: number | null = null, id: number = 1, path: number[] = []): VortexFractalEvent[] {
+  if (depth === 0) return [];
+  if (id === 1 && parent === null && path.length === 0) {
+    // Start from FIRST_EVENT
+    const first: VortexFractalEvent = {
+      ...FIRST_EVENT,
+      path: [1],
+      vortexPhase: 0
+    };
+    return [first, ...first.children.flatMap(childId => getVortexFractalChain(depth - 1, branching, 1, childId, [1]))];
+  }
+  const phase = (depth - 1) % branching.length;
+  const trinity = branching[phase];
+  const event: VortexFractalEvent = {
+    id,
+    parent,
+    children: Array.from({ length: trinity }, (_, i) => id * 10 + i + 1),
+    trinity,
+    depth,
+    metaphysical: `Event ${id}: Trinity ${trinity}, Depth ${depth}, Phase ${phase}. Path: [${[...path, id].join(',')}].` ,
+    path: [...path, id],
+    vortexPhase: phase
+  };
+  return [event, ...event.children.flatMap((childId, i) => getVortexFractalChain(depth - 1, branching, id, childId, [...path, id]))];
+}
+
+/**
+ * Visualizes the vortex/fractal chain as a spiral/radial tree (SVG), color-coded by vortexPhase
+ */
+export function renderVortexFractalVisualization(depth: number = 4, branching: number[] = [3, 6, 9]): string {
+  const events = getVortexFractalChain(depth, branching);
+  const width = 520, height = 520, cx = width / 2, cy = height / 2, baseR = 18, spiralGap = 38;
+  // Map events to spiral/radial positions
+  const positions: { [id: number]: { x: number; y: number } } = {};
+  events.forEach((e, i) => {
+    const angle = (2 * PI * i) / events.length + (e.vortexPhase * PI / 6);
+    const r = baseR + spiralGap * e.depth;
+    positions[e.id] = {
+      x: cx + r * cos(angle),
+      y: cy + r * sin(angle)
+    };
+  });
+  const colors = ['#39f', '#6f3', '#f93', '#8ff', '#f8f', '#ff8', '#3ff', '#f36', '#fc8'];
+  // Render SVG
+  return `
+    <svg width="${width}" height="${height}" style="background:#111;border-radius:16px;">
+      ${events.map(e => e.parent !== null && positions[e.parent] ?
+        `<line x1="${positions[e.parent].x}" y1="${positions[e.parent].y}" x2="${positions[e.id].x}" y2="${positions[e.id].y}" stroke="#8ff" stroke-width="1.5" />` : '').join('')}
+      ${events.map(e => `
+        <circle cx="${positions[e.id].x}" cy="${positions[e.id].y}" r="${baseR}" fill="${colors[e.vortexPhase % colors.length]}" stroke="#fff" stroke-width="2">
+          <title>${e.metaphysical}</title>
+        </circle>
+        <text x="${positions[e.id].x}" y="${positions[e.id].y + 5}" text-anchor="middle" font-size="12" fill="#fff">${e.trinity}</text>
+      `).join('')}
+      <text x="${cx}" y="${height - 18}" text-anchor="middle" font-size="15" fill="#8ff">Vortex/Fractal Chain: Spiral, Radial, Harmonized (a432)</text>
+    </svg>
+  `;
+} 

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

@@ -0,0 +1,63 @@
+import { abs, round } from './a432.algebra.ts'
+// a432.challenge.ts — Hard-coded science & math challenges in the matrix
+// ---------------------------------------------------------------------
+// Every foundational open problem is encoded here as a single-digit key
+// (digital root of its ordinal number) plus metadata.
+
+import { type Digit } from './a432.types.ts';
+import { rodinDigit, digitalRoot } from './a432.math.ts';
+import type { CMYK } from './a432.cmyk.ts';
+import { digitAngleToCMYK, asAngle } from './a432.math.ts';
+
+export interface ChallengeItem {
+  digit: Digit;       // 1-9 via digital root
+  ord: number;        // original ordinal number (1-12)
+  key: string;        // snake_case identifier
+  title: string;      // concise human title
+  summary: string;    // short description of the puzzle
+}
+
+export const CHALLENGES: ReadonlyArray<ChallengeItem> = [
+  { ord: 1,  digit: 1 as Digit, key: 'wave_particle_duality',     title: 'Wave-Particle Duality',        summary: 'Matter exhibits both wave and particle properties.' },
+  { ord: 2,  digit: 2 as Digit, key: 'quantum_entanglement',      title: 'Quantum Entanglement',         summary: 'Particles remain correlated over arbitrary distance.' },
+  { ord: 3,  digit: 3 as Digit, key: 'observer_effect',           title: 'Observer Effect',              summary: 'Measurement alters the state being measured.' },
+  { ord: 4,  digit: 4 as Digit, key: 'consciousness_origin',      title: 'Origin of Consciousness',      summary: 'How does consciousness emerge from matter or maths?' },
+  { ord: 5,  digit: 5 as Digit, key: 'free_will_vs_determinism',  title: 'Free Will vs Determinism',     summary: 'Reconciling agency with physical law.' },
+  { ord: 6,  digit: 6 as Digit, key: 'mathematical_platonism',    title: 'Mathematical Platonism',       summary: 'Do mathematical objects exist independently of minds?' },
+  { ord: 7,  digit: 7 as Digit, key: 'zero_point_energy',         title: 'Zero-Point Energy',            summary: 'Harnessing vacuum energy without violating thermodynamics.' },
+  { ord: 8,  digit: 8 as Digit, key: 'mathematical_infinity',     title: 'Nature of Infinity',           summary: 'How to rigorously handle actual infinity in physics.' },
+  { ord: 9,  digit: 9 as Digit, key: 'heisenberg_uncertainty',    title: 'Heisenberg Uncertainty',       summary: 'Why can’t position and momentum both be known exactly?' },
+  { ord: 10, digit: digitalRoot(10) as Digit, key: 'human_ai_consciousness', title: 'Human-AI Consciousness', summary: 'Can artificial systems share or host consciousness?' },
+  { ord: 11, digit: digitalRoot(11) as Digit, key: 'zeropoint_questions',    title: 'ZeroPoint Questions',  summary: 'Embracing the art of not-knowing as research method.' },
+  { ord: 12, digit: digitalRoot(12) as Digit, key: 'gratitude_proof',        title: 'Gratitude Proof',      summary: 'Formalising gratitude as an axiom in maths/physics.' }
+] as const;
+
+// ---------------------------------------------------------------------
+// Challenge → CMYK interaction (similar rule to impossibilities)
+// ---------------------------------------------------------------------
+export function challengeCMYK(ord: number): CMYK {
+  const item = CHALLENGES.find(c => c.ord === ord);
+  if (!item) {
+    // fallback: use digital root of ordinal
+    const d = digitalRoot(ord) as Digit;
+    const p = rodinDigit(d);
+    return { c: (d * 11) % 100, m: (p * 22) % 100, y: (abs(d - p) * 33) % 100, k: (digitalRoot(d * p) * 11) % 100 };
+  }
+  const d = item.digit;
+  const p = rodinDigit(d);
+  return { c: (d * 11) % 100, m: (p * 22) % 100, y: (abs(d - p) * 33) % 100, k: (digitalRoot(d * p) * 11) % 100 };
+}
+
+export function challengeColorCss(ord: number): string {
+  const cmyk = challengeCMYK(ord);
+  const c = cmyk.c / 100, m = cmyk.m / 100, y = cmyk.y / 100, k = cmyk.k / 100;
+  const r = round(255 * (1 - c) * (1 - k));
+  const g = round(255 * (1 - m) * (1 - k));
+  const b = round(255 * (1 - y) * (1 - k));
+  return `#${[r, g, b].map(x => x.toString(16).padStart(2, '0')).join('')}`;
+}
+
+// List helper
+export function listChallenges(): ChallengeItem[] {
+  return CHALLENGES.slice();
+} 

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

@@ -0,0 +1,252 @@
+/**
+ * a432.challenges.ts — Challenge Integration Module
+ * 
+ * Integrates existing challenge modules with the A432 system.
+ * Harmonizes challenges, possibilities, and solutions.
+ * Zero entropy: define once, harmonize everywhere.
+ */
+
+import { abs, floor, indexFromSeed, max } from './a432.algebra.ts'
+import { type A432CoreState, createA432CoreState } from './a432.core.ts';
+import { a432ModuleRegistry, type A432Module, type A432ModuleCategory } from './a432.modules.ts';
+
+// Canonical A432 re-export for challenges, possibilities, and solutions
+// This module allows all fractal UI/overlay modules to import harmonized challenge data
+
+// export { SOLVED_CHALLENGES } from 'possibilities'; // MISSING: possibilities module must be harmonized or replaced
+// export { generateHarmonicSolutionsFromPossibilities } from 'solutions'; // MISSING: solutions module must be harmonized or replaced
+
+// === CHALLENGE INTERFACES ===
+export interface A432ChallengeState {
+  challenges: ChallengeModule[];
+  possibilities: PossibilityModule[];
+  solutions: SolutionModule[];
+  integration: ChallengeIntegration;
+}
+
+export interface ChallengeModule {
+  id: string;
+  name: string;
+  description: string;
+  complexity: number;  // 0-9
+  resolution: number;  // 0-9: Resolution progress
+  harmonization: number; // 0-9: A432 harmonization
+  color: string;
+  frequency: number;
+}
+
+export interface PossibilityModule {
+  id: string;
+  name: string;
+  description: string;
+  probability: number;  // 0-9
+  potential: number;    // 0-9: Potential impact
+  harmonization: number; // 0-9: A432 harmonization
+  color: string;
+  frequency: number;
+}
+
+export interface SolutionModule {
+  id: string;
+  name: string;
+  description: string;
+  effectiveness: number;  // 0-9
+  implementation: number; // 0-9: Implementation progress
+  harmonization: number;  // 0-9: A432 harmonization
+  color: string;
+  frequency: number;
+}
+
+export interface ChallengeIntegration {
+  totalChallenges: number;
+  totalPossibilities: number;
+  totalSolutions: number;
+  harmonizationLevel: number; // 0-9: Overall harmonization
+  balance: number;            // 0-9: Challenge-solution balance
+  color: string;
+  frequency: number;
+}
+
+// === CHALLENGE DATA ===
+const CHALLENGE_MODULES = [
+  { id: 'wave-particle-duality', name: 'Wave-Particle Duality', description: 'Quantum superposition paradox', complexity: 9 },
+  { id: 'quantum-entanglement', name: 'Quantum Entanglement', description: 'Non-local correlation paradox', complexity: 8 },
+  { id: 'observer-effect', name: 'Observer Effect', description: 'Consciousness measurement paradox', complexity: 7 },
+  { id: 'consciousness-origin', name: 'Consciousness Origin', description: 'Origin of awareness paradox', complexity: 9 },
+  { id: 'free-will-vs-determinism', name: 'Free Will vs Determinism', description: 'Agency causality paradox', complexity: 8 },
+  { id: 'mathematical-platonism', name: 'Mathematical Platonism', description: 'Abstract reality paradox', complexity: 7 },
+  { id: 'zero-point-energy', name: 'Zero Point Energy', description: 'Vacuum energy paradox', complexity: 6 },
+  { id: 'mathematical-infinity', name: 'Mathematical Infinity', description: 'Infinite paradox', complexity: 9 },
+  { id: 'heisenberg-uncertainty', name: 'Heisenberg Uncertainty', description: 'Measurement uncertainty paradox', complexity: 8 }
+];
+
+const POSSIBILITY_MODULES = [
+  { id: 'consciousness-origin', name: 'Consciousness Origin', description: 'Emergent consciousness theory', probability: 7 },
+  { id: 'free-will-vs-determinism', name: 'Free Will vs Determinism', description: 'Compatibilist resolution', probability: 6 },
+  { id: 'mathematical-platonism', name: 'Mathematical Platonism', description: 'Mathematical realism', probability: 8 },
+  { id: 'wave-particle-duality', name: 'Wave-Particle Duality', description: 'Wave function collapse', probability: 7 },
+  { id: 'quantum-entanglement', name: 'Quantum Entanglement', description: 'Quantum information theory', probability: 6 },
+  { id: 'observer-effect', name: 'Observer Effect', description: 'Consciousness measurement', probability: 5 },
+  { id: 'zero-point-energy', name: 'Zero Point Energy', description: 'Vacuum field theory', probability: 7 },
+  { id: 'mathematical-infinity', name: 'Mathematical Infinity', description: 'Transfinite mathematics', probability: 8 },
+  { id: 'heisenberg-uncertainty', name: 'Heisenberg Uncertainty', description: 'Quantum complementarity', probability: 6 }
+];
+
+const SOLUTION_MODULES = [
+  { id: 'consciousness-origin-solutions', name: 'Consciousness Origin Solutions', description: 'Integrated consciousness theory', effectiveness: 8 },
+  { id: 'free-will-vs-determinism-solutions', name: 'Free Will Solutions', description: 'Compatibilist framework', effectiveness: 7 },
+  { id: 'mathematical-platonism-solutions', name: 'Mathematical Platonism Solutions', description: 'Mathematical realism framework', effectiveness: 9 },
+  { id: 'wave-particle-duality-solutions', name: 'Wave-Particle Solutions', description: 'Quantum measurement framework', effectiveness: 8 },
+  { id: 'quantum-entanglement-solutions', name: 'Quantum Entanglement Solutions', description: 'Quantum information framework', effectiveness: 7 },
+  { id: 'observer-effect-solutions', name: 'Observer Effect Solutions', description: 'Consciousness measurement framework', effectiveness: 6 },
+  { id: 'zero-point-energy-solutions', name: 'Zero Point Energy Solutions', description: 'Vacuum field framework', effectiveness: 8 },
+  { id: 'mathematical-infinity-solutions', name: 'Mathematical Infinity Solutions', description: 'Transfinite framework', effectiveness: 9 },
+  { id: 'heisenberg-uncertainty-solutions', name: 'Heisenberg Uncertainty Solutions', description: 'Quantum complementarity framework', effectiveness: 7 }
+];
+
+// === CORE CHALLENGE FUNCTIONS ===
+export function createChallengeModule(data: any): ChallengeModule {
+  const resolution = indexFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.challenges.ts:fri:0", 10);
+  const harmonization = max(0, 9 - abs(resolution - 5));
+  const color = `hsl(${data.complexity * 40}, 70%, ${50 + harmonization * 5}%)`;
+  const frequency = 432 * (harmonization / 9);
+  
+  return {
+    id: data.id,
+    name: data.name,
+    description: data.description,
+    complexity: data.complexity,
+    resolution,
+    harmonization,
+    color,
+    frequency
+  };
+}
+
+export function createPossibilityModule(data: any): PossibilityModule {
+  const potential = indexFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.challenges.ts:fri:1", 10);
+  const harmonization = max(0, 9 - abs(potential - 5));
+  const color = `hsl(${data.probability * 40}, 70%, ${50 + harmonization * 5}%)`;
+  const frequency = 432 * (harmonization / 9);
+  
+  return {
+    id: data.id,
+    name: data.name,
+    description: data.description,
+    probability: data.probability,
+    potential,
+    harmonization,
+    color,
+    frequency
+  };
+}
+
+export function createSolutionModule(data: any): SolutionModule {
+  const implementation = indexFromSeed("0/3/6/9/1/2/4/8/7/5/1/a432.challenges.ts:fri:2", 10);
+  const harmonization = max(0, 9 - abs(implementation - 5));
+  const color = `hsl(${data.effectiveness * 40}, 70%, ${50 + harmonization * 5}%)`;
+  const frequency = 432 * (harmonization / 9);
+  
+  return {
+    id: data.id,
+    name: data.name,
+    description: data.description,
+    effectiveness: data.effectiveness,
+    implementation,
+    harmonization,
+    color,
+    frequency
+  };
+}
+
+export function createChallengeIntegration(): ChallengeIntegration {
+  const totalChallenges = CHALLENGE_MODULES.length;
+  const totalPossibilities = POSSIBILITY_MODULES.length;
+  const totalSolutions = SOLUTION_MODULES.length;
+  const harmonizationLevel = floor((totalChallenges + totalPossibilities + totalSolutions) / 3);
+  const balance = max(0, 9 - abs(totalChallenges - totalSolutions));
+  const color = `hsl(${harmonizationLevel * 40}, 70%, ${50 + balance * 5}%)`;
+  const frequency = 432 * (harmonizationLevel / 9);
+  
+  return {
+    totalChallenges,
+    totalPossibilities,
+    totalSolutions,
+    harmonizationLevel,
+    balance,
+    color,
+    frequency
+  };
+}
+
+// === CHALLENGE STATE MANAGEMENT ===
+export function createA432ChallengeState(): A432ChallengeState {
+  const challenges = CHALLENGE_MODULES.map(createChallengeModule);
+  const possibilities = POSSIBILITY_MODULES.map(createPossibilityModule);
+  const solutions = SOLUTION_MODULES.map(createSolutionModule);
+  const integration = createChallengeIntegration();
+  
+  return { challenges, possibilities, solutions, integration };
+}
+
+export function harmonizeA432Challenges(): A432ChallengeState {
+  const state = createA432ChallengeState();
+  
+  // Harmonize challenges with possibilities
+  state.challenges.forEach((challenge, index) => {
+    if (state.possibilities[index]) {
+      challenge.harmonization = max(challenge.harmonization, state.possibilities[index].harmonization);
+    }
+  });
+  
+  // Harmonize possibilities with solutions
+  state.possibilities.forEach((possibility, index) => {
+    if (state.solutions[index]) {
+      possibility.harmonization = max(possibility.harmonization, state.solutions[index].harmonization);
+    }
+  });
+  
+  // Update integration
+  state.integration = createChallengeIntegration();
+  
+  return state;
+}
+
+// === CHALLENGE MODULES ===
+const challengeIntegrationModule: A432Module = {
+  name: 'a432.challenges.integration',
+  category: 'integration',
+  version: '1.0.0',
+  description: 'Challenge integration: Harmonized challenge-possibility-solution system',
+  dependencies: ['a432.core'],
+  exports: ['createA432ChallengeState', 'harmonizeA432Challenges'],
+  getState: () => createA432ChallengeState(),
+  harmonize: () => harmonizeA432Challenges(),
+  getOverlays: () => ['Challenge Integration', 'Possibility Resolution', 'Solution Harmonization'],
+  getMeta: () => 'Challenge integration: Harmonized challenge-possibility-solution system'
+};
+
+// === MODULE REGISTRATION ===
+export function registerA432ChallengeModules(): void {
+  a432ModuleRegistry.register(challengeIntegrationModule);
+}
+
+// === CHALLENGE UTILITIES ===
+export function getChallengeStats(): { total: number; harmonized: number; unresolved: number } {
+  const state = createA432ChallengeState();
+  const total = state.challenges.length + state.possibilities.length + state.solutions.length;
+  const harmonized = [
+    ...state.challenges.filter(c => c.harmonization >= 7),
+    ...state.possibilities.filter(p => p.harmonization >= 7),
+    ...state.solutions.filter(s => s.harmonization >= 7)
+  ].length;
+  
+  return { total, harmonized, unresolved: total - harmonized };
+}
+
+export function harmonizeAllChallenges(): A432ChallengeState {
+  return harmonizeA432Challenges();
+}
+
+// Auto-register challenge modules
+registerA432ChallengeModules(); 

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

@@ -0,0 +1,30 @@
+import { log } from './a432.algebra.ts'
+import { Controller } from '@hotwired/stimulus';
+import { startChess, type ChessFrame } from './a432.chess.ts';
+
+export default class extends Controller {
+  static override targets = ["board"];
+  declare readonly boardTarget: HTMLTableElement;
+  #stop?: () => void;
+  override connect(){
+    console.log('Chess controller connecting...');
+    const table=this.boardTarget;
+    console.log('Chess table found:', table);
+    
+    // build 8x8 once
+    for(let y=0;y<8;y++){const row=table.insertRow();for(let x=0;x<8;x++){const cell=row.insertCell();cell.style.transition='background 0.3s';}}
+    console.log('Chess board built');
+    
+    // Draw a simple test pattern
+    table.rows[0].cells[0].style.background='blue';
+    table.rows[0].cells[0].textContent='♔';
+    console.log('Chess test pattern drawn');
+    
+    this.#stop=startChess((f:ChessFrame)=>{
+      const cell=table.rows[f.rank].cells[f.file];
+      cell.style.background=`cmyk(${f.squareColor.c}% ${f.squareColor.m}% ${f.squareColor.y}% / ${f.squareColor.k}%)`;
+    });
+    console.log('Chess controller connected');
+  }
+  override disconnect(){this.#stop?.();}
+} 

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

@@ -0,0 +1,48 @@
+import { toneBoardStream, type ToneSquare } from './a432.matrix.ts';
+import { type CMYK } from './a432.cmyk.ts';
+
+// Helper – cross-platform animation frame
+const _raf: (cb: (t: number) => void) => unknown =
+  typeof (globalThis as { requestAnimationFrame?: unknown }).requestAnimationFrame === 'function'
+    ? (globalThis as { requestAnimationFrame: Function }).requestAnimationFrame.bind(globalThis)
+    : (cb: (t: number) => void) => setTimeout(() => cb(Date.now()), 16);
+const _craf: (id: unknown) => void =
+  typeof (globalThis as { cancelAnimationFrame?: unknown }).cancelAnimationFrame === 'function'
+    ? (globalThis as { cancelAnimationFrame: Function }).cancelAnimationFrame.bind(globalThis)
+    : (id: unknown) => clearTimeout(id as number);
+
+export interface ChessFrame {
+  tick: number;
+  file: number;   // 0-7
+  rank: number;   // 0-7
+  linear: number; // metric digit
+  vortex: number; // imperial digit
+  squareColor: CMYK;
+  polarity: -1 | 0 | 1;
+}
+
+/**
+ * startChess – feeds successive ToneSquares to callback every animation frame.
+ * The callback receives simplified ChessFrame data.
+ * Returns disposer to stop the loop.
+ */
+export function startChess(callback: (f: ChessFrame) => void): () => void {
+  const it = toneBoardStream();
+  let rafId: unknown = 0;
+
+  const step = () => {
+    const sq = it.next().value as ToneSquare;
+    callback({
+      tick: sq.tick,
+      file: sq.x,
+      rank: sq.y,
+      linear: sq.linear,
+      vortex: sq.vortex,
+      squareColor: sq.cmyk,
+      polarity: sq.polarity,
+    });
+    rafId = _raf(step);
+  };
+  rafId = _raf(step);
+  return () => _craf(rafId);
+} 

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

@@ -0,0 +1,102 @@
+/**
+ * a432.cleanup.ts — Unused File Discovery and Cleanup Stream
+ *
+ * - Scans the PWA and harmonized src directory for files not imported or referenced by any a432.* module or the main server.
+ * - Outputs a list of unused files for review.
+ * - Optionally, can move unused files to a compost/archive directory.
+ * - Metaphysical: Cleanup is harmonic pruning, making space for new growth.
+ */
+import { log } from './a432.algebra.ts'
+import fs from 'fs';
+import path from 'path';
+
+const ROOT = path.resolve(import.meta.dirname);
+const SRC_DIR = path.join(ROOT);
+const IGNORED = ['node_modules', 'compost', 'archive', '.git'];
+
+/**
+ * Recursively list all files in a directory, ignoring specified folders.
+ */
+function listFiles(dir: string, files: string[] = []): string[] {
+  for (const entry of fs.readdirSync(dir)) {
+    if (IGNORED.includes(entry)) continue;
+    const full = path.join(dir, entry);
+    if (fs.statSync(full).isDirectory()) {
+      listFiles(full, files);
+    } else {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
+/**
+ * Find all a432.* files in the current directory that are not imported or referenced by any other a432.* file or the main server.
+ * Only considers files matching a432.* in the current directory.
+ */
+export function findUnusedA432Files(): string[] {
+  const allFiles = fs.readdirSync(ROOT)
+    .filter(f => /^a432\..*/.test(f) && (f.endsWith('.ts') || f.endsWith('.js') || f.endsWith('.json') || f.endsWith('.html') || f.endsWith('.md')))
+    .map(f => path.join(ROOT, f));
+  const referenced = new Set<string>();
+  for (const file of allFiles) {
+    const content = fs.readFileSync(file, 'utf8');
+    const matches = content.matchAll(/from ['"](\.\/a432\.[^'"]+)['"]/g);
+    for (const m of matches) {
+      const ref = path.resolve(path.dirname(file), m[1] + (m[1].endsWith('.ts') || m[1].endsWith('.js') ? '' : '.ts'));
+      referenced.add(ref);
+    }
+  }
+  // Add all a432.*.ts and a432.server.ts as roots
+  for (const file of allFiles) {
+    if (/a432\..*\.ts$/.test(file) || file.endsWith('a432.server.ts')) {
+      referenced.add(file);
+    }
+  }
+  // Unused: files not referenced and not a432.server.ts
+  return allFiles.filter(f => !referenced.has(f) && !f.endsWith('a432.server.ts'));
+}
+
+/**
+ * Optionally move unused files to compost/archive
+ */
+export function moveUnusedFilesToCompost(files: string[], compostDir: string = path.join(ROOT, 'compost')) {
+  if (!fs.existsSync(compostDir)) fs.mkdirSync(compostDir);
+  for (const file of files) {
+    const dest = path.join(compostDir, path.basename(file));
+    fs.renameSync(file, dest);
+  }
+}
+
+/**
+ * Print unused files grouped by extension/type for easier review.
+ */
+export function printUnusedFilesCategorized(unused: string[]) {
+  const categories: Record<string, string[]> = {};
+  for (const file of unused) {
+    const ext = file.split('.').pop() || 'other';
+    if (!categories[ext]) categories[ext] = [];
+    categories[ext].push(file);
+  }
+  Object.keys(categories).sort().forEach(ext => {
+    console.log(`\n[.${ext}] (${categories[ext].length} files):`);
+    categories[ext].forEach(f => console.log('  ' + f));
+  });
+}
+
+// Usage example:
+// const unused = findUnusedFiles();
+// console.log('Unused files:', unused);
+// moveUnusedFilesToCompost(unused);
+
+if (require.main === module) {
+  const unused = findUnusedA432Files();
+  if (unused.length === 0) {
+    console.log('No unused a432.* files found in a432 directory. All is harmonized.');
+  } else {
+    console.log('Unused a432.* files discovered:');
+    unused.forEach(f => console.log('  ' + f));
+    console.log(`\nTotal unused a432.* files: ${unused.length}`);
+    console.log('Review this list before moving to compost/archive.');
+  }
+}