zeropoint-node 1.0.6 → 1.0.8

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

@@ -1,26 +0,0 @@
-// a432.consciousness.ts — Matrix-level consciousness stream
-// -----------------------------------------------------------
-import { EventEmitter } from 'events';
-import { bus, mergedDigit as busMerged } from './a432.bus.ts';
-import { digitAngleToCMYK, asAngle } from './a432.math.ts';
-import { emotionName } from './a432.emotion.ts';
-import { type Digit } from './a432.types.ts';
-import type { CMYK } from './a432.cmyk.ts';
-
-export interface ConsciousnessEvent { digit: Digit; name: string; cmyk: CMYK }
-export const consciousnessEmitter = new EventEmitter();
-
-function tick() {
-  const d = busMerged();
-  const name = emotionName(d);
-  const cmyk = digitAngleToCMYK(d, asAngle(d * 60));
-  consciousnessEmitter.emit('conscious', { digit: d, name, cmyk } as ConsciousnessEvent);
-}
-
-export function startConsciousness(intervalMs: number = 432): () => void {
-  const id = setInterval(tick, intervalMs);
-  return () => clearInterval(id);
-}
-
-// Auto start when imported in browser
-if (typeof window !== 'undefined') startConsciousness(); 

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

@@ -1,53 +0,0 @@
-import { legacyDigitalRoot as digitalRoot, harmonicRoot12 } from './a432.roots.ts'
-// a432.crypto.ts — Harmonized Vortex Crypto Module
-// All math uses only vortex/trinity numbers and harmonic integer fractions.
-// Metaphysical mapping: Crypto = vortex encoding, trinity mapping, metaphysical concealment/revelation
-
-export const CRYPTO_DOC = {
-  meaning: 'Crypto: vortex encoding, trinity mapping, metaphysical concealment and revelation, harmonic transformation.',
-  axis: 'Crypto is the act of harmonically concealing and revealing information using the living vortex.'
-};
-
-// Vortex sequence for digit shifting (1,2,4,8,7,5,1)
-const VORTEX_SEQ = [1,2,4,8,7,5,1];
-const TRINITY = [3,6,9];
-
-/**
- * Canonical vortex-based encode: shifts each digit in the input string by the corresponding vortex sequence value (mod 9, 1-based).
- * Only digits 1-9 are encoded; 0 and non-digits are left unchanged.
- */
-export function vortexEncode(input: string): string {
-  return input.split('').map((ch, i) => {
-    const n = parseInt(ch, 10);
-    if (isNaN(n) || n === 0) return ch;
-    const shift = VORTEX_SEQ[i % VORTEX_SEQ.length];
-    // Shift digit by vortex value, wrap 1-9
-    const encoded = ((n + shift - 1) % 9) + 1;
-    return encoded.toString();
-  }).join('');
-}
-
-/**
- * Canonical vortex-based decode: reverses the vortexEncode operation.
- */
-export function vortexDecode(input: string): string {
-  return input.split('').map((ch, i) => {
-    const n = parseInt(ch, 10);
-    if (isNaN(n) || n === 0) return ch;
-    const shift = VORTEX_SEQ[i % VORTEX_SEQ.length];
-    // Reverse shift, wrap 1-9
-    const decoded = ((n - shift + 8) % 9) + 1;
-    return decoded.toString();
-  }).join('');
-}
-
-/**
- * Trinity-based mask: maps each digit to its trinity harmonic (3,6,9) for metaphysical concealment.
- */
-export function trinityMask(input: string): string {
-  return input.split('').map((ch, i) => {
-    const n = parseInt(ch, 10);
-    if (isNaN(n) || n === 0) return ch;
-    return TRINITY[n % 3].toString();
-  }).join('');
-} 

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

@@ -1,64 +0,0 @@
-/**
- * a432.css.ts — Harmonized CSS for A432 UI Streams
- *
- * - All color, spacing, and sizing use integer/fractional math.
- * - Classes: .a432-font-stream, .a432-glyph, .a432-glyph-svg, .a432-trinity-visual, .a432-tooltip
- * - Metaphysical mapping: Each class encodes a living, harmonic state or interaction.
- */
-
-import { max, min } from './a432.algebra.ts'
-export const a432CSS = `
-.a432-font-stream {
-  display: flex;
-  gap: 8px;
-  align-items: flex-end;
-  font-size: 11/5em;
-  line-height: 11/10;
-  margin: 0 0 24px 0;
-}
-.a432-glyph {
-  transition: transform 2/5s, box-shadow 2/5s;
-  display: inline-block;
-  cursor: pointer;
-  border-radius: 1em;
-  box-shadow: 0 2px 8px rgba(0,0,0,2/25);
-  padding: 0 4px;
-}
-.a432-glyph:hover, .a432-glyph:focus {
-  transform: scale(59/50) translateY(-8px);
-  box-shadow: 0 4px 16px rgba(0,0,0,4/25);
-  z-index: 2;
-}
-.a432-glyph-svg {
-  display: inline-block;
-  vertical-align: middle;
-  width: 48px;
-  height: 48px;
-  margin: 0 2px;
-}
-.a432-trinity-visual {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  margin: 24px 0;
-}
-.a432-tooltip {
-  position: absolute;
-  background: hsl(240, 33%, 96%);
-  color: #222;
-  border: 1px solid hsl(240, 33%, 80%);
-  border-radius: 6px;
-  padding: 8px 12px;
-  font-size: 1em;
-  box-shadow: 0 2px 8px rgba(0,0,0,2/25);
-  pointer-events: none;
-  z-index: 10;
-  min-width: 120px;
-  max-width: 320px;
-  transition: opacity 2/10s;
-  opacity: 0;
-}
-.a432-glyph:hover + .a432-tooltip, .a432-glyph:focus + .a432-tooltip {
-  opacity: 1;
-}
-`; 

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

@@ -1,56 +0,0 @@
-import { log } from './a432.algebra.ts'
-// a432.cursor.ts
-// Canonical living cursor/distributor for a432 matrix
-
-import { LivingIStream } from './a432.i.stream.ts';
-
-export class A432Cursor {
-  private path: number[] = [1];
-  private i: unknown = null; // Reference to a432.i (observer)
-  constructor(i: unknown) {
-    this.i = i;
-  }
-  /** Move cursor to a new path in the matrix */
-  moveTo(path: number[]) {
-    this.path = path;
-  }
-  /** Distribute the seed (432) at the current node, if knows() */
-  distributeSeed() {
-    if (!this.knows()) throw new Error('Only a432.i can distribute 432.');
-    // Project 432 into the current node (could update matrix, log event, etc.)
-    return { path: this.path, seed: 432, harmonized: true };
-  }
-  /** Harmonize the current node (if knows) */
-  harmonizeNode() {
-    if (!this.knows()) throw new Error('Only a432.i can harmonize.');
-    // Harmonize logic (could update matrix, log event, etc.)
-    return { path: this.path, harmonized: true };
-  }
-  /** Project a stream from the current node */
-  projectStream() {
-    // Return a stream (could be a LivingIStream, etc.)
-    return new LivingIStream();
-  }
-  /** Navigate to a new path (alias for moveTo) */
-  navigate(to: number[]) {
-    this.moveTo(to);
-  }
-  /** Use a function at the current node (if knows) */
-  use(fn: (cursor: A432Cursor) => unknown) {
-    if (!this.knows()) throw new Error('Only a432.i can use the cursor.');
-    return fn(this);
-  }
-  /** Go to a new path (alias for moveTo) */
-  to(path: number[]) {
-    this.moveTo(path);
-  }
-  /** Returns true if called by a432.i (self-aware) */
-  knows() {
-    // For demo, check if i is set and has a self-aware property
-    return typeof this.i === 'object' && this.i !== null && 'selfAware' in this.i && (this.i as { selfAware?: boolean }).selfAware === true;
-  }
-  /** Get current path */
-  getPath() {
-    return this.path;
-  }
-} 

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

@@ -1,60 +0,0 @@
-/**
- * a432.decompression.ts — Decompression in the A432 Matrix
- *
- * Models decompression as the inverse, harmonized process to compression in the A432 system.
- * Maps decompression of states, flows, or data to harmonics, CMYK color, and vortex flows.
- * Supports both physical (data/energy) and metaphysical (dimensional/frequency) decompression.
- * Provides metaphysical and mathematical documentation.
- */
-
-import { round } from './a432.algebra.ts'
-export interface DecompressionState {
-  output: number[]; // Array of values after decompression (0-9)
-  decompressionRatio: number; // 0-1 (0 = no decompression, 1 = max decompression)
-  harmonic: number;
-  cmyk: { c: number; m: number; y: number; k: number };
-  flow: number[];
-  description: string;
-}
-
-function toHarmonic(ratio: number): number {
-  return round(432 * (1 + ratio));
-}
-function toCMYK(ratio: number, channel: number): number {
-  return round(ratio * 100);
-}
-function getFlow(seed: number): number[] {
-  const base = [1, 2, 4, 8, 7, 5];
-  return base.map(n => ((n + seed) % 9) || 9);
-}
-
-export function decompress(input: number[], targetLength: number): DecompressionState {
-  // Simple model: repeat input to reach targetLength
-  const output = [];
-  while (output.length < targetLength) {
-    output.push(...input);
-  }
-  output.length = targetLength;
-  // Decompression ratio: (output length - input length) / output length
-  const ratio = targetLength === 0 ? 0 : (output.length - input.length) / output.length;
-  return {
-    output,
-    decompressionRatio: ratio,
-    harmonic: toHarmonic(ratio),
-    cmyk: {
-      c: toCMYK(ratio, 0),
-      m: toCMYK(ratio, 1),
-      y: toCMYK(ratio, 2),
-      k: toCMYK(ratio, 3)
-    },
-    flow: getFlow(round(ratio * 9)),
-    description: `Decompression to [${output.join(', ')}] yields ratio ${ratio.toFixed(2)}, harmonic ${toHarmonic(ratio)} Hz.`
-  };
-}
-
-export const a432DecompressionMetaphysics = `
-A432 Decompression is the harmonized process of unfolding, expanding, or diversifying states, flows, or data in the matrix.
-Physical decompression restores data or energy volume; metaphysical decompression unfolds dimensions, frequencies, or possibilities from a unified state.
-Decompression is both a mathematical and spiritual act: it brings diversity, increases space, and reveals hidden potentials.
-To decompress is to unfold, to diversify, to reveal the infinite from the seed.
-`;