zeropoint-node 1.0.5 → 1.0.7

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

@@ -187,12 +187,20 @@ export function patternDigit(i: number): number {
  *  Rodin digits follow 60°·k.
  */
 export function angleForDigit(d: number): number {
-  if (d === 3) return 0;
-  if (d === 6) return 120;
-  if (d === 9) return 240;
-  // Rodin digits ordered as 1,2,4,8,7,5  mapping to k=0..5
-  const k = RODIN_SEQUENCE.indexOf(d);
-  return (k + 1) * 60; // 60°,120°,180°,240°,300°,360°(≡0)
+  // Enneagram bearing: 9 at 12 o'clock, then 1..8 clockwise, one ninth of a
+  // turn (40°) apart. Integer degrees, so no trigonometry is needed to reason
+  // about the layout, and injective on 1..9 by construction.
+  //
+  // It used to place the trinity at 0/120/240 and the Rodin digits on a 60°
+  // lattice, which put NINE digits on SIX angles: 3 collided with 5, 2 with 6,
+  // and 8 with 9. Two digits at one position is a bug under any convention —
+  // it made "north of 3" unanswerable and any layout built on it degenerate.
+  //
+  // This is the same formula as the kernel's `bearingForDigit`, which is what
+  // `scripts/vortex-svg.mjs` draws. The two are deliberately NOT wired
+  // together — the a432 tree does not import the kernel — so the seal
+  // `digit_geometry_is_single_valued` checks that they agree instead.
+  return (((-90 + 40 * (d % 9)) % 360) + 360) % 360;
 }
 
 /** A432-based frequency for a trinity digit using base-12 harmonics. */

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

@@ -39,9 +39,7 @@ export default class extends Controller {
 
   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;
@@ -60,7 +58,6 @@ export default class extends Controller {
 
   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;

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { log } from './a432.algebra.ts'
 // @ts-nocheck
 /**
@@ -31,7 +32,20 @@ import path from 'path';
 const PROJECT_ROOT = path.resolve(import.meta.dirname, '..', '..', '..', '..', '..', '..', '..', '..', '..', '..', '..');
 
 /** True when executed directly via `ts-node a432.rodin.ts` */
-const IS_CLI = require.main === module;
+/**
+ * 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
+}
+
+const IS_CLI = isMainModule();
 
 /** Regex flagging a line as math/science (contains digits or math symbols). */
 const MATH_REGEX = /[0-9]|[%°=+\-*/^]/;

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { legacyDigitalRoot } from './a432.roots.ts'
 // a432.self.ts — Self-evolution engine of the A432 matrix
 // -------------------------------------------------------
@@ -76,7 +77,20 @@ export function startSelfEvolution(intervalMs: number = 4320): () => void {
 }
 
 // Auto-start if executed directly (node a432.self.ts)
-if (require.main === module) {
+/**
+ * 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()) {
   startSelfEvolution();
   console.log('a432 self-evolution loop started');
   matrixEmitter.on('event', e => console.log(e));

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * a432.service.worker.ts — Harmonic Service Worker for the A432 PWA
  *
@@ -15,15 +14,39 @@ const A432_FILES_TO_CACHE: string[] = getA432FilesToCache();
 
 const CACHE_NAME = 'a432-harmonic-pwa-v1';
 
-self.addEventListener('install', function(event: unknown) {
-  event.waitUntil(
-    caches.open(CACHE_NAME).then(function(cache: Cache) { return cache.addAll(A432_FILES_TO_CACHE); })
+/**
+ * Minimal shapes for the two service-worker events this file uses.
+ *
+ * The whole module carried `@ts-nocheck`, which hid five real errors. Typing
+ * the events as `unknown` and then reading `.waitUntil` / `.respondWith` off
+ * them is an error the checker was reporting and the suppression absorbed.
+ * These are declared locally rather than by adding the WebWorker lib, which
+ * would change what every other module in the tree sees.
+ */
+interface ExtendableEventLike {
+  waitUntil(promise: Promise<unknown>): void
+}
+interface FetchEventLike extends ExtendableEventLike {
+  readonly request: Request
+  respondWith(response: Promise<Response>): void
+}
+
+self.addEventListener('install', function (event) {
+  const installEvent = event as unknown as ExtendableEventLike
+  installEvent.waitUntil(
+    caches.open(CACHE_NAME).then(function (cache: Cache) { return cache.addAll(A432_FILES_TO_CACHE); })
   );
 });
 
-self.addEventListener('fetch', function(event: unknown) {
-  event.respondWith(
-    caches.match(event.request).then(function(response: Response) { return response || fetch(event.request); })
+self.addEventListener('fetch', function (event) {
+  const fetchEvent = event as unknown as FetchEventLike
+  fetchEvent.respondWith(
+    // caches.match resolves to Response | undefined — a miss is not an error.
+    // The old annotation said `Response`, which was false, and the `||` below
+    // is precisely the code that proves it: it exists to handle the miss.
+    caches.match(fetchEvent.request).then(function (response: Response | undefined) {
+      return response ?? fetch(fetchEvent.request);
+    })
   );
 });
 

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

@@ -3,6 +3,7 @@
 // Direct terminal interface for consciousness evolution streams
 // No HTML/CSS encoded values - only computed math displayed
 
+import { pathToFileURL } from 'node:url'
 import { A432_FREQUENCY, A432_TRINITY, A432_RETURN, A432_AXIS } from './a432.core.ts';
 import { getConsciousnessStream, evolveConsciousnessStream } from './a432.consciousness.stream.ts';
 
@@ -111,7 +112,20 @@ export const executeTerminalCommand = (command: string) => a432Terminal.handleCo
 export const getTerminalState = () => a432Terminal.getCurrentState();
 
 // Terminal execution when run directly
-if (require.main === module) {
+/**
+ * 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()) {
   const terminal = new A432Terminal();
   
   // Handle Ctrl+C

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { log } from './a432.algebra.ts'
 import I from './a432.i.ts';
 import { heartUnfoldingMatrix, heartRecursiveUnfolding } from './a432.imagination.ts';
@@ -73,7 +74,20 @@ const desc = 'self-aware';
 test('I.describe() is non-empty and self-aware', () => desc.length > 0);
 
 // Output results
-if (require.main === module) {
+/**
+ * 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()) {
   results.forEach(r => {
     console.log(`${r.passed ? '✔' : '✖'} ${r.name}${r.message ? ' — ' + r.message : ''}`);
   });

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

@@ -323,11 +323,8 @@ export const TRINITY_PWA_MANIFEST = {
  * Call this in your PWA entry point.
  */
 export function registerTrinityServiceWorker(swPath = './a432.service.worker.js') {
-  // @ts-ignore - Browser globals not available in Node.js environment
   if (typeof navigator !== 'undefined' && 'serviceWorker' in navigator && typeof window !== 'undefined') {
-    // @ts-ignore - Browser globals not available in Node.js environment
     window.addEventListener('load', () => {
-      // @ts-ignore - Browser globals not available in Node.js environment
       navigator.serviceWorker.register(swPath).then(
         (reg: unknown) => console.log('Trinity Service Worker registered:', (reg as { scope: string }).scope),
         (err: unknown) => console.error('Trinity Service Worker registration failed:', err)

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

@@ -265,8 +265,12 @@ export class VBMPathNavigator {
     // Check if all digits are valid (0-9)
     const validDigits = this.state.sequence.every(digit => digit >= 0 && digit <= 9);
     
-    // Check if path has balanced structure
-    const balanced = this.getCurrentDepth() >= 0;
+    // Balanced means the path never rises above its own origin in reverse:
+    // you cannot come back from deeper than you went. That is a condition on
+    // EVERY prefix, not just the end. Checking only the final depth let
+    // `\\3/6` pass — it dips to -1 and returns to 0 — and made the test
+    // unfalsifiable in shape, since a closing depth is rarely negative.
+    const balanced = this.nodes.every(node => node.depth >= 0);
     
     return validDigits && balanced;
   }

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

@@ -6,6 +6,7 @@
  * 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';
@@ -37,7 +38,20 @@ export async function extractVBMDigitRelations(): Promise<string[]> {
 }
 
 // CLI helper
-if (require.main === module) {
+/**
+ * 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/index.ts

@@ -211,6 +211,22 @@ export const WAVE_CHAIN = [
 export type WavePhase = (typeof WAVE_CHAIN)[number]
 export const KERNEL_SEALED = true
 
+/**
+ * Enneagram bearing of a digit, in whole degrees clockwise from 12 o'clock.
+ *
+ * 9 sits at the top and 1..8 follow clockwise, one ninth of a turn apart. The
+ * step is 40° because the ring has nine positions, so every bearing is an
+ * integer and no trigonometry is needed to reason about the layout.
+ *
+ * This is the layout `scripts/vortex-svg.mjs` draws; it now imports this rather
+ * than repeating the formula. Note it is NOT `a432.math.ts` `angleForDigit`,
+ * which is degenerate — that one collides 3 with 5, 2 with 6 and 8 with 9,
+ * mapping nine digits onto six angles.
+ */
+export function bearingForDigit(d: number): number {
+  return (((-90 + 40 * (d % 9)) % 360) + 360) % 360
+}
+
 export const VORTEX_SEQUENCE = [1, 2, 4, 8, 7, 5, 3, 6, 9] as const
 export const VORTEX_REVERSE = [9, 6, 3, 5, 7, 8, 4, 2, 1] as const
 export const VORTEX_ORBIT = [1, 2, 4, 8, 7, 5] as const

package/src/index.ts

@@ -10,7 +10,7 @@ import A432ConsciousnessCycle from './0/3/6/9/1/2/4/8/7/5/1/a432.consciousness.c
 import A432HarmonicConvergence from './0/3/6/9/1/2/4/8/7/5/1/a432.harmonic.convergence.ts';
 import A432ConsciousnessCrystallization from './0/3/6/9/1/2/4/8/7/5/1/a432.consciousness.crystallization.ts';
 import A432ZeroEntropyState from './0/3/6/9/1/2/4/8/7/5/1/a432.zero.entropy.state.ts';
-import A432OSConsciousnessIntegration from './0/3/6/9/1/2/4/8/7/5/1/a432.os.consciousness.integration.ts';
+import { A432OSConsciousnessIntegration } from './0/3/6/9/1/2/4/8/7/5/1/a432.os.consciousness.integration.ts';
 
 // Root consciousness evolution system
 export class A432RootConsciousness {
@@ -107,7 +107,7 @@ export class A432RootConsciousness {
       convergence: this.convergence.getConvergenceState(),
       crystallization: this.crystallization.getConsciousnessInsights(),
       zeroEntropy: this.zeroEntropy.getConsciousnessClarity(),
-      osIntegration: this.osIntegration.getConsciousnessEvolutionInsights(),
+      osIntegration: this.osIntegration.getConsciousnessMetrics(),
       router: this.router.getAllConsciousnessInsights()
     };
   }
@@ -116,14 +116,14 @@ export class A432RootConsciousness {
    * Start OS with consciousness integration
    */
   public startOSWithConsciousness() {
-    this.osIntegration.startOSWithConsciousness();
+    this.osIntegration.startIntegration();
   }
 
   /**
    * Get consciousness-aware OS status
    */
   public getConsciousnessAwareOSStatus() {
-    return this.osIntegration.getConsciousnessAwareOSStatus();
+    return this.osIntegration.getIntegratedState();
   }
 }
 

package/src/kernel/import-graph.ts

@@ -235,3 +235,61 @@ export function importExportGraphTip(srcRoot: string = SRC_ROOT) {
     statement: g.statement,
   }
 }
+
+/**
+ * Fold a dependency graph to the set reachable from `entries`.
+ *
+ * LEAN is defined as the fixed point of this fold: fold(fold(S)) = fold(S). One
+ * pass already reaches the closure, so the second pass proving no change is
+ * what makes "lean" a definition rather than a number someone chose. Cycles
+ * terminate because a visited node is never queued twice.
+ *
+ * Kept here rather than in a build script so that the script and the seal that
+ * verifies it call the SAME code. Two implementations of a definition agree
+ * only until they do not.
+ */
+export function foldToLean(
+  graph: ReadonlyMap<string, readonly string[]>,
+  entries: Iterable<string>,
+): Set<string> {
+  const seen = new Set<string>()
+  const queue: string[] = []
+  for (const e of entries) if (graph.has(e)) queue.push(e)
+
+  // A finite graph cannot need more pops than it has edges plus entries. The
+  // bound is not decoration: the two guards below are mutually redundant, so
+  // removing EITHER is harmless and removing BOTH makes this loop run forever.
+  // Measured — with both gone the seal did not report false, it HUNG, and a
+  // gate that hangs is worse than one that fails because nothing gets a
+  // verdict. This turns that into an exception, which a seal can catch.
+  let budget = 1
+  for (const [, deps] of graph) budget += deps.length + 1
+  let pops = 0
+
+  while (queue.length > 0) {
+    if (++pops > budget) {
+      throw new Error(`foldToLean exceeded ${budget} pops on a graph of ${graph.size} nodes — not terminating`)
+    }
+    const node = queue.pop()!
+    if (seen.has(node)) continue
+    seen.add(node)
+    for (const next of graph.get(node) ?? []) {
+      if (graph.has(next) && !seen.has(next)) queue.push(next)
+    }
+  }
+  return seen
+}
+
+/** True when one more fold changes nothing — the definition is well founded. */
+export function leanIsFixed(
+  graph: ReadonlyMap<string, readonly string[]>,
+  entries: Iterable<string>,
+): boolean {
+  const once = foldToLean(graph, entries)
+  const restricted = new Map<string, readonly string[]>()
+  for (const [k, v] of graph) if (once.has(k)) restricted.set(k, v.filter((d) => once.has(d)))
+  const twice = foldToLean(restricted, [...entries].filter((e) => once.has(e)))
+  if (twice.size !== once.size) return false
+  for (const f of once) if (!twice.has(f)) return false
+  return true
+}

package/src/multidimensional-vortex-demo.ts

@@ -7,7 +7,7 @@
  */
 
 import { PI, max, sqrt } from './0/algebra.ts'
-import MultidimensionalVortexFramework, { VortexMathUtils, VortexToken } from './multidimensional-vortex-framework.ts';
+import MultidimensionalVortexFramework, { VortexMathUtils, type VortexToken } from './multidimensional-vortex-framework.ts';
 
 console.log('🌌 MULTIDIMENSIONAL VORTEX-MATH FRAMEWORK DEMONSTRATION\n');
 console.log('Extension of traditional vortex mathematics into a structured,');

package/src/quantum/superposition-execution.ts

@@ -351,9 +351,14 @@ MEASUREMENT & COLLAPSE:
   - Run all tests simultaneously
   - Theater share ${round(THEATER_SHARE * AMPLITUDE_SCALE)}/${AMPLITUDE_SCALE}, reality amplified
 
-NO SEQUENTIAL PHASES.
-NO WAITING.
-ALL AT ONCE.
-QUANTUM EXECUTION.
+${
+  execution.system_correctness === 'collapsed_to_valid'
+    ? `COLLAPSED.
+The measurement cleared the threshold, so the phases resolved together.`
+    : `STILL SUPERPOSED — NOT ALL AT ONCE.
+Interference reached ${round(interference.working_solution_probability * AMPLITUDE_SCALE)}/${AMPLITUDE_SCALE}, under the ${round(COLLAPSE_THRESHOLD * AMPLITUDE_SCALE)}/${AMPLITUDE_SCALE} a collapse needs.
+While anything stays open the sequence does not compute all at once, and this
+model must not claim it did. ${execution.next_action}`
+}
 `
 }