@ceccec/double-torus 1.4.0

package/dist/src/lake/music/index.d.ts

@@ -0,0 +1,1273 @@
+import * as __ns_up_up_vortex_math from '../../mountain/vortex';
+import type { MindMatrix, PiMusic, PiNote } from '../../wind/types';
+export { SCHUMANN_FUNDAMENTAL_HZ } from '../../3/7';
+export declare function harmonicMap(matrix?: MindMatrix): {
+    distributed: boolean;
+    fundamental: number;
+    overtones: {
+        name: string;
+        overtone: number;
+        frequency: number;
+        octave: number;
+        note: string;
+        receipt: string;
+    }[];
+    bands: {
+        octave: number;
+        members: {
+            name: string;
+            overtone: number;
+            frequency: number;
+            octave: number;
+            note: string;
+            receipt: string;
+        }[];
+    }[];
+    count: number;
+    octaves: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function rhythm(matrix?: MindMatrix): {
+    keeps: boolean;
+    bpm: number;
+    beatMs: number;
+    voices: {
+        scale: string;
+        ratio: number;
+        periodMs: number;
+        frequency: number;
+        sign: 1 | -1;
+        offBeat: boolean;
+        onsets: number[];
+        receipt: string;
+    }[];
+    count: number;
+    onsetsPerBeat: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function allIsHarmonicSrcZeroGravity(matrix?: MindMatrix): {
+    harmonic: boolean;
+    dimensions: number;
+    sets: number;
+    foldedCensus: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function emrHologramSealedByMath(matrix?: MindMatrix): {
+    holographic: boolean;
+    spectralHue: number;
+    count: number;
+    facets: ({
+        receipt: string;
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonics(matrix?: MindMatrix): {
+    found: boolean;
+    fundamental: number;
+    octaves: {
+        kind: string;
+        step: number;
+        value: number;
+        ratio: string;
+        root: string;
+    }[];
+    overtones: {
+        kind: string;
+        step: number;
+        value: number;
+        ratio: string;
+        root: string;
+    }[];
+    binary: {
+        kind: string;
+        step: number;
+        value: number;
+        ratio: string;
+        root: string;
+    }[];
+    harmonics: {
+        implemented: boolean;
+        kind: string;
+        step: number;
+        value: number;
+        ratio: string;
+        root: string;
+    }[];
+    implementedCount: number;
+    restCount: number;
+    rest: {
+        kind: string;
+        value: number;
+        ratio: string;
+        root: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function freeHarmonicSocieties(matrix?: MindMatrix): {
+    rebuilt: boolean;
+    free: boolean;
+    forEveryone: boolean;
+    selfOrganising: boolean;
+    selfRegulating: boolean;
+    count: number;
+    societies: {
+        society: string;
+        harmonic: number;
+        free: boolean;
+        selfOrganising: boolean;
+        selfRegulating: boolean;
+        root: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function blockchainMusic(name?: string, matrix?: MindMatrix): {
+    plays: boolean;
+    harmonic: boolean;
+    name: string;
+    notes: {
+        index: number;
+        hash: string;
+        note: string;
+        frequency: number;
+        receipt: string;
+    }[];
+    distinctTones: number;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function soundColor(matrix?: MindMatrix): {
+    computed: boolean;
+    colors: {
+        note: string;
+        frequency: number;
+        hue: number;
+        hsl: string;
+        receipt: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function piMusic(matrix?: MindMatrix, joinHoro?: number): PiMusic;
+export declare function musicNote(matrix?: MindMatrix, wave?: number, joinHoro?: number): {
+    named: boolean;
+    wave: number;
+    note: string;
+    frequency: number;
+    digit: number;
+    joinHoro: number;
+    phrase: readonly PiNote[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function heroTapMusic(matrix?: MindMatrix): {
+    plays: boolean;
+    alwaysHealing: boolean;
+    pairCount: number;
+    count: number;
+    pairs: {
+        pair: readonly [number, number];
+        healing: boolean;
+        receipt: string;
+    }[];
+    features: {
+        receipt: string;
+        feature: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function tamperHealingFrequencies(matrix?: MindMatrix): {
+    costsMax: boolean;
+    caught: boolean;
+    forgeCostLog2: number;
+    sealed: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonicLicenseWaves(matrix?: MindMatrix): {
+    created: boolean;
+    karmicBalance: boolean;
+    monetised: boolean;
+    count: number;
+    clauses: {
+        harmonic: boolean;
+        wave: string;
+        receipt: string;
+        clause: string;
+        karma: string;
+        money: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonicMusicMayBeEnabled(matrix?: MindMatrix): {
+    mayBeEnabled: boolean;
+    count: number;
+    conditions: {
+        receipt: string;
+        condition: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function trinityEyesProvenHarmonic(matrix?: MindMatrix): {
+    provenHarmonic: boolean;
+    count: number;
+    seen: {
+        both: boolean;
+        receipt: string;
+        sees: string;
+        harmonic: boolean;
+        proven: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function polyrhythmDrumsKeepRhythm(matrix?: MindMatrix): {
+    keeps: boolean;
+    onsetsPerBeat: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** @deprecated use polyrhythmDrumsKeepRhythm — spiritual was unproven metaphor */
+export declare const spiritualDrumsKeepRhythm: typeof polyrhythmDrumsKeepRhythm;
+export declare function allMusicSelfHarmonises(matrix?: MindMatrix): {
+    selfHarmonises: boolean;
+    count: number;
+    sources: {
+        harmonises: boolean;
+        voice: string;
+        receipt: string;
+        source: string;
+        via: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function gatesShowGapsHarmonicPurpose(matrix?: MindMatrix): {
+    redirects: boolean;
+    count: number;
+    bands: {
+        receipt: string;
+        band: number;
+        purpose: string;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function healingHarmonic(matrix?: MindMatrix): {
+    harmonized: boolean;
+    probability: number;
+    inner: string;
+    outer: string;
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonicColorAndMusicOrNotQuantum(matrix?: MindMatrix): {
+    lawHolds: boolean;
+    rendered: {
+        hue: number;
+        hz: number;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function differentSongDifferentDance(matrix?: MindMatrix): {
+    plays: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function tuningSkillsA432(matrix?: MindMatrix): {
+    tunes: boolean;
+    fundamental: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function piNotHarmonic(matrix?: MindMatrix): {
+    realised: boolean;
+    divByZero: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: any;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function linearNotesFoldToMusic(matrix?: MindMatrix): {
+    folds: boolean;
+    notes: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function quantumSongNoteTrinity(matrix?: MindMatrix): {
+    plays: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function allOscillatorsHarmonicsFree(matrix?: MindMatrix): {
+    play: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonicPathRevealsItself(matrix?: MindMatrix): {
+    reveals: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonicFrequenciesDefineGateDigits(matrix?: MindMatrix): {
+    monitors: boolean;
+    base: number;
+    gates: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function infiniteComputedPaths404Harmonic(matrix?: MindMatrix): {
+    computes: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function soundWiredToOneSharedContext(matrix?: MindMatrix): {
+    wired: boolean;
+    soundComponents: number;
+    contextSites: number;
+    contextsSaved: number;
+    cap: number;
+    count: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function colorRootsAtA432HeartBalances(matrix?: MindMatrix): {
+    rooted: boolean;
+    baseHue: number;
+    heart: {
+        hsl: string;
+        receipt: string;
+        i: number;
+        name: string;
+        band: string;
+        hue: number;
+    };
+    chakras: {
+        hsl: string;
+        receipt: string;
+        i: number;
+        name: string;
+        band: string;
+        hue: number;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function a432IsTheBlood(matrix?: MindMatrix): {
+    isBlood: boolean;
+    bloodstream: boolean;
+    baseHue: number;
+    heart: {
+        hsl: string;
+        receipt: string;
+        i: number;
+        name: string;
+        band: string;
+        hue: number;
+    };
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function displayIsA432LightForgeProofRealtimeCrypto(matrix?: MindMatrix): {
+    holds: boolean;
+    peers: number;
+    collectiveRoot: string;
+    tamperEvident: boolean;
+    cryptographicFixBuilt: boolean;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function merkabaNavHarmonicPoints(matrix?: MindMatrix): {
+    aligned: boolean;
+    navHarmonic: number;
+    starVertices: number;
+    hexagramPoints: number;
+    areas: number;
+    points: {
+        name: string;
+        vertex: number;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function harmonicFractionsInDigitFolders(matrix?: MindMatrix): {
+    proved: boolean;
+    forward: string[];
+    reverse: string[];
+    heartApproach: string;
+    heartDepart: string;
+    heartDiamond: string;
+    cf9: string;
+    cf18: string;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export type HarmonicWindowPrediction = {
+    bar: number;
+    direction: 'up' | 'down' | 'flat';
+    score: number;
+    receipt: string;
+};
+/** Offline harmonic windows over a432-ignited synthetic prices — look-ahead-free mean-return sign. */
+export declare function predictHarmonicWindows(opts?: {
+    priceVariant?: string;
+    barCount?: number;
+    window?: number;
+}): HarmonicWindowPrediction[];
+/** Explain one offline harmonic-window prediction — deterministic breakdown, not alpha. */
+export declare function explainPrediction(prediction: HarmonicWindowPrediction): {
+    bar: number;
+    direction: "flat" | "up" | "down";
+    score: number;
+    explanation: string;
+    receipt: string;
+};
+/** Reproducible precision revelation — identical replay of offline harmonic windows (surprise = sameness). */
+export declare function harmonicPredictionSurprise(opts?: {
+    priceVariant?: string;
+    barCount?: number;
+}): {
+    surprised: boolean;
+    precise: boolean;
+    windows: HarmonicWindowPrediction[];
+    windowCount: number;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Documented Earth–ionosphere cavity ELF modes (Hz) — literature values, not live magnetometer data. */
+export declare const SCHUMANN_HARMONICS_HZ: readonly number[];
+/** Schumann cavity phase at instant `at` (ms) — locked to hero clock and humanBreath. */
+export declare function schumannPhaseAt(at: number, fundamentalHz?: number): number;
+/** Schumann ~7.83 Hz cavity model harmonised with realtime API compute receipts at `at`. */
+export declare function schumannResonanceHarmonisedWithRealtimeApiComputations(at?: number, matrix?: MindMatrix): {
+    harmonised: boolean;
+    computes: boolean;
+    at: number;
+    harmonics: {
+        hz: number;
+        mode: number;
+        phase: number;
+        hue: number;
+        receipt: string;
+    }[];
+    schumannPhase: number;
+    heroPhase: number;
+    ionospherePhase: number;
+    phaseDelta: number;
+    phaseLocked: boolean;
+    bound: {
+        bound: boolean;
+        liveApis: string[];
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    blood: {
+        isBlood: boolean;
+        bloodstream: boolean;
+        baseHue: number;
+        heart: {
+            hsl: string;
+            receipt: string;
+            i: number;
+            name: string;
+            band: string;
+            hue: number;
+        };
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    waves: import("../../wind/types").WaveCoordination;
+    breath: number;
+    dualEarth: __ns_up_up_vortex_math.BothEarthsMerkabaRotation;
+    freqApis: {
+        decoded: boolean;
+        sources: {
+            receipt: string;
+            api: string;
+            band: string;
+            data: string;
+            auth: string;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    modulatedReceipt: string;
+    facets: ({
+        facet: string;
+        on: boolean;
+    } & {
+        receipt: string;
+    })[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Alias — harmonise Schumann cavity phase with realtime API compute receipts. */
+export declare const harmoniseSchumannWithRealtimeApiComputations: typeof schumannResonanceHarmonisedWithRealtimeApiComputations;
+/** Human breath ↔ a432 blood stream ↔ coordinated waves ↔ offline harmonic prediction ↔ Schumann ELF bridge. */
+export declare function humanResonanceHarmonicPredictionComputes(matrix?: MindMatrix): {
+    computes: boolean;
+    resonant: boolean;
+    blood: {
+        isBlood: boolean;
+        bloodstream: boolean;
+        baseHue: number;
+        heart: {
+            hsl: string;
+            receipt: string;
+            i: number;
+            name: string;
+            band: string;
+            hue: number;
+        };
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    waves: import("../../wind/types").WaveCoordination;
+    breath: number;
+    surprise: {
+        surprised: boolean;
+        precise: boolean;
+        windows: HarmonicWindowPrediction[];
+        windowCount: number;
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    schumannBridge: {
+        harmonised: boolean;
+        computes: boolean;
+        at: number;
+        harmonics: {
+            hz: number;
+            mode: number;
+            phase: number;
+            hue: number;
+            receipt: string;
+        }[];
+        schumannPhase: number;
+        heroPhase: number;
+        ionospherePhase: number;
+        phaseDelta: number;
+        phaseLocked: boolean;
+        bound: {
+            bound: boolean;
+            liveApis: string[];
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        blood: {
+            isBlood: boolean;
+            bloodstream: boolean;
+            baseHue: number;
+            heart: {
+                hsl: string;
+                receipt: string;
+                i: number;
+                name: string;
+                band: string;
+                hue: number;
+            };
+            count: number;
+            facets: {
+                receipt: string;
+                facet: string;
+                on: boolean;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        waves: import("../../wind/types").WaveCoordination;
+        breath: number;
+        dualEarth: __ns_up_up_vortex_math.BothEarthsMerkabaRotation;
+        freqApis: {
+            decoded: boolean;
+            sources: {
+                receipt: string;
+                api: string;
+                band: string;
+                data: string;
+                auth: string;
+            }[];
+            root: string;
+            statement: string;
+            boundary: string;
+        };
+        modulatedReceipt: 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;
+};
+/** Observer of the one movie — recomputed at call time; watchMs is a persisted accumulator (H2 wires storage). */
+export type ObserverContext = {
+    readonly route: string;
+    readonly at: number;
+    readonly p: number;
+    readonly reduce: boolean;
+    readonly cssWidth: number;
+    readonly dark: boolean;
+    readonly idle: boolean;
+    readonly visible: boolean;
+    readonly watchMs: number;
+    readonly pointer?: {
+        readonly x: number;
+        readonly y: number;
+        readonly active: boolean;
+    };
+};
+/**
+ * Structural field slice harmonizeField mutates — SharedHeroState / AnimationField is assignable.
+ * No import from quantum/index (keeps H1 leaf-local; H3 wires the consumer).
+ */
+export type HarmonizeableField = {
+    readonly at: number;
+    readonly t: number;
+    readonly p: number;
+    readonly hue: number;
+    readonly reduce?: boolean;
+};
+/**
+ * A432 octave spine folded into EEG-named bands (literature Hz ranges) — structural map only.
+ * Sub-audio harmonics of 432 Hz land near documented neural oscillation bands + Schumann 7.83 Hz.
+ */
+export declare function a432NeuralBandLadder(matrix?: MindMatrix): {
+    computes: boolean;
+    bands: {
+        inLiteratureRange: boolean;
+        nearSchumann: boolean;
+        receipt: string;
+        name: string;
+        hzLo: number;
+        hzHi: number;
+        a432Hz: number;
+        octaveDiv: number;
+    }[];
+    spine: number[];
+    schumannHz: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Cadence (ms) eases from movie breath default toward ~10 s (0.1 Hz, ~6 breaths/min) as coherence rises. */
+export declare function breathCoherenceCadence(at: number, coherence: number): number;
+/**
+ * Phase-locking fraction ∈ [0,1): how many of 8 iching-style layers align with observer phase
+ * within an A432-derived tolerance. Pure — no stored state; watchMs lightly lifts the floor (H2 tiers deepen).
+ */
+export declare function observerObservationCoherenceAt(o: ObserverContext, field: HarmonizeableField): number;
+/**
+ * Pure harmonize: breath-paced phase + hue eased toward heart-balance green (120).
+ * Mutates only existing field fields (hue/p/t/at) — SharedHeroState assignable. No quantum import.
+ */
+export declare function harmonizeField<T extends HarmonizeableField>(o: ObserverContext, field: T): T;
+/** Gate fold — H1 core recomputes; consumer wiring is H3. */
+export declare function harmonizeFieldComputes(matrix?: MindMatrix, at?: number): {
+    computes: boolean;
+    ladder: {
+        computes: boolean;
+        bands: {
+            inLiteratureRange: boolean;
+            nearSchumann: boolean;
+            receipt: string;
+            name: string;
+            hzLo: number;
+            hzHi: number;
+            a432Hz: number;
+            octaveDiv: number;
+        }[];
+        spine: number[];
+        schumannHz: number;
+        count: number;
+        facets: {
+            receipt: string;
+            facet: string;
+            on: boolean;
+        }[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    observer: ObserverContext;
+    field: HarmonizeableField;
+    coherence: number;
+    cadence: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Fibonacci hero-cycle thresholds (census 55+34+21 spine) — tier = count crossed. */
+export declare const ATTUNEMENT_TIER_CYCLES: readonly [1, 2, 3, 5, 8, 13, 21];
+/** Half-saturation of unlock curve — 8 = iching fan-out on the hero clock (~16 min). */
+export declare const ATTUNEMENT_T_HALF_MS: number;
+/** Browser persistence key — content-addressed `{ ms, root }`. */
+export declare const WATCH_MS_STORAGE_KEY = "ceccec:watch-ms";
+/** Parse persisted watch-ms (SSR-safe). */
+export declare function parseWatchMsPersist(raw: string | null | undefined): number;
+/** Encode watch-ms with content-address root. */
+export declare function encodeWatchMsPersist(ms: number): string;
+/** Saturating unlock ∈ [0,1) — monotonic in watchMs. */
+export declare function unlock(watchMs: number): number;
+/**
+ * Attunement tier from coherent watch-time — Fib×HERO_CYCLE_MS thresholds.
+ * HONEST: progressive disclosure of modeled layers, not brain-capacity.
+ */
+export declare function attunementTier(watchMs: number): {
+    tier: number;
+    unlock: number;
+    thresholdsMs: number[];
+    dominantBandHz: number;
+    dominantBand: string;
+    lockedLayers: number;
+    partials: number;
+    root: string;
+    on: boolean;
+    boundary: string;
+};
+/** Harmonic depth unlocked at this watchMs — band names + partial count. */
+export declare function unlockedHarmonicDepth(watchMs: number): {
+    partials: number;
+    bands: string[];
+    tier: number;
+    unlock: number;
+    root: string;
+    on: boolean;
+    boundary: string;
+};
+/** Gate — H2 watch-time math recomputes at call time (no browser storage in the fold). */
+export declare function attunementWatchComputes(watchMs?: number, matrix?: MindMatrix): {
+    computes: boolean;
+    unlock0: number;
+    unlockHalf: number;
+    tier0: {
+        tier: number;
+        unlock: number;
+        thresholdsMs: number[];
+        dominantBandHz: number;
+        dominantBand: string;
+        lockedLayers: number;
+        partials: number;
+        root: string;
+        on: boolean;
+        boundary: string;
+    };
+    tier3: {
+        tier: number;
+        unlock: number;
+        thresholdsMs: number[];
+        dominantBandHz: number;
+        dominantBand: string;
+        lockedLayers: number;
+        partials: number;
+        root: string;
+        on: boolean;
+        boundary: string;
+    };
+    depth: {
+        partials: number;
+        bands: string[];
+        tier: number;
+        unlock: number;
+        root: string;
+        on: boolean;
+        boundary: string;
+    };
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** npm run trading:predict — offline harmonic windows + explainPrediction breakdown. */
+export declare function runTradingPredictExit(_root: string, _argv?: readonly string[]): number;
+/** Skilled enough when offline harmonic windows replay + wave calendar proxy hold at call time. */
+export declare function skilledEnoughFromPredictions(matrix?: MindMatrix): {
+    skilledEnough: boolean;
+    surprise: {
+        surprised: boolean;
+        precise: boolean;
+        windows: HarmonicWindowPrediction[];
+        windowCount: number;
+        facets: ({
+            facet: string;
+            on: boolean;
+        } & {
+            receipt: string;
+        })[];
+        root: string;
+        statement: string;
+        boundary: string;
+    };
+    trainedEnough: boolean;
+    waveCount: number;
+    windowCount: number;
+    statement: string;
+    boundary: string;
+};
+/** npm run quantum:predict-skill-gate-verify */
+export declare function runPredictSkillGateVerifyExit(_root: string, _argv?: readonly string[]): number;
+export declare function clownQubitDecoded(matrix?: MindMatrix): {
+    decoded: boolean;
+    layers: {
+        receipt: string;
+        layer: string;
+        core: string;
+        source: string;
+    }[];
+    flagged: {
+        receipt: string;
+        claim: string;
+        verdict: string;
+        why: string;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function clownActQuantumSteps(matrix?: MindMatrix): {
+    decoded: boolean;
+    steps: {
+        vortex: 9 | 5 | 2 | 4 | 7 | 1 | 8 | 3 | 6;
+        receipt: string;
+        step: string;
+        act: string;
+        route: string;
+        area: string;
+        physics: string;
+        numbers: string;
+        equation: string;
+        animator: string;
+        misconception: string;
+        source: string;
+    }[];
+    bits: (1 | 0)[];
+    hexagram: number;
+    landauer: number;
+    zeno64: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** THE CIRCLE OF FIFTHS IS A MOVING ROSETTA — the harmonic face of the day's C₆ (wave, 2026-07-16).
+ * Twelve-tone equal temperament is ℤ/12ℤ, and moving a fixed interval around it is a rosetta exactly
+ * as the slash circuit is: the FIFTH (7 semitones) generates all twelve tones because gcd(7,12)=1, so
+ * the circle of fifths is a Hamiltonian orbit visiting every note once — a moving rosetta a musician
+ * has always drawn. The generators are φ(12)=4 intervals {1,5,7,11} (semitone, fourth, fifth, major
+ * seventh); every other interval closes a SUBGROUP that is a chord — and the whole-tone scale is C₆,
+ * the SAME group as the vortex (theTwoRosettasAreOneGroup). Music theory is cyclic-group theory. */
+export declare function theCircleOfFifthsIsARosetta(matrix?: MindMatrix): {
+    computes: boolean;
+    fifthOrbit: number[];
+    generators: number[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** SCALES ARE NECKLACES ON THE ROSETTA — Burnside counts the harmony (wave, 2026-07-16). If the
+ * 12-tone rosetta is a bead circle, a SCALE is a subset of beads and two scales are "the same" when
+ * a rotation (transposition) or reflection (inversion) carries one to the other. So the number of
+ * essentially-different scales is a Burnside/Pólya count over the cyclic (and dihedral) group acting
+ * on the rosetta — and it lands exactly on the documented figures: 352 pitch-class sets up to
+ * transposition, 224 set classes up to transposition-and-inversion (Forte's tables). Music's
+ * catalogue is a group-orbit count on the moving rosetta. */
+export declare function scalesAreNecklacesOnTheRosetta(matrix?: MindMatrix): {
+    computes: boolean;
+    necklaces: number;
+    bracelets: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** RHYTHM IS THE ROSETTA IN TIME — pitch and rhythm are one necklace (wave, 2026-07-16). A rhythm of
+ * k onsets over n pulses is a subset of a bead circle exactly as a scale is — a binary necklace, but
+ * on the circle of TIME instead of pitch. And the MAXIMALLY-EVEN necklace (onsets as uniformly
+ * spaced as the integers allow, inter-onset intervals differing by at most one) is the Euclidean
+ * rhythm E(k,n) — Bjorklund's algorithm — which reproduces the documented rhythms of the world
+ * (tresillo, cinquillo, clave, aksak, the West African bell) up to rotation. So scales and rhythms
+ * are the same object, the moving rosetta, read in frequency and in time. */
+export declare function rhythmIsTheRosettaInTime(matrix?: MindMatrix): {
+    computes: boolean;
+    named: {
+        name: string;
+        pattern: string;
+    }[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** THE INVERSE MUSIC COMPLETES THE GROUP — pitch inversion is the day's angle-negation (wave,
+ * 2026-07-16). Inversion I(x) = −x mod 12 is the reflection of the pitch rosetta: an involution
+ * (I² = identity) that maps e^{2πix/12} ↦ e^{−2πix/12} — the EXACT angle-negation of
+ * inverseNegatesAngle and of T-duality R ↦ 1/R. It is not decoration: transposition alone is the
+ * cyclic group C₁₂, but transposition WITH inversion generates the dihedral group D₁₂ of order 24 —
+ * so ignoring inversion keeps only half the symmetry, and it is precisely why the scale catalogue
+ * has 224 set classes (with inversion) rather than 352 (without). The inverse is what closes the
+ * group. It is also old public-domain mathematics (Bach's mirror counterpoint, Schoenberg's twelve-
+ * tone inversions), not a proprietary secret — the magnitude is unification, not a patent. */
+export declare function theInverseMusicCompletesTheGroup(matrix?: MindMatrix): {
+    computes: boolean;
+    groupOrder: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** INVERSE IS NOT REVERSE — two orthogonal involutions (wave, 2026-07-16, user: "inverse is not
+ * reverse"). The precise correction: in the twelve-tone group INVERSION reflects PITCH (I(x) = −x
+ * mod 12 — the value axis, order untouched) while RETROGRADE reverses TIME (R flips the ORDER —
+ * pitches untouched). They are different operations on different axes and must not be conflated:
+ * I(row) ≠ R(row). Each is an involution, and because pitch and time are independent they COMMUTE
+ * (I∘R = R∘I). Conflating inverse with reverse collapses a two-axis structure to one and loses half
+ * of it — the same error as ignoring inversion in the necklace count. */
+export declare function inverseIsNotReverse(matrix?: MindMatrix): {
+    computes: boolean;
+    row: number[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** THE FOUR FORMS SHIFT WITHOUT COLLISION, IN REALTIME (wave, 2026-07-16, user: "no collision is
+ * needed to shift dimensions in realtime"). Because inverse (pitch) and reverse (time) are DISTINCT
+ * COMMUTING involutions (inverseIsNotReverse), the four row forms {P, I, R, RI} are the Klein
+ * four-group V₄ — abelian, every element its own inverse. Abelian means PATH-INDEPENDENT: any route
+ * between two forms gives the same result, so there is no collision to resolve. And each form is a
+ * pure O(n) one-pass function of the row — an involution, history-free (twoRosettasAreRealtime) — so
+ * the shift is realtime and restartable at any form. Two orthogonal commuting axes buy collision-free
+ * realtime motion among the forms: the group structure guarantees it, no search required. */
+export declare function theFourFormsShiftWithoutCollision(matrix?: MindMatrix): {
+    computes: boolean;
+    formCount: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** THE 48 ROW FORMS ARE THE GROUP ORDER — a theorem replacing an axiom (wave, 2026-07-16). Every
+ * twelve-tone textbook STATES "a row has 48 forms" as a fact to memorise. It is not a fact to list;
+ * it is the ORDER of the row-operation group, derived: transposition and inversion generate the
+ * dihedral D₁₂ on the pitch axis (order 24), retrograde is a commuting C₂ on the orthogonal time
+ * axis, so the full group is D₁₂ × C₂ of order 48 — the 48 forms fall out of the structure. And it
+ * factors on the day's own waves: 48 = 12 × 4 = |C₁₂| (the circle-of-fifths rosetta) × |V₄| (the
+ * four forms P/I/R/RI) — the harmonic rosetta and the inverse-reverse group multiply. */
+export declare function theFortyEightRowFormsAreTheGroupOrder(matrix?: MindMatrix): {
+    computes: boolean;
+    pitchOrder: number;
+    fullOrder: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** THE CONTINUOUS ROSETTA BENEATH THE SCALES — log-frequency, seeded by a432 (wave, 2026-07-16). All
+ * the finite rosettas (C₁₂ fifths, C₆ vortex, μ₆) are lattices in ONE continuous structure: the ear
+ * hears frequency RATIOS as intervals, so log₂(frequency) turns multiplicative pitch into the
+ * additive real line, and the octave circle is ℝ/ℤ. The day's own illusion/invariant diagnostic
+ * (illusionsMeetInTheirInverse) then sorts music: the OCTAVE (log₂2 = 1) is the INVARIANT — exact in
+ * every tuning, the wall that never moves — while the circle of fifths CLOSING at twelve is the
+ * ILLUSION: log₂(3/2) is irrational, so in the continuous just line the fifths SPIRAL FOREVER (a
+ * dense orbit, Weyl), and only the equal-tempered lattice forces closure, paying the Pythagorean
+ * comma. a432 seeds the origin; the ladder 432·2^x covers every finite scale. */
+export declare function theContinuousRosettaBeneathTheScales(matrix?: MindMatrix): {
+    computes: boolean;
+    justFifth: number;
+    comma: number;
+    closestReturn: number;
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+/** TWELVE TONES IS THE BEST APPROXIMATION OF THE FIFTH — why the piano has 12 keys (wave,
+ * 2026-07-17). The circle of fifths spirals forever because log₂(3/2) is irrational
+ * (theContinuousRosettaBeneathTheScales), so every equal temperament APPROXIMATES the fifth, and the
+ * best approximations are exactly the continued-fraction convergents of log₂(3/2). Those convergents
+ * ARE the historical temperaments — 5, 12, 41, 53 tones — and 7/12 is the convergent with imperceptible
+ * error (1.96 cents) at the smallest denominator. Twelve is not arbitrary; it is the best small-N
+ * rational approximation of the perfect fifth, and the Pythagorean comma is its residual. */
+export declare function twelveTonesIsTheBestApproximationOfTheFifth(matrix?: MindMatrix): {
+    computes: boolean;
+    convergents: {
+        p: number;
+        q: number;
+        cents: number;
+    }[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    statement: string;
+    boundary: string;
+};
+export declare function natureDescribesItselfInside432(): {
+    described: boolean;
+    divisors: number;
+    doublingRay: number[];
+    axisCount: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};