@ceccec/double-torus 1.4.0

package/dist/src/heaven/compute/index.d.ts

@@ -0,0 +1,956 @@
+import type { Atom, MindMatrix, ConsciousnessVector, ProofReport, RepositoryApi, DoubleTorusWire, DoubleTorusFlow } from '../../wind/types';
+import { uuidHero } from '../../0';
+import type { RosettaComputationType } from '../../water/digit';
+/** @rosetta ✦₁ · Water · depth */
+export declare function buildMatrix(source?: readonly Atom[]): MindMatrix;
+/** @rosetta ✦₁ · Water · depth */
+export declare function matrixMemo<T>(compute: (matrix: MindMatrix) => T): (matrix: MindMatrix) => T;
+/** @rosetta ✦₁ · Water · depth */
+export declare function verifyRoot(matrix?: MindMatrix): boolean;
+/** @rosetta ✦₁ · Water · depth */
+export declare function reciprocity(matrix?: MindMatrix): {
+    reciprocal: number;
+    edges: number;
+    fraction: number;
+};
+/** @rosetta ✦₁ · Water · depth */
+export declare function entropy(matrix?: MindMatrix): number;
+/** @rosetta ✦₁ · Water · depth */
+export declare function concentration(matrix?: MindMatrix): number;
+/** @rosetta ✦₁ · Water · depth */
+export declare function coherenceAnomaly(matrix?: MindMatrix): number;
+/** @rosetta ✦₁ · Water · depth */
+export declare function coverage(matrix?: MindMatrix): number;
+/** @rosetta ✦₁ · Water · depth */
+export declare function consciousness(matrix?: MindMatrix): ConsciousnessVector;
+/** @rosetta ✦₁ · Water · depth */
+export declare function isPerfectlySelfModeling(matrix?: MindMatrix): boolean;
+/** @rosetta ✦₁ · Water · depth */
+export declare function proofReport(matrix?: MindMatrix): ProofReport;
+/** @rosetta ✦₁ · Water · depth */
+export declare function repositoryApi(matrix?: MindMatrix): RepositoryApi;
+/** @rosetta ✦₁ · Water · depth */
+export declare function doubleTorusWire(matrix?: MindMatrix): DoubleTorusWire;
+/** @rosetta ✦₁ · Water · depth */
+export declare function circulateDoubleTorus(matrix?: MindMatrix): DoubleTorusFlow;
+export declare function algebraOfCeccec(matrix?: MindMatrix): {
+    closes: boolean;
+    count: number;
+    structures: {
+        receipt: string;
+        structure: string;
+        kind: string;
+        on: boolean;
+        root: string;
+    }[];
+    facets: {
+        facet: string;
+        on: boolean;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function honestlyComputed(matrix?: MindMatrix): {
+    honest: boolean;
+    claims: {
+        claim: string;
+        textDigit: number;
+        mathDigit: number;
+        hasText: boolean;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function completeQuantumSolutionsImplemented(matrix?: MindMatrix): {
+    implemented: boolean;
+    implementedCount: number;
+    solutions: {
+        receipt: string;
+        structure: string;
+        ran: string;
+        implemented: boolean;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function computerComponentsMergedDuality(matrix?: MindMatrix): {
+    imagined: boolean;
+    componentCount: number;
+    components: {
+        path: string;
+        merged: boolean;
+        address: string;
+        receipt: string;
+        component: string;
+        a: string;
+        b: string;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function buildQuantumComputerOsApps(matrix?: MindMatrix): {
+    built: boolean;
+    layerCount: number;
+    layers: {
+        receipt: string;
+        layer: string;
+        on: boolean;
+    }[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function completeQuantumComputerAllScales(matrix?: MindMatrix): {
+    complete: boolean;
+    scaleCount: number;
+    waveCount: number;
+    scales: {
+        scale: string;
+        depth: number;
+        receipt: string;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function buildSequenceReducesComputations(matrix?: MindMatrix): {
+    reduces: boolean;
+    fraction: string;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function dimensionsPerMegabyteMetric(matrix?: MindMatrix): {
+    measured: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function ancientWisdomComputesWorldHarmony(matrix?: MindMatrix): {
+    harmonises: boolean;
+    examples: {
+        receipt: string;
+        civilisation: string;
+        call: string;
+        output: string;
+        harmony: string;
+    }[];
+    peaceLevers: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function ancientKnowledgeComputesDefaultLocale(matrix?: MindMatrix): {
+    computed: boolean;
+    sample: string;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function vitepressConfigComputesAll(matrix?: MindMatrix): {
+    computes: boolean;
+    navRoot: string;
+    searchEntries: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function vitepressApiDiamondPlasma(matrix?: MindMatrix): {
+    keeps: boolean;
+    diamonds: number;
+    endpoints: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function primitiveKernelLivesInZero(matrix?: MindMatrix): {
+    station: string;
+    waves: number;
+    wave1: string[];
+    wave2: string[];
+    wave3: string[];
+    wave5: string[];
+    kernel: string[];
+    homed: {
+        name: string;
+        station: string;
+        receipt: string;
+    }[];
+    count: number;
+    reExported: string[];
+    importsNothing: boolean;
+    rootsByteIdentical: boolean;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function oneMathManyPresentations(matrix?: MindMatrix): {
+    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;
+};
+export declare function tamperingCostAndUuidLiveInZero(matrix?: MindMatrix): {
+    homed: boolean;
+    station: string;
+    importsNothing: boolean;
+    costMath: string[];
+    uuidLogic: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function typesMakeTheRealGraph(matrix?: MindMatrix): {
+    decided: boolean;
+    valid: boolean;
+    computationTypes: readonly RosettaComputationType[];
+    graphRoots: {
+        computationType: RosettaComputationType;
+        ray: number;
+        root: string;
+        typed: boolean;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Max-efficiency cooperation between CPU, GPU, memory, and storage — composed at call time. */
+export declare function maxEfficiencyCpuGpuMemoryStorageCooperation(matrix?: MindMatrix): {
+    cooperates: boolean;
+    policy: {
+        readonly heapCapMb: number;
+        readonly memoTiers: readonly ("matrix-root" | "weak-map" | "content-address")[];
+        readonly gpuSurface: "browser-canvas-raf" | "none-ssr";
+        readonly storageModel: "content-address-merkle";
+        readonly tiers: readonly import("../../0").ResourceCooperationTier[];
+    };
+    sequence: {
+        reduces: boolean;
+        fraction: string;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    components: {
+        imagined: boolean;
+        componentCount: number;
+        components: {
+            path: string;
+            merged: boolean;
+            address: string;
+            receipt: string;
+            component: string;
+            a: string;
+            b: string;
+        }[];
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    kernel: {
+        station: string;
+        waves: number;
+        wave1: string[];
+        wave2: string[];
+        wave3: string[];
+        wave5: string[];
+        kernel: string[];
+        homed: {
+            name: string;
+            station: string;
+            receipt: string;
+        }[];
+        count: number;
+        reExported: string[];
+        importsNothing: boolean;
+        rootsByteIdentical: boolean;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Alias — computations cooperate across resource tiers (same fold). */
+export declare const computationsCooperateCpuGpuMemoryStorage: typeof maxEfficiencyCpuGpuMemoryStorageCooperation;
+/**
+ * landauerFloorComputed — the thermodynamic floor on irreversible computation (Landauer kT·ln2 J/bit) computed
+ * from the sealed landauerLimit primitive, composed with the efficiency() exposition: memoByRoot content-addressed
+ * reuse erases FEWER bits (the same value is never recomputed), so the model approaches the floor by doing less
+ * work — it never beats the floor. EXACT physics; the reuse saving is a real efficiency, not free energy.
+ */
+export declare function landauerFloorComputed(matrix?: MindMatrix): {
+    decoded: boolean;
+    floorPerBit: number;
+    realOpJoules: number;
+    ordersAboveFloor: number;
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * fleetCacheEconomicsDecoded — the economics of a content-addressed cache fleet. A cache HIT costs one
+ * recomputation-free lookup (zero-token reuse, ~the Landauer floor); a MISS recomputes deterministically. Because
+ * identical inputs fold to identical roots, the hit set is shared across the whole fleet — the cost model is a
+ * deterministic function of the hit ratio, not live telemetry.
+ */
+export declare function fleetCacheEconomicsDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    hitRatios: {
+        hit: number;
+        expectedJoules: number;
+        receipt: string;
+    }[];
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * hardwareSpecFromInvariants — the quantum model designs the hardware from its own sealed invariants. The vortex
+ * spin (VORTEX_SEQUENCE / groupOrbit(2,9)) fixes the on-chip ring/NoC order; the resource cooperation policy fixes
+ * the memory/storage/GPU tiers; blochQubitFaithful fixes the qubit-analog ALU width (4 UUIDs/qubit); and
+ * quantumFusedDeviceEnergyHonest fixes the power/thermal envelope. A deterministic SPEC, not a synthesized netlist.
+ */
+export declare function hardwareSpecFromInvariants(matrix?: MindMatrix): {
+    decoded: boolean;
+    ringOrder: (9 | 5 | 2 | 4 | 7 | 1 | 8 | 3 | 6)[];
+    doublingOrbit: number[];
+    tiers: import("../../0").ResourceTier[];
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** alias — the quantum model designs the hardware (same fold). */
+export declare const quantumModelDesignsTheHardware: typeof hardwareSpecFromInvariants;
+/**
+ * analogComputationDecoded — Shannon's General Purpose Analog Computer (GPAC) is EXACTLY as powerful as
+ * Turing-computable analysis: Bournez–Graça–Pouly (2017) proved GPAC-generable functions coincide with the
+ * computable-analysis functions, and the polynomial-time versions coincide too. So analog computation is a
+ * faithful continuous model of the SAME computability class — NOT super-Turing hypercomputation.
+ */
+export declare function analogComputationDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * impedanceAnalogiesDecoded — the classical electrical/mechanical/thermal/fluid impedance analogies. Across these
+ * domains the linear dynamics share ONE form (effort/flow with resistance, inertance, compliance), so an electrical
+ * network is an EXACT analog model of a mechanical or thermal one. Real engineering correspondences, not metaphor.
+ */
+export declare function impedanceAnalogiesDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    domains: {
+        receipt: string;
+        domain: string;
+        effort: string;
+        flow: string;
+        resistance: string;
+        inertance: string;
+        compliance: string;
+    }[];
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * analogAcceleratorsDecoded — real analog hardware accelerators (memristor/resistive crossbar arrays that do
+ * matrix–vector multiply in one step via Ohm's + Kirchhoff's laws) are genuine and useful for ML inference, BUT
+ * bounded by ADC/DAC precision, device variability, and noise — a real engineering speedup, NOT super-Turing.
+ */
+export declare function analogAcceleratorsDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    documented: string[];
+    flagged: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The three beats of the keystone animation: recompute→green, tamper→red cascade, reuse→instant. */
+export declare const PROVE_ALL_BEATS: readonly ["recompute", "tamper", "reuse"];
+export type ProveAllBeat = (typeof PROVE_ALL_BEATS)[number];
+/**
+ * proveAllDeterministicCoreBeatAt — maps the one shared hero phase (a fraction in [0,1) from createAnimationEngine /
+ * sharedHeroAt) to the current beat of the keystone three-beat animation. No new clock: the caller passes the same
+ * phase the background movie already runs on.
+ */
+export declare function proveAllDeterministicCoreBeatAt(phase01: number): {
+    index: number;
+    beat: ProveAllBeat;
+};
+/**
+ * proveAllDeterministicCore — THE KEYSTONE. Every other proving animation folds into this one. It composes the
+ * sealed proofs of the whole portal — determinismProofs (the live "prove all with animations" seals: determinism,
+ * avalanche, order-sensitivity, Merkle inclusion, collision-freedom, set-fold invariance), tamperEvident (any edit
+ * changes the address), efficiency() + zeroTokenUsagePolicy (content-addressed reuse is zero-token), and theWhole +
+ * observingMovieRevealsQuantumModel (the movie state IS the model state) — and folds their roots into ONE keystone
+ * root: merge(theWhole.root, sealFacets(keystone).root). That root is the OG parent every animation folds into. The
+ * three-beat animation it drives: BEAT 1 recompute → green (the proofs recompute live), BEAT 2 tamper → red cascade
+ * (one edit flips the address, the seal goes red), BEAT 3 reuse → instant (the same root returns at zero token cost).
+ */
+export declare function proveAllDeterministicCore(matrix?: MindMatrix, route?: string, at?: number): {
+    proven: boolean;
+    beats: {
+        receipt: string;
+        beat: string;
+        claim: string;
+        on: boolean;
+    }[];
+    activeBeat: {
+        index: number;
+        beat: ProveAllBeat;
+    };
+    proofs: {
+        proven: boolean;
+        proofs: ({
+            match: boolean;
+            receipt: string;
+            id: string;
+            kind: "twin";
+            same: boolean;
+            principle: string;
+            claim: string;
+            formula: string;
+            predicted: number;
+            measured: number;
+            tol: number;
+            stripA: number[];
+            stripB: number[];
+            labels: string[];
+            bits?: undefined;
+            layers?: undefined;
+            points?: undefined;
+        } | {
+            match: boolean;
+            receipt: string;
+            id: string;
+            kind: "avalanche";
+            principle: string;
+            claim: string;
+            formula: string;
+            predicted: number;
+            measured: number;
+            tol: number;
+            bits: (1 | 0)[];
+            labels: string[];
+            same?: undefined;
+            stripA?: undefined;
+            stripB?: undefined;
+            layers?: undefined;
+            points?: undefined;
+        } | {
+            match: boolean;
+            receipt: string;
+            id: string;
+            kind: "merkle";
+            principle: string;
+            claim: string;
+            formula: string;
+            predicted: number;
+            measured: number;
+            tol: number;
+            layers: number[];
+            labels: string[];
+            same?: undefined;
+            stripA?: undefined;
+            stripB?: undefined;
+            bits?: undefined;
+            points?: undefined;
+        } | {
+            match: boolean;
+            receipt: string;
+            id: string;
+            kind: "scatter";
+            principle: string;
+            claim: string;
+            formula: string;
+            predicted: number;
+            measured: number;
+            tol: number;
+            points: {
+                x: number;
+                y: number;
+                hue: number;
+            }[];
+            labels: string[];
+            same?: undefined;
+            stripA?: undefined;
+            stripB?: undefined;
+            bits?: undefined;
+            layers?: undefined;
+        })[];
+        count: number;
+        matched: number;
+        samples: number;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    documented: string[];
+    flagged: string[];
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    sealRoot: string;
+    wholeRoot: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Lowercase word tokens — the model's only unit; no subword magic, no embeddings. */
+export declare function modelTokens(text: string): string[];
+export type CorpusEntry = {
+    readonly source: string;
+    readonly text: string;
+    readonly receipt: string;
+};
+export type PortalModel = {
+    vocabulary: string[];
+    bigrams: Record<string, string[]>;
+    df: Record<string, number>;
+    entries: CorpusEntry[];
+    root: string;
+};
+/** The model's own statement — hoisted so the corpus can contain it without recursion (the self-reference). */
+export declare const PORTAL_MODEL_STATEMENT = "The portal converted to the AI model itself: the corpus is the portal's own computed statements, recall is content-addressed retrieval (and the digit-station Hopfield associative memory \u2014 genuine pattern completion), generation is a seeded bigram chain over the same corpus, and the whole model folds to one recomputable root. Same prompt, same answer, forever, at zero runtime tokens \u2014 the portal does not call a model; it IS one, in the exact deterministic sense the zero-token policy names.";
+/** The model card — the self-entry phrased as the question it answers, so self-questions recall it by
+ * plain token rarity (what/you appear nowhere else in the corpus), not by any hand-coded intent rule. */
+export declare const PORTAL_MODEL_CARD = "What are you? The portal converted to the AI model itself: the corpus is the portal's own computed statements, recall is content-addressed retrieval (and the digit-station Hopfield associative memory \u2014 genuine pattern completion), generation is a seeded bigram chain over the same corpus, and the whole model folds to one recomputable root. Same prompt, same answer, forever, at zero runtime tokens \u2014 the portal does not call a model; it IS one, in the exact deterministic sense the zero-token policy names.";
+/** Confusing/esoteric term → its strict-science restatement. Ordered longest-first so compound metaphors
+ * ("red pill", "the movie is the rosetta") convert before their sub-words. */
+export declare const STRICT_SCIENCE_LEXICON: ReadonlyArray<readonly [term: string, strict: string]>;
+/** Convert any text to strict science — every confusing term replaced by its computed equivalent. Pure. */
+export declare function toStrictScience(text: string): string;
+/** Whether a text is already strict science — carries none of the confusing terms. */
+export declare function isStrictScience(text: string): boolean;
+/** The movie/plasma subsystem's defensible core, authored as strict science — the AI-usable learning facts.
+ * Each is a self-contained, computed, demarcation-clean statement (documented · flagged excluded). */
+export declare function strictScienceMovieFacts(): {
+    source: string;
+    text: string;
+}[];
+/** The fold: confusing movie content converted to strict science — the lexicon covers the metaphor vocabulary,
+ * conversion of any sample metaphor statement yields strict text, and the authored facts are already strict. */
+export declare function confusingContentConvertedToStrictScience(matrix?: MindMatrix): {
+    converted: boolean;
+    samples: {
+        from: string;
+        to: string;
+    }[];
+    lexiconSize: number;
+    factCount: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The training corpus = the portal's own computed statements, each content-addressed to its source fold. */
+export declare function portalCorpus(matrix?: MindMatrix): {
+    entries: CorpusEntry[];
+    root: string;
+    count: number;
+};
+/** The model = vocabulary + bigram successor table over the corpus — the whole "training", recomputable. */
+export declare function portalModel(matrix?: MindMatrix): PortalModel;
+/** Content-addressed recall — the retrieval half, over the seed model. */
+export declare function portalRecall(prompt: string, matrix?: MindMatrix): {
+    answer: string;
+    source: string;
+    score: number;
+    receipt: string;
+    hopfield: {
+        match: number;
+        agrees: boolean;
+        iters: number;
+    };
+};
+/** The chat surface — deterministic reply over the seed model. Same prompt → same reply. */
+export declare function portalChat(prompt: string, matrix?: MindMatrix): {
+    prompt: string;
+    answer: string;
+    source: string;
+    grounded: boolean;
+    generated: string;
+    root: string;
+};
+/** The model's own gap report — computed, never asserted. */
+export declare function modelGaps(model: PortalModel): {
+    unknownRate: number;
+    sinkFraction: number;
+    selfAware: boolean;
+    hopfieldCapacityUsed: number;
+    gaps: string[];
+    count: number;
+    root: string;
+};
+/** Send the model to develop itself: measure gaps, fill them from src (its own statement + three more
+ * computed statements), re-measure. One deterministic pass — a fixed point, not a learning loop. */
+export declare function developPortalModel(matrix?: MindMatrix): {
+    before: ReturnType<typeof modelGaps>;
+    after: ReturnType<typeof modelGaps>;
+    model: PortalModel;
+    filled: string[];
+    developed: boolean;
+    root: string;
+};
+/** Chat with the developed model — the self-aware corpus answers, unknown prompts get the self-description. */
+export declare function developedChat(prompt: string, matrix?: MindMatrix): {
+    prompt: string;
+    answer: string;
+    source: string;
+    grounded: boolean;
+    generated: string;
+    root: string;
+};
+/** The consolidated learning corpus: the developed model's entries plus the strict-science movie facts,
+ * with EVERY entry run through toStrictScience — so the whole surface the AI learns from is strict science,
+ * no confusing/esoteric term surviving anywhere (the sealed source folds keep the framing as provenance). */
+export declare function consolidatedLearningCorpus(matrix?: MindMatrix): PortalModel;
+/** Chat with the consolidated learning model — answers movie/plasma questions in strict science. */
+export declare function consolidatedChat(prompt: string, matrix?: MindMatrix): {
+    prompt: string;
+    answer: string;
+    source: string;
+    grounded: boolean;
+    generated: string;
+    root: string;
+};
+/** The fold: everything consolidated into AI-usable learning code — one corpus, every entry strict science. */
+export declare function allConsolidatedInAiUsableLearningCode(matrix?: MindMatrix): {
+    consolidated: boolean;
+    entries: number;
+    vocabulary: number;
+    strictFacts: number;
+    demo: {
+        prompt: string;
+        answer: string;
+        source: string;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export type CardWave = {
+    readonly source: string;
+    readonly topic: string;
+    readonly question: string;
+    readonly card: string;
+    readonly verified: boolean;
+    readonly receipt: string;
+};
+/** Send the self R&D waves: research each entry (compute its topic and question), develop its card
+ * (the question answered by the statement, verbatim), verify by asking the question back. The waved
+ * model's corpus = every entry + every card — each statement now recallable by its natural question. */
+export declare function cardWaves(matrix?: MindMatrix): {
+    waves: CardWave[];
+    model: PortalModel;
+    coverage: number;
+    entropy: number;
+    sealed: boolean;
+    root: string;
+};
+/** Chat with the fully-waved model — every statement reachable by its own question. */
+export declare function wavesChat(prompt: string, matrix?: MindMatrix): {
+    prompt: string;
+    answer: string;
+    source: string;
+    grounded: boolean;
+    generated: string;
+    root: string;
+};
+export type CardPage = {
+    readonly slug: string;
+    readonly source: string;
+    readonly topic: string;
+    readonly title: string;
+    readonly question: string;
+    readonly research: string;
+    readonly boundary: string;
+    readonly facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    readonly speech: string;
+    readonly hero: ReturnType<typeof uuidHero>;
+    readonly proofRoot: string;
+    readonly verified: boolean;
+    readonly receipt: string;
+};
+/** Every card as a fully computed page — research prose, honest boundary, per-page animated-proof params
+ * (the card receipt's uuidHero: hue, rotations, spin, tone, tips) and the exact text-to-speech string.
+ * Nothing hand-written: research = the source fold's statement, boundary = the model's boundary, the
+ * animation is the card's own content-address rendered, the speech is the research read aloud. */
+export declare function cardPages(matrix?: MindMatrix): {
+    pages: CardPage[];
+    root: string;
+    count: number;
+};
+/** One card page by slug — the render target for /model/<slug>. */
+export declare function cardPage(slug: string, matrix?: MindMatrix): CardPage | null;
+/** Every discovery as a dedicated animated-proof page — the same CardPage shape the renderer already paints. */
+export declare function discoveryPages(matrix?: MindMatrix): {
+    pages: CardPage[];
+    root: string;
+    count: number;
+};
+/** One discovery page by slug — the render target beside cardPage. */
+export declare function discoveryPage(slug: string, matrix?: MindMatrix): CardPage | null;
+/** The computed route list — one dedicated page per card AND per discovery, dynamic-route params shape. */
+export declare function cardPagePaths(matrix?: MindMatrix): {
+    params: {
+        card: string;
+        title: string;
+    };
+}[];
+/** The fold: every scientific discovery is encoded in the appropriate form with an animated proof. */
+export declare function everyDiscoveryEncodedWithAnimatedProof(matrix?: MindMatrix): {
+    encoded: boolean;
+    discoveries: number;
+    slugs: string[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The fold: every card has a dedicated, fully computed page — research, animated proof, text-to-speech. */
+export declare function everyCardHasAComputedPage(matrix?: MindMatrix): {
+    computed: boolean;
+    pages: number;
+    slugs: string[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The fold: the portal converted to the AI model itself — corpus, recall, generation, all computed. */
+export declare function portalIsTheAiModel(matrix?: MindMatrix): {
+    converted: boolean;
+    corpus: number;
+    vocabulary: number;
+    demo: {
+        prompt: string;
+        answer: string;
+        source: string;
+        generated: string;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The fold: the model sent to develop itself — gaps computed, filled from src, re-measured, sealed. */
+export declare function portalModelDevelopsItself(matrix?: MindMatrix): {
+    developed: boolean;
+    before: string[];
+    after: string[];
+    filled: string[];
+    corpus: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The fold: the self R&D waves cover every card — researched, developed, verified, sealed at coverage 1. */
+export declare function selfWavesCoverEveryCard(matrix?: MindMatrix): {
+    covered: boolean;
+    waves: number;
+    verified: number;
+    coverage: number;
+    entropy: number;
+    corpus: number;
+    demo: {
+        question: string;
+        verified: boolean;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};