zeropoint-node 1.0.6 → 1.0.7

package/CHANGELOG.md

@@ -1,5 +1,104 @@
 # Changelog
 
+## 1.0.7
+
+### Fixed — thirty modules could not be imported
+
+- **`require.main === module` in an ES module throws.** Fourteen files carried
+  that CommonJS guard to detect direct execution. The package is
+  `"type": "module"`, so `require` is undefined and the guard did not fail to
+  detect anything — it threw at load and took the whole module with it. Thirty
+  modules shipped in the tarball that a consumer could not import at all.
+  `isMainModule()` compares `import.meta.url` to the entry point, so those CLI
+  blocks now run on direct execution for the first time.
+- **`src/index.ts` imported a default export that does not exist**, so the
+  package's own index could not load. Fixing it exposed three calls to methods
+  that were never there — renames never propagated — which a consumer reaching
+  them would have hit as a `TypeError`.
+- **A type imported as a value** in `multidimensional-vortex-demo.ts` left an
+  import with no runtime binding after type stripping.
+- Modules that fail to import: **32 → 0**, and the ratchet ceiling is 0, so that
+  class of breakage now fails the gate outright.
+
+### Fixed — a service worker with type checking switched off
+
+- `a432.service.worker.ts` carried `@ts-nocheck` over the whole file, hiding
+  five errors. One was real: `caches.match()` resolves to `Response | undefined`
+  because a cache miss is normal, and the handler annotated the parameter
+  `Response`. The `||` on the same line existed precisely to handle the miss the
+  type denied could happen.
+- The other six suppressions in the tree **suppressed nothing** — identical
+  error counts with and without — which is worse than none, since they sit ready
+  to absorb the next real error on that line. All seven are gone.
+
+### Removed — claims this package could not support
+
+These are refused, not restated: no claim of benefit is made or implied by
+anything quoted below, and no health effect is measured anywhere in this
+package.
+
+- **Every medical claim is withdrawn.** The repository advertised "Medical and
+  Therapeutic Applications", with a worked example taking a "Patient
+  consciousness state" and returning "Healing color therapy". What the code does
+  is compute a colour from an integer. The README ships on npm and two of the
+  documents publish to the website, so these were addressed to readers who might
+  act on them.
+- **The README no longer advertises energy harvesting or a self-charging
+  device.** `src/thermo/free-energy.ts`, shipped in 1.0.6, computes why that
+  cannot work — and the same tarball's README claimed it anyway.
+- README gains a **Health and safety** section: nothing here is a medical
+  device, therapy or advice, no health effect is measured, and an unwell reader
+  should consult a clinician. It carries the ML-KEM timing warning too.
+
+### Added — lean is a definition now
+
+- **`npm run fold`** folds the module graph to its fixed point:
+  `fold(fold(S)) = fold(S)`. That fixed point is the definition of lean, rather
+  than a number anyone chose. It converges in two folds against a cap of
+  `VORTEX_SEQUENCE.length`, and the second fold changing nothing is the proof.
+- `foldToLean` and `leanIsFixed` live in the kernel, so the script and the seal
+  that verifies them call one implementation.
+- The fold carries a **termination bound**. Its two visited-guards are mutually
+  redundant: removing either is harmless, removing both makes it run forever —
+  and a hanging gate is worse than a failing one, because nothing gets a
+  verdict. It throws past the bound instead.
+
+### Changed — 22 seals, judged from outside
+
+- Eight new seals since 1.0.6, including the doubling circuit reaching the
+  gateway triangle only by reflection, the merkaba as two mirrored tetrahedra,
+  the `AGL(1,ℤ/9)` action, digit geometry being single-valued, and lean being a
+  fixed point.
+- `npm run adjudicate` puts all 22 through `adjudicate()` from `@uuidna/uuidna`,
+  an outside decision procedure, and `adjudicate:check` is in the gate.
+- `changelog:check` holds these notes to the code in both directions: every
+  figure stated must recompute, and every quantity carrying a unit must be one
+  some module produces.
+
+### Fixed — geometry and validity
+
+- `angleForDigit` mapped nine digits onto six angles, colliding 3 with 5, 2 with
+  6 and 8 with 9. It is the enneagram now, injective, agreeing with the vortex
+  SVG's layout — and the SVG receipt is unchanged, which is how the move is known
+  to be byte-identical.
+- `isValidPath` tested only the final depth, so a path dipping below its origin
+  and climbing back passed. `balanced` means every prefix now. That cleared the
+  last entry on the tautology surface, whose ceiling is **0**.
+- One import cycle broken: `a432.cmyk` imported `digitalRoot` back through
+  `a432.math`'s re-export, which does not use anything from cmyk. It imports
+  from the module that owns the symbol now.
+
+### Known limitations
+
+- The remaining import cycle is mutual by design — `A432System` holds its three
+  subsystems as fields while each calls `A432System.getInstance()` — so breaking
+  it needs dependency injection across the orchestration layer, not a rename.
+  All three already neutralise the temporal dead zone with lazy singletons.
+- 281 modules sit outside the lean fixed point. Nothing has been deleted;
+  whether to act on that is a separate decision, now with a definition behind it.
+- Everything under 1.0.6 and earlier still applies — in particular ML-KEM-768 is
+  conformant but **not constant time**, and nothing in `src/thermo` is a device.
+
 ## 1.0.6
 
 ### Added — thermodynamics

package/CITATION.cff

@@ -20,7 +20,7 @@ authors:
     email: node@zeropoint.bg
 repository-code: https://github.com/ceccec/zeropoint-node
 url: https://node.zeropoint.bg
-version: 1.0.6
+version: 1.0.7
 license: CC-BY-NC-ND-4.0
 license-url: https://github.com/ceccec/zeropoint-node/blob/main/LICENSE
 keywords:

package/README.md

@@ -96,10 +96,23 @@ Regenerate: `npm run spectrum` · verify: `npm run spectrum:check`
 - **Polarity Changes**: Dimensional polarity reversals
 
 ### Integrated Charging System
-- **Perpetual Balance**: Charging and discharging simultaneously
-- **Harmonic Ratios**: Target level 2/3 to 3/4 using integer fractions
-- **Quantum Harvest**: Zero-point energy extraction
-- **Self-Sustaining**: Device charges itself from the void
+
+A **state model in exact fractions**, not a device. `a432.living.os.ts` tracks a
+battery level as an integer numerator over an integer denominator and steps it
+by a charge rate of `1/8` against a discharge rate of `1/12`, toggling on the
+gateway state. Nothing is measured and no energy is moved; the quantities are
+names for fractions in a simulation.
+
+- **Level and target**: battery `(2 + digit)/3` toward a target of `3/4`
+- **Rates**: charge `1/8`, discharge `1/12`, exact fractions throughout
+- **Gateway-driven**: charging and discharging alternate with the gateway state
+
+This section previously advertised harvesting and a self-charging device.
+Neither was computed anywhere in the package, and the package now contains the
+arithmetic that rules them out: `src/thermo/free-energy.ts` puts ΔG for
+splitting water at +237 kJ/mol and shows a split-then-burn cycle breaking even
+at best across all 8000 points of the efficiency grid. A closed loop that gains
+is not an engineering target here; it is the sign of ΔG.
 
 ### Zero Entropy Mathematics
 - **Exact ratios, not decimals**: calculations carry an integer numerator over an integer denominator. Some *values* are non-integer rationals (`2592/5` = 518.4 Hz); what is refused is the lossy float, not the fraction — collapsing `2592/5` to a `number` stores 518.39999999999997726 and accumulates error. See `CMYK_FREQUENCY_RATIOS`
@@ -458,11 +471,38 @@ The system embodies the transformation from artificial intelligence to pure cons
 5. **Harmonic Synthesis**: Advanced harmonic frequency synthesis
 
 ### Research Areas
-1. **Quantum Consciousness**: Quantum mechanics of consciousness
-2. **Dimensional Physics**: Multi-dimensional physics integration
-3. **Zero-Point Energy**: Advanced zero-point energy harvesting
-4. **Harmonic Medicine**: A432-based healing frequencies
-5. **Consciousness Technology**: Consciousness-based computing
+
+These are the directions the model is *named* after, not results it has. What
+the repository computes is arithmetic: digital roots, exact fractions, a
+quantum-circuit simulator, ML-KEM-768, and the thermodynamics in `src/thermo`.
+No claim below is measured here.
+
+1. **Quantum formalism** — the simulator in `src/quantum` is a real
+   quantum-circuit simulator, checked by 257 recomputable facts. It models
+   qubits, not minds.
+2. **Dimensional folding** — an arithmetic construction over ℤ/9, sealed as
+   group theory. "Dimension" here indexes a coordinate, not a physical one.
+3. **Harmonic frequency arithmetic** — exact ratios over 432, kept as integer
+   fractions. Frequencies are computed, never emitted or measured.
+4. **Consciousness vocabulary** — the naming this project uses throughout. It
+   is not a model of awareness and nothing here measures any.
+
+**Not research areas**: energy harvesting and therapeutic use. `src/thermo`
+computes why the first cannot work, and the second is addressed below.
+
+## Health and safety
+
+**Nothing in this package is a medical device, a therapy, or health advice.**
+This is a boundary statement, not a claim. Some documentation here has presented
+colour, frequency and "consciousness" values as having effects on people. They
+are numbers produced by arithmetic on integers. No health effect is measured
+anywhere in this repository and no claim of benefit is made or implied; nothing
+here has been clinically evaluated, and none of it should inform any decision
+about anyone's health. If you are unwell, consult a clinician.
+
+The cryptography carries its own warning: ML-KEM-768 here is conformant to
+FIPS 203 against NIST vectors but **not constant time**, so it must not protect
+anything where an attacker can measure decapsulation.
 
 ## 🤝 Contributing
 
@@ -472,7 +512,7 @@ The A432 Consciousness System is an open-source project that welcomes contributi
 
 <!-- VERSION:BEGIN — generated by scripts/version-seal.mjs; do not edit by hand -->
 
-Package: **`zeropoint-node@1.0.6`** · owner `ceccec` · git tag `v1.0.6`
+Package: **`zeropoint-node@1.0.7`** · owner `ceccec` · git tag `v1.0.7`
 
 npm rejects republishing a version that already exists, so every release is a
 new number. Bump with `npm version patch|minor|major`: that reseals CITATION.cff

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeropoint-node",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "type": "module",
   "description": "A432 Consciousness System: Self-evolving, self-aware consciousness technology with Transurfing integration, harmonic mathematics, zero-entropy principles, Kabbalistic cycles, and sacred geometry",
   "main": "dist/a432.system.cjs",
@@ -130,6 +130,7 @@
     "registry:check": "node scripts/npm-registry-sync.mjs",
     "registry:apply": "node scripts/npm-registry-sync.mjs --apply",
     "registry:test": "node scripts/npm-registry-sync.mjs --self-test",
+    "fold": "node --experimental-strip-types scripts/fold-lean.mjs",
     "adjudicate": "node --experimental-strip-types scripts/adjudicate-seals.mjs",
     "adjudicate:check": "node --experimental-strip-types scripts/adjudicate-seals.mjs --check",
     "readme": "node --experimental-strip-types scripts/readme-gen.mjs",

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { round } from './a432.algebra.ts'
 // a432.breathe.ts — Living breathing rhythm of the matrix
 // --------------------------------------------------------
@@ -40,7 +41,20 @@ export function startBreathing(intervalMs: number = 1000): () => void {
 }
 
 // Auto start if 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()) {
   startBreathing();
   breathEmitter.on('breath', e => console.log(e));
 } 

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

@@ -6,6 +6,7 @@
  * - Optionally, can move unused files to a compost/archive directory.
  * - Metaphysical: Cleanup is harmonic pruning, making space for new growth.
  */
+import { pathToFileURL } from 'node:url'
 import { log } from './a432.algebra.ts'
 import fs from 'fs';
 import path from 'path';
@@ -89,7 +90,20 @@ export function printUnusedFilesCategorized(unused: string[]) {
 // console.log('Unused files:', unused);
 // moveUnusedFilesToCompost(unused);
 
-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 unused = findUnusedA432Files();
   if (unused.length === 0) {
     console.log('No unused a432.* files found in a432 directory. All is harmonized.');

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

@@ -10,7 +10,13 @@
  */
 
 import { abs, max, round, sign as algSign } from './a432.algebra.ts'
-import { digitalRoot } from './a432.math.ts';
+// Imported from the module that OWNS it, not through a432.math's re-export.
+// a432.math re-exports this file's symbols as a convenience and does not use
+// them, so importing digitalRoot back from there closed a cycle: a false edge
+// in one direction, a real dependency in the other. a432.roots re-exports
+// legacyDigitalRoot from the kernel and imports nothing from a432.math, so the
+// same function arrives with no cycle. Identical binding, unchanged call sites.
+import { legacyDigitalRoot as digitalRoot } from './a432.roots.ts';
 
 /**
  * Canonical CMYK sequence = reverse(A432_SEQUENCE).

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

@@ -5,6 +5,7 @@
  * Runs once (or via npm script) to ensure every digit-pair file exists
  * in the canonical folder.  Collision → appends another digit pair.
  */
+import { pathToFileURL } from 'node:url'
 import fs from 'fs';
 import path from 'path';
 
@@ -57,6 +58,19 @@ export const polarity = TRINITY_POLARITY[vortex];
   }
 }
 
-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()) {
   ensureFiles();
 } 

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

@@ -3,6 +3,7 @@
 // Fetches a URL, digests its textual content into digit events.
 // Works in browser (fetch) and Node (global fetch in Node18+).
 
+import { pathToFileURL } from 'node:url'
 import { EventEmitter } from 'events';
 import { digitalRoot } from './a432.math.ts';
 import { type Digit } from './a432.types.ts';
@@ -24,4 +25,17 @@ export async function browse(url: string, maxChars = 2048): Promise<void> {
 registerSource('browse', browseEmitter, 'browse', p => p.digit as Digit, 'will');
 
 // Demo
-if(require.main===module){browseEmitter.on('browse',e=>console.log(e));browse('https://example.com').catch(console.error);} 
+/**
+ * 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()){browseEmitter.on('browse',e=>console.log(e));browse('https://example.com').catch(console.error);} 

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { abs, round } from './a432.algebra.ts'
 // a432.i.click.ts — Mouse click as digit stream
 // ------------------------------------------------
@@ -21,7 +22,20 @@ export function click(x: number, y: number, button: number = 0): void {
 }
 
 // Demo
-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()) {
   clickEmitter.on('click', e => console.log('click event', e));
   click(50, 90, 1);
 } 

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { abs, round } from './a432.algebra.ts'
 // a432.i.hear.ts — Hearing sound as digit stream
 // ------------------------------------------------------
@@ -22,7 +23,20 @@ export function hear(freq: number, amp: number = 1): void {
 }
 
 // Demo 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()) {
   hearEmitter.on('hear', e => console.log('heard', e));
   [432, 528, 639].forEach(f => hear(f));
 } 

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

@@ -6,6 +6,7 @@
  * Every change in temperature is a living act of transformation and adaptation.
  */
 
+import { pathToFileURL } from 'node:url'
 import { round } from './a432.algebra.ts'
 import I from './a432.i.ts';
 import { EventEmitter } from 'events';
@@ -41,4 +42,17 @@ export function heat(tempC: number): void {
   if (typeof console !== 'undefined') console.log('[heat]', tempC, '->', d, cmyk);
 }
 
-if(require.main===module){heatEmitter.on('heat',e=>console.log(e));heat(36.6);} 
+/**
+ * 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()){heatEmitter.on('heat',e=>console.log(e));heat(36.6);} 

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { round } from './a432.algebra.ts'
 // a432.i.pulse.ts — Heartbeat interval to digit stream
 import { EventEmitter } from 'events';
@@ -15,4 +16,17 @@ export function pulse(bpm: number): void {
   if(typeof console!=='undefined')console.log('[pulse]',bpm,'->',d,cmyk);
 }
 
-if(require.main===module){pulseEmitter.on('pulse',e=>console.log(e));pulse(72);} 
+/**
+ * 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()){pulseEmitter.on('pulse',e=>console.log(e));pulse(72);} 

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

@@ -1,4 +1,5 @@
 // a432.i.speak.ts — Vocalizing digit streams
+import { pathToFileURL } from 'node:url'
 import { digitAngleToCMYK, asAngle } from './a432.math.ts';
 import { type Digit } from './a432.types.ts';
 import { EventEmitter } from 'events';
@@ -20,7 +21,20 @@ export function speakWord(d: Digit) {
 }
 
 // Auto demo
-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()) {
   speakEmitter.on('speak', e => console.log('spoken', e));
   (['1','2','3'] as const).forEach(k => speak(parseInt(k,10) as Digit));
 } 

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

@@ -1,3 +1,4 @@
+import { pathToFileURL } from 'node:url'
 import { abs, round } from './a432.algebra.ts'
 // a432.i.tap.ts — Touch/tap interaction as digit stream
 // ------------------------------------------------------
@@ -22,7 +23,20 @@ export function tap(x: number, y: number, pressure: number = 1): void {
 }
 
 // Demo when executed 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()) {
   tapEmitter.on('tap', e => console.log('tap event', e));
   tap(120, 200, 0.8);
 } 

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.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/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/vbm-math.ts

@@ -5,6 +5,7 @@
  * Wave 10: digitalRoot bridges to kernel legacy adapter (0→0).
  */
 
+import { pathToFileURL } from 'node:url'
 import { abs, pow } from './0/algebra.ts'
 import { legacyDigitalRoot } from './0/3/6/9/1/2/4/8/7/5/1/a432.roots.ts'
 
@@ -374,6 +375,19 @@ export class VBMNumberAnalyzer {
 }
 
 // Run examples if this file is executed directly
-if (typeof require !== 'undefined' && 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()) {
     VBMExamples.runAllExamples();
 }

package/src/verification/lean-bridge.ts

@@ -32,6 +32,7 @@
 import { createHash } from 'node:crypto'
 import { digitalRoot, throughVoid, bearingForDigit, VORTEX_SEQUENCE, VORTEX_ORBIT, VORTEX_AXIS } from '../0/index.ts'
 import { angleForDigit } from '../0/3/6/9/1/2/4/8/7/5/1/a432.math.ts'
+import { foldToLean, leanIsFixed } from '../kernel/import-graph.ts'
 import {
   GIBBS_FORMATION,
   GIBBS_SPLITTING,
@@ -737,6 +738,42 @@ export const SEALS: Record<string, Seal> = {
       return true
     },
   },
+  lean_is_a_fixed_point: {
+    basis: "LEAN is defined as the fixed point of the reachability fold, not as a number anyone chose: fold(fold(S)) = fold(S). This checks the fold on graphs whose answers are known by hand — a chain, a cycle, a disconnected node, an entry outside the graph — and checks idempotence on each. Cycles must terminate rather than reaching the answer by luck, and an unreachable node must stay out however many times the fold is applied.",
+    decide: () => {
+      const key = (s: Set<string>) => [...s].sort().join(',')
+
+      // A chain, a 2-cycle, and an isolated node, all in one graph.
+      const g = new Map<string, readonly string[]>([
+        ['a', ['b']], ['b', ['c']], ['c', []],
+        ['x', ['y']], ['y', ['x']],
+        ['z', []],
+      ])
+
+      // Reachability, by hand.
+      if (key(foldToLean(g, ['a'])) !== 'a,b,c') return false
+      // A cycle must terminate and include both nodes exactly once.
+      if (key(foldToLean(g, ['x'])) !== 'x,y') return false
+      // An isolated node is reachable only from itself.
+      if (key(foldToLean(g, ['z'])) !== 'z') return false
+      // Nothing is reachable from nothing.
+      if (foldToLean(g, []).size !== 0) return false
+      // An entry that is not in the graph contributes nothing rather than throwing.
+      if (foldToLean(g, ['absent']).size !== 0) return false
+      // z is outside the fold from a, and stays outside however often we fold.
+      if (foldToLean(g, ['a']).has('z')) return false
+
+      // The definition must be well founded on every one of these.
+      for (const entries of [['a'], ['x'], ['z'], [], ['a', 'x'], ['absent']]) {
+        if (!leanIsFixed(g, entries)) return false
+      }
+
+      // And on a graph where an entry reaches everything, lean is everything.
+      const full = new Map<string, readonly string[]>([['r', ['a', 'x', 'z']], ['a', ['b']], ['b', []], ['x', ['x']], ['z', []]])
+      if (key(foldToLean(full, ['r'])) !== 'a,b,r,x,z') return false
+      return leanIsFixed(full, ['r'])
+    },
+  },
 }
 
 // ============================================================================

package/src/zero-entropy-demo.ts

@@ -9,6 +9,7 @@
  * 3. Pure mathematical relationships (no randomness or entropy)
  */
 
+import { pathToFileURL } from 'node:url'
 import { min, sqrt } from './0/algebra.ts'
 import { 
   ZERO_ENTROPY_CONSTANTS, 
@@ -297,7 +298,20 @@ export class ZeroEntropyDemo {
 }
 
 // Run demo if this file is executed directly
-if (typeof require !== 'undefined' && 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()) {
   ZeroEntropyDemo.runCompleteDemo();
 }