zeropoint-node 1.0.10 → 1.0.12

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

@@ -1,9 +1,21 @@
 /**
  * a432.resolved.ts — A432 Decimal Conflict Resolution
  *
- * Eliminates all decimal conflicts and maintains zero entropy mathematics
- * with only integer fractions whose reciprocals are integers.
- * All decimals are replaced with A432-compliant fractions.
+ * Eliminates all decimal conflicts by carrying every quantity as an exact
+ * integer ratio instead of a decimal literal.
+ *
+ * This file used to claim "only integer fractions whose reciprocals are
+ * integers", and validateAllA432Fractions() checked exactly that and returned
+ * false: 23 of the 37 fractions here fail it. The rule was not achievable.
+ * A reciprocal-integer fraction is precisely 1/n, and values the UI and audio
+ * actually need — 4/5 for a focus level, 19/20 for a threshold — have no 1/n
+ * form at all. The validator was faithful to a rule the data could never meet.
+ *
+ * The property that matters, and that all 37 do satisfy, is canonical exactness:
+ * integer numerator, non-zero positive denominator, in lowest terms. That is
+ * what keeps decimals out of the source, and lowest terms is the part that
+ * earns the name zero entropy — one value has exactly one representation, so
+ * 2/4 and 1/2 cannot both appear and drift apart.
  *
  * @module A432.Resolved
  * @version 1.0.0
@@ -14,7 +26,8 @@ import { abs } from './a432.algebra.ts'
 import './a432.core.ts';
 
 // === A432 RESOLVED FRACTIONS ===
-// All fractions have integer reciprocals (zero entropy mathematics)
+// Every fraction is an exact ratio in lowest terms (zero entropy: one
+// representation per value). See validateA432Fraction for the checked rule.
 
 export const A432_RESOLVED_FRACTIONS = {
   // Geometry / analog signal fractions for the three.js surfaces.
@@ -172,23 +185,55 @@ export function calculateA432FractionValue(fraction: { numerator: number; denomi
   return fraction.numerator / fraction.denominator;
 }
 
+/** Greatest common divisor, for the lowest-terms test. Integers only. */
+function gcd(a: number, b: number): number {
+  let x = abs(a);
+  let y = abs(b);
+  while (y !== 0) {
+    const t = y;
+    y = x % y;
+    x = t;
+  }
+  return x;
+}
+
 /**
- * Validate A432 fraction (integer reciprocals only)
+ * Validate an A432 fraction: an exact ratio in canonical form.
+ *
+ * Three conditions, and each one rules out a way a decimal could re-enter or a
+ * value could acquire a second spelling:
+ *
+ *   integer parts      a non-integer numerator IS the decimal this file exists
+ *                      to eliminate, just wearing a fraction's clothes
+ *   denominator > 0    zero is undefined; a negative denominator gives every
+ *                      value a second spelling (-1/2 and 1/-2)
+ *   lowest terms       the zero-entropy condition proper: one value, exactly
+ *                      one representation, so 2/4 and 1/2 cannot drift apart
+ *
+ * This replaces a check for `denominator / numerator` being an integer, which
+ * admits only 1/n and which 23 of this file's 37 fractions could never satisfy.
+ * For that narrower property, which is a real thing about some of them but not
+ * a validity condition, see isUnitReciprocal.
  */
 export function validateA432Fraction(fraction: { numerator: number; denominator: number }): boolean {
-  // Check if numerator and denominator are integers
   if (!Number.isInteger(fraction.numerator) || !Number.isInteger(fraction.denominator)) {
     return false;
   }
-
-  // Check if denominator is not zero
-  if (fraction.denominator === 0) {
+  if (fraction.denominator <= 0) {
     return false;
   }
+  return gcd(fraction.numerator, fraction.denominator) === 1;
+}
 
-  // Check if the reciprocal is an integer (for zero entropy)
-  const reciprocal = fraction.denominator / fraction.numerator;
-  return Number.isInteger(reciprocal);
+/**
+ * Whether a fraction is a unit reciprocal, 1/n.
+ *
+ * The old validator's rule, kept under a name that says what it tests. 14 of
+ * the 37 fractions here are of this form; the rest are exact ratios that
+ * simply are not 1/n, which is a fact about them and not a defect.
+ */
+export function isUnitReciprocal(fraction: { numerator: number; denominator: number }): boolean {
+  return validateA432Fraction(fraction) && fraction.numerator === 1;
 }
 
 // === RESOLVED CONSTANTS ===

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

@@ -47,10 +47,20 @@ export class A432Math {
 }
 
 export class A432Sequence {
+  /**
+   * The vortex sequence: the doubling circuit 1,2,4,8,7,5.
+   *
+   * This is the second copy of the same defect fixed in a432.utils.ts — it
+   * walked digitalRoot(i + 1), which is counting, not a vortex. A collision
+   * trial found it: the output was identical to a differently-named function,
+   * and it contained 3, 6 and 9, which doubling provably never reaches.
+   */
   static generateVortexSequence(length: number = 9): number[] {
-    const sequence = [];
+    const sequence: number[] = [];
+    let v = 1;
     for (let i = 0; i < length; i++) {
-      sequence.push(A432Math.calculateDigitalRoot(i + 1));
+      sequence.push(v);
+      v = A432Math.calculateDigitalRoot(v * 2);
     }
     return sequence;
   }

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

@@ -334,7 +334,18 @@ export class A432System {
       const vortexSequence = this.sacredGeometrySystem.calculateVortexSequence(1, length);
       return vortexSequence.map((step: any) => step.digit);
     }
-    return Array.from({ length }, (_, i) => (i % 9) + 1);
+    // Third copy of the counting-sequence defect, latent in a fallback: this
+    // returned (i % 9) + 1, which is 1..9, not a vortex. It stayed invisible
+    // because the two delegates above almost always answer first, so the wrong
+    // branch is the one nothing ever runs. Generated by doubling, like the
+    // other two, and reachable now only when there is no delegate to ask.
+    const sequence: number[] = [];
+    let v = 1;
+    for (let i = 0; i < length; i++) {
+      sequence.push(v);
+      v = this.calculateDigitalRoot(v * 2);
+    }
+    return sequence;
   }
 
   // === SYSTEM STATUS ===

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/0/3/6/9/1/2/4/8/7/5/1/a432.utils.ts

@@ -145,10 +145,25 @@ export class A432Sequence {
   }
 
   /**
-   * Generate vortex sequence
+   * Generate the vortex sequence: the doubling circuit 1,2,4,8,7,5.
+   *
+   * This returned digitalRoot(i + 1) — the counting sequence 1..9 — which is
+   * not a vortex at all. Two tells: it was byte-identical to
+   * generateConsciousness(9), and it contained 3, 6 and 9, which the doubling
+   * circuit provably never reaches (gcd(2,9) = 1 makes every power of 2 a unit
+   * mod 9, so no term is ever a multiple of 3).
+   *
+   * The orbit is generated by doubling rather than written down as a literal,
+   * so it cannot drift away from the theorem it comes from.
    */
   static generateVortex(length: number = 9): number[] {
-    return Array.from({ length }, (_, i) => A432Math.digitalRoot(i + 1));
+    const out: number[] = [];
+    let v = 1;
+    for (let i = 0; i < length; i++) {
+      out.push(v);
+      v = A432Math.digitalRoot(v * 2);
+    }
+    return out;
   }
 
   /**

package/src/quantum/adaptive.ts

@@ -38,11 +38,18 @@ export class AdaptiveOptimizer {
    */
   recordSuccess(name: string, result: VQEResult, initialTheta: number[]): void {
     if (result.converged) {
-      this.state.successfulAnsatze.push({ name, theta: result.theta })
-      this.state.convergedRuns += 1
+      // Rebuilt rather than mutated. These fields are readonly, and assigning
+      // through the annotation was the same defect fixed in orchestrator.ts:
+      // the type was reporting a real violation, not being pedantic.
       const steps = result.history.length
-      this.state.averageConvergenceSteps =
-        (this.state.averageConvergenceSteps * (this.state.convergedRuns - 1) + steps) / this.state.convergedRuns
+      const convergedRuns = this.state.convergedRuns + 1
+      this.state = {
+        ...this.state,
+        successfulAnsatze: [...this.state.successfulAnsatze, { name, theta: result.theta }],
+        convergedRuns,
+        averageConvergenceSteps:
+          (this.state.averageConvergenceSteps * (convergedRuns - 1) + steps) / convergedRuns,
+      }
     }
   }