zeropoint-node 1.0.11 → 1.0.12

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # Changelog
 
+## 1.0.12
+
+### Added — the a432 layer has tests
+
+- **198 modules, 35,876 lines, 1,489 exports, and until now no tests at all.**
+  That is why a function named `generateVortex` could return the counting
+  sequence in three separate places without a word. Writing 198 example-based
+  test files would not have caught it: nobody writes an assertion for a function
+  they believe already works, and if they did they would write it from the same
+  wrong belief that produced the bug.
+- So the tests are **properties over every module**, run in 0.55s: every module
+  loads, nullary exports are deterministic, digit sequences hold digits, an
+  empty return is a decision, anything named for the doubling circuit stays in
+  the orbit and advances by doubling, and no two differently-named functions
+  quietly return the same value. A new module is covered the day it appears.
+  Exceptions are declared in `a432.test.json` and a declaration that stops being
+  true fails too.
+- It immediately found two defects. **`getTrinityAxisFromRodin` always returned
+  `[]`** — it filtered the doubling circuit for 3, 6 and 9, which
+  `doubling_avoids_the_triad` proves are never in it, so this was not a search
+  that sometimes failed but one that could not succeed. It reflects through the
+  void now, which is how the theorem says the triad is actually reached.
+  **`getTrinityTriangulationFromRodin` declared a parameter and ignored it**, so
+  every input gave the same answer.
+
+### Added — a census of retyped constants
+
+- A sweep of the other 56 modules found the kernel's constants **retyped 89
+  times across 56 file/constant pairs** — `VORTEX_ORBIT` 37 times,
+  `VORTEX_AXIS` 51 — in `kernel/`, `security/`, the vbm modules and a432. Each
+  copy is somewhere a value the kernel already exports can drift unnoticed.
+- `npm run constants:check` asks this of the whole tree. Not every literal is a
+  defect — default parameters and membership tests are fine — so the answer is a
+  declaration with a reason rather than a ban. **The patterns are derived**: the
+  kernel is imported and the literals to hunt for are built from it at run time,
+  because retyping them in the checker would make it the very thing it checks
+  for. `vbm-math` is bound rather than declared, which took the count from 91
+  to 89.
+
+### Added — versioning explored as an address and a calendar
+
+- The four gateways cut the vortex tour into fields of width **4.3.2.1** — a
+  dotted quad with a descending staircase rather than IPv4's equal octets.
+  Cutting *before* each gateway instead gives five fields, so four is a result
+  and not a choice of where to cut. Compatibility becomes an operation:
+  `^` is a /3 prefix mask and `~` is /6.
+- Read as a calendar those widths are the minimal ones for year, lunation,
+  ISO week and weekday — `2026.095.35.6`. Worth less than it looks, and the
+  test says so: an hour-based reading fits the same widths, so the match
+  constrains without determining.
+- **These are sketches, not this package's versioning.** `package.json` remains
+  the single source. Their self-tests are in the gate because the computed
+  halves guard the kernel stroke.
+
+### Fixed — a calendar drifts like a float
+
+- `version-calendar.mjs` used `Math.floor`, `Math.abs` and the literals
+  `29.530588` and `365.2422` — precisely what this repository bans everywhere
+  else — and passed only because `scripts/` is excluded from `math-ban`. A
+  calendar drifts from the sky for the same reason a float drifts from a ratio.
+  Rewritten in exact scaled integers; the output is byte-identical, so it is
+  exact rather than merely different.
+- `npm run calendar:drift` then measures each calendar as the integer ratio it
+  is, in exact arithmetic. Gregorian tracks the sun an order of magnitude better
+  than any ancient cycle; Hipparchic is the only one whose lunar drift is
+  negative. The constructions are checked as arithmetic, not quoted.
+
+### Known limitations
+
+- Unchanged from 1.0.11: 1.0.0–1.0.3 stay undeprecated pending an npm
+  automation token, 126 modules stay outside LEAN, ML-KEM-768 is conformant but
+  **not constant time**, and nothing in `src/thermo` is a device.
+- The 89 retyped constants are **declared, not fixed**. One file was bound to
+  the kernel as a demonstration; the other 55 pairs are recorded so the next
+  copy cannot arrive unnoticed, which is a smaller claim than having removed
+  them.
+- The mean tropical year and mean synodic month are **observed**, not derived,
+  and both are slowly changing. Exact arithmetic removes drift between the code
+  and its intent; it cannot remove drift between the intent and the sky.
 ## 1.0.11
 
 ### Fixed — a function named vortex that returned the counting sequence

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.11
+version: 1.0.12
 license: CC-BY-NC-ND-4.0
 license-url: https://github.com/ceccec/zeropoint-node/blob/main/LICENSE
 keywords:

package/README.md

@@ -527,7 +527,7 @@ behind it, and no sponsor gets a say in what the checks report.
 
 <!-- VERSION:BEGIN — generated by scripts/version-seal.mjs; do not edit by hand -->
 
-Package: **`zeropoint-node@1.0.11`** · owner `ceccec` · git tag `v1.0.11`
+Package: **`zeropoint-node@1.0.12`** · owner `ceccec` · git tag `v1.0.12`
 
 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.11",
+  "version": "1.0.12",
   "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",
@@ -170,7 +170,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 notes:test && npm run notes:check && 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 pages: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 version:address:test && npm run version:calendar:test && npm run calendar:drift:test && npm run notes:test && npm run notes:check && 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 test:a432 && npm run constants:check && 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 pages: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",
@@ -180,7 +180,17 @@
     "postversion": "echo \"tagged v$npm_package_version — fill in the CHANGELOG entry if it is still a stub, then: git push --follow-tags\"",
     "notes": "node scripts/release-notes.mjs",
     "notes:test": "node scripts/release-notes.test.mjs",
-    "notes:check": "node scripts/release-notes.mjs --check"
+    "notes:check": "node scripts/release-notes.mjs --check",
+    "test:a432": "node --experimental-strip-types src/0/3/6/9/1/2/4/8/7/5/1/a432.test.ts",
+    "test:a432:seed": "node --experimental-strip-types src/0/3/6/9/1/2/4/8/7/5/1/a432.test.ts --seed",
+    "version:address": "node scripts/version-address.mjs",
+    "version:address:test": "node scripts/version-address.mjs --test",
+    "version:calendar": "node scripts/version-calendar.mjs",
+    "version:calendar:test": "node scripts/version-calendar.mjs --test",
+    "calendar:drift": "node scripts/calendar-drift.mjs",
+    "calendar:drift:test": "node scripts/calendar-drift.mjs --test",
+    "constants:check": "node scripts/constants-check.mjs",
+    "constants:seed": "node scripts/constants-check.mjs --seed"
   },
   "keywords": [
     "a432",

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

@@ -0,0 +1,59 @@
+{
+  "browserOnly": {
+    "src/0/3/6/9/1/2/4/8/7/5/1/a432.main.ts": "document is not defined"
+  },
+  "stateful": {
+    "a432.bus.ts:mergedDigit": "returns a different value on a second call with no arguments",
+    "a432.consciousness.stream.ts:evolveConsciousnessStream": "returns a different value on a second call with no arguments",
+    "a432.consciousness.stream.ts:getConsciousnessStream": "returns a different value on a second call with no arguments",
+    "a432.documentation.ts:generateDocumentationIndex": "returns a different value on a second call with no arguments",
+    "a432.experience.ui.ts:createA432ExperienceState": "returns a different value on a second call with no arguments",
+    "a432.experience.ui.ts:harmonizeA432Experience": "returns a different value on a second call with no arguments",
+    "a432.index.ts:exportA432Registry": "returns a different value on a second call with no arguments",
+    "a432.index.ts:getA432RegistryStats": "returns a different value on a second call with no arguments",
+    "a432.living.ui.ts:getLivingUIStatus": "returns a different value on a second call with no arguments",
+    "a432.navigation.ts:getPath": "returns a different value on a second call with no arguments",
+    "a432.navigation.ts:nextSuggestion": "returns a different value on a second call with no arguments",
+    "a432.os.ts:a432OSState": "returns a different value on a second call with no arguments",
+    "a432.os.ts:getA432SystemStatus": "returns a different value on a second call with no arguments",
+    "a432.os.ts:getSystemInfo": "returns a different value on a second call with no arguments",
+    "a432.registry.ts:exportA432Registry": "returns a different value on a second call with no arguments",
+    "a432.registry.ts:getA432RegistryStats": "returns a different value on a second call with no arguments",
+    "a432.stream.vortex.ts:getStreamVortexOverlayData": "returns a different value on a second call with no arguments",
+    "a432.time.ts:now": "returns a different value on a second call with no arguments"
+  },
+  "notDigits": {
+    "a432.mirror.ts:a432PrimeSquaredBases": "returns numbers outside 0..9, so it is not a digit sequence",
+    "a432.pi.ts:piHarmonicStream": "returns numbers outside 0..9, so it is not a digit sequence",
+    "a432.shear.electron.ts:a432NestedVortices": "returns numbers outside 0..9, so it is not a digit sequence",
+    "a432.vbm.audio.ts:getVBMAudioFrequencies": "returns numbers outside 0..9, so it is not a digit sequence",
+    "a432.vbm.visualization.ts:getVBMVisualizationAngles": "returns numbers outside 0..9, so it is not a digit sequence"
+  },
+  "emptyByDesign": {
+    "a432.harmonized.ts:getAllHarmonizationStrategies": "returns an empty array with no arguments",
+    "a432.index.ts:getAllA432Modules": "returns an empty array with no arguments",
+    "a432.matrix.ts:getTrinityIndices": "returns an empty array with no arguments",
+    "a432.navigation.ts:getPath": "returns an empty array with no arguments",
+    "a432.registry.ts:getAllA432Modules": "returns an empty array with no arguments",
+    "a432.ui.session.ts:getSessionHistory": "returns an empty array with no arguments"
+  },
+  "triadByDesign": {
+    "a432.coil.ts:a432VortexWell": "named for the doubling circuit but contains 3, 6 or 9",
+    "a432.trinity.ts:getTrinityAxisFromRodin": "named for the doubling circuit but contains 3, 6 or 9",
+    "a432.trinity.ts:getTrinityTriangulationFromRodin": "named for the doubling circuit but contains 3, 6 or 9"
+  },
+  "sharedValues": {
+    "getDoublingSequence = getRodinSequence": "[1,2,4,8,7,5,1]",
+    "a432ApertureFlow = a432RodinCoil = getOpenDoublingSequence = rodinOrbit = stringTheoryOrbit": "[1,2,4,8,7,5]",
+    "a432DandelionPuff = a432DiamondFacets = generateConsciousness": "[1,2,3,4,5,6,7,8,9]",
+    "a432ClosedSystem = a432ConsciousnessMap = a432RodinCoilStream = a432ToroidalMap": "[1,2,4,8,7,5,1,2,4,8,7,5]",
+    "a432HeatDissipation = a432Palindrome396 = a432SpiritDispersion": "[3,9,6,6,9,3,3,9,6]",
+    "getMetaDescriptions = getRecursiveMetaObservation": "[\"TrinityNavigation: Navigates, observes, and harmonizes the trinity and family streams.\"]",
+    "generateCycle = getVBMAudioSequence = getVBMVisualizationSequence": "[0,3,6,9,1,2,4,8,7,5,1]",
+    "generateVortex = generateVortexSequence": "[1,2,4,8,7,5,1,2,4]",
+    "getTrinityAxis = getTrinityAxisFromRodin = manifestTrinityAxis = stringTheoryAxis": "[3,6,9]",
+    "a432MetaVortex = a432UnifiedMatrix": "{\"trinity\":[3,6,9,3,6,9,3,6,9],\"family\":{\"F1\":[1,2,4,8,7,5,1],\"F2\":[3,9,6,3],\"F3\":[9]},\"nine\":[3,9,6,3,9,6,3,9,6],\"casca…",
+    "a432ElectronShear = a432Shears": "[1,4,7]",
+    "getCurrentNavState = trinityPrev": "{\"step\":1,\"trinity\":3,\"family\":1,\"archetype\":\"Creation\",\"metaphysical\":\"Step 1: Trinity 3 (Creation), Family 1\"}"
+  }
+}

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

@@ -0,0 +1,344 @@
+/**
+ * The a432 layer, tested by property rather than by example.
+ *
+ * 198 modules, 35,876 lines, 1,489 exports, and until this file no tests at
+ * all. That is why a function named generateVortex could return the counting
+ * sequence in THREE separate places and nothing said a word.
+ *
+ * Writing 198 example-based test files would not have caught it. Nobody writes
+ * `expect(generateVortex(9)).toEqual([1,2,4,8,7,5,1,2,4])` for a function they
+ * believe already works — and if they did, they would write the assertion from
+ * the same wrong belief that produced the bug. Every defect found in this layer
+ * was found MECHANICALLY, by running everything and looking for a shape that
+ * cannot be right:
+ *
+ *   - output identical to a differently-named function
+ *   - a "vortex" containing 3, 6 or 9, which doubling provably never reaches
+ *   - a validator returning false about its own data
+ *   - a branch nothing ever executes
+ *
+ * So those are the properties. They run over every module, so a NEW module is
+ * covered the day it appears rather than the day somebody remembers it.
+ *
+ * Exceptions are declared in a432.test.json, seeded from the current state the
+ * way the ratchet records its ceilings. The point is not to relitigate what is
+ * already here; it is that the next one cannot arrive unnoticed. A declaration
+ * that stops being true fails too, so the file cannot rot into a list of
+ * excuses for things that no longer exist.
+ *
+ *   npm run test:a432       run the properties
+ *   npm run test:a432:seed  rewrite the declarations from the current state
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { pathToFileURL } from 'node:url'
+import { VORTEX_ORBIT, VORTEX_AXIS, digitalRoot, vortexStrokeGateways } from '../../../../../../../../../../index.ts'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+/** Walk up to the package root rather than counting ../ eleven times. */
+function packageRoot(from: string): string {
+  let d = from
+  for (;;) {
+    try { statSync(join(d, 'package.json')); return d } catch { /* keep going */ }
+    const up = dirname(d)
+    if (up === d) throw new Error('no package.json above ' + from)
+    d = up
+  }
+}
+const ROOT = packageRoot(HERE)
+const DECL = join(HERE, 'a432.test.json')
+const SEED = process.argv.includes('--seed')
+
+interface Declarations {
+  browserOnly: Record<string, string>
+  stateful: Record<string, string>
+  notDigits: Record<string, string>
+  emptyByDesign: Record<string, string>
+  triadByDesign: Record<string, string>
+  sharedValues: Record<string, string>
+}
+const EMPTY: Declarations = {
+  browserOnly: {}, stateful: {}, notDigits: {}, emptyByDesign: {}, triadByDesign: {}, sharedValues: {},
+}
+let decl: Declarations = EMPTY
+try { decl = { ...EMPTY, ...JSON.parse(readFileSync(DECL, 'utf8')) } } catch { /* seeding */ }
+
+let failures = 0
+const problems: string[] = []
+function check(name: string, ok: boolean, detail = ''): void {
+  if (ok) return
+  failures++
+  problems.push(`${name}${detail ? ' — ' + detail : ''}`)
+}
+
+// ------------------------------------------------------------------ modules
+function a432Files(dir: string, out: string[] = []): string[] {
+  for (const n of readdirSync(dir)) {
+    const full = join(dir, n)
+    if (statSync(full).isDirectory()) a432Files(full, out)
+    else if (/^a432\..*\.ts$/.test(n) && !n.endsWith('.test.ts')) out.push(full)
+  }
+  return out
+}
+const files = a432Files(join(ROOT, 'src')).sort()
+
+// ------------------------------------------------------ load every module
+interface Callable { where: string; call: () => unknown }
+const callables: Callable[] = []
+const loaded: string[] = []
+const seedBrowserOnly: Record<string, string> = {}
+
+// Imported IN ORDER, deliberately, and this is not an oversight.
+//
+// I parallelised this with Promise.all first, on the reasoning that the modules
+// do not depend on each other's evaluation order. Several of them register
+// themselves at module scope, so the order decides what the registry contains
+// when a later module reads it — and the suite went flaky, failing 3 runs in 6
+// with a different function named each time. It also bought nothing measurable:
+// 198 sequential imports are ~395ms, and the parallel suite still took ~407ms
+// end to end. A flaky gate is worse than a slow one, and this one was not even
+// faster.
+const imported: { file: string; mod: Record<string, unknown> | null; err: Error | null }[] = []
+for (const file of files) {
+  try { imported.push({ file, mod: (await import(pathToFileURL(file).href)) as Record<string, unknown>, err: null }) }
+  catch (e) { imported.push({ file, mod: null, err: e as Error }) }
+}
+
+for (const { file, mod: maybeMod, err } of imported) {
+  const rel = relative(ROOT, file)
+  const short = file.split('/').pop()!
+  if (err !== null) {
+    const msg = err.message.split('\n')[0]!
+    // A module needing `document` is a browser module, not a broken one — but
+    // it has to SAY so, so that a genuine load failure cannot hide among them.
+    if (/\b(document|window|self|localStorage) is not defined\b/.test(msg)) {
+      seedBrowserOnly[rel] = msg
+      check(`${short} loads`, rel in decl.browserOnly, `browser-only and undeclared: ${msg}`)
+    } else {
+      check(`${short} loads`, false, msg)
+    }
+    continue
+  }
+  const mod = maybeMod!
+  loaded.push(rel)
+  const visit = (name: string, fn: unknown, self: unknown): void => {
+    if (typeof fn !== 'function' || fn.length !== 0) return
+    callables.push({ where: `${short}:${name}`, call: () => (fn as (this: unknown) => unknown).call(self) })
+  }
+  for (const [k, v] of Object.entries(mod)) {
+    visit(k, v, mod)
+    if (typeof v === 'function') {
+      for (const s of Object.getOwnPropertyNames(v)) {
+        if (['length', 'name', 'prototype', 'caller', 'arguments'].includes(s)) continue
+        visit(`${k}.${s}`, (v as Record<string, unknown>)[s], v)
+      }
+    }
+  }
+}
+
+// Every declared browser-only module must still BE one.
+for (const rel of Object.keys(decl.browserOnly)) {
+  check(`declaration browserOnly ${rel}`, !loaded.includes(rel), 'it loads fine now — drop the entry')
+}
+
+// --------------------------------------------------------------- run them
+interface Result { where: string; a: string | undefined; b: string | undefined; value: unknown }
+// Two full passes, not two back-to-back calls.
+//
+// Calling f() twice in a row puts both calls in the same millisecond, so a
+// function that reads the clock returns the same value and looks deterministic.
+// That is not a hypothetical: getStreamVortexOverlayData passed the paired-call
+// version most of the time and failed about one run in eight, and the SEED had
+// the same blind spot, so it was never declared either. Sampling noise in both
+// the measurement and the allowlist built from it.
+//
+// Separating each function's two calls by a whole pass over the other 405 gives
+// a real time gap for the same total number of calls — cheaper than sleeping
+// per function, and it decides rather than samples.
+const results: Result[] = []
+const first: { c: Callable; a: string | undefined; value: unknown }[] = []
+for (const c of callables) {
+  try { const value = c.call(); first.push({ c, a: JSON.stringify(value), value }) } catch { /* not callable bare */ }
+}
+for (const { c, a, value } of first) {
+  let b: string | undefined
+  try { b = JSON.stringify(c.call()) } catch { /* second call threw; a !== b catches it */ }
+  results.push({ where: c.where, a, b, value })
+}
+
+// ---------------------------------------------------- P1 determinism
+// This layer bans Math.random and fork(), so a nullary export that answers
+// differently twice is either holding mutable state or reading the clock.
+// Both are legitimate for some things; neither may be silent.
+const seedStateful: Record<string, string> = {}
+for (const r of results) {
+  if (r.a === r.b) continue
+  seedStateful[r.where] = 'returns a different value on a second call with no arguments'
+  check(`${r.where} is deterministic`, r.where in decl.stateful, 'undeclared state or clock dependence')
+}
+// No reverse check on `stateful`, unlike the other declarations. Calling a
+// function twice can only ever DETECT non-determinism, never establish
+// determinism: one that reads the clock returns the same value whenever both
+// calls land in the same millisecond, which is most of the time. Requiring a
+// declared entry to keep failing would make the suite fail at random, which is
+// exactly what it did before this note existed. Undeclared non-determinism
+// still fails, and that is the direction that finds things.
+
+// ------------------------------------------- P2 digit sequences are digits
+// A digit in this system is 0..9. An array of numbers that leaves that range
+// is an angle or a frequency, which is fine, but must say so.
+const seedNotDigits: Record<string, string> = {}
+const isNumArray = (v: unknown): v is number[] =>
+  Array.isArray(v) && v.length > 0 && v.every((x) => typeof x === 'number')
+for (const r of results) {
+  if (!isNumArray(r.value)) continue
+  const bad = r.value.some((x) => !Number.isInteger(x) || x < 0 || x > 9)
+  if (!bad) continue
+  seedNotDigits[r.where] = 'returns numbers outside 0..9, so it is not a digit sequence'
+  check(`${r.where} yields digits`, r.where in decl.notDigits, 'outside 0..9 and undeclared')
+}
+
+// ------------------------------------------------ P3 empty is a decision
+// getTrinityAxisFromRodin returned [] because it filtered the doubling circuit
+// for 3, 6 and 9 — which doubling_avoids_the_triad proves are never there. An
+// empty array is how a function that cannot work looks from outside.
+const seedEmpty: Record<string, string> = {}
+for (const r of results) {
+  if (!Array.isArray(r.value) || r.value.length !== 0) continue
+  seedEmpty[r.where] = 'returns an empty array with no arguments'
+  check(`${r.where} returns something`, r.where in decl.emptyByDesign, 'empty and undeclared')
+}
+for (const w of Object.keys(decl.emptyByDesign)) {
+  const r = results.find((x) => x.where === w)
+  if (r) check(`declaration emptyByDesign ${w}`, Array.isArray(r.value) && r.value.length === 0, 'it returns data now — drop the entry')
+}
+
+// ---------------------------------- P4 the doubling circuit is the doubling circuit
+// The property the three broken copies of generateVortex all failed.
+const DOUBLING_NAME = /vortex|rodin|orbit|doubling/i
+const TRIAD: readonly number[] = VORTEX_AXIS
+const seedTriad: Record<string, string> = {}
+for (const r of results) {
+  if (!DOUBLING_NAME.test(r.where)) continue
+  if (!isNumArray(r.value)) continue
+  if (r.value.some((x) => x > 9)) continue // an angle series, covered by P2
+  const hasTriad = r.value.some((d) => TRIAD.includes(d))
+  if (hasTriad) {
+    seedTriad[r.where] = 'named for the doubling circuit but contains 3, 6 or 9'
+    check(`${r.where} avoids the triad`, r.where in decl.triadByDesign, 'doubling cannot reach 3, 6 or 9')
+    continue
+  }
+  // No triad: then every step must actually be a doubling step, and every
+  // member must be in the kernel's orbit. This is what makes 1..9 impossible.
+  const inOrbit = r.value.every((d) => VORTEX_ORBIT.includes(d))
+  check(`${r.where} stays in the orbit`, inOrbit, JSON.stringify(r.value))
+  if (inOrbit && r.value.length > 1) {
+    const steps = r.value.every((d, i) => i === 0 || digitalRoot(r.value[i - 1]! * 2) === d)
+    check(`${r.where} advances by doubling`, steps, JSON.stringify(r.value))
+  }
+}
+
+// ------------------------------------------------- P5 no silent duplicates
+// Two differently-named nullary functions returning the same value means at
+// least one is not computing what its name says. That is how generateVortex
+// was caught: it was byte-identical to generateConsciousness.
+const byValue = new Map<string, string[]>()
+for (const r of results) {
+  if (r.a === undefined || r.a.length < 5 || r.a.length > 400) continue
+  if (!byValue.has(r.a)) byValue.set(r.a, [])
+  byValue.get(r.a)!.push(r.where)
+}
+const seedShared: Record<string, string> = {}
+for (const [value, who] of byValue) {
+  const distinct = new Set(who.map((w) => w.split(':')[1]!.split('.').pop()!))
+  if (distinct.size < 2) continue // re-exports of one function are not duplicates
+  const key = [...distinct].sort().join(' = ')
+  seedShared[key] = value.length > 120 ? value.slice(0, 120) + '…' : value
+  check(`no undeclared duplicate: ${key}`, key in decl.sharedValues, value.slice(0, 60))
+}
+for (const k of Object.keys(decl.sharedValues)) {
+  check(`declaration sharedValues ${k}`, k in seedShared, 'these no longer agree — drop the entry')
+}
+
+// ------------------------------------------------------------- regressions
+// Named, so the three specific defects this layer shipped cannot come back.
+/** Only the members these regressions touch — `any` would defeat the point. */
+type Seq = { A432Sequence: { generateVortex(n: number): number[]; generateVortexSequence(n: number): number[]; generateConsciousness(n: number): number[] } }
+type Frac = {
+  validateAllA432Fractions(): boolean
+  validateA432Fraction(f: { numerator: number; denominator: number }): boolean
+}
+type Trin = { getTrinityAxisFromRodin(seq?: number[]): number[]; getTrinityTriangulationFromRodin(seq?: number[]): number[] }
+const load = async <T>(name: string): Promise<T> => (await import(pathToFileURL(join(HERE, name)).href)) as T
+const utils = await load<Seq>('a432.utils.ts')
+const simple = await load<Seq>('a432.simple.ts')
+const resolved = await load<Frac>('a432.resolved.ts')
+const trinity = await load<Trin>('a432.trinity.ts')
+
+const orbit = VORTEX_ORBIT.join()
+check('utils.generateVortex is the orbit', utils.A432Sequence.generateVortex(VORTEX_ORBIT.length).join() === orbit)
+check('simple.generateVortexSequence is the orbit', simple.A432Sequence.generateVortexSequence(VORTEX_ORBIT.length).join() === orbit)
+check(
+  'generateVortex differs from generateConsciousness',
+  utils.A432Sequence.generateVortex(9).join() !== utils.A432Sequence.generateConsciousness(9).join(),
+)
+check('every declared A432 fraction validates', resolved.validateAllA432Fractions() === true)
+check('the fraction validator still rejects a decimal', resolved.validateA432Fraction({ numerator: 4 / 5, denominator: 1 }) === false)
+check('the fraction validator still rejects 2/4', resolved.validateA432Fraction({ numerator: 2, denominator: 4 }) === false)
+// ---------------------------------------------------------------- gateways
+// A gateway is not a label. The vortex stroke is a closed ten-step tour
+// 1\2\4\8/7/5/3\6\9/0\1, each step drawn `\` or `/`, and a gateway is a digit
+// whose outgoing stroke REVERSES from the one that arrived at it. There are
+// exactly four. Re-derived here from the steps rather than compared against a
+// stored list, so a change to the stroke has to survive the derivation.
+const stroke = vortexStrokeGateways() as {
+  gateways: number[]; steps: { from: number; to: number; stroke: string }[]; tour: number[]
+}
+const st = stroke.steps
+const derivedGateways = st
+  .filter((step, i) => step.stroke !== st[(i - 1 + st.length) % st.length]!.stroke)
+  .map((step) => step.from)
+check('gateways are the polarity reversals of the stroke', derivedGateways.join() === stroke.gateways.join(),
+  `derived ${JSON.stringify(derivedGateways)} vs ${JSON.stringify(stroke.gateways)}`)
+check('there are exactly four gateways', stroke.gateways.length === 4, JSON.stringify(stroke.gateways))
+check('the tour is closed', st[st.length - 1]!.to === st[0]!.from)
+check('the tour visits every digit once', new Set(stroke.tour).size === 10 && stroke.tour.length === 10)
+check('the tour opens with the doubling orbit', stroke.tour.slice(0, VORTEX_ORBIT.length).join() === VORTEX_ORBIT.join())
+// 6 is on the axis and is NOT a gateway: being on the axis is not what makes
+// one, which is the whole reason they have to be derived rather than listed.
+check('6 is on the axis but is not a gateway', VORTEX_AXIS.includes(6) && !stroke.gateways.includes(6))
+
+check('the trinity axis derived from Rodin is the triad', trinity.getTrinityAxisFromRodin().join() === VORTEX_AXIS.join(),
+  JSON.stringify(trinity.getTrinityAxisFromRodin()))
+check('trinity triangulation uses its argument', trinity.getTrinityTriangulationFromRodin([1, 2, 4]).length !== trinity.getTrinityTriangulationFromRodin([3, 6, 9]).length,
+  'same answer for different inputs: the parameter is ignored')
+
+// -------------------------------------------------------------------- seed
+if (SEED) {
+  const seeded: Declarations = {
+    browserOnly: seedBrowserOnly,
+    stateful: seedStateful,
+    notDigits: seedNotDigits,
+    emptyByDesign: seedEmpty,
+    triadByDesign: seedTriad,
+    sharedValues: seedShared,
+  }
+  writeFileSync(DECL, JSON.stringify(seeded, null, 2) + '\n')
+  const n = Object.values(seeded).reduce((s, o) => s + Object.keys(o).length, 0)
+  console.log(`a432 test:seed wrote ${n} declarations to ${relative(ROOT, DECL)}`)
+  process.exit(0)
+}
+
+console.log(
+  `a432 properties — ${files.length} modules, ${loaded.length} loaded, ` +
+    `${results.length} nullary exports called`,
+)
+for (const p of problems) console.error(`  ✗ ${p}`)
+if (failures > 0) {
+  console.error(`a432 tests FAIL — ${failures} problem(s)`)
+  process.exit(1)
+}
+console.log('a432 tests ok — every property holds, and every declaration is still true')
+process.exit(0)

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

@@ -18,6 +18,7 @@ import { PI, abs, cos, floor, min, round, sin, sqrt } from './a432.algebra.ts'
 import { digitAngleToCMYK, cmykToCss, type CMYK } from './a432.cmyk.ts';
 import { A432_FREQUENCY } from './a432.core.ts';
 import { TRINITY_AXIS, RODIN_SEQUENCE } from './a432.math.ts';
+import { throughVoid } from '../../../../../../../../../../index.ts';
 export { TRINITY_AXIS, RODIN_SEQUENCE };
 
 /**
@@ -34,13 +35,37 @@ export function trinityFieldFold(angleA: number, angleB: number): number {
   return trinityFieldState(mergedAngle);
 }
 
+const isTriad = (n: number): boolean => n === 3 || n === 6 || n === 9;
+
+/**
+ * The trinity axis reached from a Rodin sequence.
+ *
+ * This filtered rodinSeq for 3, 6 and 9 directly, and therefore always returned
+ * an empty array — the sealed theorem doubling_avoids_the_triad proves that the
+ * doubling circuit never contains them, because gcd(2,9) = 1 makes every power
+ * of two a unit mod 9. Filtering for something a proof says is not there is not
+ * a search that sometimes fails; it is one that cannot succeed.
+ *
+ * The same theorem says how the triad IS reached: by reflection through the
+ * void, which carries 1, 4 and 7 onto 9, 6 and 3. So the sequence is reflected
+ * first, and the triad members of the reflection are the axis.
+ */
 export function getTrinityAxisFromRodin(rodinSeq: number[] = RODIN_SEQUENCE): number[] {
-  return Array.from(new Set(rodinSeq.filter(n => n === 3 || n === 6 || n === 9)));
+  const reflected = rodinSeq.map(throughVoid).filter(isTriad);
+  return Array.from(new Set(reflected)).sort((a, b) => a - b);
 }
 
+/**
+ * The trinity triangulation reached from a Rodin sequence.
+ *
+ * This declared a rodinSeq parameter and then ignored it, testing membership
+ * against a hardcoded cycle instead, so every input produced the same answer.
+ * It now answers about the sequence it was actually given, by the same
+ * reflection: 3, 9, 6 in triangulation order, keeping those the input can reach.
+ */
 export function getTrinityTriangulationFromRodin(rodinSeq: number[] = RODIN_SEQUENCE): number[] {
-  const fullCycle = [0, 3, 6, 9, 1, 2, 4, 8, 7, 5, 1];
-  return [3, 9, 6].filter(n => fullCycle.includes(n));
+  const reachable = new Set(rodinSeq.map(throughVoid).filter(isTriad));
+  return [3, 9, 6].filter(n => reachable.has(n));
 }
 
 // Use canonical constants from a432.math.ts

package/src/vbm-math.ts

@@ -7,6 +7,7 @@
 
 import { pathToFileURL } from 'node:url'
 import { abs, pow } from './0/algebra.ts'
+import { VORTEX_ORBIT, VORTEX_AXIS } from './0/index.ts'
 import { legacyDigitalRoot } from './0/3/6/9/1/2/4/8/7/5/1/a432.roots.ts'
 
 export class VortexMath {
@@ -41,10 +42,14 @@ export class VortexMath {
     }
 
     /**
-     * Get the core Mobius Circuit pattern [1,2,4,8,7,5]
+     * The core Mobius circuit — the kernel's VORTEX_ORBIT, not a second copy.
+     *
+     * This returned a literal, so it was one of 91 places in the tree holding
+     * its own copy of a constant the kernel already exports. Bound rather than
+     * retyped, it cannot drift from the definition.
      */
     static getMobiusCircuit(): number[] {
-        return [1, 2, 4, 8, 7, 5];
+        return [...VORTEX_ORBIT];
     }
 
     /**
@@ -52,7 +57,7 @@ export class VortexMath {
      * These numbers form the higher dimensional control axis in VBM
      */
     static getSpiritNumbers(): number[] {
-        return [3, 6, 9];
+        return [...VORTEX_AXIS];
     }
 
     /**