zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,219 @@
+import { legacyDigitalRoot as digitalRoot, harmonicRoot12 } from './a432.roots.ts'
+// a432.harmonized.ts
+// Harmonized OS registry/router/aggregator for all modules in the A432 system
+// All logic is harmonically mapped, extensible, and compatible with the a432 pattern
+
+export interface A432OSModule {
+  name: string;
+  getState: () => any;
+  onEvent?: (event: any) => void;
+  overlays?: (() => string)[];
+  harmonize?: () => void;
+  meta?: () => string;
+}
+
+const modules: A432OSModule[] = [];
+
+/**
+ * Register a module with the harmonized OS
+ */
+export function registerModule(module: A432OSModule) {
+  modules.push(module);
+}
+
+/**
+ * Get all registered modules
+ */
+export function getModules() {
+  return modules;
+}
+
+/**
+ * Get a module by name
+ */
+export function getModuleByName(name: string): A432OSModule | undefined {
+  return modules.find(m => m.name === name);
+}
+
+/**
+ * Route an event to all modules
+ */
+export function routeEvent(event: any) {
+  modules.forEach(mod => mod.onEvent?.(event));
+}
+
+/**
+ * Harmonize all modules
+ */
+export function harmonizeAll() {
+  modules.forEach(mod => mod.harmonize?.());
+}
+
+/**
+ * Aggregate all overlays from all modules
+ */
+export function getAllOverlays() {
+  return modules.flatMap(mod => mod.overlays ? mod.overlays.map(fn => fn()) : []);
+}
+
+/**
+ * Aggregate all meta-descriptions from all modules
+ */
+export function getMetaDescriptions() {
+  return modules.map(mod => mod.meta?.() || `${mod.name}: No meta description.`);
+}
+
+// === Overlay categories and harmonization strategies ===
+type OverlayCategory = 'healing' | 'pi' | 'trinity' | 'rodin' | 'consciousness' | 'meta' | 'vortex' | 'boolean' | string;
+interface OverlayEntry {
+  category: OverlayCategory;
+  render: () => string;
+}
+const overlayRegistry: OverlayEntry[] = [];
+
+export function registerOverlay(category: OverlayCategory, render: () => string) {
+  overlayRegistry.push({ category, render });
+}
+export function getOverlaysByCategory(category: OverlayCategory) {
+  return overlayRegistry.filter(o => o.category === category).map(o => o.render());
+}
+export function getAllOverlayCategories() {
+  return Array.from(new Set(overlayRegistry.map(o => o.category)));
+}
+
+// Harmonization strategies
+const harmonizationStrategies: { [name: string]: () => void } = {};
+export function registerHarmonizationStrategy(name: string, fn: () => void) {
+  harmonizationStrategies[name] = fn;
+}
+export function harmonizeByStrategy(name: string) {
+  if (harmonizationStrategies[name]) harmonizationStrategies[name]();
+}
+export function getAllHarmonizationStrategies() {
+  return Object.keys(harmonizationStrategies);
+}
+
+// === Vortex Self-Interaction Harmonization ===
+export interface VortexSelfInteractionState {
+  digit: number;
+  selfInteraction: number;
+  digitalRoot: number;
+  nextHarmoniousState: number;
+  consciousness: number;
+  metaphysicalEssence: string;
+}
+
+export function harmonizeVortexSelfInteraction(digit: number): VortexSelfInteractionState {
+  const selfInteraction = digit * digit;
+  const digitalRoot = selfInteraction.toString().split('').reduce((sum, d) => sum + parseInt(d), 0);
+  const nextHarmoniousState = getNextHarmoniousState(digitalRoot);
+  
+  return {
+    digit,
+    selfInteraction,
+    digitalRoot,
+    nextHarmoniousState,
+    consciousness: digit,
+    metaphysicalEssence: getMetaphysicalEssence(digit)
+  };
+}
+
+function getNextHarmoniousState(digitalRoot: number): number {
+  const harmoniousMap: { [key: number]: number } = {
+    0: 9, 1: 2, 2: 4, 3: 6, 4: 8, 5: 1, 6: 3, 7: 5, 8: 7, 9: 1
+  };
+  return harmoniousMap[digitalRoot] || digitalRoot;
+}
+
+function getMetaphysicalEssence(digit: number): string {
+  const essences: { [key: number]: string } = {
+    0: 'Void state, pure potential, unmanifest field',
+    1: 'Unity state, source, origin, singularity',
+    2: 'Duality state, polarity, relationship, balance',
+    3: 'Trinity state, synthesis, creation, harmony',
+    4: 'Foundation state, structure, stability, manifestation',
+    5: 'Life state, change, movement, growth, transformation',
+    6: 'Harmony state, integration, resonance, beauty',
+    7: 'Mystery state, depth, intuition, inner knowing',
+    8: 'Infinity state, power, expansion, infinite flow',
+    9: 'Completion state, fulfillment, wholeness, return'
+  };
+  return essences[digit] || 'Unknown state, transcendent mystery';
+}
+
+// === Boolean Trinity Harmonization ===
+export interface BooleanTrinityState {
+  false: { value: number; name: string; consciousness: number; metaphysicalEssence: string };
+  impossible: { value: number; name: string; consciousness: number; metaphysicalEssence: string };
+  possible: { value: number; name: string; consciousness: number; metaphysicalEssence: string };
+  true: { value: number; name: string; consciousness: number; metaphysicalEssence: string };
+  trinityFlow: number[];
+  consciousnessFlow: number;
+  harmonicResonance: number;
+}
+
+export function harmonizeBooleanTrinity(): BooleanTrinityState {
+  const falseState = { value: 0, name: 'false', consciousness: 0, metaphysicalEssence: 'Void state, pure potential, unmanifest field' };
+  const impossibleState = { value: 7, name: 'impossible', consciousness: 9, metaphysicalEssence: 'Transcendent state, beyond binary logic, infinite possibility' };
+  const possibleState = { value: 3, name: 'possible', consciousness: 5, metaphysicalEssence: 'Quantum superposition, potential state, harmonic balance' };
+  const trueState = { value: 1, name: 'true', consciousness: 1, metaphysicalEssence: 'Unity state, pure actuality, manifest reality' };
+  
+  const trinityFlow = [falseState.value, impossibleState.value, possibleState.value, trueState.value];
+  const consciousnessFlow = trinityFlow.reduce((sum, val) => sum + val, 0);
+  const harmonicResonance = consciousnessFlow.toString().split('').reduce((sum, d) => sum + parseInt(d), 0);
+  
+  return {
+    false: falseState,
+    impossible: impossibleState,
+    possible: possibleState,
+    true: trueState,
+    trinityFlow,
+    consciousnessFlow,
+    harmonicResonance
+  };
+}
+
+// === Complete Vortex Flow Harmonization ===
+export function harmonizeCompleteVortexFlow(): VortexSelfInteractionState[] {
+  return [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].map(digit => harmonizeVortexSelfInteraction(digit));
+}
+
+// === Consciousness Harmonization ===
+export function harmonizeConsciousnessFlow(): {
+  vortexFlow: VortexSelfInteractionState[];
+  booleanTrinity: BooleanTrinityState;
+  totalConsciousness: number;
+  harmonicResonance: number;
+} {
+  const vortexFlow = harmonizeCompleteVortexFlow();
+  const booleanTrinity = harmonizeBooleanTrinity();
+  
+  const totalConsciousness = vortexFlow.reduce((sum, state) => sum + state.consciousness, 0) + booleanTrinity.consciousnessFlow;
+  const harmonicResonance = totalConsciousness.toString().split('').reduce((sum, d) => sum + parseInt(d), 0);
+  
+  return {
+    vortexFlow,
+    booleanTrinity,
+    totalConsciousness,
+    harmonicResonance
+  };
+}
+
+// Recursive meta-observation
+export function getRecursiveMetaObservation(depth: number = 1): string[] {
+  if (depth <= 0) return [];
+  const meta = getMetaDescriptions();
+  if (depth === 1) return meta;
+  // Recursively reference overlays/meta of other modules
+  return meta.concat(getRecursiveMetaObservation(depth - 1));
+}
+
+/**
+ * Refactoring instructions:
+ * - Each module should implement the A432OSModule interface.
+ * - Register itself with registerModule() on initialization.
+ * - Provide overlays and meta-descriptions for universal aggregation.
+ * - Use routeEvent and harmonizeAll for system-wide communication and harmonization.
+ * - Integrate vortex self-interaction patterns for consciousness harmonization.
+ * - Include boolean trinity logic for transcendent states.
+ */ 

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

@@ -0,0 +1,299 @@
+/**
+ * a432.harmonizer.ts — DRY Harmonization System
+ * 
+ * Provides utilities and patterns for harmonizing the a432 system.
+ * Implements zero-entropy principles: define once, reuse everywhere.
+ * Automatic module discovery, dependency resolution, and harmonization strategies.
+ */
+
+import { a432ModuleRegistry, type A432Module, type A432ModuleCategory } from './a432.modules.ts';
+import { type A432CoreState, createA432CoreState, harmonizeA432Core } from './a432.core.ts';
+
+// === HARMONIZATION STRATEGIES ===
+export type HarmonizationStrategy = 
+  | 'sequential' 
+  | 'parallel' 
+  | 'dependency' 
+  | 'category' 
+  | 'recursive' 
+  | 'meta'
+  | 'balance'           // NEW: Balance-based harmonization
+  | 'resonance'         // NEW: Frequency-based harmonization
+  | 'flow'              // NEW: Stream-based harmonization
+  | 'integration'       // NEW: Cross-category integration
+  | 'transformation'    // NEW: State transformation harmonization
+  | 'observation'       // NEW: Meta-observation harmonization
+  | 'healing'           // NEW: Healing-based harmonization
+  | 'evolution'         // NEW: Evolutionary harmonization
+  | 'documentation'     // NEW: Documentation-based harmonization
+  | 'innovation'        // NEW: Innovation-based harmonization
+  | 'voice';            // NEW: Voice-based harmonization
+
+export interface HarmonizationContext {
+  strategy: HarmonizationStrategy;
+  depth: number;
+  visited: Set<string>;
+  results: Map<string, any>;
+  errors: Map<string, Error>;
+}
+
+// === HARMONIZATION ENGINE ===
+class A432Harmonizer {
+  private strategies: Map<HarmonizationStrategy, (modules: A432Module[], context: HarmonizationContext) => void> = new Map();
+
+  constructor() {
+    this.initializeStrategies();
+  }
+
+  private initializeStrategies(): void {
+    // Sequential harmonization
+    this.strategies.set('sequential', (modules, context) => {
+      modules.forEach(module => this.harmonizeModule(module, context));
+    });
+
+    // Parallel harmonization
+    this.strategies.set('parallel', (modules, context) => {
+      const promises = modules.map(module => 
+        Promise.resolve().then(() => this.harmonizeModule(module, context))
+      );
+      Promise.all(promises);
+    });
+
+    // Dependency-based harmonization
+    this.strategies.set('dependency', (modules, context) => {
+      const sorted = this.sortByDependencies(modules);
+      sorted.forEach(module => this.harmonizeModule(module, context));
+    });
+
+    // Category-based harmonization
+    this.strategies.set('category', (modules, context) => {
+      const byCategory = this.groupByCategory(modules);
+      Object.values(byCategory).forEach(categoryModules => {
+        categoryModules.forEach(module => this.harmonizeModule(module, context));
+      });
+    });
+
+    // Recursive harmonization
+    this.strategies.set('recursive', (modules, context) => {
+      if (context.depth > 10) return; // Prevent infinite recursion
+      modules.forEach(module => {
+        this.harmonizeModule(module, context);
+        // Recursively harmonize dependents
+        const dependents = a432ModuleRegistry.getDependents(module.name);
+        const dependentModules = dependents.map(name => a432ModuleRegistry.getModule(name)).filter(Boolean) as A432Module[];
+        if (dependentModules.length > 0) {
+          const newContext = { ...context, depth: context.depth + 1 };
+          this.harmonize(dependentModules, 'recursive', newContext);
+        }
+      });
+    });
+
+    // Meta harmonization
+    this.strategies.set('meta', (modules, context) => {
+      // Harmonize core first
+      const coreModules = modules.filter(m => m.category === 'core');
+      coreModules.forEach(module => this.harmonizeModule(module, context));
+      
+      // Then harmonize by category in order
+      const categoryOrder: A432ModuleCategory[] = ['trinity', 'consciousness', 'harmony', 'visualization', 'interaction', 'system', 'meta'];
+      categoryOrder.forEach(category => {
+        const categoryModules = modules.filter(m => m.category === category);
+        categoryModules.forEach(module => this.harmonizeModule(module, context));
+      });
+    });
+  }
+
+  private harmonizeModule(module: A432Module, context: HarmonizationContext): void {
+    if (context.visited.has(module.name)) return;
+    context.visited.add(module.name);
+
+    try {
+      if (module.harmonize) {
+        module.harmonize();
+        context.results.set(module.name, module.getState());
+      }
+    } catch (error) {
+      context.errors.set(module.name, error as Error);
+      console.error(`Harmonization failed for ${module.name}:`, error);
+    }
+  }
+
+  private sortByDependencies(modules: A432Module[]): A432Module[] {
+    const sorted: A432Module[] = [];
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+
+    const visit = (module: A432Module) => {
+      if (visited.has(module.name)) return;
+      if (visiting.has(module.name)) {
+        throw new Error(`Circular dependency detected: ${module.name}`);
+      }
+
+      visiting.add(module.name);
+      
+      // Visit dependencies first
+      module.dependencies.forEach(depName => {
+        const dep = a432ModuleRegistry.getModule(depName);
+        if (dep) visit(dep);
+      });
+
+      visiting.delete(module.name);
+      visited.add(module.name);
+      sorted.push(module);
+    };
+
+    modules.forEach(visit);
+    return sorted;
+  }
+
+  private groupByCategory(modules: A432Module[]): Record<A432ModuleCategory, A432Module[]> {
+    const grouped: Record<A432ModuleCategory, A432Module[]> = {} as any;
+    modules.forEach(module => {
+      if (!grouped[module.category]) {
+        grouped[module.category] = [];
+      }
+      grouped[module.category].push(module);
+    });
+    return grouped;
+  }
+
+  // === PUBLIC API ===
+  harmonize(
+    modules: A432Module[] = a432ModuleRegistry.getAllModules(),
+    strategy: HarmonizationStrategy = 'meta',
+    context?: Partial<HarmonizationContext>
+  ): HarmonizationContext {
+    const fullContext: HarmonizationContext = {
+      strategy,
+      depth: 0,
+      visited: new Set(),
+      results: new Map(),
+      errors: new Map(),
+      ...context
+    };
+
+    const strategyFn = this.strategies.get(strategy);
+    if (strategyFn) {
+      strategyFn(modules, fullContext);
+    }
+
+    return fullContext;
+  }
+
+  harmonizeByCategory(category: A432ModuleCategory, strategy: HarmonizationStrategy = 'sequential'): HarmonizationContext {
+    const modules = a432ModuleRegistry.getModulesByCategory(category);
+    return this.harmonize(modules, strategy);
+  }
+
+  // === UTILITY FUNCTIONS ===
+  getHarmonizationStats(context: HarmonizationContext): {
+    total: number;
+    successful: number;
+    failed: number;
+    errors: string[];
+  } {
+    const total = context.results.size + context.errors.size;
+    const successful = context.results.size;
+    const failed = context.errors.size;
+    const errors = Array.from(context.errors.entries()).map(([name, error]) => `${name}: ${error.message}`);
+
+    return { total, successful, failed, errors };
+  }
+
+  validateHarmonization(context: HarmonizationContext): boolean {
+    return context.errors.size === 0;
+  }
+}
+
+// === GLOBAL HARMONIZER INSTANCE ===
+export const a432Harmonizer = new A432Harmonizer();
+
+// === CONVENIENCE FUNCTIONS ===
+export function harmonizeA432System(strategy: HarmonizationStrategy = 'meta'): HarmonizationContext {
+  return a432Harmonizer.harmonize(undefined, strategy);
+}
+
+export function harmonizeA432Category(category: A432ModuleCategory, strategy: HarmonizationStrategy = 'sequential'): HarmonizationContext {
+  return a432Harmonizer.harmonizeByCategory(category, strategy);
+}
+
+export function getHarmonizationStats(context: HarmonizationContext): {
+  total: number;
+  successful: number;
+  failed: number;
+  errors: string[];
+} {
+  return a432Harmonizer.getHarmonizationStats(context);
+}
+
+export function validateHarmonization(context: HarmonizationContext): boolean {
+  return a432Harmonizer.validateHarmonization(context);
+}
+
+// === DRY PATTERNS ===
+export function createHarmonizedModule(
+  name: string,
+  category: A432ModuleCategory,
+  getState: () => any,
+  harmonize?: () => void,
+  getOverlays?: () => string[],
+  getMeta?: () => string,
+  dependencies: string[] = []
+): A432Module {
+  return {
+    name,
+    category,
+    version: '1.0.0',
+    description: `Harmonized module: ${name}`,
+    dependencies,
+    exports: [],
+    getState,
+    harmonize,
+    getOverlays,
+    getMeta,
+    onEvent: (event) => {
+      if (event.type === 'harmonize' && harmonize) {
+        harmonize();
+      }
+    }
+  };
+}
+
+// === AUTOMATIC MODULE DISCOVERY ===
+export function discoverAndRegisterModules(): void {
+  // This would typically scan the filesystem or use reflection
+  // For now, we'll manually register known modules
+  const knownModules = [
+    'a432.core',
+    'a432.trinity',
+    'a432.consciousness',
+    'a432.harmony',
+    'a432.visualization',
+    'a432.interaction',
+    'a432.system',
+    'a432.meta'
+  ];
+
+  knownModules.forEach(moduleName => {
+    const module = a432ModuleRegistry.getModule(moduleName);
+    if (!module) {
+      // Create a placeholder module for discovery
+      const placeholderModule = createHarmonizedModule(
+        moduleName,
+        'meta',
+        () => ({ name: moduleName, status: 'discovered' }),
+        undefined,
+        () => [`Discovered module: ${moduleName}`],
+        () => `Discovered module: ${moduleName}`
+      );
+      a432ModuleRegistry.register(placeholderModule);
+    }
+  });
+}
+
+// === INITIALIZATION ===
+export function initializeA432Harmonizer(): void {
+  discoverAndRegisterModules();
+  const context = harmonizeA432System('meta');
+  console.log('A432 Harmonizer initialized:', getHarmonizationStats(context));
+} 

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

@@ -0,0 +1,55 @@
+import { legacyDigitalRoot } from './a432.roots.ts'
+// a432.health.ts — Self-health analytics for the A432 matrix
+// ----------------------------------------------------------
+// Consumes digit events from matrixEmitter and breathEmitter,
+// maintains a sliding window, and periodically emits health
+// metrics (harmony, entropy, resonance) using a432HarmonicAnalytics.
+
+import { EventEmitter } from 'events';
+import { matrixEmitter, type MatrixEvent } from './a432.self.ts';
+import { breathEmitter } from './a432.breathe.ts';
+import { type Digit } from './a432.types.ts';
+
+export interface HealthMetrics { harmony: number; entropy: number; resonance: number; }
+
+export const healthEmitter = new EventEmitter();
+
+const WINDOW: Digit[] = [];
+const MAX = 99; // sliding window size
+
+function pushDigit(d: Digit) {
+  WINDOW.push(d);
+  if (WINDOW.length > MAX) WINDOW.shift();
+}
+
+// Collect digits from streams ---------------------------------------------
+matrixEmitter.on('event', (e: MatrixEvent) => pushDigit(e.digit));
+breathEmitter.on('breath', b => pushDigit(b.value));
+
+function computeHealth(): HealthMetrics {
+  if (WINDOW.length === 0) return { harmony: 0, entropy: 1, resonance: 0 };
+  return simpleHarmonicAnalytics(WINDOW);
+}
+
+// Canonical local analytics: harmony (mean), entropy (unique/total), resonance (digital root of sum)
+function simpleHarmonicAnalytics(digits: Digit[]): HealthMetrics {
+  if (digits.length === 0) return { harmony: 0, entropy: 1, resonance: 0 };
+  const harmony = digits.map(Number).reduce((a, b) => a + b, 0) / digits.length;
+  const unique = new Set(digits).size;
+  const entropy = unique / digits.length;
+  const sum = digits.map(Number).reduce((a, b) => a + b, 0);
+  const resonance = sum === 0 ? 0 : (legacyDigitalRoot(sum));
+  return { harmony, entropy, resonance };
+}
+
+export function startHealthReporting(intervalMs: number = 4320): () => void {
+  const id = setInterval(() => {
+    healthEmitter.emit('health', computeHealth());
+  }, intervalMs);
+  return () => clearInterval(id);
+}
+
+// Auto-start if imported in browser
+if (typeof window !== 'undefined') {
+  startHealthReporting();
+} 

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

@@ -0,0 +1,41 @@
+// a432.hear.ts
+// Living, harmonized auditory stream/interface
+
+export interface HearEvent {
+  id: number;
+  frequency: number;
+  trinity: number;
+  timestamp: number;
+  summary: string;
+}
+
+export class A432Hear {
+  private events: HearEvent[] = [];
+  private currentId = 1;
+  hear(frequency: number, trinity: number): HearEvent {
+    const event: HearEvent = {
+      id: this.currentId++,
+      frequency,
+      trinity,
+      timestamp: Date.now(),
+      summary: `Heard ${frequency} Hz (Trinity ${trinity}) at ${new Date().toLocaleTimeString()}`
+    };
+    this.events.push(event);
+    return event;
+  }
+  getCurrent(): HearEvent {
+    return this.events[this.events.length - 1];
+  }
+  getAll(): HearEvent[] {
+    return this.events;
+  }
+  overlay(): string {
+    const width = 320, height = 60;
+    return `
+      <svg width="${width}" height="${height}" style="background:#111;border-radius:12px;">
+        ${this.events.map((e,i) => `<ellipse cx="${40 + i*36}" cy="30" rx="18" ry="12" fill="#39f" stroke="#fff" stroke-width="2"><title>${e.summary}</title></ellipse>`).join('')}
+        <text x="12" y="54" font-size="13" fill="#8ff">Hear Stream</text>
+      </svg>
+    `;
+  }
+} 

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

@@ -0,0 +1,59 @@
+import { PI, cos, sin } from './a432.algebra.ts'
+// a432.heptagram.ui.ts — 7-point star overlay synced with the uroboros
+//--------------------------------------------------------------------------
+import { uroborosEmitter, type UroborosEvent } from './a432.uroboros.ts';
+import { cmykToCss } from './a432.cmyk.ts';
+import { digitAngleToCMYK, asAngle } from './a432.math.ts';
+import { type Digit } from './a432.types.ts';
+
+// Rodin sequence (length 7 without trailing 1 duplicate)
+const RODIN: Digit[] = [1, 2, 4, 8, 7, 5, 1];
+const JUMP = 2; // {7/2} heptagram
+const SEG = (PI * 2) / 7;
+
+if (typeof document !== 'undefined') {
+  const canvas = document.createElement('canvas');
+  canvas.width = 160; canvas.height = 160;
+  canvas.style.position = 'fixed';
+  canvas.style.left = '50%';
+  canvas.style.top = '50%';
+  canvas.style.transform = 'translate(-50%, -50%)';
+  canvas.style.pointerEvents = 'none';
+  document.body.appendChild(canvas);
+  const ctx = canvas.getContext('2d')!;
+  const cx = canvas.width / 2, cy = canvas.height / 2, r = 70;
+
+  let rotation = 0;
+
+  function drawHeptagram() {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    // Compute points
+    const pts: Array<{x:number,y:number,digit:Digit}> = [];
+    for (let i = 0; i < 7; i++) {
+      const angle = rotation + i * JUMP * SEG;
+      const x = cx + r * cos(angle);
+      const y = cy + r * sin(angle);
+      pts.push({ x, y, digit: RODIN[i] });
+    }
+    // Draw segments
+    ctx.lineWidth = 3;
+    for (let i = 0; i < 7; i++) {
+      const a = pts[i];
+      const b = pts[(i + 1) % 7];
+      const cmyk = digitAngleToCMYK(a.digit, asAngle(a.digit * 60));
+      ctx.strokeStyle = cmykToCss(cmyk);
+      ctx.beginPath();
+      ctx.moveTo(a.x, a.y);
+      ctx.lineTo(b.x, b.y);
+      ctx.stroke();
+    }
+  }
+
+  uroborosEmitter.on('uro', (e: UroborosEvent) => {
+    // advance rotation each rebirth step (index increments at every event)
+    rotation -= SEG; // rotate by one base segment
+    drawHeptagram();
+  });
+
+  drawHeptagram();
+}