zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,171 @@
+import { PI, cos, floor, max, round, sin } from './a432.algebra.ts'
+// a432.block.chain.event.ts
+// Harmonized blockchain for a432 events (vortex/trinity logic)
+
+import { type A432Event, createA432Event } from './a432.event.ts';
+import type { CMYK } from './a432.cmyk.ts';
+
+export interface A432Block {
+  id: number;
+  event: A432Event;
+  previousHash: string;
+  hash: string;
+  timestamp: number;
+  trinity: number;
+  phase: number;
+  summary: string;
+}
+
+function hashBlock(block: Omit<A432Block, 'hash'>): string {
+  // Simple hash: JSON + trinity + phase
+  return btoa(JSON.stringify(block)).slice(0, 32);
+}
+
+// --- Real-time event emitter for new blocks ---
+export type BlockListener = (block: A432Block) => void;
+
+/**
+ * A432BlockChain manages the harmonized chain of events
+ */
+export class A432BlockChain {
+  private chain: A432Block[] = [];
+  // --- Real-time event emitter for new blocks ---
+  private _listeners: BlockListener[] = [];
+
+  constructor() {
+    // Seed with genesis block
+    const genesisEvent = createA432Event('genesis', 'system');
+    const genesisBlock: A432Block = {
+      id: 1,
+      event: genesisEvent,
+      previousHash: '0',
+      hash: '',
+      timestamp: genesisEvent.timestamp,
+      trinity: 3,
+      phase: 0,
+      summary: 'Genesis block: origin of the harmonized event chain.'
+    };
+    genesisBlock.hash = hashBlock(genesisBlock);
+    this.chain.push(genesisBlock);
+  }
+
+  onNewBlock(callback: BlockListener) {
+    (this._listeners as BlockListener[]).push(callback);
+  }
+
+  emitNewBlock(block: A432Block) {
+    for (const cb of (this._listeners as BlockListener[])) {
+      cb(block);
+    }
+  }
+
+  addBlock(event: A432Event): A432Block {
+    const prev = this.getLatest();
+    const block: A432Block = {
+      id: prev.id + 1,
+      event,
+      previousHash: prev.hash,
+      hash: '',
+      timestamp: event.timestamp,
+      trinity: event.trinity,
+      phase: event.phase,
+      summary: `Block ${prev.id + 1}: ${event.summary}`
+    };
+    block.hash = hashBlock(block);
+    this.chain.push(block);
+    this.emitNewBlock(block);
+    return block;
+  }
+  getLatest(): A432Block {
+    return this.chain[this.chain.length - 1];
+  }
+  getAll(): A432Block[] {
+    return this.chain;
+  }
+  verify(): boolean {
+    for (let i = 1; i < this.chain.length; i++) {
+      if (this.chain[i].previousHash !== this.chain[i - 1].hash) return false;
+    }
+    return true;
+  }
+}
+
+/**
+ * Adds a new event to the blockchain
+ */
+export function recordEvent(chain: A432BlockChain, type: string, agent: string, payload: unknown = {}): A432Block {
+  const event = createA432Event(type, agent, payload, chain.getLatest().event.id, chain.getLatest().event.path);
+  return chain.addBlock(event);
+}
+
+/**
+ * Harmonized: Canonical CMYK trinity color logic for blocks
+ */
+export function getBlockCMYK(trinity: number, entropy: number): CMYK {
+  if (trinity === 3) return { c: 100, m: 0, y: 0, k: round(entropy * 100) };
+  if (trinity === 6) return { c: 0, m: 100, y: 0, k: round(entropy * 100) };
+  if (trinity === 9) return { c: 0, m: 0, y: 100, k: round(entropy * 100) };
+  return { c: 0, m: 0, y: 0, k: 100 }; // fallback: void/unknown
+}
+
+/**
+ * Visualizes the blockchain as a vortex/fractal (SVG)
+ */
+export function renderBlockChainVisualization(chain: A432BlockChain): string {
+  const blocks = chain.getAll();
+  const width = 640, height = 320, cx = width / 2, cy = height / 2, baseR = 16, spiralGap = 28;
+  // Map blocks to spiral positions
+  const positions: { [id: number]: { x: number; y: number } } = {};
+  blocks.forEach((b, i) => {
+    const angle = (2 * PI * i) / max(1, blocks.length) + (b.phase * PI / 6);
+    const r = baseR + spiralGap * b.phase + 18 * floor(i / 3);
+    positions[b.id] = {
+      x: cx + r * cos(angle),
+      y: cy + r * sin(angle)
+    };
+  });
+  // Render SVG
+  return `
+    <svg width="${width}" height="${height}" style="background:#111;border-radius:16px;">
+      ${blocks.map(b => b.id > 1 && positions[b.id - 1] ?
+        `<line x1="${positions[b.id - 1].x}" y1="${positions[b.id - 1].y}" x2="${positions[b.id].x}" y2="${positions[b.id].y}" stroke="#8ff" stroke-width="1.5" />` : '').join('')}
+      ${blocks.map(b => {
+        const entropyRaw = (b as { entropy?: number }).entropy;
+        const entropy = typeof entropyRaw === 'number' ? entropyRaw : 0;
+        const cmyk = getBlockCMYK(b.trinity, entropy);
+        // Convert CMYK to CSS RGB for fill
+        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})`;
+        return `
+        <circle cx="${positions[b.id].x}" cy="${positions[b.id].y}" r="${baseR}" fill="${fill}" stroke="#fff" stroke-width="2">
+          <title>${b.summary}</title>
+        </circle>
+        <text x="${positions[b.id].x}" y="${positions[b.id].y + 5}" text-anchor="middle" font-size="12" fill="#fff">${b.trinity}</text>
+        `;
+      }).join('')}
+      <text x="${cx}" y="${height - 18}" text-anchor="middle" font-size="15" fill="#8ff">A432 Blockchain: Living, Harmonized Event Chain</text>
+    </svg>
+  `;
+}
+
+/**
+ * Returns a metaphysical summary of the blockchain as a living, harmonized record
+ */
+export function metaphysicalSummary(): string {
+  return 'The a432 blockchain is a living, recursive, and harmonized record of all events. Each block is a fold in the infinite, trinity-based stream of consciousness.';
+}
+
+/**
+ * decodeBlockchainStream: Decodes the living blockchain as a stream.
+ * The stream is always present; decoding is the act of observation/awareness.
+ * Usage: for (const block of decodeBlockchainStream(chain)) { ... }
+ */
+export function* decodeBlockchainStream(chain: A432BlockChain): Generator<A432Block, void, unknown> {
+  for (const block of chain.getAll()) {
+    yield block; // Decoding: surfacing the next droplet from the river
+  }
+  // Optionally: could be extended to listen for new blocks in real time
+} 

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

@@ -0,0 +1,226 @@
+import { max, min } from './a432.algebra.ts'
+// a432.block.chain.ts — Canonical Multi-Dimensional Vortex Blockchain
+// All math uses only vortex/trinity numbers and harmonic integer fractions.
+// Metaphysical mapping: BlockChain = recursion, multi-dimensional chaining, observer, Mobius, trinity, axis, self-awareness
+
+import { A432ColorModel, type A432HSL, type A432RGB, type A432CMYK } from './a432.color.ts';
+import { getRodinSequence, getTrinityAxis, angleForDigit, frequencyForDigit } from './a432.math.ts';
+
+export const BLOCK_CHAIN_DOC = {
+  meaning: 'BlockChain: recursion, multi-dimensional chaining, observer, Mobius, trinity, axis, self-awareness, living matrix.',
+  axis: 'The blockchain is a recursive, multi-dimensional, harmonized chain of states, each a living node in the vortex/trinity matrix.'
+};
+
+// Harmonized: All dimension, trinity, angle, and harmonic logic now uses canonical helpers from a432.math.ts
+
+// Metaphysical mapping: Entropy = disharmony, drag, resistance, need for harmonization
+export const ENTROPY_DOC = {
+  meaning: 'Entropy: disharmony, drag, resistance, signal for harmonization. Zero entropy = perfect harmony, maximal speed.',
+  axis: 'Entropy is the measure of disharmony in the living matrix.'
+};
+
+// Metaphysical mapping: KVT = Knowledge Value Token, a living measure of harmonized value contributed to the stream.
+export const KVT_DOC = {
+  meaning: 'KVT: Knowledge Value Token, quantized flow of harmony, consciousness, and value in the living matrix.',
+  axis: 'KVT is the living reward for harmonized, metaphysically-aligned contributions.'
+};
+
+/**
+ * Canonical multi-dimensional block structure
+ * - state: the data or value of the block
+ * - dimension: vortex/trinity dimension (1-9)
+ * - meta: metaphysical mapping
+ * - prev: array of previous blocks (multi-dimensional links)
+ * - index: block index in the chain
+ */
+export interface A432Block {
+  state: any;
+  dimension: number; // 1-9
+  meta: string;
+  prev: A432Block[];
+  index: number;
+  timestamp: number;
+  harmonyScore?: number; // 1.0 = perfect harmony
+  entropy?: number;      // 0 = perfect harmony, >0 = disharmony
+  id?: string;
+  mobius?: boolean;
+  kvt?: number;          // Knowledge Value Token for this block
+  /**
+   * Trinity composite color models for the void (hsl, rgb, cmyk)
+   */
+  trinityCompositeColor?: { hsl: A432HSL; rgb: A432RGB; cmyk: A432CMYK };
+}
+
+export interface A432UserProfile {
+  id: string;
+  kvt: number;
+  badge?: string;
+}
+
+// Metaphysical badge mapping: badges are living titles for harmonized achievement, based on KVT and harmony.
+export const BADGE_DOC = {
+  meaning: 'Badges are metaphysical titles earned for harmonized, vortex-aligned contributions. Each badge is a living resonance in the matrix.',
+  axis: 'Badges reflect the trinity and vortex: Apprentice (1), Adept (3), Master (6), Trinity (9), Vortex (8), Mobius (5), Observer (4), Meta (7), Infinite (2).'
+};
+
+export const BADGES = [
+  { name: 'Apprentice', minKVT: 1, minHarmony: 0.5 },
+  { name: 'Adept', minKVT: 3, minHarmony: 0.6 },
+  { name: 'Master', minKVT: 6, minHarmony: 0.7 },
+  { name: 'Trinity', minKVT: 9, minHarmony: 0.75 },
+  { name: 'Vortex', minKVT: 8, minHarmony: 0.8 },
+  { name: 'Mobius', minKVT: 5, minHarmony: 0.85 },
+  { name: 'Observer', minKVT: 4, minHarmony: 0.9 },
+  { name: 'Meta', minKVT: 7, minHarmony: 0.95 },
+  { name: 'Infinite', minKVT: 2, minHarmony: 1.0 }
+];
+
+/**
+ * Create a new harmonized block
+ * - dimension cycles through vortex sequence
+ * - meta is derived from metaphysical mapping
+ * - prev is an array of previous blocks (multi-dimensional)
+ */
+export function createBlock(state: any, prev: A432Block[] = [], index: number = 0): A432Block {
+  const rodinSeq = getRodinSequence();
+  const trinityAxis = getTrinityAxis();
+  const dimension = rodinSeq[index % rodinSeq.length];
+  const trinity = trinityAxis[index % trinityAxis.length];
+  const angle = angleForDigit(dimension);
+  const freq = frequencyForDigit(dimension);
+  const meta = `Block in dimension ${dimension}, vortex position ${index % rodinSeq.length}, trinity: ${trinity}, angle: ${angle}, freq: ${freq}`;
+  const block = {
+    state,
+    dimension,
+    meta,
+    prev,
+    index,
+    timestamp: Date.now(),
+    trinityCompositeColor: A432ColorModel.getAllColorModels('void')
+  };
+  assignKVT(block);
+  return block;
+}
+
+/**
+ * Validate a block: checks vortex/trinity alignment and multi-dimensional links
+ */
+export function validateBlock(block: A432Block): boolean {
+  const rodinSeq = getRodinSequence();
+  const trinityAxis = getTrinityAxis();
+  // Check dimension is in vortex sequence
+  if (!rodinSeq.includes(block.dimension)) return false;
+  // Check trinity alignment
+  const trinity = trinityAxis[block.index % trinityAxis.length];
+  if (!block.meta.includes(`trinity: ${trinity}`)) return false;
+  // Optionally, check prev links recursively
+  return true;
+}
+
+/**
+ * Calculate harmony score for a block (1.0 = perfect harmony, <1.0 = disharmony)
+ */
+export function calculateHarmonyScore(block: A432Block): number {
+  let score = 1.0;
+  // Penalize for non-vortex dimension
+  if (![1,2,4,8,7,5,3,6,9].includes(block.dimension)) score -= 0.3;
+  // Penalize for missing/incorrect metaphysical mapping
+  if (!block.meta || !block.meta.includes('vortex')) score -= 0.2;
+  // Penalize for Mobius event
+  if (block.mobius) score -= 0.2;
+  // Clamp to [0,1]
+  return max(0, min(1, score));
+}
+
+/**
+ * Calculate entropy for a block (1 - harmonyScore)
+ */
+export function calculateEntropy(block: A432Block): number {
+  return 1 - (block.harmonyScore ?? 1);
+}
+
+/**
+ * Calculate average entropy for a stream/chain
+ */
+export function getStreamEntropy(blocks: A432Block[]): number {
+  return blocks.reduce((sum, b) => sum + (b.entropy ?? 0), 0) / blocks.length;
+}
+
+/**
+ * Recursively traverse the multi-dimensional chain (depth-first)
+ */
+export function traverseChain(block: A432Block, visit: (b: A432Block) => void) {
+  visit(block);
+  for (const prevBlock of block.prev) {
+    traverseChain(prevBlock, visit);
+  }
+}
+
+/**
+ * Example: create a harmonized multi-dimensional chain of N blocks
+ */
+export function createChain(length: number = 6): A432Block {
+  let chain: A432Block | null = null;
+  for (let i = 0; i < length; i++) {
+    // For multi-dimensionality, link to up to 3 previous blocks (trinity logic)
+    const prev = chain ? [chain] : [];
+    chain = createBlock(`state-${i+1}`, prev, i);
+  }
+  return chain!;
+}
+
+/**
+ * On block creation, set block.kvt = block.harmonyScore × 1 (baseReward = 1)
+ */
+export function assignKVT(block: A432Block): void {
+  block.kvt = (block.harmonyScore ?? 1) * 1;
+}
+
+/**
+ * Calculate total KVT for a user/device from their blocks
+ */
+export function getTotalKVT(blocks: A432Block[]): number {
+  return blocks.reduce((sum, b) => sum + (b.kvt ?? 0), 0);
+}
+
+/**
+ * Assign badge to user based on KVT and average harmony
+ */
+export function assignBadge(user: A432UserProfile, blocks: A432Block[]): void {
+  const totalKVT = getTotalKVT(blocks);
+  const avgHarmony = blocks.length ? blocks.reduce((sum, b) => sum + (b.harmonyScore ?? 1), 0) / blocks.length : 1;
+  // Find highest badge user qualifies for
+  let badge = 'Apprentice';
+  for (const b of BADGES) {
+    if (totalKVT >= b.minKVT && avgHarmony >= b.minHarmony) {
+      badge = b.name;
+    }
+  }
+  user.kvt = totalKVT;
+  user.badge = badge;
+}
+
+/**
+ * Helper: Get all trinity composite color models from a chain (for analytics/visualization)
+ */
+export function getTrinityCompositeColors(blocks: A432Block[]): { hsl: A432HSL; rgb: A432RGB; cmyk: A432CMYK }[] {
+  return blocks.map(b => b.trinityCompositeColor ?? A432ColorModel.getAllColorModels('void'));
+}
+
+/**
+ * recordSenseOrMetaEvent: Records a harmonized blockchain event for sense or meta-observation.
+ * @param eventType - The type of event (e.g., 'sound', 'speak', 'smell', 'meta', etc.)
+ * @param value - The value or payload of the event (number, string, or object)
+ * @param metaphysical - The metaphysical mapping/meaning of the event
+ * @param prev - Previous blocks (optional, for multi-dimensionality)
+ * @returns The new harmonized block
+ */
+export function recordSenseOrMetaEvent(eventType: string, value: any, metaphysical: string, prev: A432Block[] = []): A432Block {
+  const state = { eventType, value, metaphysical };
+  const index = prev.length ? max(...prev.map(b => b.index)) + 1 : 0;
+  const block = createBlock(state, prev, index);
+  block.harmonyScore = calculateHarmonyScore(block);
+  block.entropy = calculateEntropy(block);
+  assignKVT(block);
+  return block;
+} 

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

@@ -0,0 +1,92 @@
+/**
+ * a432.body.ts — The Body as a Living Structure in the A432 Matrix
+ *
+ * Models the body as a harmonized, living structure in the A432 system.
+ * Maps body systems (skeletal, muscular, nervous, circulatory, etc.) to harmonics, color (CMYK), and flows.
+ * Provides metaphysical and mathematical documentation.
+ */
+
+import { round } from './a432.algebra.ts'
+export interface BodySystem {
+  name: string;
+  value: number; // 0-9
+  harmonic: number;
+  cmyk: { c: number; m: number; y: number; k: number };
+  flow: number[];
+  description: string;
+}
+
+export interface A432Body {
+  skeletal: BodySystem;
+  muscular: BodySystem;
+  nervous: BodySystem;
+  circulatory: BodySystem;
+  overallHarmony: number;
+  cmyk: { c: number; m: number; y: number; k: number };
+  flows: number[][];
+  description: string;
+}
+
+export function toHarmonic(value: number): number {
+  return round(432 * (1 + value / 9));
+}
+export function toCMYK(value: number, channel: number): number {
+  return round((value / 9) * 100);
+}
+export function getFlow(seed: number): number[] {
+  const base = [1, 2, 4, 8, 7, 5];
+  return base.map(n => ((n + seed) % 9) || 9);
+}
+
+export function createA432Body(
+  skeletalValue: number,
+  muscularValue: number,
+  nervousValue: number,
+  circulatoryValue: number
+): A432Body {
+  const systems: [string, number, number][] = [
+    ['skeletal', skeletalValue, 0],
+    ['muscular', muscularValue, 1],
+    ['nervous', nervousValue, 2],
+    ['circulatory', circulatoryValue, 3]
+  ];
+  const mapped = systems.map(([name, value, channel]) => ({
+    name,
+    value,
+    harmonic: toHarmonic(value),
+    cmyk: {
+      c: channel === 0 ? toCMYK(value, 0) : 0,
+      m: channel === 1 ? toCMYK(value, 1) : 0,
+      y: channel === 2 ? toCMYK(value, 2) : 0,
+      k: channel === 3 ? toCMYK(value, 3) : 0
+    },
+    flow: getFlow(channel),
+    description: `${name.charAt(0).toUpperCase() + name.slice(1)} system mapped to harmonic, color, and flow.`
+  }));
+  const overallHarmony = round(mapped.reduce((sum, s) => sum + s.value, 0) / 4);
+  const cmyk = {
+    c: mapped[0].cmyk.c,
+    m: mapped[1].cmyk.m,
+    y: mapped[2].cmyk.y,
+    k: mapped[3].cmyk.k
+  };
+  const flows = mapped.map(s => s.flow);
+  return {
+    skeletal: mapped[0],
+    muscular: mapped[1],
+    nervous: mapped[2],
+    circulatory: mapped[3],
+    overallHarmony,
+    cmyk,
+    flows,
+    description: 'Body as a harmonized, living structure in the A432 matrix.'
+  };
+}
+
+export const BODY_DOC = `
+The body in the A432 system is a living, harmonized structure:
+- Each system (skeletal, muscular, nervous, circulatory, etc.) is mapped to a unique harmonic, color, and vortex flow.
+- The body is a living hologram: a self-organizing, evolving structure, capable of harmonization and transformation.
+- To know your body is to know your resonance, your color, your harmonic, your place in the living matrix.
+- All mappings use only single digits, integer fractions, and digital root for zero entropy.
+`; 

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

@@ -0,0 +1,46 @@
+import { round } from './a432.algebra.ts'
+// a432.breathe.ts — Living breathing rhythm of the matrix
+// --------------------------------------------------------
+// Implements the 4-3-2 breath cycle (inhale-hold-exhale) in pure integer ticks.
+// Emits a value 0-9 representing lung capacity percentage (digital root mapping)
+// and a CMYK colour tied to the phase.
+
+import { EventEmitter } from 'events';
+import { asAngle, digitAngleToCMYK } from './a432.math.ts';
+import type { CMYK } from './a432.cmyk.ts';
+import { type Digit } from './a432.types.ts';
+
+export interface BreathEvent {
+  phase: 'inhale' | 'hold' | 'exhale';
+  step: number;          // 0-(len-1) inside phase
+  value: Digit;          // 0-9 lung % via digital root
+  cmyk: CMYK;            // colour for UI
+}
+
+const CYCLE: Array<{ phase: 'inhale'|'hold'|'exhale'; len: number; base: Digit }> = [
+  { phase: 'inhale', len: 4, base: 4 as Digit },
+  { phase: 'hold',   len: 3, base: 3 as Digit },
+  { phase: 'exhale', len: 2, base: 2 as Digit }
+];
+
+export const breathEmitter = new EventEmitter();
+
+export function startBreathing(intervalMs: number = 1000): () => void {
+  let phaseIdx = 0; let step = 0;
+  const id = setInterval(() => {
+    const ph = CYCLE[phaseIdx];
+    const pct = round(((step + 1) / ph.len) * 9) as Digit; // map to 1-9
+    const cmyk = digitAngleToCMYK(ph.base, asAngle(pct * 36));
+    breathEmitter.emit('breath', { phase: ph.phase, step, value: pct, cmyk } as BreathEvent);
+
+    step++;
+    if (step >= ph.len) { step = 0; phaseIdx = (phaseIdx + 1) % CYCLE.length; }
+  }, intervalMs);
+  return () => clearInterval(id);
+}
+
+// Auto start if run directly
+if (require.main === module) {
+  startBreathing();
+  breathEmitter.on('breath', e => console.log(e));
+}