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

package/dist/glass/fallback/regions.js

@@ -0,0 +1,249 @@
+import { regionSpec, emergeRegionSpec, emergeProfile } from '../webgpu/regionScene.js';
+import { menuMorphDuration, sampleMenuMorph, transitionMenuMorph } from '../lens/menuMorphMotion.js';
+import { sampleMenuCorner } from '../lens/menuCornerMotion.js';
+import { confirmHeldSources, heldPresentations } from '../presentationFrame.js';
+import { animateElement, timelineStart } from '../../motion/animate.js';
+import { FallbackMaterial } from './material.js';
+import { GLASS_SHAPE_TRACK_EVENT, glassShapeTrack } from '../shapeTrackRegistry.js';
+import { trackedShapeSpec } from '../shapeTrack.js';
+import { glassRadius } from '../regions.js';
+/** Registered DOM owners already follow scroll, sheets and navigation on the compositor. */
+export class FallbackRegions {
+    entries = new Map();
+    unsubscribe = [];
+    frame = 0;
+    commitFrame = 0;
+    disposed = false;
+    registry;
+    appearance;
+    constructor(registry, appearance) {
+        this.registry = registry;
+        this.appearance = appearance;
+        if (!registry)
+            return;
+        this.unsubscribe = [
+            registry.subscribe(this.schedule),
+            registry.subscribePresentation(this.schedule),
+        ];
+        window.addEventListener(GLASS_SHAPE_TRACK_EVENT, this.schedule);
+        this.refresh();
+    }
+    schedule = () => {
+        if (!this.frame)
+            this.frame = requestAnimationFrame(() => {
+                this.frame = 0;
+                this.refresh();
+            });
+    };
+    setAppearance(appearance) {
+        if (appearance === this.appearance)
+            return;
+        this.appearance = appearance;
+        this.refresh();
+    }
+    refresh() {
+        const registrations = this.registry?.values() ?? [];
+        const live = new Set(registrations.map(entry => entry.id));
+        for (const [id, entry] of this.entries) {
+            if (!live.has(id)) {
+                entry.ink?.cancel();
+                entry.material.dispose();
+                entry.restoreCanvas();
+                this.entries.delete(id);
+            }
+        }
+        cancelAnimationFrame(this.commitFrame);
+        const shows = registrations.map(entry => ({
+            entry,
+            show: entry.canvas.dataset.satinGlassShow,
+        }));
+        this.commitFrame = requestAnimationFrame(() => {
+            if (this.disposed)
+                return;
+            // CSS samples the live backdrop. It needs no image capture, but first-show ownership and
+            // generation checks are identical to the other material renderer's submission receipts.
+            confirmHeldSources(heldPresentations().filter(([panel]) => registrations.some(entry => panel.contains(entry.element))));
+            for (const { entry, show } of shows) {
+                if (!entry.element.isConnected ||
+                    !this.entries.has(entry.id) ||
+                    entry.canvas.dataset.satinGlassShow !== show)
+                    continue;
+                entry.canvas.dataset.satinGlassPresented = 'true';
+                if (show !== undefined)
+                    entry.canvas.dataset.satinGlassPresentedShow = show;
+            }
+        });
+        for (const registration of registrations) {
+            const { id, element, descriptor } = registration;
+            const width = element.offsetWidth;
+            const height = element.offsetHeight;
+            if (!width || !height)
+                continue;
+            // Only menu endpoint submission needs viewport geometry; ordinary motion stays local.
+            const box = descriptor.emerge ? element.getBoundingClientRect() : { x: 0, y: 0 };
+            const region = {
+                ...descriptor,
+                shapeTrack: glassShapeTrack(element),
+                frame: { x: box.x, y: box.y, width, height },
+                layer: { id: 'fallback', depth: 0, attachment: { kind: 'fixed' } },
+            };
+            const signature = JSON.stringify([region, this.appearance]);
+            let entry = this.entries.get(id);
+            if (!entry) {
+                // A live demotion can leave the last GPU frame on this canvas. Retain the
+                // canvas for presentation receipts, but let only the CSS material paint.
+                const canvas = registration.canvas;
+                const visibility = canvas.style.visibility;
+                canvas.style.visibility = 'hidden';
+                entry = {
+                    material: new FallbackMaterial(element),
+                    signature: '',
+                    generation: 0,
+                    restoreCanvas: () => {
+                        canvas.style.visibility = visibility;
+                    },
+                };
+                this.entries.set(id, entry);
+            }
+            if (entry.signature === signature)
+                continue;
+            const previous = entry.signature;
+            entry.signature = signature;
+            const presenter = {
+                id,
+                layerId: 'fallback',
+                regionIds: [id],
+                origin: box,
+                width,
+                height,
+                resolution: 1,
+            };
+            const scene = { revision: 0, regions: [region], layers: [region.layer], scrolls: [] };
+            const spec = regionSpec(region, presenter, scene);
+            const emerge = region.emerge;
+            if (region.shapeTrack && !emerge) {
+                const track = region.shapeTrack;
+                const frames = track.frames.map((_, index) => trackedShapeSpec(spec, track, track.epoch +
+                    (track.frames.length > 1 ? (index / (track.frames.length - 1)) * track.duration : 0), (w, h) => glassRadius(region.shape, w, h)));
+                // A demotion joins the original run at its current time. It never restarts from zero.
+                if (track.epoch === Number.MAX_VALUE || frames.length === 1)
+                    entry.material.paint(frames[0], this.appearance);
+                else
+                    void entry.material.play(frames, track.duration, timelineStart(track.epoch - performance.timeOrigin), this.appearance);
+                continue;
+            }
+            if (!emerge || emerge.ready === false) {
+                entry.material.paint(spec, this.appearance);
+                continue;
+            }
+            // inkDom changes are acknowledgements, not another trajectory.
+            if (previous && JSON.parse(previous)[0].emerge?.generation === emerge.generation)
+                continue;
+            const generation = ++entry.generation;
+            const direction = emerge.closing ? 'close' : 'open';
+            const profile = emergeProfile(emerge);
+            const reduced = matchMedia('(prefers-reduced-motion: reduce)').matches;
+            const duration = reduced ? 1 : menuMorphDuration(direction, profile);
+            const at = performance.now();
+            const previousMotion = entry.motion?.(at);
+            const sample = (ms) => reduced
+                ? sampleMenuMorph(direction, Infinity, profile, this.appearance)
+                : previousMotion
+                    ? transitionMenuMorph(direction, ms, previousMotion.pose, previousMotion.velocity, profile, this.appearance)
+                    : sampleMenuMorph(direction, ms, profile, this.appearance);
+            entry.motion = now => sample(now - at);
+            const previousCorner = entry.corner?.(at);
+            const corner = (ms) => sampleMenuCorner(direction, ms, previousCorner?.pose, previousCorner?.velocity);
+            entry.corner = now => corner(now - at);
+            const ink = element.querySelector('[data-satin-menu-ink]');
+            const inkWidth = ink?.offsetWidth || width;
+            const inkHeight = ink?.offsetHeight || height;
+            // Supply DOM ink bounds to the renderer-neutral field. No atlas is captured or uploaded.
+            const inkRegion = {
+                ...region,
+                emerge: {
+                    ...emerge,
+                    inkDom: false,
+                    ink: {
+                        atlas: { width: inkWidth, height: inkHeight },
+                        rows: {
+                            source: { x: 0, y: 0, width: inkWidth, height: inkHeight },
+                            frame: {
+                                x: box.x + (ink?.offsetLeft ?? 0),
+                                y: box.y + (ink?.offsetTop ?? 0),
+                                width: inkWidth,
+                                height: inkHeight,
+                            },
+                        },
+                    },
+                },
+            };
+            const specs = Array.from({ length: 121 }, (_, index) => {
+                const ms = (index / 120) * duration;
+                return emergeRegionSpec(spec, inkRegion, presenter, sample(ms).pose, reduced ? { rounding: 0 } : corner(ms).pose, undefined, {
+                    direction,
+                    ms: reduced ? Infinity : ms,
+                    pressHighlight: 0,
+                    settled: reduced || (direction === 'open' && ms >= duration),
+                }, this.appearance);
+            });
+            entry.ink?.cancel();
+            if (ink) {
+                // The shared field gives rows their own scale/fade. Toolbar text starts at full
+                // size while the aperture grows; scaling it by the glass width makes it unreadable.
+                const frames = specs.map((frame, index) => {
+                    const rows = frame.ink?.layers[0];
+                    return {
+                        offset: index / (specs.length - 1),
+                        transformOrigin: '0 0',
+                        transform: rows
+                            ? `translate(${frame.frameX + rows.frame.x - ink.offsetLeft}px,${frame.frameY + rows.frame.y - ink.offsetTop}px) scale(${rows.frame.width / inkWidth},${rows.frame.height / inkHeight})`
+                            : 'none',
+                        opacity: rows?.opacity ?? 0,
+                        filter: `blur(${rows?.blur ?? 0}px)`,
+                    };
+                });
+                entry.ink = animateElement(ink, frames, { duration, easing: 'linear', fill: 'both' });
+                entry.ink.startTime = at;
+            }
+            if (emerge.closing)
+                this.registry?.emergeInk({
+                    type: 'emerge-ink',
+                    regionId: id,
+                    generation: emerge.generation,
+                    phase: 'close-started',
+                });
+            const activeEntry = entry;
+            void entry.material.play(specs, duration, at, this.appearance).then(() => {
+                if (this.disposed ||
+                    this.entries.get(id) !== activeEntry ||
+                    activeEntry.generation !== generation)
+                    return;
+                if (emerge.closing)
+                    this.registry?.emergeSettled(id, emerge.generation);
+                else {
+                    activeEntry.ink?.cancel();
+                    this.registry?.emergeInk({
+                        type: 'emerge-ink',
+                        regionId: id,
+                        generation: emerge.generation,
+                        phase: 'open-settled',
+                    });
+                }
+            });
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        window.removeEventListener(GLASS_SHAPE_TRACK_EVENT, this.schedule);
+        cancelAnimationFrame(this.frame);
+        cancelAnimationFrame(this.commitFrame);
+        this.unsubscribe.forEach(unsubscribe => unsubscribe());
+        this.entries.forEach(entry => {
+            entry.ink?.cancel();
+            entry.material.dispose();
+            entry.restoreCanvas();
+        });
+        this.entries.clear();
+    }
+}

package/dist/glass/fallback/runtime.d.ts

@@ -0,0 +1,72 @@
+import { type RuntimeOptions, type RuntimeGeometry, type LensMode } from '../renderSpecs.js';
+import type { RestorePath } from '../lens/tabRestoreMotion.js';
+import type { ScreenId } from '../lens/Scene.js';
+/** Material replacement only: semantic controls and measured motion keep their existing owners. */
+export declare class FallbackGlassRuntime {
+    private regions;
+    private dock;
+    private thumb;
+    private minimize;
+    private minimizeDom;
+    private tab;
+    private unsubscribeAppearance?;
+    private tabFrame;
+    private tabPressed;
+    private pointer?;
+    private disposed;
+    private options;
+    private constructor();
+    static create(options: RuntimeOptions): Promise<FallbackGlassRuntime>;
+    private bindScroll;
+    private unbindScroll;
+    private begin;
+    private endContact;
+    private endScroll;
+    private scroll;
+    private dockSpec;
+    private minimizeTrack;
+    restoreMinimizingTabBar(path?: RestorePath): boolean;
+    private thumbSpec;
+    private paintTabs;
+    updateGeometry(next: Partial<RuntimeGeometry>): void;
+    setTabSelection(index: number | undefined): void;
+    private sampleTab;
+    private scheduleTab;
+    private commitTab;
+    selectTabAnimated(index: number): void;
+    tabPointerDown(x: number, index: number): boolean;
+    tabPointerMove(x: number): void;
+    tabPointerUp(cancelled?: boolean): void;
+    retargetContent(scroller: HTMLDivElement, contentHost: HTMLDivElement): void;
+    setContentHost(host: HTMLDivElement): void;
+    setAppearance(appearance: 'light' | 'dark'): void;
+    commitAppearance(appearance: 'light' | 'dark'): void;
+    setScroll(offset: number): void;
+    setScreen(_screen: ScreenId): void;
+    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;
+    regionDiagnostics(): undefined;
+    resetMetrics(): void;
+    exportFrameTrace(_includeBuffers?: boolean): {
+        backend: string;
+        events: never[];
+        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(): never;
+    detach(owner?: RuntimeOptions): void;
+    dispose(_owner?: RuntimeOptions): void;
+}

package/dist/glass/fallback/runtime.js

@@ -0,0 +1,278 @@
+import { getGlassErrors } from '../errors.js';
+import { createRenderSpecs, } from '../renderSpecs.js';
+import { TabMotion, TAB_INTERACTIVE_MOTION } from '../lens/tabMotion.js';
+import { TabMinimizeIntent } from '../lens/tabMinimizeMotion.js';
+import { tabHeldGeometry } from '../webgpu/interactionProfiles.js';
+import { WorkerMinimize } from '../webgpu/minimize.js';
+import { FallbackMaterial } from './material.js';
+import { FallbackRegions } from './regions.js';
+/** Material replacement only: semantic controls and measured motion keep their existing owners. */
+export class FallbackGlassRuntime {
+    regions;
+    dock;
+    thumb;
+    minimize = new TabMinimizeIntent();
+    minimizeDom;
+    tab = new TabMotion(TAB_INTERACTIVE_MOTION);
+    unsubscribeAppearance;
+    tabFrame = 0;
+    tabPressed = false;
+    pointer;
+    disposed = false;
+    options;
+    constructor(options) {
+        this.options = options;
+        Object.assign(globalThis, {
+            __SATIN_GLASS_RENDERER__: { backend: 'fallback', errors: getGlassErrors },
+        });
+        this.regions = new FallbackRegions(options.regions, options.appearance);
+        this.dock = new FallbackMaterial(options.elements.chrome.dock);
+        this.thumb = new FallbackMaterial(options.elements.chrome.dock);
+        this.dock.element.style.zIndex = '-2';
+        this.thumb.element.style.zIndex = '-1';
+        this.minimizeDom = new WorkerMinimize(options, path => this.restoreMinimizingTabBar(path), {
+            begin: x => {
+                this.tabPointerDown(x, this.options.geometry.tabBarSelectedIndex ?? 0);
+            },
+            move: x => this.tabPointerMove(x),
+            end: cancelled => this.tabPointerUp(cancelled),
+        });
+        this.bindScroll();
+        this.unsubscribeAppearance = options.subscribeAppearance?.(() => this.commitAppearance(options.currentAppearance?.() ?? options.appearance));
+        this.updateGeometry({});
+    }
+    static async create(options) {
+        const runtime = new FallbackGlassRuntime(options);
+        await document.fonts.ready;
+        // Let committed CSS material reach a rendering opportunity before releasing the launch cover.
+        await new Promise(resolve => requestAnimationFrame(() => resolve()));
+        if (!runtime.disposed) {
+            options.onSourceReady?.(options.elements.contentHost);
+            options.onPresented?.(true);
+        }
+        return runtime;
+    }
+    bindScroll() {
+        const host = this.options.elements.scroller;
+        host.addEventListener('scroll', this.scroll, { passive: true });
+        host.addEventListener('pointerdown', this.begin, { passive: true });
+        host.addEventListener('scrollend', this.endScroll);
+        document.addEventListener('pointerup', this.endContact, true);
+    }
+    unbindScroll() {
+        const host = this.options.elements.scroller;
+        host.removeEventListener('scroll', this.scroll);
+        host.removeEventListener('pointerdown', this.begin);
+        host.removeEventListener('scrollend', this.endScroll);
+        document.removeEventListener('pointerup', this.endContact, true);
+    }
+    begin = (event) => {
+        this.pointer = event.pointerId;
+        this.minimize.beginGesture(this.options.elements.scroller.scrollTop);
+    };
+    endContact = (event) => {
+        if (event.pointerId !== this.pointer)
+            return;
+        this.pointer = undefined;
+        this.minimize.endContact(this.options.elements.scroller.scrollTop);
+    };
+    endScroll = () => this.minimize.endGesture();
+    scroll = () => {
+        const host = this.options.elements.scroller;
+        const direction = this.minimize.observe(host.scrollTop, host.scrollHeight - host.clientHeight, this.options.geometry.tabBarPlacement);
+        if (direction)
+            this.minimizeTrack(direction);
+    };
+    dockSpec() {
+        const spec = createRenderSpecs(this.options.geometry, this.options.appearance).find(spec => spec.id === 'dock');
+        // Chrome's DOM host already owns the viewport placement.
+        return { ...spec, frameX: 0, frameY: 0 };
+    }
+    minimizeTrack(direction, path = 'tap') {
+        const track = this.minimizeDom.start(direction, this.dockSpec(), path);
+        void this.dock.play(track.specs, track.duration, track.at, this.options.appearance);
+        void this.thumb.play(track.specs.map(spec => this.thumbSpec(spec)), track.duration, track.at, this.options.appearance);
+    }
+    restoreMinimizingTabBar(path = 'tap') {
+        if (!this.minimize.compact)
+            return false;
+        this.minimize.restore(this.options.elements.scroller.scrollTop);
+        this.minimizeTrack('restore', path);
+        return true;
+    }
+    thumbSpec(spec) {
+        const capsule = spec.tabSelection?.capsule ?? spec.shape.first;
+        return {
+            ...spec,
+            opacity: spec.tabSelection?.materialMix ?? 0,
+            shape: { ...spec.shape, first: capsule, members: undefined, second: undefined },
+            variant: 'clear',
+            tint: [1, 1, 1, this.options.appearance === 'dark' ? 0.12 : 0.32],
+        };
+    }
+    paintTabs() {
+        const spec = this.minimizeDom.current(this.dockSpec());
+        this.dock.element.hidden = this.options.geometry.tabBarSelectedIndex === undefined;
+        this.thumb.element.hidden = this.dock.element.hidden;
+        this.dock.paint(spec, this.options.appearance);
+        const selection = !this.minimizeDom.inkTransformed && spec.tabSelection
+            ? { ...spec, tabSelection: { ...spec.tabSelection, capsule: this.tab.capsule() } }
+            : spec;
+        this.thumb.paint(this.thumbSpec(selection), this.options.appearance);
+    }
+    updateGeometry(next) {
+        const previousPlacement = this.options.geometry.tabBarPlacement;
+        this.options = { ...this.options, geometry: { ...this.options.geometry, ...next } };
+        const geometry = this.options.geometry;
+        this.tab.configure(geometry.tabBarCentres, geometry.tabBarPillWidth, geometry.tabBarPillHeight, geometry.dockWidth, {
+            selected: geometry.tabBarSelectedIndex ?? 0,
+            centerY: geometry.tabBarPillCenterY,
+            parameters: TAB_INTERACTIVE_MOTION,
+            heldGeometry: tabHeldGeometry(geometry.tabBarPillWidth, geometry.tabBarPillHeight, geometry.dockWidth, geometry.tabBarPlacement),
+            widths: geometry.tabBarPillWidths,
+        });
+        this.minimizeDom.update(this.options);
+        if (previousPlacement !== geometry.tabBarPlacement) {
+            this.minimize.rebase(this.options.elements.scroller.scrollTop);
+            if (geometry.tabBarPlacement === 'top')
+                this.restoreMinimizingTabBar();
+        }
+        if (!this.minimizeDom.active)
+            this.paintTabs();
+    }
+    setTabSelection(index) {
+        this.updateGeometry({ tabBarSelectedIndex: index });
+    }
+    sampleTab(now = performance.now()) {
+        this.tab.sample(now, matchMedia('(prefers-reduced-motion: reduce)').matches);
+    }
+    scheduleTab() {
+        if (this.tabFrame || this.disposed)
+            return;
+        this.tabFrame = requestAnimationFrame(now => {
+            this.tabFrame = 0;
+            this.sampleTab(now);
+            // Sample only the live model. Precomputing a track would advance its position and
+            // velocity into the future before the next pointer event could interrupt it.
+            if (!this.minimizeDom.inkTransformed) {
+                const base = this.dockSpec();
+                this.thumb.paint(this.thumbSpec({
+                    ...base,
+                    tabSelection: { ...base.tabSelection, capsule: this.tab.capsule() },
+                }), this.options.appearance);
+            }
+            if (this.tab.needsFrame)
+                this.scheduleTab();
+        });
+    }
+    commitTab(index) {
+        const changed = this.options.geometry.tabBarSelectedIndex !== index;
+        this.options = {
+            ...this.options,
+            geometry: { ...this.options.geometry, tabBarSelectedIndex: index },
+        };
+        this.options.onTabActivated?.(index);
+        if (changed)
+            this.options.onTabSelected?.(index);
+    }
+    selectTabAnimated(index) {
+        this.sampleTab();
+        this.tab.select(index, performance.now());
+        this.commitTab(index);
+        this.scheduleTab();
+    }
+    tabPointerDown(x, index) {
+        if (this.tabPressed)
+            return false;
+        this.sampleTab();
+        this.tabPressed = this.tab.down(x, index, performance.now());
+        this.scheduleTab();
+        return this.tabPressed;
+    }
+    tabPointerMove(x) {
+        if (!this.tabPressed)
+            return;
+        this.sampleTab();
+        this.tab.move(x);
+        this.scheduleTab();
+    }
+    tabPointerUp(cancelled = false) {
+        if (!this.tabPressed)
+            return;
+        this.sampleTab();
+        this.tabPressed = false;
+        const selected = this.tab.up(performance.now(), cancelled, this.options.geometry.tabBarSelectedIndex ?? 0);
+        if (!cancelled && selected !== undefined)
+            this.commitTab(selected);
+        this.scheduleTab();
+    }
+    retargetContent(scroller, contentHost) {
+        if (scroller === this.options.elements.scroller &&
+            contentHost === this.options.elements.contentHost)
+            return;
+        this.unbindScroll();
+        this.options = {
+            ...this.options,
+            elements: { ...this.options.elements, scroller, contentHost },
+        };
+        this.bindScroll();
+        this.options.onSourceReady?.(contentHost);
+    }
+    setContentHost(host) {
+        this.retargetContent(host, host);
+    }
+    setAppearance(appearance) {
+        this.options = { ...this.options, appearance };
+        this.regions.setAppearance(appearance);
+        this.paintTabs();
+    }
+    commitAppearance(appearance) {
+        this.setAppearance(appearance);
+    }
+    setScroll(offset) {
+        this.options.elements.scroller.scrollTop = offset;
+    }
+    setScreen(_screen) { }
+    setBridgeEnabled(_enabled) { }
+    setGlassEnabled(enabled) {
+        if (!enabled)
+            throw Error('Fallback glass cannot be disabled');
+    }
+    setLensMode(_mode) { }
+    setMarkers(_enabled) { }
+    setVelocityFadeEnabled(_enabled) { }
+    setDragProgress(_progress) {
+        throw Error('Use production navigation gestures');
+    }
+    startLiquidMotion(_repeats, _speed) {
+        throw Error('Use production glass regions');
+    }
+    regionDiagnostics() {
+        return undefined;
+    }
+    resetMetrics() { }
+    exportFrameTrace(_includeBuffers = true) {
+        return { backend: 'fallback', events: [], errors: getGlassErrors() };
+    }
+    benchmarkRestingMaterials() {
+        throw Error('CSS material needs Web Inspector profiling');
+    }
+    exportDiagnosticBuffers() {
+        throw Error('CSS material has no GPU diagnostic buffers');
+    }
+    detach(owner) {
+        this.dispose(owner);
+    }
+    dispose(_owner) {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unbindScroll();
+        cancelAnimationFrame(this.tabFrame);
+        this.unsubscribeAppearance?.();
+        this.minimizeDom.dispose();
+        this.regions.dispose();
+        this.dock.dispose();
+        this.thumb.dispose();
+    }
+}

package/dist/glass/fallback/selection.d.ts

@@ -0,0 +1,2 @@
+/** Explicit initial selection. Release error recovery is owned separately by MaterialEffectRoot. */
+export declare function fallbackGlassRequested(): boolean;

package/dist/glass/fallback/selection.js

@@ -0,0 +1,9 @@
+import { strictGlassRequested } from '../failurePolicy.js';
+/** Explicit initial selection. Release error recovery is owned separately by MaterialEffectRoot. */
+export function fallbackGlassRequested() {
+    if (typeof document === 'undefined' || strictGlassRequested())
+        return false;
+    const query = new URLSearchParams(window.location.search).get('glass');
+    return (query === 'fallback' ||
+        (query === null && document.documentElement.dataset.satinGlass === 'fallback'));
+}

package/dist/glass/fieldGeometry.d.ts

@@ -0,0 +1,28 @@
+/** Geometry in frame-local CSS pixels; independent of any renderer. */
+export type GlassFieldMember = {
+    centerX: number;
+    centerY: number;
+    halfWidth: number;
+    halfHeight: number;
+    radius: number;
+};
+/** A diagnostic glass union outline and its bounds in field coordinates. */
+export type GlassUnionFrame = {
+    members: readonly GlassFieldMember[];
+    blendRadius: number;
+};
+/** Sequential native frames bracket contact at 4.50–5.04, 9.23–10.57,
+ * 18.53–20.94, 36.56–41.92 pt. See phase-morph-engine-notes.md.
+ * Polynomial smooth-min joins equal members at gap = k/2. */
+export declare function glassBlendRadius(spacing: number): number;
+export declare function roundedRectDistance(x: number, y: number, s: GlassFieldMember): number;
+export declare function smoothMinimum(a: number, b: number, k: number): number;
+export declare const GLASS_BLEND_ANGLE_POWER = 1;
+/** One smooth-union step: the running field `d` (normal `n`) with member distance `b` (normal `nb`). */
+export declare function glassFieldJoin(d: number, n: readonly [number, number], b: number, nb: readonly [number, number], blendRadius: number): {
+    distance: number;
+    normal: readonly [number, number];
+};
+export declare function roundedRectNormal(x: number, y: number, s: GlassFieldMember): readonly [number, number];
+/** Returns the signed distance to the diagnostic glass union in points. */
+export declare function glassFieldDistance(x: number, y: number, members: readonly GlassFieldMember[], blendRadius: number): number;