@grafloria/element 0.3.20 → 0.3.22

package/src/libs/renderer/src/lazy/types.d.ts

@@ -1,43 +0,0 @@
-/** The two things that have views. */
-export type EntityKind = 'node' | 'link';
-/**
- * The gate the renderer consults before instantiating an entity's VIEW.
- *
- * A gate can only ever SUBTRACT from what culling already admitted — it never adds
- * an off-screen entity back in. That asymmetry is deliberate: a gate bug can make
- * something arrive late, never wrong.
- */
-export interface MountGate {
-    /** May the renderer build (or refresh) this entity's view on this frame? */
-    admits(kind: EntityKind, id: string): boolean;
-    /**
-     * True while a progressive mount is running — the renderer's cue that the scene
-     * is being brought up in slices and is not yet whole.
-     */
-    isDeferring?(): boolean;
-}
-/** What one `mount()` actually did — the numbers the claim lives on. */
-export interface MountStats {
-    /** ms from `mount()` to the first frame that reached the screen. */
-    firstPaintMs: number;
-    /** Wall clock from `mount()` to the last entity mounted — INCLUDING the rAF waits. */
-    completeMs: number;
-    /**
-     * CPU actually spent, summed over the slices — i.e. `completeMs` minus the time spent
-     * yielded to the browser.
-     *
-     * This is the number that says whether slicing costs anything REAL. Wall clock has to
-     * grow (that is what yielding means: ~16.7ms of vsync per slice, during which the tab
-     * paints and handles input). Work is what must not grow, and this is what proves it.
-     */
-    cpuMs: number;
-    /** rAF slices used (1 = it all fitted in the first frame). */
-    slices: number;
-    /** Entities whose views were built. */
-    nodesMounted: number;
-    linksMounted: number;
-    /** The worst single slice — the jank a user would actually feel. */
-    worstSliceMs: number;
-    /** True if the mount was cancelled or pre-empted by a model change. */
-    aborted: boolean;
-}

package/src/libs/renderer/src/lazy/types.js

@@ -1,14 +0,0 @@
-"use strict";
-// Wave 8 — Card 3: deferred / lazy view instantiation.
-//
-// The renderer already CULLS: it asks the spatial index which entities intersect
-// the viewport and builds VNodes only for those. What it did not have was a say in
-// the matter — culling is recomputed from geometry every frame, and every entity it
-// admits pays the full price of a view (route + style + VNode) on the very first
-// frame, all of it before anything reaches the screen.
-//
-// A `MountGate` is that say. It sits between "the spatial index says this is on
-// screen" and "build its view", and it is what lets a huge graph reach first paint
-// without routing every link first.
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/src/libs/renderer/src/lazy/view-lifecycle.d.ts

@@ -1,97 +0,0 @@
-import type { EntityKind, MountGate } from './types';
-export interface ViewLifecycleOptions {
-    /**
-     * Drop the view of any entity that leaves the viewport. Default false — the
-     * historical behaviour (views linger in the LRU until evicted by pressure).
-     */
-    autoFreeze?: boolean;
-}
-export declare class ViewLifecycle implements MountGate {
-    /** Explicitly frozen by the host. Survives everything until unfrozen. */
-    private readonly frozen;
-    /** Frozen by autoFreeze because they left the viewport. Thawed on return. */
-    private readonly autoFrozen;
-    /** What the last frame could see — the set autoFreeze diffs against. */
-    private retained;
-    private autoFreeze;
-    /** While true, NOTHING is admitted except what `admit()` has let through. */
-    private deferring;
-    /** Admitted so far by the mount in progress (cumulative across slices). */
-    private readonly admitted;
-    /** Kinds admitted wholesale — nodes are cheap, so slice 0 takes all of them. */
-    private readonly openKinds;
-    /**
-     * Called when an entity's view is dropped, so the renderer can evict its cache
-     * entry. Set by `SVGRenderer.setViewLifecycle`.
-     */
-    private evictHook;
-    /**
-     * Called whenever THIS OBJECT changes what the renderer would draw — a freeze, an
-     * unfreeze, a progressive-mount admission, an autoFreeze toggle.
-     *
-     * This hook exists because of a bug the wave-8 merge produced and neither branch
-     * could have caught alone. The frame gate (Card 0) skips a frame whose MODEL and
-     * VIEWPORT are unchanged — and freezing a node changes neither. Nor does admitting
-     * the next mount slice. So the gate correctly concluded "you have already drawn
-     * this frame" and handed back the previous picture, and freeze/lazy-mount silently
-     * did nothing: five tests that passed on both branches in isolation failed the
-     * moment they were composed.
-     *
-     * The lesson generalises, and it is the same one three times over in this wave:
-     * ask what can change the PICTURE without changing the MODEL. The answer is always
-     * longer than it looks — the route solver's refined answer, the quality governor's
-     * tier bias, and now this.
-     */
-    private changeHook;
-    constructor(options?: ViewLifecycleOptions);
-    /**
-     * Give up this entity's view. It keeps its model and its spatial-index entry;
-     * it stops being drawn and stops costing anything per frame.
-     */
-    freeze(kind: EntityKind, id: string): void;
-    /** Give it a view again. It is rebuilt on the next frame that can see it. */
-    unfreeze(kind: EntityKind, id: string): void;
-    isFrozen(kind: EntityKind, id: string): boolean;
-    /** Explicitly frozen only — NOT the ones autoFreeze is holding off-screen. */
-    isExplicitlyFrozen(kind: EntityKind, id: string): boolean;
-    unfreezeAll(): void;
-    setAutoFreeze(on: boolean): void;
-    isAutoFreeze(): boolean;
-    /**
-     * The views currently retained — i.e. what the renderer is paying for.
-     *
-     * This is the number autoFreeze exists to bound, so it is measurable rather
-     * than asserted.
-     */
-    retainedCount(): number;
-    frozenCount(): number;
-    /**
-     * Called by the renderer each frame with what culling admitted, BEFORE the gate
-     * is applied. Anything that was on screen and no longer is gets its view dropped.
-     *
-     * Not called at all when autoFreeze is off — the whole feature is one Set diff
-     * per frame, and a host that has not asked for it pays nothing.
-     */
-    retainVisible(visible: ReadonlyArray<readonly [EntityKind, string]>): void;
-    /** Defer EVERYTHING. Nothing has a view until `admit()` says so. */
-    beginDeferred(): void;
-    /** Let this entity's view be built from now on. */
-    admit(kind: EntityKind, id: string): void;
-    /**
-     * Admit a whole KIND without naming its members. Slice 0 uses this for nodes: a
-     * node's view is cheap (no routing), and enumerating 10k ids to admit them one
-     * at a time would cost more than building the ~56 views culling actually keeps.
-     */
-    admitAll(kind: EntityKind): void;
-    /** The mount is over (finished, cancelled, or pre-empted). Gate opens fully. */
-    endDeferred(): void;
-    admits(kind: EntityKind, id: string): boolean;
-    isDeferring(): boolean;
-    /** @internal — wired by SVGRenderer.setViewLifecycle. */
-    setEvictHook(hook: ((kind: EntityKind, id: string) => void) | null): void;
-    /**
-     * Tell the renderer that what it would draw has changed, even though the model
-     * has not. Set by `SVGRenderer.setViewLifecycle`; see `changeHook`.
-     */
-    setChangeHook(hook: (() => void) | null): void;
-}

package/src/libs/renderer/src/lazy/view-lifecycle.js

@@ -1,221 +0,0 @@
-"use strict";
-// Wave 8 — Card 3: freeze / unfreeze / autoFreeze, and the admission set a
-// progressive mount admits into.
-//
-// FREEZE is the explicit form of "this entity has a model, and a place in the
-// spatial index, and NO view". A frozen entity is not routed, not styled, not
-// turned into a VNode, and holds no cache entry. It still exists: it still has a
-// position, it still answers a spatial query, it still serialises. It simply is not
-// drawn, and costs nothing per frame.
-//
-// AUTOFREEZE applies that automatically to everything outside the viewport. On its
-// face that is what culling already does — but culling is a per-frame geometric
-// decision that leaves the entity's CACHED VNODE behind. Pan a 10k-node graph from
-// end to end with autoFreeze off and the renderer accumulates cached views for
-// every entity it ever passed over (bounded only by `maxCacheSize`, which is a
-// backstop, not a policy). With autoFreeze on, a view is dropped the moment its
-// entity leaves the viewport, and the retained set stays O(on screen) instead of
-// O(everything ever seen). That is the difference between a cache and a leak.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewLifecycle = void 0;
-/** `node:n12` / `link:l7` — one keyspace, so a node and a link can share an id. */
-const keyOf = (kind, id) => `${kind}:${id}`;
-class ViewLifecycle {
-    constructor(options = {}) {
-        var _a;
-        /** Explicitly frozen by the host. Survives everything until unfrozen. */
-        this.frozen = new Set();
-        /** Frozen by autoFreeze because they left the viewport. Thawed on return. */
-        this.autoFrozen = new Set();
-        /** What the last frame could see — the set autoFreeze diffs against. */
-        this.retained = new Set();
-        // --- progressive mount ----------------------------------------------------
-        /** While true, NOTHING is admitted except what `admit()` has let through. */
-        this.deferring = false;
-        /** Admitted so far by the mount in progress (cumulative across slices). */
-        this.admitted = new Set();
-        /** Kinds admitted wholesale — nodes are cheap, so slice 0 takes all of them. */
-        this.openKinds = new Set();
-        /**
-         * Called when an entity's view is dropped, so the renderer can evict its cache
-         * entry. Set by `SVGRenderer.setViewLifecycle`.
-         */
-        this.evictHook = null;
-        /**
-         * Called whenever THIS OBJECT changes what the renderer would draw — a freeze, an
-         * unfreeze, a progressive-mount admission, an autoFreeze toggle.
-         *
-         * This hook exists because of a bug the wave-8 merge produced and neither branch
-         * could have caught alone. The frame gate (Card 0) skips a frame whose MODEL and
-         * VIEWPORT are unchanged — and freezing a node changes neither. Nor does admitting
-         * the next mount slice. So the gate correctly concluded "you have already drawn
-         * this frame" and handed back the previous picture, and freeze/lazy-mount silently
-         * did nothing: five tests that passed on both branches in isolation failed the
-         * moment they were composed.
-         *
-         * The lesson generalises, and it is the same one three times over in this wave:
-         * ask what can change the PICTURE without changing the MODEL. The answer is always
-         * longer than it looks — the route solver's refined answer, the quality governor's
-         * tier bias, and now this.
-         */
-        this.changeHook = null;
-        this.autoFreeze = (_a = options.autoFreeze) !== null && _a !== void 0 ? _a : false;
-    }
-    // =========================================================================
-    // Freeze
-    // =========================================================================
-    /**
-     * Give up this entity's view. It keeps its model and its spatial-index entry;
-     * it stops being drawn and stops costing anything per frame.
-     */
-    freeze(kind, id) {
-        var _a, _b;
-        const key = keyOf(kind, id);
-        if (this.frozen.has(key))
-            return;
-        this.frozen.add(key);
-        (_a = this.evictHook) === null || _a === void 0 ? void 0 : _a.call(this, kind, id);
-        (_b = this.changeHook) === null || _b === void 0 ? void 0 : _b.call(this);
-    }
-    /** Give it a view again. It is rebuilt on the next frame that can see it. */
-    unfreeze(kind, id) {
-        var _a;
-        if (!this.frozen.delete(keyOf(kind, id)))
-            return;
-        (_a = this.changeHook) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    isFrozen(kind, id) {
-        const key = keyOf(kind, id);
-        return this.frozen.has(key) || this.autoFrozen.has(key);
-    }
-    /** Explicitly frozen only — NOT the ones autoFreeze is holding off-screen. */
-    isExplicitlyFrozen(kind, id) {
-        return this.frozen.has(keyOf(kind, id));
-    }
-    unfreezeAll() {
-        var _a;
-        if (this.frozen.size === 0)
-            return;
-        this.frozen.clear();
-        (_a = this.changeHook) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    setAutoFreeze(on) {
-        var _a;
-        if (this.autoFreeze === on)
-            return;
-        this.autoFreeze = on;
-        if (!on) {
-            // Everything autoFreeze was holding gets its view back on the next frame.
-            this.autoFrozen.clear();
-        }
-        (_a = this.changeHook) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    isAutoFreeze() {
-        return this.autoFreeze;
-    }
-    /**
-     * The views currently retained — i.e. what the renderer is paying for.
-     *
-     * This is the number autoFreeze exists to bound, so it is measurable rather
-     * than asserted.
-     */
-    retainedCount() {
-        return this.retained.size;
-    }
-    frozenCount() {
-        return this.frozen.size + this.autoFrozen.size;
-    }
-    /**
-     * Called by the renderer each frame with what culling admitted, BEFORE the gate
-     * is applied. Anything that was on screen and no longer is gets its view dropped.
-     *
-     * Not called at all when autoFreeze is off — the whole feature is one Set diff
-     * per frame, and a host that has not asked for it pays nothing.
-     */
-    retainVisible(visible) {
-        var _a;
-        if (!this.autoFreeze)
-            return;
-        const next = new Set();
-        for (const [kind, id] of visible) {
-            const key = keyOf(kind, id);
-            next.add(key);
-            // Back on screen: thaw it, so the next frame builds its view again.
-            this.autoFrozen.delete(key);
-        }
-        for (const key of this.retained) {
-            if (next.has(key))
-                continue;
-            // Left the viewport. Drop the view; keep the model.
-            this.autoFrozen.add(key);
-            const sep = key.indexOf(':');
-            (_a = this.evictHook) === null || _a === void 0 ? void 0 : _a.call(this, key.slice(0, sep), key.slice(sep + 1));
-        }
-        this.retained = next;
-    }
-    // =========================================================================
-    // Progressive mount (the admission set)
-    // =========================================================================
-    /** Defer EVERYTHING. Nothing has a view until `admit()` says so. */
-    beginDeferred() {
-        var _a;
-        this.deferring = true;
-        this.admitted.clear();
-        this.openKinds.clear();
-        (_a = this.changeHook) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    /** Let this entity's view be built from now on. */
-    admit(kind, id) {
-        var _a;
-        this.admitted.add(keyOf(kind, id));
-        (_a = this.changeHook) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    /**
-     * Admit a whole KIND without naming its members. Slice 0 uses this for nodes: a
-     * node's view is cheap (no routing), and enumerating 10k ids to admit them one
-     * at a time would cost more than building the ~56 views culling actually keeps.
-     */
-    admitAll(kind) {
-        var _a;
-        this.openKinds.add(kind);
-        (_a = this.changeHook) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    /** The mount is over (finished, cancelled, or pre-empted). Gate opens fully. */
-    endDeferred() {
-        var _a;
-        this.deferring = false;
-        this.admitted.clear();
-        this.openKinds.clear();
-        (_a = this.changeHook) === null || _a === void 0 ? void 0 : _a.call(this);
-    }
-    // =========================================================================
-    // MountGate
-    // =========================================================================
-    admits(kind, id) {
-        const key = keyOf(kind, id);
-        // An explicit freeze outranks a mount admission: a host that froze something
-        // did so on purpose, and a mount is no reason to overrule it.
-        if (this.frozen.has(key) || this.autoFrozen.has(key))
-            return false;
-        if (this.deferring)
-            return this.openKinds.has(kind) || this.admitted.has(key);
-        return true;
-    }
-    isDeferring() {
-        return this.deferring;
-    }
-    // =========================================================================
-    /** @internal — wired by SVGRenderer.setViewLifecycle. */
-    setEvictHook(hook) {
-        this.evictHook = hook;
-    }
-    /**
-     * Tell the renderer that what it would draw has changed, even though the model
-     * has not. Set by `SVGRenderer.setViewLifecycle`; see `changeHook`.
-     */
-    setChangeHook(hook) {
-        this.changeHook = hook;
-    }
-}
-exports.ViewLifecycle = ViewLifecycle;
-//# sourceMappingURL=view-lifecycle.js.map

package/src/libs/renderer/src/perf/index.d.ts

@@ -1,2 +0,0 @@
-export * from './quality-governor';
-export * from './perf-hud';

package/src/libs/renderer/src/perf/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-// Wave 8 (Performance & scale) — Card 7: runtime instrumentation.
-tslib_1.__exportStar(require("./quality-governor"), exports);
-tslib_1.__exportStar(require("./perf-hud"), exports);
-//# sourceMappingURL=index.js.map

package/src/libs/renderer/src/perf/perf-hud.d.ts

@@ -1,46 +0,0 @@
-import type { GovernorState } from './quality-governor';
-export interface PerfSnapshot {
-    /** Rolling FPS. */
-    fps: number;
-    /** Last frame, ms. */
-    frameMs: number;
-    /** Entities in the model. */
-    nodes: number;
-    links: number;
-    /** Entities that survived viewport culling — i.e. what we actually paid for. */
-    visibleNodes: number;
-    visibleLinks: number;
-    /** Entities whose views exist in the DOM right now (lazy mounting, Card 3). */
-    mountedViews: number;
-    /** Entities re-rendered this frame (the dirty set, Card 0). */
-    dirtyNodes: number;
-    dirtyLinks: number;
-    /** Links whose route was recomputed this frame (Card 6). Should be ~0 on an idle frame. */
-    routedLinks: number;
-    /** The LOD tier actually rendered, and the governor's reasoning. */
-    tier: string;
-    governor?: GovernorState;
-}
-export declare const EMPTY_SNAPSHOT: PerfSnapshot;
-/**
- * Format a snapshot for a human.
- *
- * Deliberately calls out the ratios that reveal a bug rather than just printing
- * numbers: "culled 0/10000" reads as fine until you notice it means nothing was
- * culled. The HUD's job is to make that impossible to miss.
- */
-export declare function formatSnapshot(s: PerfSnapshot): string[];
-/**
- * A DOM overlay, framework-free.
- *
- * Absolutely positioned, `pointer-events: none` — a debug HUD that eats clicks is a
- * bug generator of its own. It is opt-in and never mounted unless asked for.
- */
-export declare class PerfHud {
-    private readonly host;
-    private el?;
-    constructor(host: HTMLElement);
-    show(): void;
-    update(snapshot: PerfSnapshot): void;
-    hide(): void;
-}

package/src/libs/renderer/src/perf/perf-hud.js

@@ -1,105 +0,0 @@
-"use strict";
-// Wave 8 (Performance & scale) — Card 7: the runtime perf HUD.
-//
-// The card asks for "a runtime perf HUD (FPS, dirty/culled/mounted-view counts)".
-// The counts are the point, not the FPS. FPS tells you THAT the frame was slow; the
-// counts tell you WHY — and in this engine the why has been the story every time:
-//
-//   • "culled 0 of 10,000" would have shown at a glance that viewport culling was
-//     not culling.
-//   • "routed 9,998 links" on a frame where nothing moved is the 5.5-second drag,
-//     visible without a profiler.
-//   • "governor: stepped-down (median 41ms)" is the difference between a governor
-//     that is working and one that is silently doing nothing.
-//
-// So the HUD is a DATA structure first and a DOM overlay second. The data is what
-// the benchmark harness and the tests consume; the overlay is a convenience for a
-// human with a real diagram in front of them.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerfHud = exports.EMPTY_SNAPSHOT = void 0;
-exports.formatSnapshot = formatSnapshot;
-exports.EMPTY_SNAPSHOT = {
-    fps: 0,
-    frameMs: 0,
-    nodes: 0,
-    links: 0,
-    visibleNodes: 0,
-    visibleLinks: 0,
-    mountedViews: 0,
-    dirtyNodes: 0,
-    dirtyLinks: 0,
-    routedLinks: 0,
-    tier: 'high',
-};
-/**
- * Format a snapshot for a human.
- *
- * Deliberately calls out the ratios that reveal a bug rather than just printing
- * numbers: "culled 0/10000" reads as fine until you notice it means nothing was
- * culled. The HUD's job is to make that impossible to miss.
- */
-function formatSnapshot(s) {
-    const culledNodes = s.nodes - s.visibleNodes;
-    const culledLinks = s.links - s.visibleLinks;
-    const lines = [
-        `${s.fps.toFixed(0)} fps   ${s.frameMs.toFixed(1)} ms/frame`,
-        `nodes  ${s.visibleNodes}/${s.nodes} visible   (culled ${culledNodes})`,
-        `links  ${s.visibleLinks}/${s.links} visible   (culled ${culledLinks})`,
-        `views  ${s.mountedViews} mounted`,
-        `dirty  ${s.dirtyNodes} nodes, ${s.dirtyLinks} links`,
-        `routed ${s.routedLinks} links this frame`,
-        `tier   ${s.tier}`,
-    ];
-    if (s.governor) {
-        const g = s.governor;
-        lines.push(`gov    bias ${g.bias} · median ${g.medianMs.toFixed(1)}ms · ${g.lastDecision}`);
-    }
-    return lines;
-}
-/**
- * A DOM overlay, framework-free.
- *
- * Absolutely positioned, `pointer-events: none` — a debug HUD that eats clicks is a
- * bug generator of its own. It is opt-in and never mounted unless asked for.
- */
-class PerfHud {
-    constructor(host) {
-        this.host = host;
-    }
-    show() {
-        if (this.el)
-            return;
-        const el = this.host.ownerDocument.createElement('div');
-        el.setAttribute('data-grafloria-perf-hud', '');
-        // A debug overlay must never intercept input, and must never be picked up by a
-        // screen reader — it is developer instrumentation, not content.
-        el.setAttribute('aria-hidden', 'true');
-        el.style.cssText = [
-            'position:absolute',
-            'top:8px',
-            'left:8px',
-            'z-index:2147483000',
-            'pointer-events:none',
-            'font:11px/1.45 ui-monospace,SFMono-Regular,Menlo,monospace',
-            'white-space:pre',
-            'padding:8px 10px',
-            'border-radius:6px',
-            'background:rgba(15,23,42,.82)',
-            'color:#e2e8f0',
-        ].join(';');
-        this.host.appendChild(el);
-        this.el = el;
-    }
-    update(snapshot) {
-        if (!this.el)
-            return;
-        this.el.textContent = formatSnapshot(snapshot).join('\n');
-    }
-    hide() {
-        var _a;
-        (_a = this.el) === null || _a === void 0 ? void 0 : _a.remove();
-        this.el = undefined;
-    }
-}
-exports.PerfHud = PerfHud;
-//# sourceMappingURL=perf-hud.js.map

package/src/libs/renderer/src/perf/quality-governor.d.ts

@@ -1,77 +0,0 @@
-/** How many tiers below the zoom-derived one we are currently rendering. */
-export type QualityBias = 0 | 1 | 2;
-export interface GovernorOptions {
-    /** The frame budget. 16.7ms = 60fps. */
-    budgetMs?: number;
-    /**
-     * Step DOWN when the median frame exceeds budget × this. Default 1.0 — the budget
-     * IS the line; there is no point having a budget you are content to miss.
-     */
-    downFactor?: number;
-    /**
-     * Step UP only when the median frame is below budget × this. Default 0.55 — the
-     * DEAD BAND. A tier that renders at 0.9× budget is doing its job; restoring detail
-     * would put us straight back over it, which is the oscillation this exists to
-     * prevent.
-     */
-    upFactor?: number;
-    /** Frames in the rolling window. */
-    window?: number;
-    /** Consecutive fast windows required before restoring a tier. Recovery is patient. */
-    recoveryWindows?: number;
-    /** Worst tier the governor may impose. */
-    maxBias?: QualityBias;
-    /**
-     * ESCALATION. A frame this many times over budget is not a slow frame, it is a
-     * structurally wrong one — and waiting a full window to notice means 12 frames
-     * of a visibly locked-up canvas. Default 4× (≈67ms: a third of a second of
-     * these and the user is already reaching for the tab close button).
-     */
-    panicFactor?: number;
-    /**
-     * How many frames the escalation path looks at. THREE, NOT ONE — and that is the
-     * whole subtlety. Reacting to a single catastrophic frame would make one GC pause
-     * indistinguishable from a scene the machine genuinely cannot draw. A median over
-     * three still rejects a lone spike (two of the three must be bad for the median to
-     * be bad) while reacting 4× sooner than the main window.
-     */
-    panicWindow?: number;
-}
-export interface GovernorState {
-    bias: QualityBias;
-    /** Median frame time over the window — what the decision is actually made on. */
-    medianMs: number;
-    /** Frames recorded so far in the current window. */
-    samples: number;
-    /** Consecutive fast windows accumulated toward a step back up. */
-    recoveryStreak: number;
-    /** Why the governor last changed its mind — surfaced in the HUD, because an
-     *  invisible governor is indistinguishable from a bug. */
-    lastDecision: 'steady' | 'stepped-down' | 'stepped-up' | 'escalated';
-}
-export declare class QualityGovernor {
-    private readonly options;
-    private frames;
-    private bias;
-    private recoveryStreak;
-    private lastDecision;
-    private lastMedian;
-    constructor(options?: GovernorOptions);
-    /** Feed the governor one frame time (ms). Returns the bias to render the NEXT frame at. */
-    record(frameMs: number): QualityBias;
-    /** The bias to apply right now. */
-    getBias(): QualityBias;
-    getState(): GovernorState;
-    /**
-     * Apply the bias to a zoom-derived tier.
-     *
-     * `tiers` must be ordered richest → poorest, which is the order the LOD config
-     * declares them in. The governor can only ever make the picture SIMPLER than the
-     * zoom asked for — never richer. A governor that could upgrade detail beyond what
-     * the zoom wants would draw labels on 4px nodes to fill spare budget, which is
-     * not a feature.
-     */
-    effectiveTier(zoomTier: string, tiers: readonly string[]): string;
-    /** Forget everything — e.g. after a diagram swap, where past frames say nothing. */
-    reset(): void;
-}