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

package/dist/glass/webgpu/rasterUniforms.js

@@ -0,0 +1,415 @@
+import { touchLightUniforms } from './touchLight.js';
+import { morphFieldUniforms } from '../morphField.js';
+import lightingFit from './lensLightingFit.json';
+import { TAB_MOTION_FIT } from '../lens/tabMotionFit.js';
+import { tabInkBand } from './tabGlyphInk.js';
+import { materialUniformMix, materialUniformValues } from '../lens/materialUniforms.js';
+import selectionRecipes from '../lens/selectionParameters.json';
+/** The grouped page background (light) or black behind every backdrop. */
+export const pageBackground = (appearance) => appearance === 'light' ? [242 / 255, 242 / 255, 247 / 255, 1] : [0, 0, 0, 1];
+/** Glass-vibrant glyph ink offsets per appearance. */
+export const glyphVibrancy = (appearance) => appearance === 'light' ? [13 / 255, 10 / 255] : [-4 / 255, 0];
+/** Composite shader uniform (struct P in raster.ts): sample frame, source extents, navigation
+ * pose (the live pose, or the tab-drag fallback) and the eight route-atlas slots. */
+export function compositeUniforms(setup, navigation, scrollY, x, background, frontHeight, rearHeight) {
+    const { spec, resolution, width } = setup;
+    const dragDim = Math.floor(0.12 * (1 - x / width) * 255) / 255;
+    return [
+        spec.sampleWidth,
+        spec.sampleHeight,
+        resolution,
+        setup.sourceWidth ?? width,
+        spec.frameX - spec.sampleInsetX + (setup.sourceOrigin?.x ?? 0),
+        spec.frameY - spec.sampleInsetY + (setup.sourceOrigin?.y ?? 0),
+        x,
+        dragDim,
+        ...background,
+        frontHeight / resolution,
+        rearHeight / resolution,
+        scrollY,
+        0,
+        ...(navigation
+            ? [navigation.frontX, navigation.rearX, navigation.frontDim, navigation.rearDim]
+            : [x, x - width, 0, dragDim]),
+        ...Array.from({ length: 8 }, (_, i) => {
+            const route = navigation?.routes?.[i];
+            return [route?.x ?? 0, route?.dim ?? 0, ...(route?.zoom?.origin ?? [0, 0])];
+        }).flat(),
+        setup.navigationAtlas ?? 0,
+        // The fill beyond an open window edge (see compositeSource); a raster's own capture has no
+        // open edge (`source.w` above is 0) unless its plane's layer says so (composeBackdrop).
+        ...background.slice(0, 3),
+        1,
+        1,
+        0,
+        0,
+        ...Array.from({ length: 8 }, (_, i) => {
+            const zoom = navigation?.routes?.[i]?.zoom;
+            return zoom ? [zoom.x, zoom.y, zoom.scale, zoom.radius] : [0, 0, 0, 0];
+        }).flat(),
+        ...Array.from({ length: 8 }, (_, i) => navigation?.routes?.[i]?.zoom?.clip ?? [0, 0, 0, 0]).flat(),
+    ];
+}
+/** Fill outside capture windows or real scrolling content. Band clipping uses openEdges alone. */
+export const backdropFillEdges = (layer) => (layer.openEdges ?? 0) | (layer.fillEdges ?? 0);
+/** Composite uniform for a backdrop plane other than the content plane: its own capture,
+ * scrolled, no navigation pose and no atlas. */
+export function planeCompositeUniforms(size, resolution, layer, rect, scale = [1, 1]) {
+    return [
+        size[0],
+        size[1],
+        resolution,
+        layer.width,
+        rect[0] - layer.origin.x,
+        rect[1] - layer.origin.y,
+        0,
+        0,
+        ...layer.fill,
+        layer.height,
+        layer.height,
+        layer.scroll.y,
+        backdropFillEdges(layer),
+        -layer.scroll.x,
+        1e9,
+        0,
+        0,
+        ...Array.from({ length: 32 }, () => 0),
+        0,
+        ...layer.fill.slice(0, 3),
+        ...scale,
+        0,
+        0,
+        ...Array.from({ length: 64 }, () => 0),
+    ];
+}
+/** A kernel's input texture: logical size and a half-texel clamp. */
+export const inputUniforms = (source, logicalWidth, logicalHeight) => ({
+    uInputSize: [logicalWidth, logicalHeight, 1 / logicalWidth, 1 / logicalHeight],
+    uInputClamp: [
+        0.5 / source.width,
+        0.5 / source.height,
+        1 - 0.5 / source.width,
+        1 - 0.5 / source.height,
+    ],
+});
+/** A shape part in sample-rectangle coordinates: [centerX, centerY, halfWidth, halfHeight]. */
+export const shapeUniform = (spec, part) => [
+    spec.sampleInsetX + part.centerX,
+    spec.sampleInsetY + part.centerY,
+    part.halfWidth,
+    part.halfHeight,
+];
+/** A kernel's output frame inside the result texture (local result) or the layer. */
+export function outputUniforms(layout, frameWidth, frameHeight) {
+    const { spec, resolution } = layout;
+    return layout.local
+        ? {
+            __outputFrame: [
+                layout.resultSampleX / resolution,
+                layout.resultSampleY / resolution,
+                frameWidth,
+                frameHeight,
+            ],
+            __outputTexture: [
+                layout.result.width / resolution,
+                layout.result.height / resolution,
+                1,
+                1,
+            ],
+            __filterScale: [1, 1],
+        }
+        : {
+            __outputFrame: [
+                spec.frameX - spec.sampleInsetX,
+                spec.frameY - spec.sampleInsetY,
+                frameWidth,
+                frameHeight,
+            ],
+            __outputTexture: [layout.width, layout.height, 1, 1],
+            __filterScale: [1, 1],
+        };
+}
+/** The material regular material (bar or menu kernel) sampling the backdrop pyramid. A menu
+ * draws its two-part morph outline and trigger regime, and outputs over its padded pyramid. */
+/** The bar's darker band just inside its top edge: [amount, rise end, fall start, fall end], the
+ * distances in points inside the edge. Fitted 2026-09-30 to the native tab bar (ParityReference
+ * `--tab-glass-scroll`, iOS 27.0 Simulator) over a flat white card, a flat dark card and a photo
+ * in both appearances: 4 luma darker than the interior from 8 to 12 pt over mid and bright
+ * content, 1 over the dark card, none by 20 pt. The amount enters as P * (1 + a * w * (3 - 2P)),
+ * where w fades the shade out over dark glass (smoothstep of the glass luminance, 0.05 to 0.5). */
+export const BAR_TOP_INNER_SHADE = [-0.0145, 8, 11, 20];
+/** Whether a bar-kernel surface is the tab bar. The tab bar's optics were fitted to the native
+ * tab bar: full-resolution detail, a four-tap fill, no highlight floor, the inner shade (all in
+ * the bar shader, switched by `uTabBarOptics`). Every bar surface, the tab bar included, reads
+ * the same area-average blur pyramid (rasterMaterial.ts usesAreaMips). Every other
+ * bar surface (toolbar buttons, glass buttons, a merged group, a button opening into its menu)
+ * keeps the optics the morph engine's material was fitted and approved on: under the tab bar's
+ * optics an open menu's backdrop read sharper and brighter than in that build. */
+export function usesTabBarOptics(spec) {
+    return spec.id === 'dock';
+}
+/** The material recipe row a surface's material reads. */
+function materialSurface(spec) {
+    if (spec.materialProfile === 'menu')
+        return 'menu';
+    return spec.materialProfile === 'searchField' ? 'searchField' : 'bar';
+}
+export function materialUniforms(layout, setup, pyramid, scale) {
+    const { spec, appearance, resolution, sampleWidth, sampleHeight } = layout;
+    const first = spec.shape.first;
+    const second = spec.shape.second ?? first;
+    const menu = spec.materialProfile === 'menu';
+    const material = {
+        ...touchLightUniforms(spec.touchLight, spec.sampleInsetX, spec.sampleInsetY),
+        ...morphFieldUniforms(spec),
+        ...(menu && spec.recipeMix !== undefined
+            ? materialUniformMix(appearance, spec.recipeMix)
+            : materialUniformValues(materialSurface(spec), appearance)),
+        ...inputUniforms(pyramid, pyramid.width / (resolution * scale), pyramid.height / (resolution * scale)),
+        __uvScale: [
+            (sampleWidth * resolution * scale) / pyramid.width,
+            (sampleHeight * resolution * scale) / pyramid.height,
+        ],
+        // The shape's coordinates (vFilterCoord * uResolution) keep the scale they had when the
+        // pyramid's storage was its content rounded up to whole texels: the bar pyramid's padding
+        // to whole coarse texels (areaMips.ts) changes where the backdrop is read, not the shape.
+        __filterScale: [
+            (sampleWidth * resolution * scale) / Math.ceil(sampleWidth * resolution * scale),
+            (sampleHeight * resolution * scale) / Math.ceil(sampleHeight * resolution * scale),
+        ],
+        uResolution: [sampleWidth, sampleHeight],
+        uShape: shapeUniform(spec, first),
+        uRadius: first.radius,
+        uMaterialMix: 1,
+        uCoverageWidth: 0.5 / resolution,
+        uDiagnosticOutput: 0,
+        uInnerShade: BAR_TOP_INNER_SHADE,
+        uTabBarOptics: usesTabBarOptics(spec) ? 1 : 0,
+    };
+    if (menu)
+        Object.assign(material, {
+            uShapeA: shapeUniform(spec, first),
+            uShapeB: shapeUniform(spec, second),
+            uShapeRadii: [first.radius, second.radius],
+            uShapeParams: [spec.shape.second ? 2 : 1, spec.shape.blendRadius, 0, spec.shape.rimAlpha],
+            uContinuousMenu: 1,
+            uMenuMaterialMix: spec.recipeMix !== undefined ? 1 : (spec.materialMix ?? 1) * (spec.menuTintMix ?? 1),
+            uReturningTrigger: spec.returningTrigger && spec.recipeMix === undefined
+                ? [
+                    spec.sampleInsetX + spec.returningTrigger.centerX,
+                    spec.sampleInsetY + spec.returningTrigger.centerY,
+                    spec.returningTrigger.radius,
+                    spec.returningTrigger.mix,
+                ]
+                : [0, 0, 0, 0],
+            uTriggerContext: setup.trigger?.context ?? [0, 0, 0, 0],
+            uTriggerResponse: setup.trigger?.response ?? [1, 0, 1, 0],
+            uTriggerChroma: setup.trigger?.chroma ?? 1,
+            uTriggerRegime: setup.trigger?.regime ?? 0,
+            uTriggerEnabled: setup.trigger ? 1 : 0,
+        });
+    if (menu)
+        Object.assign(material, outputUniforms(layout, pyramid.width / (resolution * scale), pyramid.height / (resolution * scale)), { __uvScale: [1, 1] });
+    return material;
+}
+/** The selection pill's shared uniforms: the capsule over the composed (material) scratch. */
+export function selectionBaseUniforms(layout, composed) {
+    const { spec, resolution, sampleWidth, sampleHeight } = layout;
+    const selection = spec.tabSelection;
+    const capsule = selection.capsule;
+    const lensMix = selection.lensMix ?? 0;
+    return {
+        ...morphFieldUniforms({ ...spec, shape: { ...spec.shape, members: undefined } }),
+        ...inputUniforms(composed, sampleWidth, sampleHeight),
+        ...outputUniforms(layout, sampleWidth, sampleHeight),
+        uResolution: [sampleWidth, sampleHeight],
+        uShape: [
+            spec.sampleInsetX + capsule.centerX,
+            spec.sampleInsetY + capsule.centerY,
+            capsule.halfWidth,
+            capsule.halfHeight,
+        ],
+        uRadius: capsule.radius,
+        uMaterialMix: selection.materialMix * (selection.restMix ?? 1) * (1 - lensMix),
+        uCoverageWidth: 0.5 / resolution,
+        uDiagnosticOutput: 0,
+    };
+}
+/** The native selection recipe's separable Gaussian over the composed scratch (quarter scale). */
+export function selectionBlurUniforms(layout, composed) {
+    const { appearance, resolution, sampleWidth, sampleHeight } = layout;
+    const recipe = selectionRecipes[appearance];
+    const sigma = Math.max(0.01, recipe.blurRadius * recipe.blurSigmaPerRadius * resolution * 0.25);
+    const weights = Array.from({ length: 6 }, (_, i) => Math.exp(-0.5 * (i / sigma) ** 2));
+    const sum = weights[0] + 2 * weights.slice(1).reduce((total, weight) => total + weight, 0);
+    return {
+        ...inputUniforms(composed, sampleWidth, sampleHeight),
+        uStep: [1 / (resolution * 0.25 * sampleWidth), 0],
+        uCross: [0, 1 / composed.height],
+        uWeights0: weights.slice(0, 4).map(weight => weight / sum),
+        uWeights1: weights.slice(4).map(weight => weight / sum),
+    };
+}
+/** The selection pill (recipe colour matrix and contour) over the blurred scratch. */
+export function selectionPillUniforms(layout, base, vertical) {
+    const { appearance, resolution } = layout;
+    const recipe = selectionRecipes[appearance];
+    return {
+        ...base,
+        uSelectionSize: [
+            vertical.width / (resolution * 0.25),
+            vertical.height / (resolution * 0.25),
+            1 / vertical.width,
+            1 / vertical.height,
+        ],
+        uSelectionRow0: recipe.matrix[0],
+        uSelectionRow1: recipe.matrix[1],
+        uSelectionRow2: recipe.matrix[2],
+        uSelectionContourAngular: recipe.contour.angular,
+        uSelectionContourProfile: [recipe.contour.width, recipe.contour.center],
+    };
+}
+/** Anchors of the dock's first and last glyphs, evenly spaced inside the bar's first shape. */
+export function dockGlyphAnchors(spec, count) {
+    const first = spec.shape.first;
+    const spacing = (first.halfWidth * 2 - 20) / count;
+    const anchor = spec.sampleInsetX + first.centerX - first.halfWidth + 10.5 + spacing / 2;
+    return [anchor, anchor + spacing * (count - 1)];
+}
+/** How much of a lift is visible: its amount, or any lens field / lighting clock still showing.
+ * Geometry-only diffuse height/spread tails do not keep an invisible layer alive. */
+export function liftVisibleAmount(lift, appearance) {
+    const lensField = appearance === 'dark' ? lift?.optics?.lensDark : lift?.optics?.lensLight;
+    const lightingField = appearance === 'dark' ? lift?.optics?.lightingDark : lift?.optics?.lightingLight;
+    const lightingAmount = lightingField
+        ? Math.max(lightingField[0], lightingField[1], lightingField[3], lightingField[5], lightingField[6])
+        : 0;
+    return Math.max(lift?.amount ?? 0, Math.abs(lensField?.[0] ?? 0) / 10.5, lightingAmount);
+}
+/** The lighting fit a lift uses: its explicit profile (a held control thumb), else a glass button's
+ * (composed source, no tab selection) or a tab's. */
+export function liftLighting(lift, spec, appearance) {
+    const profile = lift.profile ?? (lift.source === 'composed' && !spec.tabSelection ? 'button' : 'tab');
+    return { ...TAB_LENS_MAP, ...NO_RIM_LINE, ...NO_TOP_SHADE, ...lightingFit[profile][appearance] };
+}
+/** Only the control profile draws the measured dark rim line (gain, width in points) with a
+ * device-pixel edge; tab and button keep their 0.4 pt edge. */
+const NO_RIM_LINE = { rimLineGain: 0, rimLineWidthPt: 0 };
+/** Only the control profile has native's top inner shadow (amplitude, centre in points below the
+ * rim, rim-side and centre-side sigma in points). */
+const NO_TOP_SHADE = { topShade: [0, 0, 1, 1] };
+/** The tab selection's analytic normal field (broad amplitude, broad support, edge amplitude;
+ * field gains on the press clock's [edge refraction, depth, edge support, fringe]). */
+const TAB_LENS_MAP = { lensMap: [9, 36, -17.5], fieldGain: [1, 1, 1, 1] };
+/** The lift's lighting clocks (seven phases), all at the lift amount when the optics carry none. */
+export function liftLightingClocks(lift, optics, appearance) {
+    return ((appearance === 'dark' ? optics.lightingDark : optics.lightingLight) ?? [
+        lift.amount,
+        lift.amount,
+        lift.amount,
+        lift.amount,
+        lift.amount,
+        lift.amount,
+        lift.amount,
+    ]);
+}
+/** The shared-lift kernel: the lens aperture, its lighting and the lifted foreground glyphs. */
+export function sharedLiftUniforms(layout, lift, optics, capsule, lensDebug, lensAmount) {
+    const { spec, appearance, resolution, sampleWidth, sampleHeight } = layout;
+    const fit = TAB_MOTION_FIT;
+    const first = spec.shape.first;
+    const lighting = liftLighting(lift, spec, appearance);
+    const clocks = liftLightingClocks(lift, optics, appearance);
+    const centerX = spec.sampleInsetX + capsule.centerX;
+    const centerY = spec.sampleInsetY + capsule.centerY;
+    const count = lift.glyphCount ?? spec.tabSelection?.glyphCount ?? 1;
+    const anchors = lift.glyphAnchors ?? (spec.tabSelection ? dockGlyphAnchors(spec, count) : [centerX, centerX]);
+    const contentGlyphs = lift.glyphLayout === 'content';
+    const inkBand = tabInkBand(spec, resolution);
+    return {
+        ...outputUniforms(layout, sampleWidth, sampleHeight),
+        uResolution: [sampleWidth, sampleHeight],
+        uShape: [centerX, centerY, capsule.halfWidth, capsule.halfHeight],
+        uRadius: capsule.radius,
+        uLensDebug: [lensDebug, resolution, 32, 0],
+        uLensLightRotation: 0,
+        uLensBandScale: lighting.bandScale,
+        uLensBandDirections: [lighting.capBandScale, lighting.bottomBandScale],
+        uLensFringe: [
+            lighting.straightFringeGain,
+            lighting.capFringeGain,
+            lighting.straightFringeWidthPt,
+            lighting.capFringeWidthPt,
+        ],
+        uLensDepthShade: lighting.depthShade,
+        uLensDepthIsotropic: lift.source === 'composed' && !spec.tabSelection ? 1 : 0,
+        uLensFaceTreatment: [lighting.faceSaturation, lighting.faceRadialMix],
+        uLensCrestVertical: [
+            lighting.crestTopGain,
+            lighting.crestBottomGain,
+            lighting.rimLineGain,
+            lighting.rimLineWidthPt,
+        ],
+        uLensExteriorShadow: [lighting.shadowOpacity, lighting.shadowOffsetPt, lighting.shadowSigmaPt],
+        uLensLighting: [
+            lighting.faceGain,
+            lighting.faceBias,
+            lighting.crestSigmaPt,
+            lighting.crestCenterPt,
+        ],
+        uLensLightStrength: [
+            lighting.crestGain,
+            lighting.crestGain,
+            lighting.diffuseGain,
+            lighting.crestGain,
+        ],
+        uLensLightingClock: clocks.slice(0, 4),
+        uLensLightingClock2: [clocks[4], clocks[5], clocks[6], 0],
+        uLensField: ((appearance === 'dark' ? optics.lensDark : optics.lensLight) ?? [
+            -10.5 * lift.amount,
+            7 * lift.amount,
+            11.2 * lift.amount,
+            3.68 * lift.amount,
+        ]).map((value, i) => value * lighting.fieldGain[i]),
+        uLensMap: lighting.lensMap,
+        uLensTopShade: lighting.topShade,
+        uLiftMix: lensAmount,
+        uMotionMix: optics.motionMix,
+        uBackgroundWarpPt: optics.backgroundWarpPt,
+        uTravelWarpPt: optics.travelWarpPt,
+        uForegroundChroma: optics.foregroundChroma,
+        uForegroundScaleX: optics.foregroundScaleX,
+        uForegroundScaleY: optics.foregroundScaleY,
+        uForegroundLabelScaleX: optics.foregroundLabelScaleX,
+        uForegroundLabelScaleY: optics.foregroundLabelScaleY,
+        uForegroundShiftPt: contentGlyphs
+            ? [0, 0]
+            : [fit.foregroundShiftPt.icon, fit.foregroundShiftPt.label],
+        uRimGradient: optics.rimGradient,
+        uGlyphAnchors: anchors,
+        uGlyphCount: count,
+        uGlyphLayers: spec.tabSelection?.glyphLayers
+            ? [1, inkBand.top / sampleHeight, sampleHeight / inkBand.height]
+            : 0,
+        uDockShape: contentGlyphs ? [0, -1e6, 0, 0] : shapeUniform(spec, first),
+        uGlyphVibrancy: lift.glyphVibrancy ?? glyphVibrancy(appearance),
+    };
+}
+/** The plain lens kernel for a lift without fitted optics. */
+export function lensLiftUniforms(layout, lift, capsule, source) {
+    const { spec, appearance, sampleWidth, sampleHeight } = layout;
+    const centerX = spec.sampleInsetX + capsule.centerX;
+    const centerY = spec.sampleInsetY + capsule.centerY;
+    return {
+        ...inputUniforms(source, sampleWidth, sampleHeight),
+        ...outputUniforms(layout, sampleWidth, sampleHeight),
+        uResolution: [sampleWidth, sampleHeight],
+        uShape: [centerX, centerY, capsule.halfWidth, capsule.halfHeight],
+        uRadius: capsule.radius,
+        uMaterialMix: Math.max(0, Math.min(1, lift.amount)),
+        uGlyphAnchors: lift.glyphAnchors ?? [centerX, centerX],
+        uGlyphCount: lift.glyphCount ?? 1,
+        uDockShape: shapeUniform(spec, spec.shape.first),
+        uGlyphVibrancy: glyphVibrancy(appearance),
+    };
+}

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

@@ -0,0 +1,8 @@
+type RegionMembership = {
+    readonly size: number;
+    subscribe(listener: () => void): () => void;
+};
+/** Chrome-only launch does not upload a backdrop for app materials. The first
+ * later material needs a source preparation before its first-show hold can end. */
+export declare function watchRegionBackdrop(registry: RegionMembership, prepare: () => void): () => void;
+export {};

package/dist/glass/webgpu/regionBackdrop.js

@@ -0,0 +1,12 @@
+/** Chrome-only launch does not upload a backdrop for app materials. The first
+ * later material needs a source preparation before its first-show hold can end. */
+export function watchRegionBackdrop(registry, prepare) {
+    let needed = registry.size > 0;
+    return registry.subscribe(() => {
+        const next = registry.size > 0;
+        const appeared = next && !needed;
+        needed = next;
+        if (appeared)
+            prepare();
+    });
+}

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

@@ -0,0 +1,145 @@
+import type { GlassRegionRegistry } from '../regionRegistry.js';
+import type { WebGPUClient } from './client.js';
+import { type SampleRect } from './captureDemand.js';
+/** DOM measurements and transport only. No drawing loop or GPU device here. */
+export declare class RegionBridge {
+    private unionWarnings;
+    private registry?;
+    private source?;
+    private unsubscribe?;
+    private unsubscribeInput?;
+    private unsubscribePresentation?;
+    private presentationQueued;
+    private frame;
+    private revision;
+    /** Scenes posted and not yet answered. A scene is the whole region state, so when the worker
+     * falls behind, superseded scenes are merged: only the newest waits for a free slot. */
+    private scenesInFlight;
+    private pendingScene?;
+    private sceneValidity;
+    private scenePresented;
+    private readiness;
+    private accessoryAdmissions;
+    private presentationAllowed;
+    private readinessQueued;
+    private queueReadiness;
+    private waitForRegion;
+    private syncReadiness;
+    private static readonly SCENES_IN_FLIGHT;
+    private flushPendingScene;
+    private sceneDone;
+    private postScene;
+    /** A scene whose reply the caller needs (new presenters): sent now, superseding any queued scene. */
+    private sendScene;
+    /** Foreground source revisions. Unique per capture: a refresh superseded between its
+     * foreground send and its scene send must not hand the next capture the same key
+     * (the worker's frame graph treats a key as immutable content). */
+    private foregroundRevision;
+    private epoch;
+    private serial;
+    private canvases;
+    private nextPresenter;
+    private foregrounds;
+    private dirtyForegrounds;
+    private unsubscribeContent?;
+    private deferredForegrounds;
+    private foregroundInputs;
+    /** An idle lift is transparent; its labels remain live DOM while layout moves them. Keep
+     * the warm ink instead of rasterizing an invisible lens at every intermediate width. */
+    private deferIdleForeground;
+    /** Regions seen in an unselected tab, with the panel they were seen in. One stays held after
+     * its tab is selected again, until the worker has installed that tab's source preparation
+     * (`sourceInstalled`): only then is its own backdrop installed, and only then may it be
+     * redrawn. A region moved into another panel is no longer the held one. */
+    private heldForTab;
+    /** Capture canvases whose bitmap is in a request that has not been sent yet. */
+    private consumedCanvases;
+    /** Release capture canvases once the request that carries their bitmap has resolved. */
+    private releaseConsumedCanvases;
+    private releaseFallback?;
+    /** A worker that never answers the carrying request must not keep the canvases allocated. */
+    private armReleaseFallback;
+    /** The regions that sit in tabs that are not selected. A source preparation sends them with its
+     * batch: the worker holds them on their own backdrop before the new plane set replaces it, and
+     * resumes every other region in the same batch. Reading them changes nothing here. */
+    inactiveRegionIds(): string[];
+    /** The selected tab's own backdrop is installed in the worker: its regions stop being held. */
+    releaseHeldRegions(): void;
+    private sourceRevision?;
+    /** Invalidate in-flight geometry before posting the replacement capture batch. */
+    sourceWillChange(revision: number): void;
+    /** A source preparation posted its batch (`installed` is the worker's reply to it). Only once
+     * the worker has acknowledged it are the selected tab's regions released and their scene sent.
+     * If the worker rejects the batch, nothing was installed and nothing was resumed there: the
+     * holds stay, so those regions keep the frames they have (the rejection reaches the caller). */
+    sourceInstalled(installed: Promise<unknown>, appearance: 'light' | 'dark'): Promise<void>;
+    private scrolls;
+    private nextScroll;
+    private client;
+    constructor(client: WebGPUClient, appearance: 'light' | 'dark');
+    private batch?;
+    private send;
+    bind(registry: GlassRegionRegistry | undefined, source: HTMLElement): void;
+    private rowScrollImpact;
+    private rowContact;
+    private scrollInvalidated;
+    private unsubscribeEvents?;
+    private viewportObservers;
+    private viewportPending;
+    /** Keep the worker's old sample covered until it acknowledges its new viewport. A source
+     * installation can redraw that old viewport before the queued move reaches the worker. */
+    private viewportSamples;
+    private viewportInFlight;
+    private presenterExtents;
+    private retainPresenterExtent;
+    private viewportSending;
+    private updateViewport;
+    unbind(): void;
+    invalidateSources(): void;
+    private fail;
+    private invalidatePresentation;
+    /** A glass element started or ended a shape track: send it now, then refresh as usual. */
+    private sendShapeTrack;
+    private sendPresentationTrack;
+    invalidate: () => void;
+    private appearance;
+    /** The source owner's coverage check (`ProductionGlassRuntime.coverFor`): a promise while a
+     * capture of rows these regions newly sample is on its way. */
+    coverage?: (rects: () => readonly SampleRect[]) => Promise<void> | undefined;
+    /** Sample rectangles of the regions on screen, in viewport points (captureDemand.ts). */
+    sampleRects(): SampleRect[];
+    /** Whether the worker needs the root transmitted backdrop (it arrives with the shared capture). */
+    get needsBackdrop(): boolean;
+    /** Navigation chrome moves horizontally. Its backdrop only needs these viewport
+     * rows, including each material's sampling halo. Other glass keeps full capture. */
+    navigationCaptureRows(height: number): {
+        top: number;
+        height: number;
+    };
+    /** The root capture changed in the worker (shared slot). Scene and foreground
+     * updates apply as one transaction; foregrounds are keyed by their own ink and
+     * appearance, so only regions whose ink changed are recaptured. */
+    setAppearance(appearance: 'light' | 'dark'): void;
+    sourceChanged(appearance: 'light' | 'dark'): Promise<void>;
+    private enqueue;
+    private navigationEpoch;
+    private navigationHold?;
+    holdNavigation(): () => void;
+    refresh(): Promise<void>;
+    admitNavigation(key: string): Promise<void>;
+    private navigationReceipt?;
+    private navigationRetry;
+    /** Captured menu ink by content key, most recent last (see INK_CAPTURES_RETAINED). */
+    private inkCaptures;
+    /** The ink key whose capture failed for an element (not retried until its content changes). */
+    private inkFailures;
+    private inkAtlases;
+    /** An emerging menu's ink: its rows and its trigger's glyph, captured once per content change
+     * into one foreground atlas (sent as the region's foreground source) and placed each refresh at
+     * their live settled rectangles. The glass draws them until the page's rows take over. */
+    private emergeInk;
+    private fieldEnvelopes;
+    private fieldEnvelope;
+    private refreshNow;
+    private refreshScene;
+}