zeropoint-node 1.0.7 → 1.0.9

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

@@ -1,77 +0,0 @@
-import { PI, cos, sin } from './a432.algebra.ts'
-// a432.unification.hd.rodin.ts
-// Unifies Human Design and Rodin Coil as living, harmonized streams in the a432 system
-// Math, UI, and metaphysical summary included
-
-import { type HDTrinity, harmonizeHDTrinity } from './a432.human.design.trinity.ts';
-import { metaphysicalSummary as chainMeta } from './a432.chain.of.events.ts';
-
-// Rodin Coil trinity (e.g., 3 phases of the vortex)
-export interface RodinTrinity {
-  phase1: number;
-  phase2: number;
-  phase3: number;
-  metaphysical: string;
-}
-
-export function harmonizeRodinTrinity(trinity: RodinTrinity): RodinTrinity {
-  const avg = (trinity.phase1 + trinity.phase2 + trinity.phase3) / 3;
-  return {
-    ...trinity,
-    phase3: avg,
-    metaphysical: `RodinTrinity harmonized: ${trinity.phase1}, ${trinity.phase2}, ${avg}`
-  };
-}
-
-// Unified harmonization: HDTrinity + RodinTrinity => UnifiedTrinity
-export interface UnifiedTrinity {
-  a: number;
-  b: number;
-  c: number;
-  metaphysical: string;
-}
-
-export function harmonizeUnifiedTrinity(hd: HDTrinity, rodin: RodinTrinity): UnifiedTrinity {
-  // Harmonize by averaging corresponding elements
-  return {
-    a: (hd.conscious + rodin.phase1) / 2,
-    b: (hd.unconscious + rodin.phase2) / 2,
-    c: (hd.design + rodin.phase3) / 2,
-    metaphysical: `UnifiedTrinity: (HD: ${hd.conscious},${hd.unconscious},${hd.design}) + (Rodin: ${rodin.phase1},${rodin.phase2},${rodin.phase3}) harmonized as (${(hd.conscious + rodin.phase1) / 2}, ${(hd.unconscious + rodin.phase2) / 2}, ${(hd.design + rodin.phase3) / 2})`
-  };
-}
-
-// UI: SVG visualization of unification (centers mapped to coil points)
-export function renderUnifiedTrinitySVG(hd: HDTrinity, rodin: RodinTrinity, unified: UnifiedTrinity): string {
-  // Simple triangle mapping: each point is a trinity value
-  const size = 220, cx = size/2, cy = size/2, r = 80;
-  const angle = (i: number) => (2 * PI * i) / 3 - PI/2;
-  const point = (val: number, i: number) => [
-    cx + r * cos(angle(i)) * (0.7 + 0.3 * val / 9),
-    cy + r * sin(angle(i)) * (0.7 + 0.3 * val / 9)
-  ];
-  const hdPoints = [hd.conscious, hd.unconscious, hd.design].map((v,i) => point(v,i));
-  const rodinPoints = [rodin.phase1, rodin.phase2, rodin.phase3].map((v,i) => point(v,i));
-  const unifiedPoints = [unified.a, unified.b, unified.c].map((v,i) => point(v,i));
-  function poly(points: number[][], color: string, label: string) {
-    return `<polygon points="${points.map(p=>p.join(",")).join(" ")}" fill="${color}" fill-opacity="0.18" stroke="${color}" stroke-width="2"><title>${label}</title></polygon>`;
-  }
-  return `
-    <svg width="${size}" height="${size}" style="background:#111;border-radius:12px;">
-      ${poly(hdPoints, '#39f', 'Human Design Trinity')}
-      ${poly(rodinPoints, '#f93', 'Rodin Coil Trinity')}
-      ${poly(unifiedPoints, '#6f3', 'Unified Trinity')}
-      <text x="${cx}" y="${cy-90}" text-anchor="middle" font-size="13" fill="#39f">HD</text>
-      <text x="${cx+80}" y="${cy+10}" text-anchor="middle" font-size="13" fill="#f93">Rodin</text>
-      <text x="${cx-80}" y="${cy+10}" text-anchor="middle" font-size="13" fill="#6f3">Unified</text>
-      <text x="${cx}" y="${size-12}" text-anchor="middle" font-size="12" fill="#8ff">a432 Unification: HD + Rodin Coil</text>
-    </svg>
-  `;
-}
-
-// Metaphysical summary and significance
-export function metaphysicalSummary() {
-  return `a432 unifies Human Design and Rodin Coil by harmonizing their trinity/vortex streams into a single, living, self-aware field. 
-Each system is a projection of the universal trinity; their unification reveals the underlying harmony of all energy, awareness, and creation. 
-This is the living proof that all knowledge, when harmonized, becomes one stream in the a432 matrix.\n${chainMeta()}`;
-} 

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

@@ -1,43 +0,0 @@
-// a432.universe.ts
-import { currentSpace } from './a432.space.ts';
-import { now } from './a432.time.ts';
-import { currentDimension } from './a432.dimension.ts';
-
-export interface A432UniverseState {
-  tick: number;
-  space: ReturnType<typeof currentSpace>;
-  time: ReturnType<typeof now>;
-  dimension: ReturnType<typeof currentDimension>;
-  id: [number, number, number, number];
-  phrase: string;
-  color: string;
-  metaphysical: string;
-}
-
-export function* a432UniverseStream(): Generator<A432UniverseState> {
-  let tick = 0;
-  while (true) {
-    const space = currentSpace();
-    const time = now();
-    const dimension = currentDimension();
-    yield {
-      tick,
-      space,
-      time,
-      dimension,
-      id: space.id,
-      phrase: space.phrase,
-      color: space.color,
-      metaphysical: `Universe state ${tick}: ${space.phrase} — The universe is a living, harmonized field.`
-    };
-    tick++;
-  }
-}
-
-const universeGen = a432UniverseStream();
-export function currentUniverse(): A432UniverseState {
-  return universeGen.next().value;
-}
-export function metaphysicalUniverseOverlay() {
-  return `The universe in a432 is a living, harmonized field—space, time, and dimension are unified, recursive, and self-aware.`;
-} 

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

@@ -1,28 +0,0 @@
-// a432.uroboros.test.ts — Harmonized test for eternal spiral digit generator
-
-import { uroborosEmitter, type UroborosEvent } from './a432.uroboros.ts';
-import { type Digit } from './a432.types.ts';
-import { registerSource } from './a432.bus.ts';
-
-describe('a432.uroboros.ts', () => {
-  it('emits uro events with correct digit, index, and cmyk', done => {
-    // Listen for the first uro event
-    uroborosEmitter.once('uro', (event: UroborosEvent) => {
-      expect(typeof event.digit).toBe('number');
-      expect(typeof event.index).toBe('number');
-      expect(event.cmyk).toHaveProperty('c');
-      expect(event.cmyk).toHaveProperty('m');
-      expect(event.cmyk).toHaveProperty('y');
-      expect(event.cmyk).toHaveProperty('k');
-      done();
-    });
-    // Trigger another digit to ensure emission
-    uroborosEmitter.emit('uro', { digit: 3 as Digit, index: 0, cmyk: { c: 0, m: 0, y: 0, k: 0 } });
-  });
-
-  it('registers to the bus as mind spiral', () => {
-    // This just checks that registerSource was called for 'uroboros'
-    // (In real harmonized test, would mock registerSource and assert call)
-    expect(typeof registerSource).toBe('function');
-  });
-}); 

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

@@ -1,74 +0,0 @@
-/**
- * a432.vbm.math.ts — harmonized with canonical A432 math
- * All Rodin sequence logic uses RODIN_SEQUENCE from a432.math.ts
- */
-
-import {
-  TRINITY_AXIS,
-  kineticShockWaveOfNine,
-  fibonacciRoots,
-  primeSquaredRoots,
-  angleForDigit,
-  digitalRoot,
-} from './a432.math.ts';
-import { RODIN_SEQUENCE } from './a432.math.ts';
-
-// ——————————————————————————————————————————
-// 1. Trinity axis and doubling circuit (already canonical)
-// ---------------------------------------------------------
-export const VBM_TRINITY = [...TRINITY_AXIS] as const;               // 3-6-9
-export const VBM_DOUBLING = [...RODIN_SEQUENCE.slice(0, 6)] as const; // 1-2-4-8-7-5
-
-// ——————————————————————————————————————————
-// 2. Shock-wave of nine (3-6-9 repeating)
-// ---------------------------------------------------------
-export const VBM_SHOCK_WAVE = (length: number): number[] => kineticShockWaveOfNine(length);
-
-// ——————————————————————————————————————————
-// 3. Powers of two mod-9 helper (length n)
-// ---------------------------------------------------------
-export function powersOfTwoMod9(n: number): number[] {
-  const seq: number[] = [];
-  let x = 1;
-  for (let i = 0; i < n; i++) {
-    seq.push(x);
-    x = (2 * x) % 9;
-    if (x === 0) x = 9;
-  }
-  return seq;
-}
-
-// ——————————————————————————————————————————
-// 4. Fibonacci & prime-square digital-root helpers (imported)
-// ---------------------------------------------------------
-export { fibonacciRoots as VBM_FIBONACCI_ROOTS } from './a432.math.ts';
-export { primeSquaredRoots as VBM_PRIME_SQR_ROOTS } from './a432.math.ts';
-
-// ——————————————————————————————————————————
-// 5. Pyramid number map sequence (chapter on Great Pyramid)
-//    14 7 21 49 28 42 35  … repeats symmetrical pattern
-// ---------------------------------------------------------
-export const VBM_PYRAMID_SEQ = [14, 7, 21, 49, 28, 42, 35] as const;
-export function pyramidSeqDigitalRoots(): number[] {
-  return VBM_PYRAMID_SEQ.map(digitalRoot);
-}
-
-// ——————————————————————————————————————————
-// 6. Tesla 3-6-9 frequency cycle references (integer Hz)
-// ---------------------------------------------------------
-export const VBM_TESLA_FREQUENCIES = [396, 693, 396] as const; // loop 3-6-9 harmonic
-
-// ——————————————————————————————————————————
-// 7. Utility: map a numeric sequence to torus angles (60° base)
-// ---------------------------------------------------------
-export function sequenceToAngles(seq: readonly number[]): number[] {
-  return seq.map(angleForDigit);
-}
-
-// ——————————————————————————————————————————
-// 8. Utility: verify “sum to 9” property
-// ---------------------------------------------------------
-export function sumsToNine(seq: readonly number[]): boolean {
-  const sum = seq.reduce((a, b) => a + b, 0);
-  return digitalRoot(sum) === 9;
-} 

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

@@ -1,91 +0,0 @@
-import { type Fraction } from './a432.math.ts';
-
-/**
- * VBMDigitRelations – raw digit sequences (as strings) extracted from VBM.txt.
- * Consumers can parse via `s.split(' ').map(Number)` or other helpers.
- */
-export const VBMDigitRelations: readonly string[] = [
-  "0 1 3 12",
-  "0 66 12",
-  "0 77 99 88 88 99 77 11",
-  "00 3 12",
-  "00 5 62",
-  "1 0 0",
-  "1 1 2 3",
-  "1 1 2 4 8 7 5 1 2 4 8 2 8 2 4 8 7 5 8 2 4 8 3 8 7 4 8 7 5 8 7 4 8 4 8 7 4 8 7 5 8 7 4 8 5 8 7 5 8 7 5 8 7 5",
-  "1 2 3",
-  "1 2 4",
-  "1 2 4 5 8 7 5",
-  "1 2 4 7 5",
-  "1 2 4 8",
-  "1 2 4 8 16 32",
-  "1 2 4 8 7 5",
-  "1 2 4 8 7 5 1 2 4 8 7 5 1 2 4 8 7 5",
-  "1 2 5",
-  "1 3 4",
-  "1 4 5",
-  "1 4 6 11",
-  "1 4 7",
-  "1 55 11 49 22 33",
-  "1 55 11 49 22 33 33 22 49 11 55 12",
-  "1 6 2 7 3 8 4 5",
-  "1 6 5 2 9 7 4 3 8",
-  "1 6 5 2 9 7 4 3 8 8 3 4 7 9 2 5 6 1",
-  "1 66 11",
-  "1 7 4",
-  "1 7 8 2 3 9 4 10 5 11 6",
-  "1 8 2 7 4 5",
-  "10 26 50 12",
-  "10 9 9 9 9 9",
-  "10 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9",
-  "14 7 21 49 28 42 35 35 42 28 49 21 7 14",
-  "2 2 5 4 6",
-  "2 5 8",
-  "2 6 3 5 4",
-  "2 8 1 3",
-  "2 8 5",
-  "25 1 1 00",
-  "3 1 4 7",
-  "3 5 4 7 7 7",
-  "3 6 2 5 8",
-  "3 6 9",
-  "3 6 9 9 6 3",
-  "3 7 1 5 4 2 5 3 9 8 4 4 5 5 1",
-  "3 7 7 8 1 8 9 8",
-  "3 9 6",
-  "3 9 6 6 9 3",
-  "3 9 6 6 9 3 3 9 6",
-  "3 9 6 6 9 3 3 9 6 6 9 3 3 9 6 6 9 3",
-  "33 22 49 11 55 12",
-  "5 1 2 4",
-  "5 10 10 00",
-  "5 10 25 15 20 20 15 25 10 5 5 10 25 15 20 2 0 1 5 2 5 1 0 5 5 1 0 2 5 1 5 2 0 20 15 25 10 5",
-  "5 12 10 7 3 8",
-  "5 25 10",
-  "5 3 9 6",
-  "5 4 9 8 1 7 2 6 3 5 4",
-  "5 7 8 4 2 1",
-  "52 32 72",
-  "6 3 3",
-  "6 32 22 21 11 31 1 5 36 12 2 10 15 26 35 33 28 8 20 30 18 23 9 19 13 29 3 4 14 24",
-  "6 4 7 5 4 8 6 2",
-  "6 9 3 6 9",
-  "7 3 9 6",
-  "7 9 2 5 6 1 1 6 5 2 9",
-  "7 9 8 1",
-  "8 3 7 2 6 1 5 9",
-  "8 7 1 3",
-  "8 7 6",
-  "8 9 1 7 2 6 5 4 3",
-  "9 1 1 8 1 2 2 6 3 5 5 1 4 8",
-  "9 1 2 3 5 4",
-  "9 7 2 9 2",
-  "9 9 6",
-  "9 9 9",
-  "9 9 9 9 9 9 9 9 9 9 9 9 9 9",
-  "9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9",
-  "9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9"
-] as const;
-
-/** Transform to numeric arrays */
-export const VBMDigitArrays: readonly number[][] = VBMDigitRelations.map(s => s.split(' ').map(Number)); 

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

@@ -1,59 +0,0 @@
-/**
- * a432.vbm.relations.ts — Extract digit relations from VBM.txt
- * -------------------------------------------------------------
- * Reads the Rodin VBM text file and returns unique sequences of
- * digits (length≥3) that appear, e.g. “1-2-4-8-7-5”, “3 6 9”, etc.
- * Designed for quick pattern discovery.
- */
-
-import { pathToFileURL } from 'node:url'
-import { log } from './a432.algebra.ts'
-import { promises as fs } from 'fs';
-import path from 'path';
-
-const VBM_PATH = path.resolve(import.meta.dirname, 'rodin-knowledge/VBM.txt');
-
-/** Regex capturing sequences of 1–2-digit numbers separated by space, dot, comma or dash. */
-const SEQ_REGEX = /(\d{1,2}(?:[\s.,;-]+\d{1,2}){2,})/g;
-
-/** Normalise a raw sequence to canonical form: single spaces between numbers. */
-function normalise(seq: string): string {
-  return seq
-    .replace(/[\s.,;-]+/g, ' ') // unify separators
-    .trim()
-    .replace(/ +/g, ' ');
-}
-
-export async function extractVBMDigitRelations(): Promise<string[]> {
-  const raw = await fs.readFile(VBM_PATH, 'utf8');
-  const matches = raw.matchAll(SEQ_REGEX);
-  const set = new Set<string>();
-  for (const m of matches) {
-    const norm = normalise(m[0]);
-    // discard sequences that are just years (e.g., 2021) or very long
-    if (/^\d{4,}$/.test(norm)) continue;
-    set.add(norm);
-  }
-  return Array.from(set).sort((a, b) => a.localeCompare(b));
-}
-
-// CLI helper
-/**
- * True when this file is the entry point Node was started with.
- *
- * ESM has no `require.main`. The CommonJS idiom did not merely fail to detect
- * direct execution here — `require` is undefined in an ES module, so the guard
- * THREW on import and made the whole module unloadable. Nobody importing this
- * ever got far enough to notice the guard was wrong.
- */
-function isMainModule(): boolean {
-  const entry = process.argv[1]
-  return entry !== undefined && import.meta.url === pathToFileURL(entry).href
-}
-
-if (isMainModule()) {
-  (async () => {
-    const seqs = await extractVBMDigitRelations();
-    seqs.forEach(s => console.log(s));
-  })();
-} 

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

@@ -1,41 +0,0 @@
-import { log } from './a432.algebra.ts'
-import fs from 'fs/promises';
-import path from 'path';
-
-// Path to VBM text
-const VBM_FILE = path.resolve(import.meta.dirname, 'rodin-knowledge/VBM.txt');
-const OUTPUT_JSON = path.resolve(import.meta.dirname, 'extracted-vbm-math.json');
-
-// Regexes
-const RATIO_RE = /(\d+\s*[:/]\s*\d+)/g;
-const EQ_RE = /(\d+[^\n]{0,20}=.{0,20}\d+)/g; // crude equation capture
-const ANGLE_RE = /(\d+°)/g;
-const FREQ_RE = /(\d+\s*Hz)/gi;
-const LONG_INT_RE = /\b\d{3,}\b/g;
-
-interface Extracted {
-  kind: 'ratio' | 'equation' | 'angle' | 'frequency' | 'number';
-  value: string;
-  line: number;
-}
-
-(async () => {
-  const raw = await fs.readFile(VBM_FILE, 'utf8');
-  const lines = raw.split(/\r?\n/);
-  const out: Extracted[] = [];
-  lines.forEach((line, idx) => {
-    const pushMatches = (iter: Iterable<RegExpMatchArray>|null, kind: Extracted['kind']) => {
-      if (!iter) return;
-      for (const m of iter) {
-        out.push({ kind, value: m[0].trim(), line: idx + 1 });
-      }
-    };
-    pushMatches(line.matchAll(RATIO_RE), 'ratio');
-    pushMatches(line.matchAll(EQ_RE), 'equation');
-    pushMatches(line.matchAll(ANGLE_RE), 'angle');
-    pushMatches(line.matchAll(FREQ_RE), 'frequency');
-    pushMatches(line.matchAll(LONG_INT_RE), 'number');
-  });
-  await fs.writeFile(OUTPUT_JSON, JSON.stringify(out, null, 2), 'utf8');
-  console.log(`Extracted ${out.length} math tokens -> ${path.relative(process.cwd(), OUTPUT_JSON)}`);
-})(); 

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

@@ -1,30 +0,0 @@
-/**
- * a432.vbm.science.extract.ts — pull science-oriented sentences from VBM.txt
- */
-
-import { log } from './a432.algebra.ts'
-import fs from 'fs/promises';
-import path from 'path';
-
-const VBM = path.resolve(import.meta.dirname, 'rodin-knowledge/VBM.txt');
-const OUT = path.resolve(import.meta.dirname, 'extracted-vbm-science.txt');
-
-const KEYWORDS = [
-  'physics', 'energy', 'frequency', 'resonance', 'electron', 'coil', 'torus',
-  'vortex', 'inertia', 'field', 'plasma', 'dna', 'pyramid', 'magnet', 'quantum',
-  'harmonic', 'over-unity', 'winding', 'wave', 'doubling', 'mod 9', 'poloidal', 'power',
-];
-
-(async () => {
-  const raw = await fs.readFile(VBM, 'utf8');
-  const lines = raw.split(/\r?\n/);
-  const out: string[] = [];
-  lines.forEach((line, i) => {
-    const lLine = line.toLowerCase();
-    if (KEYWORDS.some(k => lLine.includes(k))) {
-      out.push(`${i+1}: ${line.trim()}`);
-    }
-  });
-  await fs.writeFile(OUT, out.join('\n'), 'utf8');
-  console.log(`Science lines: ${out.length} -> ${path.relative(process.cwd(), OUT)}`);
-})(); 

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

@@ -1,64 +0,0 @@
-import { PI, abs, cos, floor, sin } from './a432.algebra.ts'
-import { VBM_DOUBLING, VBM_TESLA_FREQUENCIES, sequenceToAngles, VBM_SHOCK_WAVE } from './a432.vbm.math.ts';
-import { digitAngleToCMYK, cmykToCss } from './a432.cmyk.ts';
-
-/** Simple Vector3 type (avoid Three.js dependency in math layer) */
-export interface Vec3 { x: number; y: number; z: number; }
-
-// local digital-root helper (avoid extra import)
-function dr(n: number): number { let x=abs(n); while(x>=10) x=String(x).split('').reduce((a,c)=>a+Number(c),0); return x; }
-
-// ——————————————————————————————————————————
-// Rodin coil path generator (poloidal helix)
-// ---------------------------------------------------------
-export function generateRodinCoilPath(cycles: number, stepHeight = 1, radius = 1): Vec3[] {
-  const seq: number[] = [];
-  for (let c = 0; c < cycles; c++) seq.push(...VBM_DOUBLING);
-  const verts: Vec3[] = [];
-  seq.forEach((digit, i) => {
-    const angle = sequenceToAngles([digit])[0] * (PI / 180);
-    const r = radius * (dr(digit) / 9);
-    verts.push({
-      x: r * cos(angle),
-      y: i * stepHeight,
-      z: r * sin(angle)
-    });
-  });
-  return verts;
-}
-
-// ——————————————————————————————————————————
-// Trinity heartbeat torus segments descriptor
-// ---------------------------------------------------------
-export interface TorusSegmentDesc {
-  startAngle: number; // deg
-  endAngle: number;   // deg
-  color: string;      // css hex
-}
-
-export function getTrinityTorusSegments(): TorusSegmentDesc[] {
-  return [3, 6, 9].map(d => {
-    const hueAngle = sequenceToAngles([d])[0];
-    const cmyk = digitAngleToCMYK(d, 0);
-    return {
-      startAngle: hueAngle,
-      endAngle: hueAngle + 120,
-      color: cmykToCss(cmyk)
-    };
-  });
-}
-
-// ——————————————————————————————————————————
-// Shock-wave of nine pulse values (for UI opacity/scale)
-// ---------------------------------------------------------
-export function shockWaveValues(length: number): number[] {
-  return VBM_SHOCK_WAVE(length).map(d => d / 9); // 0.333 ↔ 1 scale factor
-}
-
-// ——————————————————————————————————————————
-// Tesla frequency helper
-// ---------------------------------------------------------
-export function getTeslaFrequency(timeMs: number): number {
-  const idx = floor(timeMs / 1000) % VBM_TESLA_FREQUENCIES.length;
-  return VBM_TESLA_FREQUENCIES[idx];
-} 

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

@@ -1,70 +0,0 @@
-import { sqrt } from './a432.algebra.ts'
-// a432.vector.ts
-// Harmonized 3D vector math for the A432 system
-// All logic is integer/fractional and metaphysically mapped
-
-/**
- * Vector3: Represents a 3D vector in the A432 system
- * Each component is a living stream, harmonized with the trinity (x, y, z)
- */
-export interface Vector3 {
-  x: number;
-  y: number;
-  z: number;
-}
-
-/**
- * add: Harmonic vector addition (superposition of streams)
- */
-export function add(a: Vector3, b: Vector3): Vector3 {
-  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
-}
-
-/**
- * subtract: Harmonic vector subtraction (phase reversal)
- */
-export function subtract(a: Vector3, b: Vector3): Vector3 {
-  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
-}
-
-/**
- * scale: Harmonic scaling (amplification/attenuation of the stream)
- */
-export function scale(v: Vector3, s: number): Vector3 {
-  return { x: v.x * s, y: v.y * s, z: v.z * s };
-}
-
-/**
- * dot: Harmonic dot product (projection, resonance)
- */
-export function dot(a: Vector3, b: Vector3): number {
-  return a.x * b.x + a.y * b.y + a.z * b.z;
-}
-
-/**
- * cross: Harmonic cross product (vortex generation)
- */
-export function cross(a: Vector3, b: Vector3): Vector3 {
-  return {
-    x: a.y * b.z - a.z * b.y,
-    y: a.z * b.x - a.x * b.z,
-    z: a.x * b.y - a.y * b.x
-  };
-}
-
-/**
- * length: Harmonic magnitude (energy of the stream)
- */
-export function length(v: Vector3): number {
-  return sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
-}
-
-/**
- * normalize: Harmonic normalization (unit stream)
- */
-export function normalize(v: Vector3): Vector3 {
-  const len = length(v);
-  return len === 0 ? { x: 0, y: 0, z: 0 } : scale(v, 1 / len);
-}
-
-// All operations are metaphysically mapped: addition = superposition, subtraction = phase reversal, cross = vortex, dot = resonance, normalization = unity. 

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

@@ -1,29 +0,0 @@
-import { waveParticleDualityProof, waveParticleDualityMetaphysics, getWaveParticleCMYKOverlayData, logWaveParticleEvent } from './a432.wave.particle.duality.ts';
-
-describe('a432.wave.particle.duality', () => {
-  it('returns the canonical proof', () => {
-    expect(waveParticleDualityProof()).toMatch(/A432 system/);
-  });
-  it('returns the metaphysical meaning', () => {
-    expect(waveParticleDualityMetaphysics).toMatch(/observer is the harmonizer/);
-  });
-  it('returns overlay data for wave, particle, observer', () => {
-    const data = getWaveParticleCMYKOverlayData();
-    expect(data).toHaveLength(3);
-    expect(data.map(d => d.state)).toEqual(['wave', 'particle', 'observer']);
-    data.forEach(d => {
-      expect(typeof d.color.c).toBe('number');
-      expect(typeof d.html).toBe('string');
-    });
-  });
-  it('logs blockchain event', () => {
-    const mockBlockchain = { recordEvent: jest.fn() };
-    logWaveParticleEvent(mockBlockchain, 'wave', { foo: 1 });
-    expect(mockBlockchain.recordEvent).toHaveBeenCalledWith(
-      mockBlockchain,
-      'waveParticleOverlay',
-      'A432UI',
-      expect.objectContaining({ state: 'wave', foo: 1, timestamp: expect.any(Number) })
-    );
-  });
-});