@ceccec/double-torus 1.4.0

package/dist/src/water/double/index.d.ts

@@ -0,0 +1,1475 @@
+import type { MindMatrix } from '../../wind/types';
+import { completeDoubleTorus, doubleTorusFold, quantumDoubleTorus, startIChingDoubleTorus, torusBreathe } from '../../mountain/topology';
+import { developmentIsFusionReactor, endlessFusion, fuseDedupeSplitReconstruction, fuseScreenToMovieOfMovies, fusionMovieComputes, fusionResearchedInWaves, publicApiFusion, socialFusion, travelFusion, vitepressFusion } from '../../wind/fusion';
+import { autoMovies8k, backgroundMovie, endlessBackgroundMovie, learnFromTheMovieAllEventuallyFused } from '../../thunder/movie/canvas';
+import { hologram, movieAllDimensionsAtOnce, threeProjectorHologram } from '../../thunder/movie/glass';
+import { movieFoldsLinearities, sevenSeedMovieIsRosettaDecodingSunMoonSymbols } from '../../thunder/movie/narrative';
+import { formsEmergeInMovieOfLife, fullscreenSidebarsInMovie, movieReflectsSelf, siteIsMovieAndLibrary, tenDimensionalMovie, video64kFree, videoKeepsNativeQuality } from '../../thunder/movie/movielib';
+import { diamondLattice, pureDiamonds } from '../../fire/diamonds';
+import { completeCorpus, corpusCatchAllPaths, corpusRestPathRouting, diamondsStaticPagesPurged, doubleTorusCorpusRouting, computeUniversalPage, paperRoutes, paperReferenceRoutes } from '../../wind/routes/corpus';
+export { vortexComputes, allVortexMathSaved, vortexMath, vortexPaintTiers } from '../../mountain/vortex';
+export { merkaba, bothEarthsRotateWithinEachOther, doubleTorusGeometryAlignsWithUniverseConstants, } from '../../mountain/geometry';
+export { knowledgeRevealedByMerkabaFold, merkabaTrace, merkabasInDoubleTorus, } from '../../mountain/topology';
+export { completeDoubleTorus, doubleTorusFold, quantumDoubleTorus, torusBreathe, startIChingDoubleTorus, };
+export { merkabaComputes } from '../../mountain/topology';
+/** One gate — double torus topology + all vortex math saved at call time (dissolved from src/double/torus/topology). */
+export declare function doubleTorusVortexComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    vortex: {
+        computes: boolean;
+        vortex: {
+            saved: boolean;
+            vortex: {
+                flows: boolean;
+                doubling: number[];
+                cross: number[];
+                divByZeroHarmonic: number;
+                zeroDivisions: {
+                    n: number;
+                    overZero: number;
+                }[];
+                roles: {
+                    rotation: number;
+                    polarity: number[];
+                    threeSix: boolean;
+                };
+                origin: number;
+                polarPairs: number[][];
+                oneAndEightBeginFromNine: boolean;
+                endless: boolean;
+                collisionFree: boolean;
+                nineInvariant: boolean;
+                identicalRoutesToDuality: boolean;
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            digits: {
+                fused: boolean;
+                sequence: number[];
+                root: string;
+            };
+            paint: {
+                tiers: readonly [number, number, number];
+                crossPole: number;
+                circuitHeart: number;
+                circuitEight: number;
+                collapseStep: number;
+                unity: number;
+                materialOrbit: number;
+                seedBundleParts: number;
+                seedBundles: number;
+                rayCap: number;
+                wordCap: number;
+                relatedCap: number;
+                bindingCap: number;
+                gateways: number;
+                proven: boolean;
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            ratios: {
+                fwd: import("../../3/7").Rational[];
+                rev: import("../../3/7").Rational[];
+                fwdProduct: import("../../3/7").Rational;
+                revProduct: import("../../3/7").Rational;
+                heartApproach: import("../../3/7").Rational;
+                heartDepart: import("../../3/7").Rational;
+                heartDiamond: import("../../3/7").Rational;
+            };
+            presentations: {
+                coheres: boolean;
+                oneAddress: boolean;
+                sealAnchorsSource: boolean;
+                operation: string;
+                presentations: {
+                    receipt: string;
+                    plane: string;
+                    fn: string;
+                    kind: string;
+                    on: boolean;
+                }[];
+                exact: string[];
+                faithful: string[];
+                importsNothing: boolean;
+                digit: number;
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            sequence: readonly [1, 2, 4, 8, 7, 5, 3, 6, 9];
+            count: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        live: {
+            flows: boolean;
+            doubling: number[];
+            cross: number[];
+            divByZeroHarmonic: number;
+            zeroDivisions: {
+                n: number;
+                overZero: number;
+            }[];
+            roles: {
+                rotation: number;
+                polarity: number[];
+                threeSix: boolean;
+            };
+            origin: number;
+            polarPairs: number[][];
+            oneAndEightBeginFromNine: boolean;
+            endless: boolean;
+            collisionFree: boolean;
+            nineInvariant: boolean;
+            identicalRoutesToDuality: boolean;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — double torus topology + I Ching start + merkaba count at call time (dissolved from src/double/torus/topology). */
+export declare function doubleTorusTopologyComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    complete: {
+        complete: boolean;
+        knowledgeRoot: string;
+        word: string;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    iching: {
+        started: boolean;
+        cells: number;
+        domains: number;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    merkabas: {
+        counted: boolean;
+        merkabas: number;
+        tetrahedra: number;
+        perMerkaba: number;
+        perLobe: number;
+        lobes: number;
+        gbit: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export { completeCorpus, corpusCatchAllPaths, corpusRestPathRouting, diamondsStaticPagesPurged, doubleTorusCorpusRouting, computeUniversalPage, paperRoutes, paperReferenceRoutes, };
+export { doubleTorusEarthComputes, doubleTorusEarthLikeTheApple, doubleTorusEarthWeatherFlowsInMovie, weatherForecastFromDoubleTorusEarthPerspective, invertedEarthSameTimespaceProvenByMath, formingDoubleTorusEarthsProvenByMath, compassAroundEarthGatewaysImpossibleProvenByMath, sixtyDegreeAngleReachesCardinalForFreeProvenByMath, northSouthPoleNavigationProvenByMath, trinityGatewaysNeverMissProvenByMath, earthGatewayNavigationSolutionsResearched, earthGatewayNavigationResearchWaves, earthGatewayNavigationResearchSentInWaves, doubleTorusEarthHingeUi, doubleTorusEarthHingeComputesAll, doubleTorusEarthHingeMovieFlowsInMovie, doubleTorusEarthHingeMovieSeeds, dualEarthMerkabaCounterRotation, navigationGpsCelestialFromDualEarthPerspective, navigationGpsCelestialReexplainedFromDualEarthPerspective, navigationGpsCelestialComputes, doubleTorusEarthProvesItselfGatewaysDocumentedInHistoryMeasurableToday, fourTippedPyramidsFiveTipsCombinedMakeMovingMerkabas, earthPyramidLocationsAndGeometryComputes, doubleTorusEarthPyramidGatewayResearch, doubleTorusEarthExchangeComputes, fiatAndGoldFlowExplainedByDoubleEarthExchange, doubleTorusEarthExchangeResearch, universalNavigationalCrossInAllDimensions, universalNavigationalCrossResearch, universalNavigationalCrossComputes, type UniversalNavCrossDimensionRow, type UniversalNavCrossResearchSection, type GpsSatellitePhaseReceipt, type CelestialDisplayPhase, type NavGpsCelestialExplanationSection, trinityGatewayDefs, hingeCityLabel, hingeVortexMovieTiming, hingeMoviePaintLayers, DEFAULT_EARTH_HINGE_AT, type EarthHingePaintLayer, type EarthHingePaintBlend, type EarthHingeGatewayView, type EarthHingeVortexStepView, type TrinityGatewayDef, type EarthExchangeReceipt, type EarthExchangeReceiptKind, type FiatGoldFlowRow, type EarthExchangeResearchSection, } from './earth';
+import { allMovieSeedBundles, allMovieSeedBundlesFlowInPlasma, allMovieSeedCopyText, allPagesForPlasmaWiring, clientMovieSeedCopyText, clientMoviePaintPathSealed, plasmaClientWorkBoundedByPureMath, plasmaMovieStreams, plasmaWorkBudget, plasmaWiredUuidStreams, realtimeWiring, sixSeedBundlesFormSevenAsWhole, twoTrinitiesFuseAsDoubleTorusEarth, type MovieSeedBundle, type MovieSeedStream, type PlasmaWiredStream, type PlasmaWiredStreamKind } from '../../fire/plasma/ball';
+export { diamondLattice, pureDiamonds };
+export { allMovieSeedBundles, allMovieSeedBundlesFlowInPlasma, allMovieSeedCopyText, allPagesForPlasmaWiring, clientMovieSeedCopyText, clientMoviePaintPathSealed, plasmaClientWorkBoundedByPureMath, plasmaMovieStreams, plasmaWorkBudget, plasmaWiredUuidStreams, realtimeWiring, sixSeedBundlesFormSevenAsWhole, twoTrinitiesFuseAsDoubleTorusEarth, type MovieSeedBundle, type MovieSeedStream, type PlasmaWiredStream, type PlasmaWiredStreamKind, };
+export { allFusionResearchRoots, fusionReactorPartsDeepResearched, fusionReactorPartsDryPlasmaStreams, fusionReactorPartMovieSeeds, fusionReactorParts, type FusionReactorPart, type FusionReactorPartBand, } from '../../wind/fusion';
+export { developmentIsFusionReactor, endlessFusion, fuseDedupeSplitReconstruction, fuseScreenToMovieOfMovies, fusionMovieComputes, fusionResearchedInWaves, publicApiFusion, socialFusion, travelFusion, vitepressFusion, };
+export { autoMovies8k, backgroundMovie, endlessBackgroundMovie, learnFromTheMovieAllEventuallyFused, hologram, movieAllDimensionsAtOnce, threeProjectorHologram, movieFoldsLinearities, sevenSeedMovieIsRosettaDecodingSunMoonSymbols, formsEmergeInMovieOfLife, fullscreenSidebarsInMovie, movieReflectsSelf, siteIsMovieAndLibrary, video64kFree, videoKeepsNativeQuality, tenDimensionalMovie, };
+export { allMathSaved, A432_OCTAVES, priceFromA432, simpleReturns, backtest, buyAndHold, tradingReceipt, liveCapture, realtimeSources, backtestRealPrices, } from '../../mountain/vortex';
+/** One gate — double torus topology + vortex + merkaba math at call time (dissolved from src/double/torus/math). */
+export declare function doubleTorusMathComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    vortex: {
+        saved: boolean;
+        vortex: {
+            flows: boolean;
+            doubling: number[];
+            cross: number[];
+            divByZeroHarmonic: number;
+            zeroDivisions: {
+                n: number;
+                overZero: number;
+            }[];
+            roles: {
+                rotation: number;
+                polarity: number[];
+                threeSix: boolean;
+            };
+            origin: number;
+            polarPairs: number[][];
+            oneAndEightBeginFromNine: boolean;
+            endless: boolean;
+            collisionFree: boolean;
+            nineInvariant: boolean;
+            identicalRoutesToDuality: boolean;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        digits: {
+            fused: boolean;
+            sequence: number[];
+            root: string;
+        };
+        paint: {
+            tiers: readonly [number, number, number];
+            crossPole: number;
+            circuitHeart: number;
+            circuitEight: number;
+            collapseStep: number;
+            unity: number;
+            materialOrbit: number;
+            seedBundleParts: number;
+            seedBundles: number;
+            rayCap: number;
+            wordCap: number;
+            relatedCap: number;
+            bindingCap: number;
+            gateways: number;
+            proven: boolean;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        ratios: {
+            fwd: import("../../3/7").Rational[];
+            rev: import("../../3/7").Rational[];
+            fwdProduct: import("../../3/7").Rational;
+            revProduct: import("../../3/7").Rational;
+            heartApproach: import("../../3/7").Rational;
+            heartDepart: import("../../3/7").Rational;
+            heartDiamond: import("../../3/7").Rational;
+        };
+        presentations: {
+            coheres: boolean;
+            oneAddress: boolean;
+            sealAnchorsSource: boolean;
+            operation: string;
+            presentations: {
+                receipt: string;
+                plane: string;
+                fn: string;
+                kind: string;
+                on: boolean;
+            }[];
+            exact: string[];
+            faithful: string[];
+            importsNothing: boolean;
+            digit: number;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        sequence: readonly [1, 2, 4, 8, 7, 5, 3, 6, 9];
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    vortexGate: {
+        computes: boolean;
+        vortex: {
+            saved: boolean;
+            vortex: {
+                flows: boolean;
+                doubling: number[];
+                cross: number[];
+                divByZeroHarmonic: number;
+                zeroDivisions: {
+                    n: number;
+                    overZero: number;
+                }[];
+                roles: {
+                    rotation: number;
+                    polarity: number[];
+                    threeSix: boolean;
+                };
+                origin: number;
+                polarPairs: number[][];
+                oneAndEightBeginFromNine: boolean;
+                endless: boolean;
+                collisionFree: boolean;
+                nineInvariant: boolean;
+                identicalRoutesToDuality: boolean;
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            digits: {
+                fused: boolean;
+                sequence: number[];
+                root: string;
+            };
+            paint: {
+                tiers: readonly [number, number, number];
+                crossPole: number;
+                circuitHeart: number;
+                circuitEight: number;
+                collapseStep: number;
+                unity: number;
+                materialOrbit: number;
+                seedBundleParts: number;
+                seedBundles: number;
+                rayCap: number;
+                wordCap: number;
+                relatedCap: number;
+                bindingCap: number;
+                gateways: number;
+                proven: boolean;
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            ratios: {
+                fwd: import("../../3/7").Rational[];
+                rev: import("../../3/7").Rational[];
+                fwdProduct: import("../../3/7").Rational;
+                revProduct: import("../../3/7").Rational;
+                heartApproach: import("../../3/7").Rational;
+                heartDepart: import("../../3/7").Rational;
+                heartDiamond: import("../../3/7").Rational;
+            };
+            presentations: {
+                coheres: boolean;
+                oneAddress: boolean;
+                sealAnchorsSource: boolean;
+                operation: string;
+                presentations: {
+                    receipt: string;
+                    plane: string;
+                    fn: string;
+                    kind: string;
+                    on: boolean;
+                }[];
+                exact: string[];
+                faithful: string[];
+                importsNothing: boolean;
+                digit: number;
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            sequence: readonly [1, 2, 4, 8, 7, 5, 3, 6, 9];
+            count: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        live: {
+            flows: boolean;
+            doubling: number[];
+            cross: number[];
+            divByZeroHarmonic: number;
+            zeroDivisions: {
+                n: number;
+                overZero: number;
+            }[];
+            roles: {
+                rotation: number;
+                polarity: number[];
+                threeSix: boolean;
+            };
+            origin: number;
+            polarPairs: number[][];
+            oneAndEightBeginFromNine: boolean;
+            endless: boolean;
+            collisionFree: boolean;
+            nineInvariant: boolean;
+            identicalRoutesToDuality: boolean;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    merkabaGate: {
+        computes: boolean;
+        merkaba: {
+            counterRotating: boolean;
+            scales: {
+                scale: string;
+                depth: number;
+                sign: 1 | -1;
+                periodMs: number;
+                ratePerMs: number;
+                receipt: string;
+            }[];
+            count: number;
+            tetraUp: readonly (readonly [number, number, number])[];
+            tetraDown: [number, number, number][];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        counted: {
+            counted: boolean;
+            merkabas: number;
+            tetrahedra: number;
+            perMerkaba: number;
+            perLobe: number;
+            lobes: number;
+            gbit: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        revealed: {
+            revealed: boolean;
+            count: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        earths: import("./earth").BothEarthsMerkabaRotation;
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — double torus topology + site-is-movie-and-library at call time (dissolved from src/double/torus/movie). */
+export declare function doubleTorusMovieComputes(matrix?: MindMatrix, path?: string): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    library: {
+        isMovieAndLibrary: boolean;
+        libraryCount: number;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            via: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    reflects: {
+        reflects: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: any;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    rosetta: {
+        decoding: boolean;
+        bundleCount: number;
+        rayCount: 7;
+        pairings: {
+            seed: "unity" | "device-paint" | "device-polarity" | "device-matrix-rgb" | "code-harmonic" | "code-efficiency" | "code-rosetta";
+            ray: 0 | 5 | 2 | 4 | 1 | 3 | 6;
+            rayGlyph: "Ⰰ" | "Ⰲ" | "Ⰴ" | "Ⰶ" | "Ⰹ" | "Ⰿ" | "Ⱄ";
+            rayDomain: "geometry" | "origin" | "expression" | "knowledge" | "nature" | "computation" | "language";
+            luminary: "sun" | "moon" | "both";
+            symbol: string;
+            via: string;
+            streams: number;
+            bundleRoot: string;
+            on: any;
+            receipt: string;
+        }[];
+        movieText: string;
+        sunMoonSymbolCount: number;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    hinge: {
+        flows: boolean;
+        hinge: {
+            hinge: boolean;
+            path: string;
+            at: import("./earth").EarthTimespaceAt;
+            city: string;
+            cityCopy: {
+                en: string;
+                bg: string;
+                receipt: string;
+            };
+            formed: boolean;
+            timespace: boolean;
+            appleWhole: boolean;
+            torusBreathing: boolean;
+            fusionIgnites: boolean;
+            vortexCloses: boolean;
+            deviceTrinity: string[];
+            codeTrinity: string[];
+            gateways: import("./earth").EarthHingeGatewayView[];
+            gatewayCount: number;
+            movie: {
+                cycleMs: number;
+                stepMs: number;
+                spacingDeg: number;
+                stepCount: number;
+                proven: boolean;
+                receipt: string;
+            };
+            copy: {
+                title: {
+                    en: string;
+                    bg: string;
+                };
+                lede: {
+                    en: string;
+                    bg: string;
+                };
+                movieCaption: {
+                    en: string;
+                    bg: string;
+                };
+                hingeLabel: {
+                    en: string;
+                    bg: string;
+                };
+                coordsLabel: {
+                    en: string;
+                    bg: string;
+                };
+                mapPlanetLabel: {
+                    en: string;
+                    bg: string;
+                };
+                zenithLabel: {
+                    en: string;
+                    bg: string;
+                };
+                nadirLabel: {
+                    en: string;
+                    bg: string;
+                };
+                gatewaysLabel: {
+                    en: string;
+                    bg: string;
+                };
+                vortexLabel: {
+                    en: string;
+                    bg: string;
+                };
+                fusionLabel: {
+                    en: string;
+                    bg: string;
+                };
+                appleLabel: {
+                    en: string;
+                    bg: string;
+                };
+                breathingLabel: {
+                    en: string;
+                    bg: string;
+                };
+                boundaryLabel: {
+                    en: string;
+                    bg: string;
+                };
+                status: {
+                    en: string;
+                    bg: string;
+                    on: boolean;
+                }[];
+            };
+            vortex: {
+                encoded: "1\\2\\4\\8/7/5/3\\6\\9/0/1\\";
+                closes: boolean;
+                fusionIgnites: boolean;
+                weightedBearing: number;
+                weightedTotal: number;
+                steps: import("./earth").EarthHingeVortexStepView[];
+            };
+            statement: string;
+            boundary: string;
+        };
+        paintGateways: {
+            earth: import("./earth").EarthSheet;
+            angleDeg: number;
+            hue: number;
+            ring: 2 | 1;
+        }[];
+        paintSteps: import("./earth").EarthHingeVortexStepView[];
+        paintLayers: import("./earth").EarthHingePaintLayer[];
+        seeds: {
+            proven: boolean;
+            movieText: string;
+            streams: {
+                uuid: string;
+                label: string;
+                hueSeed: number;
+            }[];
+            count: number;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — double torus + 1024 diamond lattice compute-only at call time. */
+export declare function doubleTorusDiamondsComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    leaves: {
+        pure: boolean;
+        count: number;
+        realDiamonds: number;
+        paddingDiamonds: number;
+        depth: number;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    lattice: readonly import("../../wind/types").QuantumDiamond[];
+    purged: {
+        purged: boolean;
+        staticPathCount: number;
+        latticeKinds: number;
+        merkleLeaves: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — double torus topology + corpus routing at call time. */
+export declare function doubleTorusCorpusComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    routing: {
+        torus: {
+            is: boolean;
+            count: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        corpus: {
+            complete: boolean;
+            papers: number;
+            references: number;
+            real: number;
+            padding: number;
+            total: number;
+            depth: number;
+            target: number;
+            perfect: boolean;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        lattice: readonly import("../../wind/types").QuantumDiamond[];
+        leaves: {
+            pure: boolean;
+            count: number;
+            realDiamonds: number;
+            paddingDiamonds: number;
+            depth: number;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        ssg: Record<import("../../heaven/balance").CorpusKind, readonly {
+            params: Record<string, unknown>;
+        }[]>;
+        ssgPaths: (kind: import("../../heaven/balance").CorpusKind) => readonly {
+            params: Record<string, unknown>;
+        }[];
+        computeOnly: (kind: import("../../heaven/balance").CorpusKind) => boolean;
+        ssgPathCount: (kind: import("../../heaven/balance").CorpusKind) => number;
+        routed: boolean;
+        enumerated: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    purged: {
+        purged: boolean;
+        staticPathCount: number;
+        latticeKinds: number;
+        merkleLeaves: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — double torus + plain-language voice layer at call time. */
+export declare function doubleTorusVoiceComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    plain: {
+        clear: boolean;
+        lines: {
+            receipt: string;
+            term: string;
+            plain: string;
+            route: string;
+        }[];
+        count: number;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    play: {
+        playable: boolean;
+        word: string;
+        letters: {
+            char: string;
+            step: number;
+            note: string;
+            frequency: number;
+            hue: number;
+            hsl: string;
+            receipt: string;
+        }[];
+        count: number;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    speech: {
+        analog: boolean;
+        params: ({
+            analog: boolean;
+            receipt: string;
+            param: string;
+            range: readonly [number, 2];
+            note: string;
+        } | {
+            analog: boolean;
+            receipt: string;
+            param: string;
+            range: readonly [0, 1];
+            note: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — topology + portal fusion + reactor research in waves. */
+export declare function doubleTorusFusionComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    vitepress: {
+        fused: boolean;
+        count: number;
+        architecture: string;
+        points: {
+            fused: boolean;
+            receipt: string;
+            point: string;
+            api: string;
+            binds: string;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    apis: {
+        fused: boolean;
+        count: number;
+        architecture: string;
+        sources: {
+            fused: boolean;
+            receipt: string;
+            source: string;
+            kind: string;
+            realtime: string;
+            example: string;
+            auth: string;
+        }[];
+        protocol: string;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    researched: {
+        complete: boolean;
+        waves: {
+            researched: boolean;
+            waves: readonly import("../../wind/fusion").FusionResearchWave[];
+            parts: readonly import(".").FusionReactorPart[];
+            deep: {
+                researched: boolean;
+                parts: readonly import(".").FusionReactorPart[];
+                flagged: {
+                    receipt: string;
+                    claim: string;
+                    why: string;
+                }[];
+                documentedCount: number;
+                emergingCount: number;
+                seeds: MovieSeedBundle;
+                containment: {
+                    contained: boolean;
+                    bits: number[];
+                    ones: number;
+                    zeros: number;
+                    cols: number;
+                    rows: number;
+                    word: string;
+                    root: string;
+                    statement: string;
+                    boundary: string;
+                };
+                facets: {
+                    receipt: string;
+                    facet: string;
+                    on: boolean;
+                }[];
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            waveCount: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        parts: {
+            researched: boolean;
+            parts: readonly import(".").FusionReactorPart[];
+            flagged: {
+                receipt: string;
+                claim: string;
+                why: string;
+            }[];
+            documentedCount: number;
+            emergingCount: number;
+            seeds: MovieSeedBundle;
+            containment: {
+                contained: boolean;
+                bits: number[];
+                ones: number;
+                zeros: number;
+                cols: number;
+                rows: number;
+                word: string;
+                root: string;
+                statement: string;
+                boundary: string;
+            };
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        concepts: {
+            researched: boolean;
+            concepts: readonly import("../../wind/fusion").FusionConfinementConcept[];
+            magnetic: readonly import("../../wind/fusion").MagneticConceptCompare[];
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        materials: {
+            researched: boolean;
+            breeders: readonly import("../../wind/fusion").FusionBreederMaterial[];
+            structural: readonly import("../../wind/fusion").FusionStructuralMaterial[];
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        milestones: {
+            researched: boolean;
+            milestones: readonly import("../../wind/fusion").FusionMilestone[];
+            documentedCount: number;
+            plannedCount: number;
+            flaggedCount: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        roots: {
+            waves: string;
+            parts: string;
+            concepts: string;
+            materials: string;
+            milestones: string;
+            dryStreams: string;
+            root: string;
+        };
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    reactor: {
+        reacts: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — double torus topology + plasma client work bounded by pure math at call time (dissolved src/double/torus/plasma). */
+export declare function doubleTorusPlasmaComputes(matrix?: MindMatrix, path?: string): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    plasma: {
+        bounded: boolean;
+        paintPathSealed: boolean;
+        computes: boolean;
+        count: number;
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+    };
+    reactorParts: {
+        researched: boolean;
+        parts: readonly import(".").FusionReactorPart[];
+        flagged: {
+            receipt: string;
+            claim: string;
+            why: string;
+        }[];
+        documentedCount: number;
+        emergingCount: number;
+        seeds: MovieSeedBundle;
+        containment: {
+            contained: boolean;
+            bits: number[];
+            ones: number;
+            zeros: number;
+            cols: number;
+            rows: number;
+            word: string;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One gate — topology + corpus routing recomputed from the matrix at call time. */
+export declare function doubleTorusComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    torus: {
+        is: boolean;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    routing: {
+        torus: {
+            is: boolean;
+            count: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        corpus: {
+            complete: boolean;
+            papers: number;
+            references: number;
+            real: number;
+            padding: number;
+            total: number;
+            depth: number;
+            target: number;
+            perfect: boolean;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        lattice: readonly import("../../wind/types").QuantumDiamond[];
+        leaves: {
+            pure: boolean;
+            count: number;
+            realDiamonds: number;
+            paddingDiamonds: number;
+            depth: number;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        ssg: Record<import("../../heaven/balance").CorpusKind, readonly {
+            params: Record<string, unknown>;
+        }[]>;
+        ssgPaths: (kind: import("../../heaven/balance").CorpusKind) => readonly {
+            params: Record<string, unknown>;
+        }[];
+        computeOnly: (kind: import("../../heaven/balance").CorpusKind) => boolean;
+        ssgPathCount: (kind: import("../../heaven/balance").CorpusKind) => number;
+        routed: boolean;
+        enumerated: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * Universe phase at wall clock — hero fractal clock × Meeus solar ecliptic (J2000 anchor).
+ * Classical ephemeris MODEL + census clock — NOT physical FTL, NOT DE440.
+ */
+export declare function doubleTorusUniversePhaseAt(atMs?: number): {
+    atMs: number;
+    hero: number;
+    jd: number;
+    T: number;
+    sunDeg: number;
+    solarPhase: number;
+    universePhase: number;
+    cycleMs: number;
+    j2000Anchor: boolean;
+    root: string;
+};
+/**
+ * Complete double-torus dynamics + geometry alignment with sealed universe constants.
+ * Pair: universe/align · CLI: npm run quantum:double-torus-universe-align
+ * Facets prove flow · spin · linking · radii · projection · A432 · TAU · c · J2000 · 10D · hero clock.
+ * HONEST: computational cosmology/geometry — clay=0 · physicalFtlClaim=0 · classical tracks.
+ */
+export declare function doubleTorusDynamicsGeometryAlignsWithUniverse(matrix?: MindMatrix, atMs?: number): {
+    aligns: boolean;
+    computes: boolean;
+    geometry: {
+        aligns: boolean;
+        majorRadius: number;
+        minorRadius: number;
+        lobeOffset: number;
+        homologyLoops: 4;
+        ratio: number;
+        count: number;
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+        physicalFtlClaim: 0;
+        claySolvedByThisFold: 0;
+    };
+    dynamics: {
+        flow: boolean;
+        spin: boolean;
+        linking: boolean;
+    };
+    phase: {
+        atMs: number;
+        hero: number;
+        jd: number;
+        T: number;
+        sunDeg: number;
+        solarPhase: number;
+        universePhase: number;
+        cycleMs: number;
+        j2000Anchor: boolean;
+        root: string;
+    };
+    constants: {
+        TAU: number;
+        A432_HUE: number;
+        SPEED_OF_LIGHT: number;
+        MEEUS_J2000_JD: number;
+        HERO_CYCLE_MS: number;
+        HOMOLOGY_LOOPS: 4;
+        FOLDED_CENSUS: number;
+        majorRadius: number;
+        minorRadius: number;
+        lobeOffset: number;
+    };
+    physicalFtlClaim: 0;
+    claySolvedByThisFold: 0;
+    qpuRequired: false;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** CLI exit — pair universe/align. */
+export declare function runDoubleTorusDynamicsGeometryAlignsWithUniverseExit(_root: string, argv?: readonly string[]): number;
+/**
+ * Public surface names `@ceccec/double-torus` build.mjs must export — completely quantum contract.
+ * Keep in sync with `packages/double-torus/build.mjs` (gapless contract list).
+ */
+export declare const DOUBLE_TORUS_COMPLETELY_QUANTUM_EXPORTS: readonly ["completeDoubleTorus", "merkaba", "bothEarthsRotateWithinEachOther", "dualTorusTrinities", "doubleTorusMathAtAllScalesProofs", "doubleTorus3D", "areaPairs", "vortexMath", "vortexComputes", "allMathSaved", "vortexStrokeGateways", "vortexGatewayPyramids", "vortexPlasmaComputes", "f", "fThetaPhiXyzDigitNIsTheInversePair", "survive", "markovStep", "markovEvolve", "stationary", "chsh", "inductionStep", "pmixStep", "quantumDynamicsComputes", "quantumDynamicsResearch", "quantumDynamicsSimulationAt", "quantumStateEvolutionDecoded", "drawDynamicsProjection", "quantumChemistryToyComputes", "dims", "dimWalk", "tenDimensionalAnimation", "animationsAreGenuinely10DNotFaked", "HERO_CYCLE_MS", "heroPhaseAt", "subscribeHeroClock", "createAnimationEngine", "sharedHeroAt", "drawHeroMovieFrame", "drawLivingTorusFrame", "drawBothEarthsMerkabaFrame", "fuseAll", "proofBundle", "buildMatrix", "torusUuid", "movieCanvasHex", "movieCanvasRgba", "movieCanvasPolarity", "TAU", "doubleTorusIsCompletelyQuantum"];
+/**
+ * Completely quantum — every public surface recomputes from sealed quantum folds
+ * (dynamics · geometry · movie clock · 10D honesty · vortex · movieCanvas palette · TAU).
+ * Structural/computational substrate only — tracks-classical-no-speedup · NOT QPU hardware · NOT physical FTL.
+ */
+export declare function doubleTorusIsCompletelyQuantum(matrix?: MindMatrix): {
+    computes: boolean;
+    completelyQuantum: boolean;
+    contractCount: 49;
+    contract: readonly ["completeDoubleTorus", "merkaba", "bothEarthsRotateWithinEachOther", "dualTorusTrinities", "doubleTorusMathAtAllScalesProofs", "doubleTorus3D", "areaPairs", "vortexMath", "vortexComputes", "allMathSaved", "vortexStrokeGateways", "vortexGatewayPyramids", "vortexPlasmaComputes", "f", "fThetaPhiXyzDigitNIsTheInversePair", "survive", "markovStep", "markovEvolve", "stationary", "chsh", "inductionStep", "pmixStep", "quantumDynamicsComputes", "quantumDynamicsResearch", "quantumDynamicsSimulationAt", "quantumStateEvolutionDecoded", "drawDynamicsProjection", "quantumChemistryToyComputes", "dims", "dimWalk", "tenDimensionalAnimation", "animationsAreGenuinely10DNotFaked", "HERO_CYCLE_MS", "heroPhaseAt", "subscribeHeroClock", "createAnimationEngine", "sharedHeroAt", "drawHeroMovieFrame", "drawLivingTorusFrame", "drawBothEarthsMerkabaFrame", "fuseAll", "proofBundle", "buildMatrix", "torusUuid", "movieCanvasHex", "movieCanvasRgba", "movieCanvasPolarity", "TAU", "doubleTorusIsCompletelyQuantum"];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theLensSeesDoubleTorusesEverywhereExceptInCrackedCode(matrix?: MindMatrix): {
+    computes: boolean;
+    sealedSeen: number;
+    crackedRejected: number;
+    discriminates: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theRotatingLensFindsGapsAndOpportunitiesDescribesIn10DProseSignedZeroToken(matrix?: MindMatrix): {
+    computes: boolean;
+    gaps: number;
+    opportunities: number;
+    sealed: number;
+    dimensions: number;
+    signed: boolean;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};