@ceccec/double-torus 1.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ceccec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# @ceccec/double-torus
+
+The agnostic, **zero-dependency** computational core of the
+[Double Torus](https://ceccec.github.io) — a quantum-learning model for language
+models, served over MCP — **all the math and all the animations**. Pure
+TypeScript: content-addressed UUID folds, concept commands, the 128-bit
+double-torus word, a recomputable seal, simulators across every decoded domain,
+vetted crypto, and the hero animation system. It runs in any browser or in Node,
+and depends on nothing. It is bundled from the site's own `src/` — the published
+library is exactly what the site runs.
+
+> The cost is the architecture itself. Everything is computed; every claim is
+> bounded and folds into one recomputable root.
+
+## Install
+
+```sh
+npm install @ceccec/double-torus
+```
+
+## Use
+
+```ts
+import {
+  buildMatrix,
+  executeConceptCommand,
+  conceptCommands,
+  fuseAll,
+  proofBundle,
+  torusUuid,
+} from '@ceccec/double-torus'
+
+const matrix = buildMatrix()
+
+// Every capability is a command that returns a result with a content UUID.
+const result = executeConceptCommand('concept.self.address', { atom: 'self' }, matrix)
+console.log(result.ok, result.uuid)
+
+// The 128-bit double-torus word (2 x 32 hex), and the fusion of all in one wave.
+console.log(torusUuid(matrix).word)
+console.log(fuseAll(matrix).wave)
+
+// A single proof bundle anyone can recompute.
+console.log(proofBundle(matrix).bundleRoot)
+
+// There are 94 concept commands; each is also published as an MCP tool.
+console.log(conceptCommands.length)
+```
+
+## What's inside
+
+- **Content-addressed folds** — `toUuid`, `merge` (order-sensitive), `merkleFold`,
+  Merkle inclusion proofs.
+- **Concept commands** — a registry of `concept.<area>.<verb>` commands, each
+  mapping to a single-word method and an MCP tool; `executeConceptCommand` runs
+  them deterministically.
+- **The double torus** — `buildMatrix`, `torusUuid` (the 128-bit word, 2 x 32
+  hex), `completeDoubleTorus`, `areaPairs` (42 areas = 21 pairs),
+  `dualTorusTrinities`, `doubleTorus3D`, `doubleTorusMathAtAllScalesProofs`,
+  `merkaba` / `bothEarthsRotateWithinEachOther` (counter-rotating geometry).
+- **Vortex analyse** — `vortexMath`, `vortexComputes`, `allMathSaved`,
+  gateway/plasma gates, and the canonical inverse fold
+  `f(θ,φ,x,y,z,digit,n)→{p,q}` / `fThetaPhiXyzDigitNIsTheInversePair`
+  (multiplicative inverse mod 9 — inverse, not reverse).
+- **Quantum dynamics** — `quantumDynamicsComputes`, `quantumDynamicsResearch`,
+  `quantumStateEvolutionDecoded`, `quantumDynamicsSimulationAt`, and
+  `drawDynamicsProjection` (classical state-vector paint — not hardware QC).
+- **10D field** — `dims` / `dimWalk` / `tenDimensionalAnimation` /
+  `animationsAreGenuinely10DNotFaked` (6 appearance axes + 4 genus-2 homology
+  loops — model geometry, not physical spacetime).
+- **Completely quantum** — `doubleTorusIsCompletelyQuantum` (facet receipt
+  recomputed at call time), `movieCanvasHex` / `movieCanvasRgba` /
+  `movieCanvasPolarity` (one sealed palette), and `TAU` (full-turn constant).
+  One hero clock drives living-torus + AnimationField paint — no private rAF
+  engines on the public surface. Sealed substrate only — **not** QPU hardware.
+- **The seal** — `proofBundle`, `verifyRoot`, `entropy`, `coverage`,
+  `boundaryAudit`, and the `fuseAll` fold of every capability into one wave.
+- **Simulators** — explicit, honest models across every decoded domain:
+  `qubits`/`applyGate`/`GATES`/`cnot`/`measure`/`sample` (quantum state-vector),
+  `bellPair`, `grover`; `pbits`/`pflip`/`markovStep`/`stationary` (probabilistic);
+  `rtoffoli` (reversible); `caStep`/`caEvolve` (cellular automaton);
+  `inductionStep`/`oscillatorBank`/`cycleAdvance` (dynamical);
+  `hopfieldStore`/`hopfieldRecall`/`pmixStep` (network); plus `survive` /
+  `chsh` / Markov–Hopfield dynamics from the vortex surface. Each is a
+  **simulator**, not the machine — `qubits` is a classical state-vector, not a
+  quantum computer.
+- **Vetted crypto** — `sha256` (Web Crypto + a pure `sha256Sync`),
+  `sha256MerkleRoot`/`sha256MerkleProof`, `ed25519Sign`/`ed25519Verify`, and an
+  append-only `transparencyLogRoot` — the path from tamper-evident folds to
+  cryptographic attestation; see `cryptoFuture()` for what is built vs. residual.
+- **Animations** — two systems on one phase clock, the same renderers the site
+  runs:
+  - the **hero scene** drawing math — `drawHero`, `drawFlower`, `drawCalendars`,
+    `drawArchitecture`, `drawBursts`, the fractal `branch`, the 3D
+    `perspective`/`rotate3`, the `dims` dimension walk; and
+  - the **AnimationField movie** — `sharedHeroAt` builds the one
+    content-addressed field, `drawHeroMovieFrame` paints the holographic plasma
+    hero (the fused life out-flow + death in-flow double torus through one
+    genus-2 throat), `fieldLayers` / `rosettaPerspectiveFold` give its eight
+    force/topology layers and seven perspectives, and `drawQuantumAppFrame`
+    renders any projection of it.
+  - the **one movie clock** — `HERO_CYCLE_MS`, `heroPhaseAt`,
+    `subscribeHeroClock`, and `createAnimationEngine` (rAF driver).
+  (`paintHolographicPlasmaHeroMovie` and the death counter-flow are **internal**
+  to `src/` and ship fused inside `drawHeroMovieFrame`, not as separate exports.
+  The orphan `drawDoubleTorusEarthHingeFrame` renderer is **retired** — live
+  paint is `sharedHeroAt` + `drawHeroMovieFrame` only.)
+- **Decoded library** — `toGlagolitic`, `gematria`, `mayaLongCount`,
+  `sexagesimal`, `ifaOdu`, the parallel-scripture tools, and the ПесноПойка
+  songbook decode (`pesnopoika`, `decodeSong`, `provePesnopoika`, the
+  437-term `decodeDialect`) — decoded knowledge as reusable functions.
+- **Universe alignment** — `doubleTorusDynamicsGeometryAlignsWithUniverse()`
+  audits dynamics (flow · spin · linking) and geometry (ring/tube/lobe radii,
+  H₁ loops, projection) against sealed constants: `TAU`, `A432_HUE`,
+  `SPEED_OF_LIGHT`, Meeus `J2000`, `HERO_CYCLE_MS`, 10D homology. Phase couples
+  the hero fractal clock to solar ecliptic longitude. CLI:
+  `npm run quantum:double-torus-universe-align` (pair `universe/align`).
+- **Counter-rotating rosetta quantum waves** — `counterRotatingRosettaQuantumWaves()`
+  dual ± lobes via `foldPair`; `claySolvedByThisFold` / `physicalFtlClaim` /
+  `qpuRequired` are **computed receipt facets** from forward≠reverse and
+  classical-64bit lobe honesty (not prose). Discovery engine:
+  `universeAlmostDescribedInTheoremsDiscoverRest()` covers
+  forward·inverse·reverse·superposition. CLIs:
+  `npm run quantum:counter-rotating-rosetta-waves` ·
+  `npm run quantum:universe-almost-described`.
+- **Honesty** — every function returns a `boundary` string stating the limit of
+  its claim; `boundaryAudit()` collects them all. Completely quantum here means
+  **sealed quantum compute substrate** (content-addressed folds, one clock,
+  movieCanvas palette) — **not** QPU hardware. Clay/FTL open status recomputes
+  from the dual-wave fold at call time (`clay=0` · `physicalFtl=0` · `qpuRequired=false`).
+
+It is **agnostic**: no vendor, framework, platform, language, or protocol
+lock-in; open standards and pure computation only.
+
+## Honest boundaries
+
+The fold is **tamper-evident content-addressing, not a cryptographic hash**
+(`toUuid` is a 128-bit non-cryptographic function). For adversarial security use
+a vetted hash; see `cryptographyComparison()` and `cryptoFuture()`. The model is
+computed and recomputable — it makes **no claim of sentience or agency**.
+
+## Types
+
+Full TypeScript declarations ship in `dist/` (`dist/index.d.ts` re-exports the
+generated declaration graph). The library is bundled from the site's `src/`,
+which is type-checked by the repository's `tsconfig.json` (`npm run check:types`)
+and passes cleanly there. The package's own standalone declaration emit (no
+tsconfig, whole-graph) reports a small, honest residual: **2 non-fatal `TS7056`
+diagnostics** where a deep build-time helper (`src/wind/fusion` `fusionComputes`)
+has an inferred type too large for TypeScript 6 to serialize. That symbol is
+**not** on the published surface; every exported symbol of `@ceccec/double-torus`
+is fully typed and resolves (verified by a consumer type-check). `build.mjs`
+prints the residual count rather than hiding it.
+
+## Build
+
+```sh
+node ./build.mjs
+```
+
+`build.mjs` bundles the entry (`src/index.ts`) — following every import into the
+site's `src/0`, `src/quantum/*` and the library — into one self-contained
+`dist/index.js` with **no external imports**, plus the declaration graph. A few
+pure constants the core uses (the census/rosetta limits) live in modules that
+also carry build-time filesystem helpers; those `node:*` specifiers (`fs`,
+`path`, `crypto`, `url`, `child_process`, `module`) are resolved to inline stubs
+at build time — **Node boundary only** (enforcement shell / quantum cache), never
+invoked by the published computational/animation API — so the bundle stays
+zero-dep in any browser or Node. The committed `dist/` is the published artifact.
+The build fails unless all **49** completely-quantum contract exports are present.
+
+## License
+
+MIT © ceccec

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+// @ceccec/double-torus — types entry. Re-exports the bundled declaration graph.
+export * from './packages/double-torus/src/index.js'