zeropoint-node 1.0.6 → 1.0.8

package/CHANGELOG.md

@@ -1,5 +1,154 @@
 # Changelog
 
+## 1.0.8
+
+### Removed — 147 modules the package never reached
+
+- **147 source modules deleted**, 29 959 lines. Every one sat outside LEAN: the
+  fixed point of the module fold, `fold(fold(S)) = fold(S)`, reachable from no
+  package export, no rollup input, no page and no gate-run test. `npm run fold`
+  computes it and `npm run audit:outside` lists what remains with the reason
+  each is kept.
+- Nothing was deleted on the fold alone. Each removal passed a **closure** — the
+  set is closed under reverse dependency, so no surviving module can import a
+  removed one — and a **static trial** that predicts breakage before anything
+  leaves disk. The audit refuses to delete if the trial finds a single edge.
+
+### Added — the entry set is guarded
+
+- **`npm run entries:check`**, in the gate. LEAN is a fixed point, but the fold
+  takes the entry set as an INPUT, and an unrecognised entry does not error — it
+  silently shrinks LEAN and grows the set that looks safe to delete.
+- That is not hypothetical. `rollup.config.js` builds its inputs from template
+  literals, and both scanners extracted them with a pattern that matches quoted
+  strings, so **every bundle entry was being counted as unreachable**. Eight
+  modules were one command from deletion while a published bundle still used
+  them. The check now asserts every declared entry resolves, lands inside LEAN,
+  and that rollup contributes more than zero.
+
+### Fixed — the ratchet's unreachable figure was wrong
+
+- Same root cause: `modules reachable from no entry` had been overstated by 8
+  for as long as the template-literal bug stood. Corrected, and the ceiling
+  moved with it.
+
+### Changed — surfaces after the purge
+
+- `unreachable` 281 → 126, `TypeScript` 146 → 117, `ESLint` 932 → 631,
+  `decimal-crack` 453 → 280. `modules that fail to import` stayed at **0**
+  throughout, which is the measure that mattered: nothing broke.
+- Tarball 1911 → 1764 files.
+
+### Known limitations
+
+- 126 modules remain outside LEAN and are NOT deleted. 59 are named by something
+  live — a manifest, three pages, the generated bundle, the README's module
+  listing, 19 documents — and the other 67 are imported by those 59. Removing
+  them means deciding what the package should still offer, which is a design
+  question rather than a fold.
+- The remaining import cycle is mutual by design; see 1.0.7.
+- Everything under 1.0.7 and earlier still applies — ML-KEM-768 is conformant
+  but **not constant time**, and nothing in `src/thermo` is a device.
+
+## 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.8
 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.8`** · owner `ceccec` · git tag `v1.0.8`
 
 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.8",
   "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,9 @@
     "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",
+    "entries:check": "node --experimental-strip-types scripts/entries-check.mjs",
+    "audit:outside": "node --experimental-strip-types scripts/audit-outside.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",
@@ -165,7 +168,7 @@
     "vortex:svg:check": "node --experimental-strip-types scripts/vortex-svg.mjs --check",
     "bundle:a432": "node scripts/build-a432-bundle.mjs",
     "bundle:a432:check": "node scripts/build-a432-bundle.mjs --check",
-    "check": "npm run version:test && npm run registry:test && npm run version:check && npm run changelog:check && npm run test:kernel && npm run test:security && npm run test:quantum && npm run test:crypto && npm run adjudicate:check && npm run test:verification && npm run math:ban && npm run bundle:a432:check && npm run skills:seal && npm run skills:check && npm run readme && npm run readme:check && npm run docs:pages && npm run docs:pages:check && npm run a432:scan && npm run a432:scan:check && npm run docs:index && npm run docs:index:check && npm run spectrum && npm run spectrum:check && npm run vortex:svg && npm run vortex:svg:check && npm run docs:build && npm run quantum:sim && npm run ratchet:check && npm run mcp:smoke && npm run self:next",
+    "check": "npm run version:test && npm run registry:test && npm run entries:check && npm run version:check && npm run changelog:check && npm run test:kernel && npm run test:security && npm run test:quantum && npm run test:crypto && npm run adjudicate:check && npm run test:verification && npm run math:ban && npm run bundle:a432:check && npm run skills:seal && npm run skills:check && npm run readme && npm run readme:check && npm run docs:pages && npm run docs:pages:check && npm run a432:scan && npm run a432:scan:check && npm run docs:index && npm run docs:index:check && npm run spectrum && npm run spectrum:check && npm run vortex:svg && npm run vortex:svg:check && npm run docs:build && npm run quantum:sim && npm run ratchet:check && npm run mcp:smoke && npm run self:next",
     "prepublishOnly": "npm run build",
     "prose": "node scripts/prose-claims.mjs --list",
     "prose:check": "node scripts/prose-claims.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.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.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.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.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/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();
 }