@satinhq/kit 0.0.0-stage → 0.1.0-beta.1

package/dist/glass/webgpu/production.d.ts

@@ -0,0 +1,552 @@
+import { SourcePixels } from './sourcePixels.js';
+import { type CaptureWindow } from '../captureWindow.js';
+import type { RegionTrack } from './productionTracks.js';
+import { RegionBridge } from './regionBridge.js';
+import { KeptGlyphs } from './keptGlyphs.js';
+import { type PinnedTop } from './productionPinnedTop.js';
+import { ResidentPlanes } from './residentPlanes.js';
+import { WebGPUClient } from './client.js';
+import { type RuntimeOptions, type RuntimeGeometry, type SurfaceRenderSpec, type LensMode } from '../renderSpecs.js';
+import type { Appearance } from '../lens/theme.js';
+import type { ScreenId } from '../lens/Scene.js';
+import type { MenuGestureDecision } from '../../menu/menuGesture.js';
+import { type NavigationGlassState } from '../../navigation/glassTransition.js';
+import { WorkerMinimize } from './minimize.js';
+import { type ResumeReadout } from './resumeOverlay.js';
+import type { RestorePath } from '../lens/tabRestoreMotion.js';
+import type { WebGPURequest as Request } from '../worker/protocol.js';
+import { MenuSurfaceGuard, type MenuSurfaceStage } from './menuSurfaceGuard.js';
+import { type MaterialContext, type PlaneEntry, type PlaneWindowHint } from './productionPlanes.js';
+import { type SampleRect } from './captureDemand.js';
+/** Resident bytes for covered routes' and unselected tabs' captures (image + texture each) and
+ * cached material context readbacks. Sized so that a phone keeps the planes of a tab bar's other
+ * tabs when one of them is a long list: a grown capture window (1320 x 8192 px, 43 MB, 86 MB
+ * resident) and three single-viewport planes (15 MB, 30 MB resident each). With the 80 MB this
+ * replaced, a long list's plane was dropped whenever its tab was left, and entering that tab
+ * again showed its content 1.8 times later than any other tab's (100 ms against 56 ms in the
+ * Catalyst host; 59 ms with everything resident). Those planes are 148 MB (149 MB with a list
+ * at the canvas ceiling); the rest is for the material contexts they made (2 to 5 MB each, a few
+ * per tab): at 160 MB they fitted with 0.4 MB to spare, and once a context was a little larger
+ * every return from the list tab recomposed one that had just been evicted. It is a ceiling, not
+ * an allocation: an app whose tabs are single viewports keeps about 30 MB per tab. See
+ * ResidentPlanes. */
+export declare const RESIDENT_BYTES = 176000000;
+/** App-lifetime worker. Reuses the semantic controls and measured geometry.
+ *
+ * Source preparation (productionPrepare.ts) and navigation glass (productionNavigation.ts) are
+ * functions over this runtime; members they use carry no access modifier. None of it is public API. */
+export declare class ProductionGlassRuntime {
+    private static shared?;
+    client: WebGPUClient;
+    sourcePixels: SourcePixels;
+    /** A source staging whose upload worker failed (its GPU device was lost, or a reply never came)
+     * stays failed. The bounded retry of a preparation replaces it, so glass recovers without a
+     * reload: the failed instance rejected its own jobs when it failed and terminated its worker,
+     * so nothing of it can reach the replacement. */
+    replaceFailedSourcePixels(): void;
+    appRegions: RegionBridge;
+    options: RuntimeOptions;
+    canvas: HTMLCanvasElement;
+    liftCanvas: HTMLCanvasElement;
+    /** The menu trigger's lift presents on its own small canvas, apart from the dock's band. */
+    menuLiftCanvas: HTMLCanvasElement;
+    /** The menu surface's own canvas, sized to its envelope. On one full-screen chrome canvas with
+     * the dock, every glass frame presented a whole-screen drawable, which WebKit commits from the
+     * worker slowly enough to block the worker thread (0-27 ms message delays on iPadOS 27 while
+     * scrolling: glass at ~40 Hz). Each chrome canvas now covers only what it draws. */
+    menuCanvas: HTMLCanvasElement;
+    /** Installed lift canvas extents, [x,y,w,h] CSS px: a band around each lift, never the full screen. */
+    liftViewports: Map<string, string>;
+    liftAttached: boolean;
+    specs: Map<string, Readonly<{
+        touchLight?: import("../renderSpecs.js").GlassTouchLight;
+        excludeRegionIds?: readonly string[];
+        restHidden?: boolean;
+        opacity?: number;
+        occluder?: import("../renderSpecs.js").CapsuleShape;
+        prewarmTransparent?: boolean;
+        recipeMix?: number;
+        sheetOpaqueMix?: number;
+        popoverArrow?: import("../regions.js").PopoverArrow;
+        variant?: import("../lens/referenceProfiles.js").ReferenceVariant;
+        treatment?: 'sheet' | 'expandedSheet' | 'alert' | 'confirmation' | 'contextBackdrop' | 'contextPreview' | 'contextMenu';
+        tint?: import("../regions.js").GlassTint;
+        memberHighlight?: Readonly<{
+            member: number;
+            amount: number;
+            light?: import("../renderSpecs.js").GlassTouchLight;
+        }>;
+        backdropExclusions?: readonly string[];
+        backdropMenuOverlay?: boolean;
+        blurSigmaCssPx?: number;
+        frameHeight: number;
+        frameWidth: number;
+        frameX: number;
+        frameY: number;
+        id: import("../renderSpecs.js").SurfaceId;
+        materialMix: number;
+        materialProfile: 'chrome' | 'searchField' | 'menu';
+        menuTintMix?: number;
+        returningTrigger?: import("../renderSpecs.js").ReturningMenuTrigger;
+        radius: number;
+        sampleHeight: number;
+        sampleInsetX: number;
+        sampleInsetY: number;
+        sampleWidth: number;
+        shaderAperture: boolean;
+        shape: import("../renderSpecs.js").SurfaceShape;
+        tabSelection?: import("../renderSpecs.js").TabSelectionShape;
+        ink?: Readonly<{
+            atlas: Readonly<{
+                width: number;
+                height: number;
+            }>;
+            layers: readonly import("../lens/menuField.js").MenuInkLayer[];
+        }>;
+    }>>;
+    context?: MaterialContext;
+    revision: number;
+    private transportRevision;
+    serial: Promise<void>;
+    attached: boolean;
+    private damageFrame;
+    private pendingDamage;
+    private observer?;
+    /** Scroll-edge strength/visibility changes (scroll-driven styles, excluded from damage). */
+    private edgeObserver?;
+    private edgeFrame;
+    installedEdges: string;
+    resize?: ResizeObserver;
+    private unsubscribeAppearance?;
+    private unsubscribe?;
+    navigationObserver?: MutationObserver;
+    navigationInput?: () => void;
+    navigationFrame: number;
+    navigationRevision: number;
+    appearanceInstall?: {
+        revision: number;
+        value: Appearance;
+    };
+    /** Holds the outgoing painted frame until the new tab's complete source/scene is installed. */
+    contentInstall?: number;
+    private prepareFrame;
+    private menuPointer?;
+    pointer: boolean;
+    private pointerX;
+    private pointerStart;
+    private pointerIndex;
+    private minimize;
+    minimizeDom?: WorkerMinimize;
+    navigationRoutes: NavigationGlassState['routes'];
+    navigationActive: boolean;
+    private navigationState?;
+    private navigationCoveragePreparation?;
+    navigationAnimations?: () => void;
+    navigationRelease?: () => void;
+    navigationCoverage?: {
+        key: string;
+        width: number;
+        height: number;
+        rows: readonly {
+            top: number;
+            bottom: number;
+        }[];
+    };
+    private events;
+    record(event: unknown): void;
+    regionIds: Map<string, string>;
+    private sourceCanvas;
+    glyphCanvases: Map<string, HTMLCanvasElement>;
+    atlasCanvas: HTMLCanvasElement | OffscreenCanvas;
+    atlasGlyphs: HTMLCanvasElement;
+    /** Pixel identity of the capture installed in the worker's `content` slot. */
+    installedSource?: {
+        signature: string;
+        key: string;
+        revision: number;
+    };
+    /** Installed backdrop planes by id: capture signature and worker image key. */
+    planes: Map<string, PlaneEntry>;
+    planeIds: WeakMap<HTMLElement, string>;
+    private nextPlane;
+    /** Each plane's main-thread capture canvas and the signature it currently holds. */
+    planeCanvases: Map<string, {
+        canvas: HTMLCanvasElement;
+        signature?: string;
+    }>;
+    /** Planes that left the set (a route covered by a push) but stay resident in the worker, so a
+     * pop back composes from them: no raster, bitmap, transfer or upload at the end of the pop. */
+    resident: ResidentPlanes<MaterialContext>;
+    planeBytes: Map<string, number>;
+    /** Installed planes with DOM damage since their capture (a pending, possibly deferred, preparation):
+     * a navigation atlas never copies them from the GPU. */
+    damaged: Set<string>;
+    /** The material context is composed here (its read areas are kept by the context). */
+    contextCanvas: HTMLCanvasElement;
+    /** Sample rectangles of every glass surface and region, read once per preparation when first
+     * needed: what a plane that does not scroll is captured for (captureDemand.ts). */
+    captureDemand: () => readonly SampleRect[];
+    /** Region refreshes waiting for a capture that covers their glass (`coverFor`). */
+    private coverageWaiters;
+    /** Content changes do not cancel a preparation; its commit only clears damage it captured. */
+    damageGenerations: Map<string, number>;
+    /** Include newly discovered planes while their first capture is still in flight. */
+    preparingPlaneHosts: Map<string, HTMLElement>;
+    preparingPinnedWindows: Map<string, CaptureWindow>;
+    preparingPlaneWindows: Map<string, Pick<PlaneEntry, "host" | "width" | "window">>;
+    lastText?: string;
+    /** Last scroll inside this scene (its planes and scroller), for the scroll-idle capture hold. */
+    private lastScrollAt;
+    private scrolled;
+    private scrollScopes;
+    coveredSince: number;
+    coveredRetry: number;
+    private scrollIdle;
+    /** Scroll listeners of the committed planes (the navigation scroller reports through `scroll`). */
+    planeScrolls: Map<HTMLElement, () => void>;
+    scrollerPlane?: string;
+    /** Plane that holds the navigation source (navigation motion and route atlases apply to it). */
+    contentPlane?: string;
+    planeId(host: HTMLElement): string;
+    captureRevision: number;
+    /** Loaded fonts change ink even when the computed CSS font and size are unchanged. */
+    fontGeneration: number;
+    navigationCapture: number;
+    navigationGlyphs: number;
+    installedNavigation?: {
+        signature: string;
+        key: string;
+    };
+    private fontsChanged;
+    private damageFontSources;
+    /** Forget every retained plane (and cached context) here and in the worker. */
+    dropRetained(): void;
+    /** Chrome glyph images installed in the worker's `glyph:<id>` slots. */
+    glyphs: Map<import("../renderSpecs.js").SurfaceId, {
+        signature: string;
+        key: string;
+    }>;
+    glyphRevision: number;
+    /** Glyph ink the renderer keeps for reuse after its slot took other ink. */
+    keptGlyphs: KeptGlyphs;
+    /** Surfaces whose new ink the last preparation put off by one revision (inkForRevision). */
+    deferredInk: Set<string>;
+    /** Each long list's capture of its top, kept while its own window is further down
+     * (productionPinnedTop.ts): a jump to the top lands on it. */
+    pinnedTops: Map<string, PinnedTop>;
+    /** The image of each installed plane capture that was read back in this document: its bytes
+     * are still on the page, so the rows of a window that leaves the top can be kept. */
+    planeImages: Map<string, ImageBitmap>;
+    /** Pinned-top slots the renderer may still hold after a failed batch: released by the next. */
+    pinnedOrphans: Set<string>;
+    private unsubscribeRegionBackdrop?;
+    private unsubscribePresentationBackdrop?;
+    private unsubscribeScrollJump?;
+    private unsubscribeNativeScroll?;
+    /** Everything the last committed preparation sent; equal means nothing to send. */
+    preparedSignature: string;
+    contextGeometry: string;
+    incompleteCaptures: Map<string, number>;
+    private menuTracks;
+    preparing?: Promise<void>;
+    prepareAgain: boolean;
+    resumePending: boolean;
+    lifecycleHidden: boolean;
+    resumeAt: number;
+    private resumeFrame;
+    private constructor();
+    /** The menu kernel draws the menu's shadow (fitted to native, bounded by the drawable top);
+     * the DOM shadow plate would draw a second, larger one. */
+    private static ownMenuShadow;
+    static create(options: RuntimeOptions): Promise<ProductionGlassRuntime>;
+    fail(stage: string, error: unknown, rebuilding?: boolean): void;
+    private send;
+    fire(request: Request): void;
+    private initialize;
+    private mount;
+    private rebind;
+    private bindAppearance;
+    private unbindAppearance;
+    private bind;
+    private menuDown;
+    private menuMove;
+    private menuUp;
+    menuCancel: () => void;
+    /** Retiming, reversal and endpoint commit republish the carrier, not a page capture. */
+    private keyboardGeometry;
+    private searchGeometryWaiting;
+    searchGeometry: (event?: Event) => void;
+    private minimizePointer?;
+    private begin;
+    private endContact;
+    private endScrollGesture;
+    /** Lag trace: numbers this scroller's scroll events (the worker reports which one each frame used). */
+    private scrollSequence;
+    private scroll;
+    /** Each plane host's last scroll offset, when it was read and the speed between the last two. */
+    private scrollSpeeds;
+    /** Record a scroll of `host`; returns its speed in points per second (signed, 0 when stale). */
+    private scrollSpeed;
+    /** Planes whose entry window may grow at the next preparation (the scene has been idle). */
+    growPlanes: Set<string>;
+    private growTimer;
+    /** A recentre was requested: the next preparation must run now, scrolling or not. */
+    pendingRecentre: boolean;
+    /** Bounded capture: recentres started, and every time a scroll left the window before its
+     * recentre was installed (how far, in points, and how fast). Diagnostics only. */
+    captureWindows: {
+        recentres: number;
+        grows: number;
+        outruns: {
+            plane: string;
+            by: number;
+            velocity: number;
+            at: number;
+            forMs?: number;
+        }[];
+    };
+    private outrunSince;
+    /** What a plane's capture window is chosen from (see measurePlane). */
+    windowHint(id: string, host: HTMLElement): PlaneWindowHint;
+    /** Undefined when the installed captures hold every row `rects` sample; otherwise a capture that
+     * does is scheduled now, and the promise resolves once the renderer has acknowledged one (or
+     * within the shared visible readiness budget, without authorizing an uncovered draw). */
+    coverFor(sampled: () => readonly SampleRect[]): Promise<void> | undefined;
+    private prepareCoverage;
+    /** Region glass is waiting for a capture of rows no capture holds yet. */
+    get coverageWaiting(): boolean;
+    /** A source batch was acknowledged (or refused): waiting region refreshes check again. */
+    coverageInstalled(): void;
+    /** The first installed plane whose bands do not hold every row `rects` sample there. */
+    private uncoveredPlane;
+    /** A scroll of a windowed plane: recentre before the scrollport reaches the window's edge, and
+     * record when it got there first. The scroll itself is always forwarded to the renderer. */
+    followWindow(id: string, host: HTMLElement): void;
+    private noteOutrun;
+    /** The plane's window covers its scrollport again (a recentre was installed, or it scrolled back). */
+    endOutrun(id: string, at?: number): void;
+    /** Whether a plane's window is smaller than a grown window of its content would be. */
+    private windowCanGrow;
+    /** Whether a plane's window has left the top of its list without a current capture of the top
+     * (the next idle preparation, or a jump to the top, captures one). */
+    needsPinnedTop(id: string, entry: PlaneEntry): boolean;
+    /** Request pixels opportunistically. Scroll ownership stays with the initiating tap. */
+    prepareScrollToTop(element: HTMLElement): undefined;
+    private invalidatePinnedTops;
+    private queueMutationDamage;
+    /** Coalesce mutation records and image loads before reading layout, once per target per frame. */
+    private queueSourceDamage;
+    /** Skip only proven downstream damage. Above-window reflow can change every captured row. */
+    damageSource(target: Node, removed?: boolean, boxes?: Map<Element, DOMRect>, styles?: Map<Element, CSSStyleDeclaration>, pendingPins?: Set<string>): boolean;
+    private markPlaneDamaged;
+    /** Release both committed pins and slots left behind by an interrupted preparation. */
+    releasePinnedTops(): void;
+    /** A preparation committed: its windows are installed. Outruns they end are closed, and the
+     * entry windows it left grow once the scene has been idle. */
+    windowsCommitted(): void;
+    private growWindows;
+    private loadTarget?;
+    private sourceLoaded;
+    /** Post the bars' scroll edges when their strength or visibility changes (one message per frame at most). */
+    scheduleEdges(scene?: HTMLElement): void;
+    /** Hidden: cancel capture work while retaining the last frame and its source planes.
+     * Visible: retint and present retained sources immediately, then refresh captures. */
+    private visibility;
+    handleVisibility(event?: Event): void;
+    /** Lifecycle transitions this page has handled (resume readout). */
+    private lifecycleCounts;
+    resumeReadout(): Promise<ResumeReadout>;
+    /** A source change during tab-bar minimize/restore is applied when the motion finishes
+     * (its track schedules a preparation): reinstalling every surface mid-motion stalled worker frames. */
+    schedulePrepare(afterMinimize?: boolean, windowRecentre?: boolean): void;
+    currentSpecs(): Readonly<{
+        touchLight?: import("../renderSpecs.js").GlassTouchLight;
+        excludeRegionIds?: readonly string[];
+        restHidden?: boolean;
+        opacity?: number;
+        occluder?: import("../renderSpecs.js").CapsuleShape;
+        prewarmTransparent?: boolean;
+        recipeMix?: number;
+        sheetOpaqueMix?: number;
+        popoverArrow?: import("../regions.js").PopoverArrow;
+        variant?: import("../lens/referenceProfiles.js").ReferenceVariant;
+        treatment?: 'sheet' | 'expandedSheet' | 'alert' | 'confirmation' | 'contextBackdrop' | 'contextPreview' | 'contextMenu';
+        tint?: import("../regions.js").GlassTint;
+        memberHighlight?: Readonly<{
+            member: number;
+            amount: number;
+            light?: import("../renderSpecs.js").GlassTouchLight;
+        }>;
+        backdropExclusions?: readonly string[];
+        backdropMenuOverlay?: boolean;
+        blurSigmaCssPx?: number;
+        frameHeight: number;
+        frameWidth: number;
+        frameX: number;
+        frameY: number;
+        id: import("../renderSpecs.js").SurfaceId;
+        materialMix: number;
+        materialProfile: 'chrome' | 'searchField' | 'menu';
+        menuTintMix?: number;
+        returningTrigger?: import("../renderSpecs.js").ReturningMenuTrigger;
+        radius: number;
+        sampleHeight: number;
+        sampleInsetX: number;
+        sampleInsetY: number;
+        sampleWidth: number;
+        shaderAperture: boolean;
+        shape: import("../renderSpecs.js").SurfaceShape;
+        tabSelection?: import("../renderSpecs.js").TabSelectionShape;
+        ink?: Readonly<{
+            atlas: Readonly<{
+                width: number;
+                height: number;
+            }>;
+            layers: readonly import("../lens/menuField.js").MenuInkLayer[];
+        }>;
+    }>[];
+    menuResting(): boolean;
+    /** The trigger surface as bar glass: the menu envelope (constant storage through the
+     * morph) with the trigger's current outline, at `opacity` over the menu surface. */
+    barTrigger(right: SurfaceRenderSpec, opacity: number): SurfaceRenderSpec;
+    /** The resting (closed) menu surface, independent of the menu's current state. */
+    closedMenuSpec(): {
+        touchLight?: import("../renderSpecs.js").GlassTouchLight;
+        excludeRegionIds?: readonly string[];
+        restHidden?: boolean;
+        opacity?: number;
+        occluder?: import("../renderSpecs.js").CapsuleShape;
+        prewarmTransparent?: boolean;
+        recipeMix?: number;
+        sheetOpaqueMix?: number;
+        popoverArrow?: import("../regions.js").PopoverArrow;
+        variant?: import("../lens/referenceProfiles.js").ReferenceVariant;
+        treatment?: 'sheet' | 'expandedSheet' | 'alert' | 'confirmation' | 'contextBackdrop' | 'contextPreview' | 'contextMenu';
+        tint?: import("../regions.js").GlassTint;
+        memberHighlight?: Readonly<{
+            member: number;
+            amount: number;
+            light?: import("../renderSpecs.js").GlassTouchLight;
+        }>;
+        backdropMenuOverlay?: boolean;
+        blurSigmaCssPx?: number;
+        frameHeight: number;
+        frameWidth: number;
+        frameX: number;
+        frameY: number;
+        id: import("../renderSpecs.js").SurfaceId;
+        materialMix: number;
+        materialProfile: 'chrome' | 'searchField' | 'menu';
+        menuTintMix?: number;
+        returningTrigger?: import("../renderSpecs.js").ReturningMenuTrigger;
+        radius: number;
+        sampleHeight: number;
+        sampleInsetX: number;
+        sampleInsetY: number;
+        sampleWidth: number;
+        shaderAperture: boolean;
+        shape: import("../renderSpecs.js").SurfaceShape;
+        tabSelection?: import("../renderSpecs.js").TabSelectionShape;
+        ink?: Readonly<{
+            atlas: Readonly<{
+                width: number;
+                height: number;
+            }>;
+            layers: readonly import("../lens/menuField.js").MenuInkLayer[];
+        }>;
+        backdropExclusions: string[];
+    } | undefined;
+    private restMenu;
+    /** Transport sequence: assigned when a source message is posted, so the worker
+     * sees strictly increasing revisions and never has to reject a stale one. */
+    post(request: Request, transfer?: Transferable[]): Promise<unknown>;
+    nextTransport(): number;
+    /** One preparation at a time (productionPrepare.ts). */
+    private prepare;
+    /** Diagnostic: the installed capture's extent and its colour at viewport row `y` (CSS px, x centre). */
+    private sourceProbe;
+    triggerValues(scroll: number): {
+        context: number[];
+        response: (-0.3451911179708627 | -0.12025038168260119 | 0.23357323336904154 | 0.7223854586442838 | 1)[] | (-0.24774618727435888 | 0.06152028922900846 | 0.5358530945042601 | 0.7019229824978999 | 0.7674240204118238)[] | (-0.003838997933491911 | 0.21213920995723007 | 0.34505442834797134 | 0.4425394744439445 | 0.9999999999998385)[];
+        chroma: 0.7674240204118238 | 0.9999999999998385 | 1;
+        regime: number;
+    } | undefined;
+    private track;
+    /** A source install replaces a surface's spec in the worker. The menu surfaces' specs are
+     * read when a prepare starts, but installed after its captures: a menu run that was live
+     * at any point since then owns them (installing the stale snapshot after the run ended
+     * left the open panel, or a stale trigger bubble, presented). */
+    /** Menu runs that find no installed surface: held until it is installed and acknowledged, else a loud glass error. */
+    menuSurface: MenuSurfaceGuard;
+    menuStage: MenuSurfaceStage;
+    /** True once the worker has acknowledged the install of the menu surface of the current enable
+     * generation (a disable, teardown or rebind starts a new generation). */
+    menuReady: boolean;
+    menuGeneration: number;
+    /** Whether a menu run may be sent to its surface now. Opening the menu while its surface is disabled
+     * is the error, once per run (the trigger's track belongs to the same run); gestures are bound only
+     * while the menu is enabled, and closing a menu that never showed has nothing to draw. A run before
+     * the surface is acknowledged is guarded until it is: sent to the worker when its install is already
+     * posted, else kept for the preparation that installs it. */
+    private menuRunAllowed;
+    menuTrackSince(id: 'right' | 'region:bar-trigger', since: number): RegionTrack | undefined;
+    tabInput(event: 'down' | 'move' | 'up' | 'select' | 'reset', index: number, cancelled?: boolean): void;
+    tabPointerDown(x: number, index: number): boolean;
+    tabPointerMove(x: number): void;
+    tabPointerUp(cancelled?: boolean): void;
+    selectTabAnimated(index: number): void;
+    private commitTabSelection;
+    setTabSelection(index: number | undefined): void;
+    private minimizeTrack;
+    restoreMinimizingTabBar(path?: RestorePath): boolean;
+    private navigation;
+    updateGeometry(next: Partial<RuntimeGeometry>): void;
+    retargetContent(scroller: HTMLDivElement, contentHost: HTMLDivElement): void;
+    setContentHost(host: HTMLDivElement): void;
+    setAppearance(appearance: Appearance): void;
+    commitAppearance(appearance: Appearance): void;
+    setScroll(offset: number): void;
+    setScreen(screen: ScreenId): void;
+    setMenuEnabled(enabled: boolean, _resetOwner?: boolean): void;
+    regionDiagnostics(): undefined;
+    setBridgeEnabled(_enabled: boolean): void;
+    setGlassEnabled(enabled: boolean): void;
+    setLensMode(mode: LensMode): void;
+    setMarkers(_enabled: boolean): void;
+    setVelocityFadeEnabled(_enabled: boolean): void;
+    setDragProgress(_progress: number): void;
+    startLiquidMotion(_repeats?: number, _speed?: number): void;
+    startMenuCadence(_repeats?: number, _speed?: number): void;
+    setMenuHandoffProbe(_hold: boolean): void;
+    setMenuPreparationProbe(_milliseconds: number): void;
+    setMenuCase(name: string): void;
+    recordMenuInteraction(event: string, phase: string): void;
+    recordMenuDecision(decision: MenuGestureDecision): void;
+    recordMenuSelection(index: number, event: unknown, source?: string): void;
+    recordMenuInput(_event: Event): void;
+    recordMenuTouch(_phase: string, _event: PointerEvent): void;
+    resetMetrics(): void;
+    exportFrameTrace(_includeBuffers?: boolean): {
+        backend: string;
+        events: unknown[];
+        errors: readonly Readonly<{
+            code: import("../errors.js").GlassErrorCode;
+            message: string;
+            stage: string;
+            reason?: string;
+            at: number;
+            transient?: true;
+            recovering?: true;
+        }>[];
+    };
+    benchmarkRestingMaterials(): Record<string, unknown>;
+    exportDiagnosticBuffers(): void;
+    /** The options of the create() call that owns this shared runtime now. A StrictMode or remount
+     * sequence can create twice while initialization is pending: the cancelled first caller's
+     * release must not tear down the runtime the second caller has already rebound. */
+    private owner?;
+    /** Releases the runtime for `owner` (every caller passes its create() options); a stale owner is ignored. */
+    detach(owner?: RuntimeOptions): void;
+    private teardown;
+    dispose(owner?: RuntimeOptions): void;
+}