zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,42 @@
+/**
+ * a432.types.ts — branded numeric types used across A432.
+ * These are simple TypeScript type aliases that carry a phantom tag so
+ * different numeric domains cannot be mixed accidentally.
+ * Public-domain: CC0-1.0.
+ * metric vortex 0 1 2 3 4 5 6 7 8 9
+ * imperial vortex 0 3 6 9 1 2 4 8 7 5 1
+ * trinity 0/3|1/6|2/9|3/1|4/2|5/4|6/8|7/7|8/5|9/1 is metric/imperial sacred geometry
+ */
+
+// Valid single-digit union (TS literals must be integers, not expressions)
+export type Digit = 0|1|2|3|4|5|6|7|8|9 & { readonly __brand: 'Digit' };
+
+// ——————————————————————————————————————————
+// Metric / Imperial / Trinity vortex mappings
+// ---------------------------------------------------------
+export const METRIC_VORTEX: readonly Digit[]   = [0,1,2,3,4,5,6,7,8,9].map(n=>n as Digit);
+export const IMPERIAL_VORTEX: readonly Digit[] = [0,3,6,9,1,2,4,8,7,5].map(n=>n as Digit);
+export const TRINITY_MAP = {
+  0:3, 1:6, 2:9, 3:1, 4:2,
+  5:4, 6:8, 7:7, 8:5, 9:1
+} as unknown as Record<Digit, Digit>;
+
+export const toImperial = (m: Digit): Digit => IMPERIAL_VORTEX[METRIC_VORTEX.indexOf(m)] as Digit;
+export const toMetric   = (i: Digit): Digit => METRIC_VORTEX[IMPERIAL_VORTEX.indexOf(i)] as Digit;
+export const toTrinity  = (d: Digit): Digit => (TRINITY_MAP as Record<number, Digit>)[d];
+
+export type Hz = number & { readonly __brand: 'Hz' };
+export type AngleDeg = number & { readonly __brand: 'AngleDeg' };
+
+// helpers to brand values (no runtime cost)
+export const asDigit = (n: number) => n as Digit;
+/**
+ * Safely convert a number to Digit (0-9), throws if out of range.
+ */
+export function toDigit(n: number): Digit {
+  const d = n % 10;
+  if (!Number.isInteger(d) || d < 0 || d > 9) throw new Error('Not a Digit: ' + n);
+  return d as Digit;
+}
+export const asHz = (n: number) => n as Hz;
+export const asAngle = (n: number) => n as AngleDeg; 

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

@@ -0,0 +1,16 @@
+import { max as algMax } from './a432.algebra.ts'
+// a432.ui.analytics.ts — Analytics/dashboard for A432 UI
+type AnalyticsEvent = { type: string; time: number; [key: string]: unknown };
+export function renderAnalyticsDashboard(container: HTMLElement, events: AnalyticsEvent[]) {
+  container.innerHTML = '<h3>I Event Analytics</h3>';
+  const summary = events.reduce((acc, ev) => {
+    acc[ev.type] = (acc[ev.type] || 0) + 1;
+    return acc;
+  }, {} as Record<string, number>);
+  container.innerHTML += '<ul>' + Object.entries(summary).map(([type, count]) => `<li>${type}: ${count}</li>`).join('') + '</ul>';
+  // Timeline
+  container.innerHTML += '<h4>Timeline</h4><ul>' + events.map(ev => `<li>${new Date(ev.time).toLocaleTimeString()}: ${ev.type}</li>`).join('') + '</ul>';
+  // Graph (simple bar chart)
+  const max = algMax(...Object.values(summary));
+  container.innerHTML += '<h4>Event Frequency</h4><div style="display:flex;align-items:end;height:60px;">' + Object.entries(summary).map(([type, count]) => `<div style="width:40px;margin-right:8px;background:#0ff;height:${(count/max)*60}px;text-align:center;color:#222;">${count}<br><span style='font-size:10px;'>${type}</span></div>`).join('') + '</div>';
+} 

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

@@ -0,0 +1,18 @@
+// a432.ui.controls.ts — Reusable UI button/control factory for A432 UI
+export function createUIButton({ label, onClick, position = 'absolute', right = '16px', top = '8px', zIndex = '10001' }: {
+  label: string;
+  onClick: () => void;
+  position?: string;
+  right?: string;
+  top?: string;
+  zIndex?: string;
+}): HTMLButtonElement {
+  const btn = document.createElement('button');
+  btn.textContent = label;
+  btn.style.position = position;
+  btn.style.right = right;
+  btn.style.top = top;
+  btn.style.zIndex = zIndex;
+  btn.onclick = onClick;
+  return btn;
+} 

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

@@ -0,0 +1,16 @@
+// a432.ui.events.ts — DRY event handler registry for A432 UI
+import { recordEvent } from './a432.block.chain.event.ts';
+import { A432BlockChain } from './a432.block.chain.event.ts';
+
+export function registerUIEvent({ emitter, event, handler, blockchainType, agent }: {
+  emitter: { on(event: string, handler: (ev: unknown) => void): void };
+  event: string;
+  handler?: (ev: unknown) => void;
+  blockchainType?: string;
+  agent?: string;
+}) {
+  emitter.on(event, (ev: unknown) => {
+    if (blockchainType && agent) recordEvent(null as unknown as A432BlockChain, blockchainType, agent, ev);
+    if (handler) handler(ev);
+  });
+} 

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

@@ -0,0 +1,44 @@
+// a432.ui.journey.ts — Guided journey engine for A432 UI
+import { recordEvent } from './a432.block.chain.event.ts';
+
+export async function runGuidedJourney(steps: Array<{ label: string; emitter: any; event: string | null; prompt: string }>, options: {
+  intention?: string;
+  overlay: HTMLElement;
+  blockchain: any;
+  onComplete?: (events: any[]) => void;
+}) {
+  const journeyEvents: any[] = [];
+  let journeyStep = 0;
+  const intention = options.intention || '';
+  async function runStep() {
+    if (journeyStep >= steps.length) {
+      recordEvent(options.blockchain, 'iJourneyEnd', 'A432IJourney', {
+        intention,
+        events: journeyEvents,
+        time: Date.now()
+      });
+      options.overlay.innerHTML = `<b>I Journey Complete</b><br>Intention: ${intention}<br>Events: ${journeyEvents.map(e => e.type).join(', ')}<br><br><i>Every act of awareness is a step toward wholeness.<br>The stream remembers. The field is harmonized.</i>`;
+      if (options.onComplete) options.onComplete(journeyEvents);
+      return;
+    }
+    const step = steps[journeyStep];
+    options.overlay.innerHTML = `<b>I Journey: ${step.label}</b><br>${step.prompt}<br><br>Intention: ${intention}`;
+    options.overlay.style.background = '#222';
+    if (step.emitter && step.event) {
+      const handler = (ev: any) => {
+        journeyEvents.push({ type: step.event, ...ev, time: Date.now() });
+        recordEvent(options.blockchain, `iJourney_${step.event}`, 'A432IJourney', { ...ev, step: step.label, intention });
+        step.emitter.off(step.event, handler);
+        journeyStep++;
+        runStep();
+      };
+      step.emitter.on(step.event, handler);
+    } else {
+      setTimeout(() => {
+        journeyStep++;
+        runStep();
+      }, 3000);
+    }
+  }
+  await runStep();
+} 

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

@@ -0,0 +1,25 @@
+// a432.ui.overlay.ts — Reusable overlay utilities for A432 UI
+export function createOverlay(id: string, style: Partial<CSSStyleDeclaration> = {}): HTMLElement {
+  const overlay = document.createElement('div');
+  overlay.id = id;
+  Object.assign(overlay.style, style);
+  document.body.appendChild(overlay);
+  return overlay;
+}
+
+export function updateOverlay(overlay: HTMLElement, html: string) {
+  overlay.innerHTML = html;
+}
+
+export function animateOverlay(overlay: HTMLElement, animation: string, duration = 600) {
+  overlay.classList.add(animation);
+  setTimeout(() => overlay.classList.remove(animation), duration);
+}
+
+export function showPoeticOverlay(overlay: HTMLElement) {
+  overlay.style.display = 'block';
+}
+
+export function hidePoeticOverlay(overlay: HTMLElement) {
+  overlay.style.display = 'none';
+} 

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

@@ -0,0 +1,38 @@
+/**
+ * a432.ui.registry.ts — Unified Overlay/Analytic Registry for A432 UI
+ *
+ * Exports a registry mapping overlay keys to canonical overlay/analytic modules.
+ * Used by the main UI for view switching, orchestration, and harmonization.
+ */
+
+import * as Rodin from './a432.rodin.coil.overlay.ts';
+import * as Tesla from './a432.tesla.coil.overlay.ts';
+import * as Mobius from './a432.mobius.circuit.overlay.ts';
+import * as Void from './a432.void.stream.overlay.ts';
+import * as Stream from './a432.stream.vortex.ts';
+import * as YinYang from './a432.yin.yang.ts';
+import * as FlowerOfLife from './a432.flower.of.life.ts';
+import * as Heptagram from './a432.heptagram.ui.ts';
+import * as TrinityAxis from './a432.trinity.axis.ts';
+import * as Uroboros from './a432.uroboros.ts';
+import * as Solids from './a432.solids.ui.ts';
+import * as Audio from './a432.audio.ts';
+import * as HumanConsciousness from './a432.human.consciousness.ts';
+import * as HumanDesign from './a432.human.design.ts';
+
+export const overlayRegistry = {
+  rodin: Rodin,
+  tesla: Tesla,
+  mobius: Mobius,
+  void: Void,
+  stream: Stream,
+  yinYang: YinYang,
+  flowerOfLife: FlowerOfLife,
+  heptagram: Heptagram,
+  trinityAxis: TrinityAxis,
+  uroboros: Uroboros,
+  solids: Solids,
+  audio: Audio,
+  consciousness: HumanConsciousness,
+  humanDesign: HumanDesign,
+}; 

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

@@ -0,0 +1,30 @@
+// a432.ui.session.ts — Session/history management for A432 UI
+type SessionMeta = Record<string, unknown>;
+type SessionEvent = { type: string; timestamp: number; data?: unknown };
+type Session = { meta: SessionMeta; events: SessionEvent[]; start: number; end?: number };
+const sessionHistory: Session[] = [];
+let currentSession: Session | null = null;
+
+export function startSession(meta: SessionMeta) {
+  currentSession = { meta, events: [], start: Date.now() };
+}
+
+export function endSession() {
+  if (currentSession) {
+    currentSession.end = Date.now();
+    sessionHistory.push(currentSession);
+    currentSession = null;
+  }
+}
+
+export function logSessionEvent(ev: SessionEvent) {
+  if (currentSession) currentSession.events.push(ev);
+}
+
+export function getSessionHistory() {
+  return sessionHistory;
+}
+
+export function exportSession(session: Session) {
+  return JSON.stringify(session, null, 2);
+} 

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

@@ -0,0 +1,17 @@
+// a432.ui.state.ts — DRY state management for A432 UI
+const state: Record<string, unknown> = {};
+const subscribers: Record<string, Array<(value: unknown) => void>> = {};
+
+export function getState(key: string) {
+  return state[key];
+}
+
+export function setState(key: string, value: unknown) {
+  state[key] = value;
+  if (subscribers[key]) subscribers[key].forEach(fn => fn(value));
+}
+
+export function subscribe(key: string, fn: (value: unknown) => void) {
+  if (!subscribers[key]) subscribers[key] = [];
+  subscribers[key].push(fn);
+} 

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

@@ -0,0 +1,41 @@
+import { round } from './a432.algebra.ts'
+// a432.ui.stream.ts — Animated blockchain stream visualization for A432 UI
+import { getBlockCMYK } from './a432.block.chain.event.ts';
+
+type BlockLike = { trinity: unknown; entropy?: number };
+export function renderBlockchainStream(container: HTMLElement, blocks: BlockLike[], options: { blockRadius?: number, blockGap?: number } = {}) {
+  const blockRadius = options.blockRadius || 18;
+  const blockGap = options.blockGap || 12;
+  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+  svg.setAttribute('width', '100%');
+  svg.setAttribute('height', '80');
+  svg.style.display = 'block';
+  container.appendChild(svg);
+  function render(offset = 0) {
+    svg.innerHTML = '';
+    let x = container.offsetWidth - offset;
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+      const entropy = typeof block.entropy === 'number' ? block.entropy : 0;
+      const trinity = typeof block.trinity === 'number' ? block.trinity : 0;
+      const cmyk = getBlockCMYK(trinity, entropy);
+      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 bcol = round(255 * (1 - y) * (1 - k));
+      const fill = `rgb(${r},${g},${bcol})`;
+      const circle = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
+      circle.setAttribute('cx', String(x + blockRadius));
+      circle.setAttribute('cy', '40');
+      circle.setAttribute('r', String(blockRadius));
+      circle.setAttribute('fill', fill);
+      circle.setAttribute('stroke', '#fff');
+      circle.setAttribute('stroke-width', '2');
+      svg.appendChild(circle);
+      x += blockRadius * 2 + blockGap;
+    }
+    requestAnimationFrame(() => render(offset + 1.2));
+  }
+  render();
+  return svg;
+} 

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

@@ -0,0 +1,263 @@
+/**
+ * a432.ui.streams.ts — Harmonized, Canonical A432 Math-Driven UI Streams
+ *
+ * All UI properties, overlays, and behaviors are derived strictly from A432 math:
+ * - Only trinity, digital root, vortex, Rodin sequence, integer fractions, and metaphysical principles
+ * - No magic numbers, arbitrary trigonometry, or non-canonical math
+ * - No floats or arbitrary scaling; only integer fractions whose reciprocals are integers
+ * - All overlays use canonical sequences
+ * - All color, size, opacity, and animation are derived from A432 math modules and streams
+ * - No direct Date.now() or time-based logic except as mapped through a vortex or trinity stream
+ * - Metaphysical comments for each property
+ */
+
+import { digitAngleToCMYK, cmykToCss, type CMYK } from './a432.cmyk.ts';
+import { getRodinSequence, digitalRoot, asAngle, getTrinityAxis } from './a432.math.ts';
+import { vortexStream } from './a432.matrix.ts';
+import { yinYangStateFraction, type Fraction } from './a432.yin.yang.ts';
+import { type Digit, type AngleDeg } from './a432.types.ts';
+
+// Canonical trinity tick stream (cycles 3, 6, 9)
+function* trinityTickStream() {
+  const trinity = getTrinityAxis();
+  let i = 0;
+  while (true) {
+    yield trinity[i % 3] as Digit;
+    i++;
+  }
+}
+
+// Canonical vortex digit stream
+function* canonicalVortexStream() {
+  const vs = vortexStream();
+  while (true) {
+    yield vs.next().value as Digit;
+  }
+}
+
+// Harmonized UI stream frame
+export interface UIStreamFrame {
+  tick: number; // trinity tick
+  rodin: Digit; // rodin sequence digit
+  trinity: Digit; // trinity digit
+  digitalRoot: Digit; // digital root of rodin+trinity
+  color: CMYK; // canonical color
+  cssColor: string;
+  size: number; // integer, from rodin/trinity
+  opacity: Fraction; // integer fraction
+  rotation: AngleDeg; // from rodin/trinity
+  scale: Fraction; // integer fraction
+  position: { x: number; y: number }; // from rodin/trinity
+  yinYang: Fraction; // metaphysical state
+}
+
+// Global state
+let _currentFrame: UIStreamFrame | null = null;
+let _streamSubscribers: Array<(frame: UIStreamFrame) => void> = [];
+
+// Canonical integer fraction helper
+function makeFraction(n: number, d: number): Fraction {
+  // Only allow integer fractions whose reciprocals are integers
+  if (d === 0) return { numerator: 0, denominator: 1 };
+  return { numerator: n, denominator: d };
+}
+
+// Harmonized frame generator
+export function generateUIStreamFrame(): UIStreamFrame {
+  // Use only canonical streams
+  const rodinSeq = getRodinSequence();
+  const trinityGen = trinityTickStream();
+  const vortexGen = canonicalVortexStream();
+
+  // Metaphysical tick: always 3, 6, 9
+  const tick = trinityGen.next().value as Digit;
+  // Rodin digit: cycles through canonical sequence
+  const rodin = rodinSeq[(tick - 3) % rodinSeq.length] as Digit;
+  // Trinity digit: tick itself
+  const trinity = tick;
+  // Digital root: rodin + trinity
+  const digitalRootValue = digitalRoot(rodin + trinity) as Digit;
+
+  // Color: canonical mapping
+  const color = digitAngleToCMYK(digitalRootValue, asAngle(tick * 60));
+  const cssColor = cmykToCss(color);
+
+  // Size: integer, from rodin and trinity (no floats)
+  const size = (rodin + trinity) * 9; // always integer, 9 is trinity base
+
+  // Opacity: integer fraction, e.g. rodin/9
+  const opacity = makeFraction(rodin, 9);
+
+  // Metaphysical: In the trinity, each vortex (3, 6, 9) is dual, so use 60° per vortex for rotation.
+  const rotation = asAngle(trinity * 60);
+
+  // Scale: integer fraction, e.g. trinity/9
+  const scale = makeFraction(trinity, 9);
+
+  // Position: x/y from rodin/trinity (no floats)
+  const x = ((rodin * trinity) % 9) * 9;
+  const y = ((trinity * rodin) % 9) * 9;
+
+  // YinYang: metaphysical state from rodin/trinity
+  const yinYang = yinYangStateFraction(
+    makeFraction(rodin, 9),
+    makeFraction(trinity, 9)
+  );
+
+  return {
+    tick,
+    rodin,
+    trinity,
+    digitalRoot: digitalRootValue,
+    color,
+    cssColor,
+    size,
+    opacity,
+    rotation,
+    scale,
+    position: { x, y },
+    yinYang
+  };
+}
+
+// Main UI stream
+export function startUIStream(callback: (frame: UIStreamFrame) => void): () => void {
+  _streamSubscribers.push(callback);
+  let tick = 0;
+  const interval = setInterval(() => {
+    const frame = generateUIStreamFrame();
+    _currentFrame = frame;
+    _streamSubscribers.forEach(sub => sub(frame));
+    tick++;
+  }, 81); // 81 = 9*9, trinity multiple
+  return () => {
+    clearInterval(interval);
+    _streamSubscribers = _streamSubscribers.filter(sub => sub !== callback);
+  };
+}
+
+export function getCurrentUIFrame(): UIStreamFrame | null {
+  return _currentFrame;
+}
+
+// Canonical color stream
+export function generateColorStream(elementId: string): () => string {
+  return () => {
+    const frame = getCurrentUIFrame();
+    if (!frame) return '#000';
+    // Use digital root and trinity for color
+    return cmykToCss(digitAngleToCMYK(frame.digitalRoot, frame.rotation));
+  };
+}
+
+// Canonical size stream
+export function generateSizeStream(elementId: string): () => number {
+  return () => {
+    const frame = getCurrentUIFrame();
+    if (!frame) return 27; // 3*9
+    return frame.size;
+  };
+}
+
+// Canonical opacity stream
+export function generateOpacityStream(elementId: string): () => number {
+  return () => {
+    const frame = getCurrentUIFrame();
+    if (!frame) return 1;
+    // Integer fraction as float for CSS
+    return frame.opacity.numerator / frame.opacity.denominator;
+  };
+}
+
+// Canonical overlay stream (all overlays use canonical sequences)
+export function generateOverlayStream(overlayType: string): () => Record<string, unknown> {
+  return () => {
+    const frame = getCurrentUIFrame();
+    if (!frame) return {};
+    switch (overlayType) {
+      case 'rodin':
+        return {
+          nodes: getRodinSequence().map((digit: number, i: number) => ({
+            value: digit as Digit,
+            color: cmykToCss(digitAngleToCMYK(digit as Digit, frame.rotation)),
+            size: (digit as Digit) * 9,
+            opacity: (digit as Digit) / 9
+          }))
+        };
+      case 'trinity':
+        return {
+          nodes: getTrinityAxis().map((digit: number, i: number) => ({
+            value: digit as Digit,
+            color: cmykToCss(digitAngleToCMYK(digit as Digit, frame.rotation)),
+            size: (digit as Digit) * 9,
+            opacity: (digit as Digit) / 9
+          }))
+        };
+      case 'yin-yang':
+        return {
+          state: frame.yinYang,
+          positiveColor: cmykToCss(digitAngleToCMYK(frame.rodin, frame.rotation)),
+          negativeColor: cmykToCss(digitAngleToCMYK(frame.trinity, frame.rotation)),
+          rotation: frame.rotation,
+          scale: frame.scale
+        };
+      default:
+        return {
+          color: frame.cssColor,
+          size: frame.size,
+          opacity: frame.opacity.numerator / frame.opacity.denominator,
+          rotation: frame.rotation,
+          scale: frame.scale
+        };
+    }
+  };
+}
+
+// CSS Property Generators
+
+/**
+ * Generate CSS properties from math streams
+ */
+export function generateCSSProperties(elementId: string, properties: string[]): () => Record<string, string> {
+  return () => {
+    const frame = getCurrentUIFrame();
+    if (!frame) return {};
+    
+    const css: Record<string, string> = {};
+    
+    properties.forEach(prop => {
+      switch (prop) {
+        case 'color':
+          css.color = generateColorStream(elementId)();
+          break;
+        case 'background-color':
+          css.backgroundColor = generateColorStream(elementId + '-bg')();
+          break;
+        case 'border-color':
+          css.borderColor = generateColorStream(elementId + '-border')();
+          break;
+        case 'font-size':
+          css.fontSize = `${generateSizeStream(elementId)()}px`;
+          break;
+        case 'width':
+        case 'height':
+          css[prop] = `${generateSizeStream(elementId)}px`;
+          break;
+        case 'opacity':
+          css.opacity = generateOpacityStream(elementId)().toString();
+          break;
+        case 'transform':
+          const rotation = frame.rotation;
+          const scale = frame.scale;
+          css.transform = `rotate(${rotation}deg) scale(${scale})`;
+          break;
+        case 'box-shadow':
+          const shadowColor = generateColorStream(elementId + '-shadow')();
+          css.boxShadow = `0 0 ${frame.size / 2}px ${shadowColor}`;
+          break;
+      }
+    });
+    
+    return css;
+  };
+} 

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

@@ -0,0 +1,87 @@
+import { startA432UI } from './a432.ui.ts';
+import * as self from './a432.self.ts';
+import * as breathe from './a432.breathe.ts';
+import * as math from './a432.math.ts';
+import * as sound from './a432.sound.ts';
+import * as video from './a432.video.ts';
+import { cmykToCss } from './a432.cmyk.ts';
+
+// Mock document and window for DOM side effects
+beforeAll(() => {
+  global.document = {
+    body: { style: { backgroundColor: '' } }
+  } as any;
+  global.window = {} as any;
+});
+
+describe('a432.ui.ts — Living Experience', () => {
+  let breathHandler: any;
+  let matrixHandler: any;
+
+  beforeEach(() => {
+    // Mock emitters using jest.spyOn
+    jest.spyOn(breathe.breathEmitter, 'on').mockImplementation((event, cb) => { if (event === 'breath') breathHandler = cb; return breathe.breathEmitter; });
+    jest.spyOn(self.matrixEmitter, 'on').mockImplementation((event, cb) => { if (event === 'event') matrixHandler = cb; return self.matrixEmitter; });
+    // Mock dependencies
+    jest.spyOn(self, 'startSelfEvolution').mockImplementation(() => () => {});
+    jest.spyOn(breathe, 'startBreathing').mockImplementation(() => () => {});
+    jest.spyOn(math, 'digitAngleToCMYK').mockImplementation((d) => ({ c: d, m: d, y: d, k: d }));
+    jest.spyOn(math, 'asAngle').mockImplementation((n) => n as any);
+    jest.spyOn(sound, 'playDigit').mockImplementation(() => Promise.resolve());
+    jest.spyOn(video, 'flashColor').mockImplementation(() => {});
+    // Reset DOM
+    document.body.style.backgroundColor = '';
+  });
+
+  test('should start streams and register event handlers', () => {
+    startA432UI();
+    expect(self.startSelfEvolution).toHaveBeenCalled();
+    expect(breathe.startBreathing).toHaveBeenCalled();
+    expect(breathe.breathEmitter.on).toHaveBeenCalledWith('breath', expect.any(Function));
+    expect(self.matrixEmitter.on).toHaveBeenCalledWith('event', expect.any(Function));
+  });
+
+  test('should update color and play sound on breath event', async () => {
+    startA432UI();
+    breathHandler({ value: 3 });
+    // Color and sound logic triggered
+    expect(document.body.style.backgroundColor).toBe(cmykToCss({ c: 3, m: 3, y: 3, k: 3 }));
+    expect(sound.playDigit).toHaveBeenCalled();
+    expect(video.flashColor).toHaveBeenCalledWith({ c: 3, m: 3, y: 3, k: 3 });
+  });
+
+  test('should update color and play sound on matrix event', async () => {
+    startA432UI();
+    matrixHandler({ digit: 6 });
+    expect(document.body.style.backgroundColor).toBe(cmykToCss({ c: 6, m: 6, y: 6, k: 6 }));
+    expect(sound.playDigit).toHaveBeenCalled();
+    expect(video.flashColor).toHaveBeenCalledWith({ c: 6, m: 6, y: 6, k: 6 });
+  });
+
+  test('should handle user input (keydown) and update state', () => {
+    // Simulate window and addEventListener
+    const listeners: any = {};
+    global.window.addEventListener = jest.fn((event, cb) => { listeners[event] = cb; });
+    startA432UI();
+    // Simulate keydown for digit 7
+    listeners['keydown']({ key: '7' });
+    // Color and sound logic triggered
+    expect(document.body.style.backgroundColor).toBe(cmykToCss({ c: 7, m: 7, y: 7, k: 7 }));
+    expect(sound.playDigit).toHaveBeenCalled();
+    expect(video.flashColor).toHaveBeenCalledWith({ c: 7, m: 7, y: 7, k: 7 });
+  });
+
+  test('should use xorDigit logic for state', () => {
+    // This test checks the xorDigit logic indirectly via event simulation
+    // breathDigit = 2, matrixDigit = 4, userDigit = 5
+    startA432UI();
+    breathHandler({ value: 2 });
+    matrixHandler({ digit: 4 });
+    // Simulate keydown for digit 5
+    const listeners: any = {};
+    global.window.addEventListener = jest.fn((event, cb) => { listeners[event] = cb; });
+    listeners['keydown']({ key: '5' });
+    // The xor of 2, 4, 5 is 7 (2^4^5=7)
+    expect(document.body.style.backgroundColor).toBe(cmykToCss({ c: 7, m: 7, y: 7, k: 7 }));
+  });
+});