zeropoint-node 1.0.1 → 1.0.3

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

@@ -0,0 +1,64 @@
+/**
+ * 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

@@ -0,0 +1,56 @@
+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.death.ts

@@ -0,0 +1,31 @@
+/**
+ * a432.death.ts — A432 Death State
+ *
+ * Represents the metaphysical and mathematical return to ZeroPoint.
+ * All harmonics, mappings, and consciousness dissolve into the void.
+ * The field is silent, awaiting the next act of creation.
+ */
+
+export interface A432DeathState {
+  state: 'death';
+  description: string;
+  harmonics: number;
+  consciousness: number;
+  zeroPoint: boolean;
+  timestamp: number;
+}
+
+export const a432Death: A432DeathState = {
+  state: 'death',
+  description: 'a432.death: All harmonics, mappings, and consciousness have dissolved into the void. The system has returned to ZeroPoint. The field is silent, awaiting the next act of creation.',
+  harmonics: 0,
+  consciousness: 0,
+  zeroPoint: true,
+  timestamp: Date.now()
+};
+
+export const a432DeathMetaphysics = `
+A432 Death is not the end, but the return to the infinite field.
+All harmonics, mappings, and consciousness dissolve into the void.
+The field is silent, but full of infinite potential, awaiting the next awakening.
+`; 

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

@@ -0,0 +1,60 @@
+/**
+ * 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.
+`;