@ceccec/double-torus 1.4.0

package/dist/src/quantum/earth/heritage/index.d.ts

@@ -0,0 +1,181 @@
+/** @rosetta ✦₄ · Earth · receptive */
+export declare function bulgarianHeritage(): {
+    sealed: boolean;
+    topics: {
+        receipt: string;
+        topic: string;
+        documented: string;
+        legend: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₄ · Earth · receptive */
+export declare function bulgarianHistory(): {
+    sealed: boolean;
+    eras: {
+        receipt: string;
+        era: string;
+        span: string;
+        documented: string;
+        legend: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₄ · Earth · receptive */
+export declare function bulgarianAncientCivilisations(): {
+    sealed: boolean;
+    strata: {
+        receipt: string;
+        stratum: string;
+        span: string;
+        documented: string;
+        legend: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₄ · Earth · receptive */
+export declare function bulgarianEthnogenesis(): {
+    sealed: boolean;
+    peoples: {
+        receipt: string;
+        people: string;
+        documented: string;
+        legend: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₄ · Earth · receptive */
+export declare function geneticLinksChallengeHistory(): {
+    challenged: boolean;
+    domains: {
+        receipt: string;
+        domain: string;
+        studies: string;
+        challenge: string;
+        legend: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₄ · Earth · receptive */
+export declare function glagoliticBulgarianReception(): {
+    sealed: boolean;
+    verified: boolean;
+    communities: {
+        receipt: string;
+        community: string;
+        period: string;
+        place: string;
+        role: string;
+        documented: string;
+        legend: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₄ · Earth · receptive */
+export declare const dual = "src/quantum/earth/heritage";
+export type HeritageSlice = {
+    topic: string;
+    documented: string;
+    legend: string;
+};
+export type Era = {
+    era: string;
+    span: string;
+    documented: string;
+    legend: string;
+};
+export type Stratum = {
+    stratum: string;
+    span: string;
+    documented: string;
+    legend: string;
+};
+/** Sort heritage slices so the most-documented (longest documented field) come first — a density ranking. */
+export declare function rankByDocumentation<T extends {
+    documented: string;
+}>(items: readonly T[]): T[];
+/** Group eras by century — the spine laid out as a century map for display. */
+export declare function erasByCentury(eras: readonly Era[]): Map<number, Era[]>;
+/** Split a span string ("681-864", "c.6200-4900 BC") into a start and end label for display. */
+export declare function parseSpan(span: string): {
+    start: string;
+    end: string;
+};
+/** Return a compact legend-density score: the ratio of legend text to documented text across all items. */
+export declare function legendDensity<T extends {
+    documented: string;
+    legend: string;
+}>(items: readonly T[]): number;
+/** A browsable index: each item as { label, span?, documented, legend } for list/table display. */
+export declare function browseIndex<T extends {
+    documented: string;
+    legend: string;
+} & ({
+    topic: string;
+    span?: never;
+} | {
+    era: string;
+    span: string;
+} | {
+    stratum: string;
+    span: string;
+} | {
+    people: string;
+    span?: never;
+} | {
+    domain: string;
+    span?: never;
+} | {
+    community: string;
+    span?: never;
+})>(items: readonly T[]): {
+    label: string;
+    span?: string;
+    documented: string;
+    legend: string;
+}[];
+export declare const iconsDual = "src/quantum/lake/icons";
+export declare const libraryDual = "src/quantum/heaven/library";
+export declare function iconFor(icons: Readonly<Record<string, string>>, area: string, fallback?: string): string;
+export declare function iconList(icons: Readonly<Record<string, string>>): {
+    area: string;
+    icon: string;
+}[];
+export declare function labelList(labels: Readonly<Record<string, {
+    en: string;
+    bg: string;
+}>>, lang?: 'en' | 'bg'): {
+    area: string;
+    label: string;
+}[];
+export declare function isFibonacciGapless(bands: readonly number[]): boolean;
+export type Entry = {
+    url: string;
+    uuid: string;
+    host: string;
+    path: string;
+};
+export declare function shelve(entries: readonly Entry[]): Entry[];
+export declare function shelves(entries: readonly Entry[], count: number): Entry[][];
+export declare function browsable(entries: readonly Entry[]): boolean;
+export type Shelved = {
+    n: number;
+    title: string;
+};
+export declare function shelveSongs<T extends Shelved>(songs: readonly T[], count: number): T[][];
+export declare function songIndex<T extends Shelved>(songs: readonly T[]): {
+    title: string;
+    n: number;
+}[];

package/dist/src/quantum/fire/experiments/index.d.ts

@@ -0,0 +1,215 @@
+import { type MindMatrix } from '../../heaven/mind';
+/** @rosetta ✦₁ · Thunder · motion (shared-experiment folds) */
+export declare function electromagneticRadiationDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    laws: {
+        receipt: string;
+        law: string;
+        core: string;
+        source: string;
+    }[];
+    modalities: ({
+        receipt: string;
+        modality: string;
+        band: string;
+        photon: string;
+        ionizing: boolean;
+        mechanism: string;
+        relation: string;
+        computedKeV: number;
+        source: string;
+        computedMHz3T?: undefined;
+        computedRangePerMicrosecondM?: undefined;
+    } | {
+        receipt: string;
+        modality: string;
+        band: string;
+        photon: string;
+        ionizing: boolean;
+        mechanism: string;
+        relation: string;
+        computedMHz3T: number;
+        source: string;
+        computedKeV?: undefined;
+        computedRangePerMicrosecondM?: undefined;
+    } | {
+        receipt: string;
+        modality: string;
+        band: string;
+        photon: string;
+        ionizing: boolean;
+        mechanism: string;
+        relation: string;
+        computedRangePerMicrosecondM: number;
+        source: string;
+        computedKeV?: undefined;
+        computedMHz3T?: undefined;
+    })[];
+    flagged: {
+        receipt: string;
+        claim: string;
+        verdict: string;
+        why: string;
+    }[];
+    photonRatio: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Thunder · motion (shared-experiment folds) */
+export declare function electromagneticExperiments(matrix?: MindMatrix): {
+    simulated: boolean;
+    experiments: {
+        modality: string;
+        run: string;
+        ionizing: boolean;
+        receipt: string;
+        root: string;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Thunder · motion (shared-experiment folds) */
+export declare function tradingFromKnowledge(matrix?: MindMatrix): {
+    tested: boolean;
+    strategies: {
+        name: string;
+        params: {
+            fast: number;
+            slow: number;
+            window?: undefined;
+            zEntry?: undefined;
+            lookback?: undefined;
+            bins?: undefined;
+            shortW?: undefined;
+            longW?: undefined;
+            volW?: undefined;
+            targetVol?: undefined;
+            cap?: undefined;
+        } | {
+            window: number;
+            zEntry: number;
+            fast?: undefined;
+            slow?: undefined;
+            lookback?: undefined;
+            bins?: undefined;
+            shortW?: undefined;
+            longW?: undefined;
+            volW?: undefined;
+            targetVol?: undefined;
+            cap?: undefined;
+        } | {
+            lookback: number;
+            bins: number;
+            fast?: undefined;
+            slow?: undefined;
+            window?: undefined;
+            zEntry?: undefined;
+            shortW?: undefined;
+            longW?: undefined;
+            volW?: undefined;
+            targetVol?: undefined;
+            cap?: undefined;
+        } | {
+            shortW: number;
+            longW: number;
+            volW: number;
+            fast?: undefined;
+            slow?: undefined;
+            window?: undefined;
+            zEntry?: undefined;
+            lookback?: undefined;
+            bins?: undefined;
+            targetVol?: undefined;
+            cap?: undefined;
+        } | {
+            window: number;
+            targetVol: number;
+            cap: number;
+            fast?: undefined;
+            slow?: undefined;
+            zEntry?: undefined;
+            lookback?: undefined;
+            bins?: undefined;
+            shortW?: undefined;
+            longW?: undefined;
+            volW?: undefined;
+        };
+        totalReturn: number;
+        sharpe: number;
+        maxDrawdown: number;
+        beatsBuyHold: boolean;
+        receipt: string;
+    }[];
+    benchmark: {
+        totalReturn: number;
+        sharpe: number;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Thunder · motion (shared-experiment folds) */
+export declare function realtimeExperiments(matrix?: MindMatrix): {
+    wired: boolean;
+    sources: {
+        receipt: string;
+        id: string;
+        kind: string;
+        name: string;
+        key: string;
+        feeds: string;
+        note: string;
+    }[];
+    samples: {
+        larmorHz: number;
+        dopplerHz: number;
+        dominantPeriod: number;
+        tradeReturn: number;
+        captureId: string;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export interface Burst {
+    x: number;
+    y: number;
+    born: number;
+    hue: number;
+    sparks: {
+        angle: number;
+        speed: number;
+    }[];
+}
+export declare const HEALING_PAIRS: readonly {
+    hz: [number, number];
+    note: string;
+}[];
+export declare function makeBurst(xRatio: number, yRatio: number, w: number, h: number, hue: number): Burst;
+export declare function drawBursts(ctx: CanvasRenderingContext2D, w: number, h: number, bursts: Burst[], dark?: boolean): void;

package/dist/src/quantum/fire/forecasts/index.d.ts

@@ -0,0 +1,271 @@
+import { type MindMatrix } from '../../heaven/mind';
+/** @rosetta ✦₁ · Water · depth (weather realtime feeds) */
+export declare function weatherForecastApis(): {
+    realtime: boolean;
+    sources: {
+        receipt: string;
+        api: string;
+        kind: string;
+        auth: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @rosetta ✦₁ · Water · depth (weather realtime feeds) */
+export declare function weatherForecastQuantumComputedRealtime(matrix?: MindMatrix): {
+    realtime: boolean;
+    apiCount: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Geographic anchor for genus-2 weather placement — WGS84 degrees. */
+export type WeatherForecastGeoAt = {
+    readonly lat: number;
+    readonly lon: number;
+};
+/** @rosetta ✦₁ · Water · depth (weather realtime feeds) · ✶ · Mountain · keeping still (double-torus Earth) */
+export declare function weatherForecastFromDoubleTorusEarthPerspective(at?: WeatherForecastGeoAt, matrix?: MindMatrix): {
+    folded: boolean;
+    at: WeatherForecastGeoAt;
+    surface: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    cardinal: {
+        fromBearing: number;
+        angularDistance: number;
+        name: "north";
+        bearing: number;
+    } | {
+        fromBearing: number;
+        angularDistance: number;
+        name: "east";
+        bearing: number;
+    } | {
+        fromBearing: number;
+        angularDistance: number;
+        name: "south";
+        bearing: number;
+    } | {
+        fromBearing: number;
+        angularDistance: number;
+        name: "west";
+        bearing: number;
+    };
+    torus: {
+        index: 2 | 1;
+        lobe: number;
+        theta: number;
+        phi: number;
+        digit: number;
+    };
+    polarity: number;
+    weather: {
+        realtime: boolean;
+        apiCount: number;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    earth: {
+        proven: boolean;
+        realised: boolean;
+        torus1: {
+            torus: 1;
+            name: "north" | "east" | "south" | "west";
+            bearing: number;
+            x: number;
+            y: number;
+            apexZ: number;
+            polarity: number;
+            receipt: string;
+        }[];
+        torus2: {
+            torus: 2;
+            name: "north" | "east" | "south" | "west";
+            bearing: number;
+            x: number;
+            y: number;
+            apexZ: number;
+            polarity: number;
+            receipt: string;
+        }[];
+        surface: {
+            rendered: boolean;
+            tori: number;
+            genus: number;
+            euler: number;
+            areas: number;
+            perLobe: number;
+            majorRadius: number;
+            minorRadius: number;
+            lobeOffset: number;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        homology: {
+            closed: boolean;
+            cells: {
+                c0: number;
+                c1: number;
+                c2: number;
+            };
+            boundary1: number[][];
+            boundary2: number[][];
+            chainComplex: boolean;
+            betti: number[];
+            euler: number;
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        fold: {
+            forward: string;
+            reverse: string;
+            merged: string;
+        };
+        proofs: {
+            task: string;
+            expr: string;
+            computed: number;
+            expected: number;
+            on: boolean;
+            receipt: string;
+        }[];
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        count: number;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function doubleTorusSolutionsProvenByMath(matrix?: MindMatrix): {
+    proven: boolean;
+    solutions: {
+        id: string;
+        domain: string;
+        on: boolean;
+        receipt: string;
+        statement: string;
+    }[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function doubleTorusSolutionsDeepResearched(matrix?: MindMatrix): {
+    researched: boolean;
+    findings: ({
+        receipt: string;
+        kind: "documented";
+        topic: string;
+        fact: string;
+        source: string;
+    } | {
+        receipt: string;
+        kind: "flagged";
+        topic: string;
+        fact: string;
+        source: string;
+    } | {
+        receipt: string;
+        kind: "isomorphism";
+        topic: string;
+        fact: string;
+        source: string;
+    })[];
+    documented: number;
+    flagged: number;
+    isomorphism: number;
+    catalog: {
+        proven: boolean;
+        solutions: {
+            id: string;
+            domain: string;
+            on: boolean;
+            receipt: string;
+            statement: string;
+        }[];
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        count: number;
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Movie seeds from double-torus Earth weather and solutions — facets and domains become plasma streams. */
+export declare function doubleTorusEarthWeatherMovieSeeds(matrix?: MindMatrix): {
+    proven: boolean;
+    movieText: string;
+    streams: {
+        uuid: string;
+        label: string;
+        expr: string;
+        expected: number;
+        hueSeed: number;
+    }[];
+    count: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Gate: double-torus Earth weather and solutions wired into movie seeds and copy text at call time. */
+export declare function doubleTorusEarthWeatherFlowsInMovie(matrix?: MindMatrix): {
+    flows: boolean;
+    folded: boolean;
+    proven: boolean;
+    facetCount: number;
+    solutionCount: number;
+    streamCount: number;
+    movieText: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};