zeropoint-node 1.0.6 → 1.0.8

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

@@ -1,14 +0,0 @@
-// a432.os.app.ts — Self-contained app interface and examples
-class A432App {
-  constructor(name) { this.name = name; }
-  onRegister() {}
-  getState() { return {}; }
-  getHarmony() { return 1; }
-}
-// Example app
-class ExampleApp extends A432App {
-  constructor() { super('Example'); }
-  override getState() { return { message: 'Hello from ExampleApp!' }; }
-}
-// const app = new ExampleApp();
-// app.getState(); 

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

@@ -1,11 +0,0 @@
-import { log } from './a432.algebra.ts'
-// a432.os.bus.ts — Self-contained event bus
-class A432Bus {
-  constructor() { this.listeners = {}; }
-  emit(event, payload) { (this.listeners[event] || []).forEach(fn => fn(payload)); }
-  on(event, fn) { (this.listeners[event] = this.listeners[event] || []).push(fn); }
-}
-// Example usage:
-// const bus = new A432Bus();
-// bus.on('test', payload => console.log(payload));
-// bus.emit('test', { hello: 'world' }); 

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

@@ -1,9 +0,0 @@
-// a432.os.ml.ts — Self-contained ML logic
-function observeEvents(events) {
-  // Example: count event types
-  const counts = {};
-  events.forEach(e => { counts[e.type] = (counts[e.type] || 0) + 1; });
-  return counts;
-}
-// Example usage:
-// observeEvents([{ type: 'launch' }, { type: 'launch' }, { type: 'close' }]); 

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

@@ -1,119 +0,0 @@
-import { PI, cos, sin } from './a432.algebra.ts'
-import { Controller } from '@hotwired/stimulus';
-// Import overlay registry or overlay functions as needed
-import { getRodinCoil2DOverlayData } from './a432.rodin.coil.overlay.ts';
-import { getTrinityAxisOverlayData } from './a432.trinity.axis.ts';
-import { getMobiusCircuit2DOverlayData } from './a432.mobius.circuit.overlay.ts';
-import { getTeslaCoil2DOverlayData } from './a432.tesla.coil.overlay.ts';
-import { getYinYangOverlayData } from './a432.yin.yang.ts';
-
-// Universal overlay registry
-const overlayRegistry = {
-  rodin: getRodinCoil2DOverlayData,
-  trinity: getTrinityAxisOverlayData,
-  mobius: getMobiusCircuit2DOverlayData,
-  tesla: getTeslaCoil2DOverlayData,
-  yinYang: getYinYangOverlayData
-};
-
-/**
- * a432.overlay.visual.controller.ts — Universal A432 Overlay Visualizer (Stimulus)
- *
- * Animates any harmonized overlay (Rodin, Trinity, Mobius, Tesla, Yin-Yang, etc.)
- * using node data with value, angle, color, polarity, and spin.
- * - Polarity: color phase, glow, size
- * - Spin: animation direction
- * - Angle: initial position
- *
- * Usage:
- * <div data-controller="a432-overlay-visual" data-a432-overlay-visual-overlay-value="rodin"></div>
- */
-export default class extends Controller {
-  static override values = { overlay: String, radius: Number, nodeSize: Number };
-
-  radius!: number;
-  nodeSize!: number;
-  centerX!: number;
-  centerY!: number;
-  raf!: number;
-
-  override connect() {
-    // Use Stimulus value API for radius/nodeSize
-    // @ts-ignore Stimulus value API
-    this.radius = (this as { radiusValue?: number }).radiusValue ?? 120;
-    // @ts-ignore Stimulus value API
-    this.nodeSize = (this as { nodeSizeValue?: number }).nodeSizeValue ?? 48;
-    const el = this.element as HTMLElement;
-    this.centerX = (el.offsetWidth || 320) / 2;
-    this.centerY = (el.offsetHeight || 320) / 2;
-    this.animate = this.animate.bind(this);
-    this.startAnimation();
-  }
-
-  override disconnect() {
-    cancelAnimationFrame(this.raf);
-  }
-
-  startAnimation() {
-    this.raf = requestAnimationFrame(this.animate);
-  }
-
-  animate() {
-    this.element.innerHTML = '';
-    // @ts-ignore overlayRegistry dynamic access
-    const overlayFn = overlayRegistry[(this as { overlayValue?: string }).overlayValue as keyof typeof overlayRegistry] || getRodinCoil2DOverlayData;
-    const nodes = overlayFn(this.radius, this.centerX, this.centerY);
-    const t = Date.now() / 1000;
-    nodes.forEach((node: unknown, i: number) => {
-      const nodeObj = typeof node === 'object' && node !== null ? node as { 
-        angle?: number; 
-        x?: number; 
-        y?: number; 
-        color?: string | { c: number; m: number; y: number; k: number }; 
-        size?: number; 
-        label?: string;
-        spin?: number;
-        polarity?: number;
-        value?: string;
-      } : {};
-      // Animate angle: spin direction (+1/-1)
-      const baseAngle = nodeObj.angle !== undefined
-        ? nodeObj.angle + (t * 60 * (i % 2 === 0 ? 1 : -1))
-        : 0;
-      const angle = (baseAngle + (nodeObj.spin || 0) * t * 60) % 360;
-      const rad = angle * PI / 180;
-      const x = this.centerX + this.radius * cos(rad) - this.nodeSize / 2;
-      const y = this.centerY + this.radius * sin(rad) - this.nodeSize / 2;
-      // Color: use node.color (should be a CSS string)
-      const color = typeof nodeObj.color === 'string'
-        ? nodeObj.color
-        : nodeObj.color && typeof nodeObj.color === 'object'
-          ? `cmyk(${nodeObj.color.c},${nodeObj.color.m},${nodeObj.color.y},${nodeObj.color.k})`
-          : '#fff';
-      // Node element
-      const el = document.createElement('div');
-      el.style.position = 'absolute';
-      el.style.left = `${x}px`;
-      el.style.top = `${y}px`;
-      el.style.width = `${this.nodeSize}px`;
-      el.style.height = `${this.nodeSize}px`;
-      el.style.backgroundColor = color;
-      el.style.border = '1px solid rgba(255,255,255,0.3)';
-      el.style.borderRadius = '50%';
-      el.style.display = 'flex';
-      el.style.alignItems = 'center';
-      el.style.justifyContent = 'center';
-      el.style.fontSize = '12px';
-      el.style.color = '#fff';
-      el.style.fontWeight = 'bold';
-      el.style.textShadow = '0 0 3px rgba(0,0,0,0.8)';
-      el.style.boxShadow = (nodeObj.polarity || 0) > 0
-        ? '0 0 8px rgba(255,255,255,0.6)'
-        : '0 0 4px rgba(0,0,0,0.4)';
-      el.style.transform = `scale(${1 + 0.2 * (nodeObj.polarity || 0)})`;
-      el.innerHTML = nodeObj.value || '';
-      this.element.appendChild(el);
-    });
-    this.raf = requestAnimationFrame(this.animate);
-  }
-} 

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

@@ -1,10 +0,0 @@
-// a432.paths.ts — Canonical YANG and YIN URL paths
-//----------------------------------------------------
-export const YANG_DIGITS = [0,3,6,9,1,2,4,8,7,5,1] as const;
-export const YANG_PATH = '/' + YANG_DIGITS.join('/') + '/';
-
-export const YIN_DIGITS  = [...YANG_DIGITS].reverse() as unknown as typeof YANG_DIGITS;
-export const YIN_PATH  = '/' + YIN_DIGITS.join('/') + '/';
-
-export function isYang(url: string): boolean { return url.startsWith(YANG_PATH); }
-export function isYin(url: string): boolean { return url.startsWith(YIN_PATH); } 

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

@@ -1,123 +0,0 @@
-import { legacyDigitalRoot } from './a432.roots.ts'
-import { decodePiDigits, piDigitStream, angleForDigit } from './a432.math.ts';
-import { digitAngleToCMYK, type CMYK } from './a432.cmyk.ts';
-import { type Digit, type AngleDeg, asAngle } from './a432.types.ts';
-import { type TrinitySwitch, DOT_TRINITY_SWITCH } from './a432.math.ts';
-
-/** Snapshot of a single π digit mapped through metric → imperial → trinity → polarity. */
-export interface PiSnapshot {
-  index: number;            // position in π stream (0-based)
-  metric: Digit;
-  imperial: Digit;
-  trinity: Digit;
-  polarity: -1 | 0 | 1;
-  angle: AngleDeg;
-  cmyk: CMYK;
-}
-
-/** Iterator that yields harmonic snapshots for the first `limit` digits of π. */
-export function* piHarmonicStream(limit: number): IterableIterator<PiSnapshot> {
-  let idx = 0;
-  for (const decoded of decodePiDigits(limit)) {
-    const angle = asAngle(angleForDigit(decoded.trinity));
-    const cmyk = digitAngleToCMYK(decoded.trinity, angle);
-    yield {
-      index: idx++,
-      metric: decoded.metric,
-      imperial: decoded.imperial,
-      trinity: decoded.trinity,
-      polarity: decoded.polarity,
-      angle,
-      cmyk,
-    };
-  }
-}
-
-/**
- * Collect π digits in 11-digit blocks (aligns with FULL_PATTERN).
- * Returns an array where each entry is the harmonic stream slice for that block.
- */
-export function collectPiBlocks(limit: number): PiSnapshot[][] {
-  const blocks: PiSnapshot[][] = [];
-  let current: PiSnapshot[] = [];
-  for (const snap of piHarmonicStream(limit)) {
-    current.push(snap);
-    if (current.length === 11) {
-      blocks.push(current);
-      current = [];
-    }
-  }
-  if (current.length) blocks.push(current);
-  return blocks;
-}
-
-/** Compute running ratio of trinity-hits (3,6,9) vs total scanned digits. */
-export function trinityHitRatios(limit: number): Array<{ idx: number; ratio: number }> {
-  let hits = 0;
-  const out: Array<{ idx: number; ratio: number }> = [];
-  let idx = 0;
-  for (const snap of piHarmonicStream(limit)) {
-    if (snap.trinity === 3 || snap.trinity === 6 || snap.trinity === 9) hits += 1;
-    idx += 1;
-    out.push({ idx, ratio: hits / idx });
-  }
-  return out;
-}
-
-/** Detect positions where nine-shock (digital-root of the last 9 digits) equals 9. */
-export function nineShockPositions(limit: number): number[] {
-  const window: Digit[] = [];
-  const positions: number[] = [];
-  let idx = 0;
-  for (const snap of piHarmonicStream(limit)) {
-    window.push(snap.metric);
-    if (window.length > 9) window.shift();
-    if (window.length === 9) {
-      const sum = window.reduce<number>((s, d) => s + (d as number), 0);
-      const dr = (legacyDigitalRoot(sum));
-      if (dr === 9) positions.push(idx);
-    }
-    idx += 1;
-  }
-  return positions;
-}
-
-/** Export helper that summarises multiple analyses at once. */
-export function piHarmonicReport(limit: number = 1000) {
-  return {
-    blocks: collectPiBlocks(limit),
-    trinityRatios: trinityHitRatios(limit),
-    nineShockPositions: nineShockPositions(limit),
-  };
-}
-
-// ——————————————————————————————————————————
-// DOT AS TRINITY TOKEN MODEL
-// ---------------------------------------------------------
-
-/** Token emitted by `piTokenStream` representing either a digit snapshot or the decimal point (trinity pulse). */
-export type PiToken =
-  | { kind: 'digit'; snap: PiSnapshot }
-  | TrinitySwitch;
-
-/**
- * piTokenStream — yields the π stream with an explicit trinity-switch token (the decimal dot).
- * The sequence is: first digit (3) → trinity token (dot) → remaining `limit` digits.
- * Existing harmonic logic is untouched; consumers that ignore the 'trinity' kind behave as before.
- */
-export function* piTokenStream(limit: number): IterableIterator<PiToken> {
-  let first = true;
-  for (const snap of piHarmonicStream(limit)) {
-    yield { kind: 'digit', snap };
-    if (first) {
-      // Immediately after the integer part emit the trinity switch (dot)
-      yield DOT_TRINITY_SWITCH;
-      first = false;
-    }
-  }
-}
-
-// Helper: collect only the tokens (useful for UI timelines)
-export function collectPiTokens(limit: number): PiToken[] {
-  return Array.from(piTokenStream(limit));
-} 

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

@@ -1,79 +0,0 @@
-import { PI, cos, sin } from './a432.algebra.ts'
-// a432.pi.trinity.ts
-// Imagine pi as trinity, visualized as a living Rodin coil
-// All logic is integer/fractional, vortex-based, and metaphysically mapped
-
-import { PI_DIGITS } from './a432.pi.ts';
-import { rodinVortexCycle } from './a432.rodin.coil.ts';
-
-export interface PiTrinityRodinState {
-  step: number;
-  piDigit: number;
-  trinity: number;
-  archetype: string;
-  rodinPosition: number;
-  metaphysical: string;
-}
-
-/**
- * Generate a stream mapping pi digits to trinity archetypes and Rodin vortex positions
- */
-export function piTrinityRodinStream(length: number): PiTrinityRodinState[] {
-  const rodinSeq = rodinVortexCycle(1, 1); // [1,2,4,8,7,5,1]
-  return Array.from({ length }, (_, i) => {
-    const piDigit = PI_DIGITS[i % PI_DIGITS.length];
-    const trinity = [3, 6, 9][piDigit % 3];
-    let archetype = '';
-    if (trinity === 3) archetype = 'Creation';
-    if (trinity === 6) archetype = 'Return';
-    if (trinity === 9) archetype = 'Axis/Unity';
-    const rodinPosition = rodinSeq[i % rodinSeq.length];
-    return {
-      step: i + 1,
-      piDigit,
-      trinity,
-      archetype,
-      rodinPosition,
-      metaphysical: `Step ${i + 1}: π digit ${piDigit} → Trinity ${trinity} (${archetype}), Rodin ${rodinPosition}`
-    };
-  });
-}
-
-/**
- * Render an SVG visualization of the pi-trinity-Rodin stream as a spiral/coil
- */
-export function renderPiTrinityRodinSVG(length: number = 120): string {
-  const stream = piTrinityRodinStream(length);
-  const width = 480, height = 480, cx = width / 2, cy = height / 2;
-  const spiralA = 60, spiralB = 12;
-  // Map trinity to color
-  const trinityColor = (t: number) => t === 3 ? '#39f' : t === 6 ? '#6f3' : '#f93';
-  // Calculate spiral points
-  const points = stream.map((s, i) => {
-    const theta = i * (2 * PI / 3); // trinity spiral
-    const r = spiralA + spiralB * i;
-    return {
-      ...s,
-      x: cx + r * cos(theta),
-      y: cy + r * sin(theta),
-      color: trinityColor(s.trinity)
-    };
-  });
-  // SVG elements
-  const circles = points.map((p, i) => `
-    <circle cx="${p.x}" cy="${p.y}" r="12" fill="${p.color}" stroke="#fff" stroke-width="2">
-      <title>${p.metaphysical}</title>
-    </circle>
-    <text x="${p.x}" y="${p.y - 18}" text-anchor="middle" font-size="10" fill="#fff">${p.piDigit}</text>
-    <text x="${p.x}" y="${p.y + 18}" text-anchor="middle" font-size="10" fill="#ff8">${p.rodinPosition}</text>
-  `).join('');
-  // Path for the spiral
-  const pathD = points.map((p, i) => (i === 0 ? `M${p.x},${p.y}` : `L${p.x},${p.y}`)).join(' ');
-  return `
-    <svg width="${width}" height="${height}" style="background:#111;border-radius:16px;">
-      <path d="${pathD}" fill="none" stroke="#0ff" stroke-width="2" />
-      ${circles}
-      <text x="${cx}" y="36" text-anchor="middle" font-size="18" fill="#8ff">π as Living Trinity in Rodin Coil</text>
-    </svg>
-  `;
-}