@ceccec/double-torus 1.4.0

package/dist/src/wind/ui/index.d.ts

@@ -0,0 +1,1109 @@
+import { EIGHT_CURRICULUM_SCIENCES } from '../../pair/enforcement/gates/computational';
+import type { MindMatrix } from '../types';
+import { type Dims } from '../../quantum/mountain/dimensions';
+export { scaleColor, oklchToHex } from '../../quantum/science';
+export { githubPermalink, SOURCE_REPO, revolutChannel, AUTHOR_HANDLE } from '../site';
+export declare function holographic(matrix?: MindMatrix): {
+    holographic: boolean;
+    reconstructed: boolean;
+    cells: {
+        kind: "animation" | "page";
+        name: string;
+        includedInWhole: boolean;
+        carriesWhole: boolean;
+        holographic: boolean;
+        cell: string;
+    }[];
+    count: number;
+    animations: number;
+    pages: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function holographicDashboard(matrix?: MindMatrix): {
+    holographic: boolean;
+    independent: boolean;
+    count: number;
+    panels: {
+        holographic: boolean;
+        root: string;
+        panel: string;
+        icon: string;
+        metrics: ({
+            label: string;
+            value: number;
+        } | {
+            label: string;
+            value: string;
+        })[];
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function animatedHeroes(matrix?: MindMatrix): {
+    everyPage: boolean;
+    holographic: boolean;
+    slider: boolean;
+    interactive: boolean;
+    count: number;
+    properties: {
+        holographic: boolean;
+        receipt: string;
+        property: string;
+        via: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function heroLawAlignment(matrix?: MindMatrix): {
+    aligned: boolean;
+    waves: number;
+    lawRoot: string;
+    lines: {
+        bound: boolean;
+        wave: string;
+        receipt: string;
+        line: string;
+        copy: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function navigationAroundHero(matrix?: MindMatrix): {
+    aroundHero: boolean;
+    hero: {
+        label: string;
+        route: string;
+    };
+    shellCount: number;
+    shells: {
+        tier: number;
+        radius: number;
+        name: string;
+        items: {
+            label: string;
+            route: string;
+            angle: number;
+            x: number;
+            y: number;
+            receipt: string;
+        }[];
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function compactHeroReplacesSimple(matrix?: MindMatrix): {
+    obsolete: boolean;
+    count: number;
+    reasons: {
+        receipt: string;
+        reason: string;
+        holds: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function oneHolographicTemplate(matrix?: MindMatrix): {
+    displayed: boolean;
+    count: number;
+    properties: {
+        receipt: string;
+        property: string;
+        via: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function holographicFractalArchitecture(matrix?: MindMatrix): {
+    is: boolean;
+    count: number;
+    properties: {
+        receipt: string;
+        property: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function freeAnimations(matrix?: MindMatrix): {
+    maxFree: boolean;
+    free: boolean;
+    bound: boolean;
+    channels: {
+        free: boolean;
+        clientCost: number;
+        networkCost: number;
+        seed: string;
+        bound: boolean;
+        channel: string;
+        sense: string;
+        motion: string;
+    }[];
+    count: number;
+    tamperingCost: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function textPayloadComputesToAnimation(matrix?: MindMatrix): {
+    converts: boolean;
+    payloadCount: number;
+    movies: {
+        receipt: string;
+        text: string;
+        root: string;
+        frames: number;
+        elements: number;
+        deterministic: boolean;
+        generated: boolean;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function proseToAudioVisual3dProof(matrix?: MindMatrix): {
+    converted: boolean;
+    proofCount: number;
+    proofs: {
+        point: number[];
+        hz: number;
+        hue: number;
+        is3D: boolean;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonisedDepthDialThreeD(matrix?: MindMatrix): {
+    harmonised: boolean;
+    depthStops: number;
+    perspectivePx: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function doubleTorusWiredToDepthDial(matrix?: MindMatrix): {
+    wired: boolean;
+    foldRange: readonly [3, 8];
+    euler: number;
+    areas: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function pagesRenderInBaguaSets(matrix?: MindMatrix): {
+    harmonised: boolean;
+    busiest: string;
+    busiestComponents: number;
+    busiestSets: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function heroLeadsTheWaves(matrix?: MindMatrix): {
+    leads: boolean;
+    conductor: string;
+    waves: {
+        receipt: string;
+        wave: string;
+        on: boolean;
+    }[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function heroSlimRespects64And42(matrix?: MindMatrix): {
+    slim: boolean;
+    words64: number;
+    areas42: number;
+    respects: {
+        receipt: string;
+        respects: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function allAnimationsInOneOg(matrix?: MindMatrix): {
+    computes: boolean;
+    count: number;
+    animations: {
+        animation: string;
+        computed: boolean;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function noDuplicateAnimationOgHero(matrix?: MindMatrix): {
+    consolidated: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: any;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function allAnimationsNative64k(matrix?: MindMatrix): {
+    native: boolean;
+    maxWidth: number;
+    count: number;
+    surfaces: {
+        receipt: string;
+        surface: string;
+        on: any;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function foldAnimationsToOneOgDry(matrix?: MindMatrix): {
+    dry: boolean;
+    count: number;
+    waves: {
+        animation: string;
+        resonates: boolean;
+        wave: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function anyUuidHeroContentFractal(matrix?: MindMatrix): {
+    fractal: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: any;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The stillness channel for SMIL hosts — strips every self-closed animate/animateTransform element. */
+export declare function stillSvg(svg: string): string;
+/** Per-UUID parametric hero (OG cards / forge chain). */
+export declare function heroSvgFromUuid(uuid: string, opts?: {
+    animate?: boolean;
+}): string;
+/**
+ * README hero — all sealed theorem atoms on two counter-rotating rosetta lobes (ω and −ω).
+ * Dynamics from merkaba + bothEarthsRotateWithinEachOther + fractalClockDur (SMIL for GitHub).
+ * Pair: edit/build · honesty: clay=0 · physicalFtl=0 · qpuRequired=false.
+ */
+export declare function readmeHeroSvgProofOfAllTheorems(matrix?: MindMatrix, opts?: {
+    animate?: boolean;
+}): string;
+export declare function tenDimensionalHeroSvg(): string;
+export declare function animatedTrigramIconSvg(trigram: number, opts?: {
+    animate?: boolean;
+}): string;
+export declare function hidingTextDoesNotHideAnimationsDiscovered(matrix?: MindMatrix): {
+    discovered: boolean;
+    realized: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** PWA icon — double torus glyph coloured from the movie palette (not static Tailwind hex). */
+export declare function computedIconSvg(matrix?: MindMatrix): string;
+/** Non-linear yin↔yang exchange → degrees (smoothstep+sin+vortex+ray — NOT linear i/frames). */
+export declare function taijiRosettaExchangeDegrees(frameIndex: number, frames: number, d: Dims, ray: number): number;
+export declare function yinYangDimensionsSvg(opts?: {
+    frames?: number;
+    scale?: number;
+    animate?: boolean;
+    size?: number;
+}): string;
+/** @rosetta ✦₂ · Wind · gentle — I Ching presented as yin-yang folding through all dimensions. */
+export declare function yinYangFoldsThroughDimensions(matrix?: MindMatrix): {
+    presented: boolean;
+    computes: boolean;
+    dimensions: number;
+    taiji: string;
+    ray: number;
+    exchangeMid: number;
+    linearMid: number;
+    svgBytes: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** A4 — animations driven by rosetta; yin-yang witness; linear i/frames = closed gap. */
+export declare function animationsDrivenByRosetta(matrix?: MindMatrix, at?: number): {
+    computes: boolean;
+    yinYang: {
+        presented: boolean;
+        computes: boolean;
+        dimensions: number;
+        taiji: string;
+        ray: number;
+        exchangeMid: number;
+        linearMid: number;
+        svgBytes: number;
+        count: number;
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    taijiRay: number;
+    offenders: {
+        computes: boolean;
+        rows: {
+            id: string;
+            process: string;
+            kind: "linear-forming";
+            criterion: string;
+            slow: boolean;
+            closed: boolean;
+            route: string;
+            receipt: string;
+        }[];
+        open: {
+            id: string;
+            process: string;
+            kind: "linear-forming";
+            criterion: string;
+            slow: boolean;
+            closed: boolean;
+            route: string;
+            receipt: string;
+        }[];
+        openCount: number;
+        closedCount: number;
+        facets: ({
+            receipt: string;
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: ({
+        receipt: string;
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    cli: string;
+    pair: string;
+    route: string;
+    statement: string;
+    boundary: string;
+};
+/** A1 — linear animation gaps (yin-yang first); closed when exchange ≠ linear midpoint. */
+export declare function linearAnimationGapsInventory(matrix?: MindMatrix, at?: number): {
+    computes: boolean;
+    rows: {
+        id: string;
+        process: string;
+        kind: "linear-forming";
+        criterion: string;
+        slow: boolean;
+        closed: boolean;
+        route: string;
+        receipt: string;
+    }[];
+    open: {
+        id: string;
+        process: string;
+        kind: "linear-forming";
+        criterion: string;
+        slow: boolean;
+        closed: boolean;
+        route: string;
+        receipt: string;
+    }[];
+    openCount: number;
+    closedCount: number;
+    facets: ({
+        receipt: string;
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** npm run quantum:animations-rosetta */
+export declare function runAnimationsRosettaGuardedExit(_root: string, _argv?: readonly string[]): number;
+/** Living I Ching SVG — drawn lines fold by bit; CSS @keyframes; scaleColor per line; animate:false → still. */
+export declare function livingIChingSvg(bits: number[], opts?: {
+    scale?: number;
+    animate?: boolean;
+    size?: number;
+}): string;
+export declare function livingTrigramSvg(trigram: number, opts?: {
+    scale?: number;
+    animate?: boolean;
+    size?: number;
+}): string;
+export declare function livingHexagramSvg(hexagram: number, opts?: {
+    scale?: number;
+    animate?: boolean;
+    size?: number;
+}): string;
+/** @rosetta ✦₂ · Wind · gentle */
+export declare function allSymbolsMoveAndFoldColoursComputedAtAllScales(matrix?: MindMatrix): {
+    rebuilt: boolean;
+    seedHue: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₂ · Wind · gentle — the lead that orders the render layer at every scale */
+export declare function iChingLeadsUiAtAllScales(matrix?: MindMatrix): {
+    leads: boolean;
+    scales: ({
+        bits: number;
+        n: number;
+        sino: string;
+        pinyin: string;
+        en: string;
+        leads: string;
+        glyphs?: undefined;
+    } | {
+        bits: number;
+        n: number;
+        sino: string;
+        pinyin: string;
+        en: string;
+        leads: string;
+        glyphs: string[];
+    })[];
+    components: {
+        name: string;
+        hexagram: number;
+        upper: number;
+        lower: number;
+        upperGlyph: string;
+        lowerGlyph: string;
+        color: string;
+        family: string;
+    }[];
+    octants: {
+        bits: number;
+        glyph: string;
+        pinyin: string;
+        name: string;
+        components: {
+            name: string;
+            hexagram: number;
+            upper: number;
+            lower: number;
+            upperGlyph: string;
+            lowerGlyph: string;
+            color: string;
+            family: string;
+        }[];
+    }[];
+    closureLimit: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function foldAsMuchToFeedHero(matrix?: MindMatrix): {
+    feeds: boolean;
+    heroHue: number;
+    heroSpinMs: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function heroGraphStatisticsEnrichFusion(matrix?: MindMatrix): {
+    merges: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function merkabaFoldsSpeechAnalogDialectsEntangle(matrix?: MindMatrix): {
+    entangles: any;
+    count: any;
+    facets: any;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function displayHeroCardThumb(matrix?: MindMatrix): {
+    displayed: boolean;
+    variants: string[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function tenDimensionalAnimation(matrix?: MindMatrix): {
+    tenDimensional: boolean;
+    grounded: boolean;
+    atEveryScale: boolean;
+    homologyLoops: ("spread" | "depthFade" | "hueShift" | "twist" | "shrink" | "breath" | "loopA1" | "loopB1" | "loopA2" | "loopB2")[];
+    crossFoldAxes: ("spread" | "depthFade" | "hueShift" | "twist" | "shrink" | "breath" | "loopA1" | "loopB1" | "loopA2" | "loopB2")[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function animationsRespectTheField(matrix?: MindMatrix): {
+    foundationReady: boolean;
+    complete: boolean;
+    fieldSources: {
+        receipt: string;
+        part: string;
+        source: string;
+        where: string;
+        does: string;
+    }[];
+    principles: {
+        receipt: string;
+        principle: string;
+        holds: boolean;
+        why: string;
+    }[];
+    wiring: ({
+        receipt: string;
+        component: string;
+        via: string;
+        wired: boolean;
+        note?: undefined;
+    } | {
+        receipt: string;
+        component: string;
+        via: string;
+        wired: boolean;
+        note: string;
+    })[];
+    wiredCount: number;
+    pending: string[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function completeUiAnimationsDesign(matrix?: MindMatrix): {
+    designed: boolean;
+    foundationDone: boolean;
+    completionDone: boolean;
+    planes: readonly {
+        readonly science: (typeof EIGHT_CURRICULUM_SCIENCES)[number];
+        readonly qc: string;
+        readonly summary: string;
+        readonly actions: readonly string[];
+        readonly surfaces: readonly string[];
+    }[];
+    cells: {
+        from: "see" | "learn" | "prove" | "pattern" | "sense" | "hear" | "ask" | "create";
+        to: "see" | "learn" | "prove" | "pattern" | "sense" | "hear" | "ask" | "create";
+        forward: string;
+        orderSensitive: boolean;
+    }[];
+    waves: readonly {
+        readonly wave: string;
+        readonly done: boolean;
+        readonly note: string;
+    }[];
+    fieldComplete: boolean;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function uiWidgetsFuseReveal(matrix?: MindMatrix): {
+    fused: boolean;
+    pair: {
+        forward: string;
+        reverse: string;
+        fuse: string;
+        reveal: string;
+    };
+    componentCount: number;
+    ichingRoot: string;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The shadcn primitives actually vendored as Ui* SFCs in .vitepress/theme/components/ui (Path A). */
+/** cva variant axes carried by the implemented primitives (variant/size enumerations). */
+export declare const SHADCN_VARIANTS: {
+    readonly Button: {
+        readonly variant: readonly ["default", "secondary", "outline", "ghost", "destructive", "link"];
+        readonly size: readonly ["default", "sm", "lg", "icon"];
+    };
+    readonly Badge: {
+        readonly variant: readonly ["default", "secondary", "outline", "destructive"];
+    };
+    readonly Alert: {
+        readonly variant: readonly ["default", "destructive"];
+    };
+};
+/** Design-system CSS-variable tokens (oklch new-york), bridged to VitePress --vp-* and .dark. */
+/** The cn() pattern the theme mount re-exports — tailwind-merge over clsx, the one class composer. */
+export declare const CN_PATTERN: "cn(...inputs) = twMerge(clsx(inputs)) \u2014 single class-name composer; theme re-exports from .vitepress/lib/cn.ts";
+/** Pure, dependency-free class join — the deterministic shadow of cn() for sealed callers (no twMerge dedupe). */
+export declare function cn(...inputs: Array<string | false | null | undefined>): string;
+/** The design-system research surface — sources, integration paths, the implemented-vs-graph delta. */
+export declare function shadcnResearch(matrix?: MindMatrix): {
+    researched: boolean;
+    sections: {
+        id: string;
+        title: string;
+        note: string;
+        receipt: string;
+    }[];
+    root: string;
+    boundary: string;
+};
+/** One gate — the canonical design-system registry composes with the 64-component graph at call time. */
+export declare function shadcnComputes(matrix?: MindMatrix, at?: number): {
+    computes: boolean;
+    graph: {
+        graphed: boolean;
+        components: {
+            form: string[];
+            overlay: string[];
+            layout: string[];
+            data: string[];
+            navigation: string[];
+            feedback: string[];
+            text: string[];
+        };
+        allComponents: string[];
+        tokens: string[];
+        deps: string[];
+        pathBDeps: string[];
+        paths: {
+            A: string;
+            B: string;
+        };
+        caveats: string[];
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    research: {
+        researched: boolean;
+        sections: {
+            id: string;
+            title: string;
+            note: string;
+            receipt: string;
+        }[];
+        root: string;
+        boundary: string;
+    };
+    implemented: readonly string[];
+    tokens: readonly ["--background", "--foreground", "--card", "--popover", "--primary", "--secondary", "--muted", "--accent", "--destructive", "--border", "--input", "--ring", "--radius"];
+    variants: {
+        readonly Button: {
+            readonly variant: readonly ["default", "secondary", "outline", "ghost", "destructive", "link"];
+            readonly size: readonly ["default", "sm", "lg", "icon"];
+        };
+        readonly Badge: {
+            readonly variant: readonly ["default", "secondary", "outline", "destructive"];
+        };
+        readonly Alert: {
+            readonly variant: readonly ["default", "destructive"];
+        };
+    };
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/**
+ * The COMPUTED act state at any phase p ∈ [0,1) — the single source both audiences consume: AI agents read
+ * this as data (see clownActTimeline), humans watch clownStepSvg render the SAME function as CSS keyframes.
+ * Nothing about the animation is assumed: position, lift, depth scale, fade, hue, shrink and the Bloch vector
+ * all derive from the sealed samplers (dims/dimWalk), the projection atoms (rot2/perspective) and the measured
+ * physics of clownActQuantumSteps.
+ */
+export declare function clownLiftState(phase: number, matrix?: MindMatrix, atStep?: number): {
+    p: number;
+    step: number;
+    name: string;
+    area: string;
+    vortex: 9 | 5 | 2 | 4 | 7 | 1 | 8 | 3 | 6;
+    channels: readonly string[];
+    dims: number;
+    shadow: {
+        x: number;
+        y: number;
+    };
+    walker: {
+        x: number;
+        y: number;
+        scale: number;
+        fade: number;
+    };
+    z: number;
+    hue: number;
+    shrink: number;
+    bloch: {
+        deg: number;
+        len: number;
+    };
+    receipt: string;
+};
+/** The computed act as a machine-readable timeline — 64 frames (the hexagram count) for agents; deterministic replay. */
+export declare function clownActTimeline(frames?: number, matrix?: MindMatrix): {
+    frames: number;
+    states: {
+        p: number;
+        step: number;
+        name: string;
+        area: string;
+        vortex: 9 | 5 | 2 | 4 | 7 | 1 | 8 | 3 | 6;
+        channels: readonly string[];
+        dims: number;
+        shadow: {
+            x: number;
+            y: number;
+        };
+        walker: {
+            x: number;
+            y: number;
+            scale: number;
+            fade: number;
+        };
+        z: number;
+        hue: number;
+        shrink: number;
+        bloch: {
+            deg: number;
+            len: number;
+        };
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** One clown step (0..5) as a self-contained CSS-@keyframes SVG — the UI computed from the I Ching + Rosetta. */
+export declare function clownStepSvg(step: number, opts?: {
+    animate?: boolean;
+    size?: number;
+}): string;
+/**
+ * THE WHOLE CLOWN LIFE — one animation, one loop of the same computed state function over the full act
+ * p ∈ [0,1): 96 samples (16 per step) + the closing frame, 36 s (6 × 6 — the d = 3 rung of the fractal
+ * clock, exactly 3 cycles per 108 s hero cycle; each step is the d = 18 rung). The 100% keyframe re-samples
+ * p = 0, so the loop closes on the state it opened with — the Bloch chain ends where it began (the bow's
+ * Zeno hold at 90° IS the entrance's unprepared 90°), the walker returns flat to the self-crossing, and the
+ * act re-enters through the figure-eight: the paper's purge fixed point (purge(clown) = clown), rendered.
+ * The hexagram builds line by line in computed step windows; the measured RECORDS persist once written
+ * (the IQ blob and the receipt stay to the loop's end — no-deleting), while the ghost fan dies with the
+ * coherence that made it. Agents read the same life as data: clownActTimeline.
+ */
+export declare function clownActSvg(opts?: {
+    animate?: boolean;
+    size?: number;
+}): string;
+/** @rosetta ✦₂ · Wind · gentle — the clown's own render: I Ching palette + Rosetta badges, physics beneath */
+export declare function clownUiDesignedByRosettaIChing(matrix?: MindMatrix): {
+    designed: boolean;
+    hexagram: number;
+    bits: (1 | 0)[];
+    accent: string;
+    dimLadder: number[];
+    timelineRoot: string;
+    steps: {
+        step: string;
+        area: string;
+        vortex: 9 | 5 | 2 | 4 | 7 | 1 | 8 | 3 | 6;
+        dims: number;
+        svgBytes: number;
+    }[];
+    svgBytes: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function cssBecomesAnotherUseCaseOfTheTheorems(matrix?: MindMatrix): {
+    useCase: boolean;
+    tokensBytes: number;
+    related: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function describeUntilDensityRevealsGatewaysThenGraphInHue(matrix?: MindMatrix): {
+    computes: boolean;
+    levels: {
+        edges: number;
+        avgDegree: number;
+        largest: number;
+        revealed: boolean;
+    }[];
+    revealedNodes: number;
+    distinctHues: number;
+    hues: number[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function rosettaIChingTopNav(matrix?: MindMatrix): {
+    computes: boolean;
+    doors: {
+        name: string;
+        rays: string[];
+    }[];
+    rayCount: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function rosettaIChingNavItems(): {
+    en: unknown[];
+    bg: unknown[];
+};
+export declare function theTopNavAnimatesOnTheFractalClockEachRayPulsesAtItsRungColouredByItsRosettaHue(matrix?: MindMatrix): {
+    computes: boolean;
+    rungs: string[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theFractalClockIsTheoremsNotConstantsTheRungCountIsTheDivisorFunctionOf108(matrix?: MindMatrix): {
+    computes: boolean;
+    rungCount: number;
+    derivedDivisorCount: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theSevenNavHuesAreTheSevenFoldWheelDivisionATheoremNotArbitraryColours(matrix?: MindMatrix): {
+    computes: boolean;
+    hues: (0 | 51 | 102 | 154 | 205 | 257 | 308)[];
+    wheelDivision: 7;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theA432NumberIsATheoremFourTimes108ButThe432HzTuningIsANamedAxiomNotPhysics(matrix?: MindMatrix): {
+    computes: boolean;
+    number: number;
+    divisorCount: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function theGatesAndWaysBecomeTheNavigationAndLinks(): {
+    navigates: boolean;
+    gates: number;
+    ways: number;
+    pagesReached: number;
+    nodeCount: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function completeTheIChingWithTheRosettaAllSixtyFourHexagramsSealedAtOnceInQuantum(): {
+    completes: boolean;
+    hexagrams: number;
+    trigrams: number;
+    seal: string;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theIChingChangingLinesAreQuantumGatesTheSixtyFourHexagramsFormTheHypercube(): {
+    changes: boolean;
+    hexagrams: number;
+    changingLineEdges: number;
+    diameter: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function animationsAreProofQuantumInteractionIsMissingComponentsInteractInTrinitiesTheBehaviorEmergesFromOneRule(): {
+    emerges: boolean;
+    components: number;
+    frames: number;
+    lessCode: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theNewUiDesignIsComputedFromTheCorpusWithoutAssumptionPaletteTypographySpacingAllDerived(): {
+    computes: boolean;
+    hues: (0 | 51 | 102 | 154 | 205 | 257 | 308)[];
+    typeScale: number[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};