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

package/dist/glass/GlassProbeIcons.d.ts

@@ -0,0 +1,8 @@
+import { MENU_ICON_SVG } from './lens/icons.js';
+export declare function RimProofMarkers(): import("react").JSX.Element;
+export declare function MenuIcon({ name }: {
+    name: keyof typeof MENU_ICON_SVG;
+}): import("react").JSX.Element;
+export declare function TabIcon({ index }: {
+    index: number;
+}): import("react").JSX.Element;

package/dist/glass/GlassProbeIcons.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { MENU_ICON_SVG, TAB_ICON_SVG } from './lens/icons.js';
+// Probe-page glyphs for GlassPresentation (rim proof markers and the probe's menu and tab icons).
+export function RimProofMarkers() {
+    return (_jsxs("span", { className: "satin-lens-rim-proof-markers", "aria-hidden": "true", children: [_jsx("i", { className: "satin-lens-rim-proof-marker satin-lens-rim-proof-marker--top" }), _jsx("i", { className: "satin-lens-rim-proof-marker satin-lens-rim-proof-marker--bottom" })] }));
+}
+export function MenuIcon({ name }) {
+    return (_jsx("i", { className: "satin-lens-glass-menu-icon", "aria-hidden": "true", dangerouslySetInnerHTML: { __html: MENU_ICON_SVG[name] } }));
+}
+export function TabIcon({ index }) {
+    return (_jsx("i", { className: "satin-lens-tab-icon", "aria-hidden": "true", dangerouslySetInnerHTML: { __html: TAB_ICON_SVG[index] } }));
+}

package/dist/glass/GlassProbeOverlay.d.ts

@@ -0,0 +1,52 @@
+import type { RefObject } from 'react';
+import type { ContentPage, tabPresentation } from './lens/tabPresentation.js';
+import type { ScreenId } from './lens/Scene.js';
+import type { LensMode } from './renderSpecs.js';
+import type { PresentationGlassRuntime } from './GlassPresentation.js';
+type OutputRef = RefObject<HTMLOutputElement | null>;
+/** Everything the probe page's diagnostics strip and controls panel read and drive. */
+export type ProbeOverlayProps = {
+    captureClean: boolean;
+    bridgeOutputRef: OutputRef;
+    pacingOutputRef: OutputRef;
+    gpuOutputRef: OutputRef;
+    passesOutputRef: OutputRef;
+    domOutputRef: OutputRef;
+    syncOutputRef: OutputRef;
+    clockOutputRef: OutputRef;
+    debugOutputRef: OutputRef;
+    buildStatusRef: OutputRef;
+    runtimeRef: RefObject<PresentationGlassRuntime | undefined>;
+    buildHealthRef: RefObject<Record<string, unknown>>;
+    loadedBuild: string;
+    tabBarVisible: boolean;
+    controlsOpen: boolean;
+    setControlsOpen: (open: boolean) => void;
+    bridgeEnabled: boolean;
+    glassEnabled: boolean;
+    lensMode: LensMode;
+    rimEnabled: boolean;
+    velocityFadeEnabled: boolean;
+    markers: boolean;
+    telemetryEnabled: boolean;
+    toggleBridge: () => void;
+    toggleGlass: () => void;
+    toggleLens: () => void;
+    toggleRim: () => void;
+    toggleVelocityFade: () => void;
+    toggleMarkers: () => void;
+    toggleTelemetry: () => void;
+    contentPage: ContentPage;
+    tabPolicy: ReturnType<typeof tabPresentation>;
+    tabBarProbe: boolean | undefined;
+    screen: ScreenId;
+    navigate: (next: ScreenId) => void;
+    selectPage: (next: ContentPage, offset?: number) => void;
+    backgroundOffset: number;
+    runtimeReady: boolean;
+    runtimeError: string | undefined;
+};
+/** The probe page's diagnostics strip, build status, controls panel and runtime status. A render
+ * function (called inline by GlassPresentation), not a component: the element tree is unchanged. */
+export declare function renderProbeOverlay(props: ProbeOverlayProps): import("react").JSX.Element;
+export {};

package/dist/glass/GlassProbeOverlay.js

@@ -0,0 +1,45 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { lensLabel, storedFlag } from './glassProbeSettings.js';
+import { previousTrace } from './lens/trace.js';
+/** The probe page's diagnostics strip, build status, controls panel and runtime status. A render
+ * function (called inline by GlassPresentation), not a component: the element tree is unchanged. */
+export function renderProbeOverlay(props) {
+    const { captureClean, bridgeOutputRef, pacingOutputRef, gpuOutputRef, passesOutputRef, domOutputRef, syncOutputRef, clockOutputRef, debugOutputRef, buildStatusRef, runtimeRef, buildHealthRef, loadedBuild, tabBarVisible, controlsOpen, setControlsOpen, bridgeEnabled, glassEnabled, lensMode, rimEnabled, velocityFadeEnabled, markers, telemetryEnabled, toggleBridge, toggleGlass, toggleLens, toggleRim, toggleVelocityFade, toggleMarkers, toggleTelemetry, contentPage, tabPolicy, tabBarProbe, screen, navigate, selectPage, backgroundOffset, runtimeReady, runtimeError, } = props;
+    return (_jsxs(_Fragment, { children: [_jsxs("aside", { style: { visibility: captureClean ? 'hidden' : undefined }, className: "satin-lens-diagnostics-strip", "aria-label": "Satin Glass rendering diagnostics", children: [_jsxs("span", { children: [_jsx("b", { children: "BRIDGE" }), _jsx("output", { ref: bridgeOutputRef, children: "starting" })] }), _jsxs("span", { children: [_jsx("b", { children: "PACING" }), _jsx("output", { ref: pacingOutputRef, children: "--" })] }), _jsxs("span", { children: [_jsx("b", { children: "DIRECT GPU" }), _jsx("output", { ref: gpuOutputRef, children: "--" })] }), _jsxs("span", { children: [_jsx("b", { children: "PASSES" }), _jsx("output", { ref: passesOutputRef, children: "--" })] }), _jsxs("span", { children: [_jsx("b", { children: "DOM/MIRROR" }), _jsx("output", { ref: domOutputRef, children: "--" })] }), _jsxs("span", { children: [_jsx("b", { children: "SYNC" }), _jsx("output", { ref: syncOutputRef, children: "--" })] }), _jsxs("span", { className: "satin-lens-diagnostics-wide", children: [_jsx("b", { children: "DEBUG" }), _jsx("output", { ref: clockOutputRef, children: "0.0s" }), " ", _jsx("output", { ref: debugOutputRef, children: "--" })] }), _jsxs("span", { className: "satin-lens-diagnostics-wide", children: [_jsx("b", { children: "PREV RUN" }), _jsx("output", { children: previousTrace() })] })] }), _jsx("div", { style: {
+                    visibility: captureClean ? 'hidden' : undefined,
+                    position: 'absolute',
+                    top: 10,
+                    left: 12,
+                    zIndex: 70,
+                    maxWidth: 245,
+                    fontSize: 11,
+                    padding: '4px 6px',
+                    borderRadius: 5,
+                    background: '#fff',
+                    color: '#111',
+                    pointerEvents: 'none',
+                }, children: _jsxs("output", { ref: buildStatusRef, style: { display: 'block' }, children: ["9c ", loadedBuild, " \u00B7 checking server"] }) }), !captureClean && tabBarVisible && storedFlag('trace', '1') === '1' ? (_jsx("button", { type: "button", style: { position: 'absolute', top: 12, right: 12, zIndex: 70 }, onClick: () => setControlsOpen(true), children: "Frame trace" })) : null, controlsOpen ? (_jsxs("aside", { className: "satin-lens-controls-panel", "aria-label": "Satin Glass controls", children: [_jsxs("header", { children: [_jsx("strong", { children: "Satin Glass" }), _jsx("button", { type: "button", onClick: () => setControlsOpen(false), children: "Done" })] }), _jsxs("div", { className: "satin-lens-control-grid", children: [_jsx("button", { type: "button", onClick: toggleBridge, children: bridgeEnabled ? 'Bridge: on' : 'Bridge: off' }), _jsx("button", { type: "button", onClick: toggleGlass, children: glassEnabled ? 'Glass: on' : 'Glass: off' }), _jsxs("button", { type: "button", onClick: toggleLens, children: ["Lens: ", lensLabel(lensMode)] }), _jsx("button", { type: "button", onClick: toggleRim, children: rimEnabled ? 'Rim: on' : 'Rim: off' }), _jsx("button", { type: "button", onClick: toggleVelocityFade, children: velocityFadeEnabled ? 'Velocity fade: on' : 'Velocity fade: off' }), _jsx("button", { type: "button", onClick: toggleMarkers, children: markers ? 'Markers: on' : 'Markers: off' }), _jsx("button", { type: "button", onClick: toggleTelemetry, children: telemetryEnabled ? 'Telemetry: on' : 'Telemetry: off' }), _jsx("button", { type: "button", onClick: () => runtimeRef.current?.resetMetrics(), children: "Reset metrics" }), _jsx("button", { type: "button", onClick: () => {
+                                    const data = {
+                                        build: document.querySelector('script[type="module"]')?.src,
+                                        buildHealth: buildHealthRef.current,
+                                        appState: {
+                                            page: contentPage,
+                                            tabPresentation: tabPolicy,
+                                            tabProbeOverride: tabBarProbe ?? 'default',
+                                        },
+                                        ...runtimeRef.current?.exportFrameTrace(),
+                                    };
+                                    const url = URL.createObjectURL(new Blob([JSON.stringify(data)], { type: 'application/json' }));
+                                    const link = document.createElement('a');
+                                    link.href = url;
+                                    link.download = 'satin-glass-frames.json';
+                                    link.click();
+                                    setTimeout(() => URL.revokeObjectURL(url), 60000);
+                                }, children: "Export frames + GPU report" }), _jsx("button", { type: "button", onClick: () => runtimeRef.current?.setScroll(620), children: "Seam position" }), _jsx("button", { type: "button", onClick: () => navigate(screen === 'root' ? 'general' : 'root'), children: screen === 'root' ? 'Open General' : 'Back to root' }), _jsxs("button", { type: "button", onClick: () => selectPage(contentPage === 'settings'
+                                    ? 'shapes'
+                                    : contentPage === 'shapes'
+                                        ? 'wallpaper'
+                                        : contentPage === 'wallpaper'
+                                            ? 'drag'
+                                            : 'settings'), children: ["Page: ", contentPage] }), _jsxs("button", { type: "button", onClick: () => selectPage(contentPage, (backgroundOffset + 137) % 702), children: ["Background offset: ", backgroundOffset] })] }), _jsx("p", { children: "Semantic WebKit DOM remains visible. The moving WebGPU layer contains refracted content only; fixed DOM optics own tint, rims and highlights outside the bridge track." })] })) : null, !runtimeReady && !runtimeError ? (_jsx("div", { className: "satin-lens-runtime-status", children: "Initializing the WebGPU glass renderer\u2026" })) : null, runtimeError ? (_jsx("div", { className: "satin-lens-runtime-error", role: "alert", children: runtimeError })) : null] }));
+}

package/dist/glass/GlassTextField.d.ts

@@ -0,0 +1,22 @@
+import { type TextFieldProps } from '../text-input/TextField.js';
+import { Glass } from './regions.js';
+export type GlassTextFieldProps = TextFieldProps & {
+    glass?: Glass;
+};
+/** Shares the 12b editing/IME/keyboard-intent contract. Glass never captures field touches. */
+export declare const GlassTextField: import("react").ForwardRefExoticComponent<Omit<import("react").InputHTMLAttributes<HTMLInputElement>, "defaultValue" | "onChange" | "onSubmit" | "size" | "value"> & {
+    label: string;
+    value: string;
+    onChange(value: string): void;
+    kind?: import("../index.js").TextFieldKind;
+    submitLabel?: import("../index.js").SubmitLabel;
+    onSubmit?(): void;
+    variant?: 'standalone' | 'row' | 'plain';
+    labelVisibility?: 'visible' | 'hidden';
+    labelPlacement?: 'leading' | 'above';
+} & {
+    glass?: Glass;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export declare const GlassSearchField: import("react").ForwardRefExoticComponent<Omit<GlassTextFieldProps, "kind" | "label"> & {
+    label?: string;
+} & import("react").RefAttributes<HTMLInputElement>>;

package/dist/glass/GlassTextField.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from 'react';
+import { TextField } from '../text-input/TextField.js';
+import { GlassEffect } from './GlassEffect.js';
+import { Glass } from './regions.js';
+/** Shares the 12b editing/IME/keyboard-intent contract. Glass never captures field touches. */
+export const GlassTextField = forwardRef(function GlassTextField({ glass = Glass.regular, ...props }, ref) {
+    return (_jsx(GlassEffect, { glass: glass, shape: { kind: 'roundedRectangle', cornerRadius: 22 }, "data-satin-glass-field": "true", children: _jsx(TextField, { ...props, ref: ref }) }));
+});
+export const GlassSearchField = forwardRef(function GlassSearchField({ label = 'Search', ...props }, ref) {
+    return _jsx(GlassTextField, { ...props, label: label, kind: "search", submitLabel: "search", ref: ref });
+});

package/dist/glass/MaterialEffectRoot.d.ts

@@ -0,0 +1,9 @@
+import { type PropsWithChildren, type RefObject } from 'react';
+/** One renderer per app. Registration is semantic; backdrop discovery is framework-owned. */
+export declare function MaterialEffectRoot({ children, scene, chrome, enabled, capabilitySettled, onLaunchReady, }: PropsWithChildren<{
+    scene: RefObject<HTMLDivElement | null>;
+    chrome: HTMLElement | null;
+    enabled: boolean;
+    capabilitySettled: boolean;
+    onLaunchReady?: (ready: boolean) => void;
+}>): import("react").JSX.Element;

package/dist/glass/MaterialEffectRoot.js

@@ -0,0 +1,189 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { fallbackGlassRequested } from './fallback/selection.js';
+import { glassFallbackRequired, reportGlassError, subscribeGlassFallback } from './errors.js';
+import { GlassRegionRegistry } from './regionRegistry.js';
+import { observeTabSources } from '../tabs/sourceRevision.js';
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore, } from 'react';
+import { createPortal } from 'react-dom';
+import { GlassPresentation } from './GlassPresentation.js';
+import { MaterialEffectContext } from './liquidContext.js';
+import { isSupportedTabCount } from './tabBarModel.js';
+/** One renderer per app. Registration is semantic; backdrop discovery is framework-owned. */
+export function MaterialEffectRoot({ children, scene, chrome, enabled, capabilitySettled, onLaunchReady, }) {
+    const automaticFallback = useSyncExternalStore(subscribeGlassFallback, glassFallbackRequired, () => false);
+    const [requestedFallback] = useState(fallbackGlassRequested);
+    const backend = requestedFallback || automaticFallback ? 'fallback' : 'webgpu';
+    const [regions] = useState(() => new GlassRegionRegistry());
+    const regionCount = useSyncExternalStore(regions.subscribe, () => regions.size, () => 0);
+    const [tabs, setTabs] = useState();
+    const [scroller, setScroller] = useState();
+    const [ready, setReady] = useState(false);
+    const [failed, setFailed] = useState(false);
+    // A reported source failure whose one bounded rebuild is still in flight.
+    const [rebuilding, setRebuilding] = useState(false);
+    const [prepared, setPrepared] = useState();
+    const [preparedSources, setPreparedSources] = useState(() => new Map());
+    const preparedScreenKey = prepared?.key;
+    const preparedAt = prepared?.at;
+    const onReady = useCallback((value) => {
+        setReady(value);
+        if (value) {
+            setFailed(false);
+            setRebuilding(false);
+        }
+    }, []);
+    // The worker reports a classified error before notifying the presenter.
+    const onError = useCallback((_error, rebuild) => {
+        setFailed(true);
+        setRebuilding(Boolean(rebuild));
+        setReady(false);
+    }, []);
+    const onSourceReady = useCallback((source) => {
+        source
+            .closest('[data-satin-tab-panel]')
+            ?.dispatchEvent(new CustomEvent('satin:tab-source-ready', { bubbles: true }));
+        const key = source.closest('[data-satin-screen-key]')?.dataset.satinScreenKey;
+        const at = performance.now();
+        // Recapturing a backdrop does not change navigation readiness. In particular, preparing
+        // sheet planes during a hold/entrance must not wake every glass-context consumer. A new
+        // source element or screen key still publishes its own readiness receipt.
+        setPrepared(current => current?.source === source && current.key === key ? current : { source, key, at });
+        if (key)
+            setPreparedSources(current => (current.has(key) ? current : new Map(current).set(key, at)));
+    }, []);
+    const registerTabs = useCallback((id, value) => {
+        setTabs(current => (value ? { id, value } : current?.id === id ? undefined : current));
+    }, []);
+    useEffect(() => {
+        // The scene belongs to our parent host; its ref is assigned after child layout effects.
+        const root = scene.current;
+        if (!root)
+            return;
+        const refresh = () => {
+            // The navigation owner prepares destination atlas pixels and region draws before
+            // playing. Keep that admitted source throughout the track; rebinding this root in
+            // mid-push would retire the incoming presenters and their current-source receipts.
+            const activePanel = root.querySelector('[data-satin-tab-active="true"]');
+            const activeRoot = activePanel ?? root;
+            if (activeRoot.querySelector('[data-satin-transition-active="true"]'))
+                return;
+            const scope = activeRoot;
+            // A split layout shows two uncovered primary scrollers. The backdrop is the
+            // content column (detail), which app glass sits over; the sidebar list is the
+            // source only when no content column is showing. DOM order puts the sidebar first.
+            const content = (element) => !element.closest('[data-satin-pane="sidebar"]');
+            const candidates = [
+                ...scope.querySelectorAll('[data-satin-scroll][data-satin-primary="true"]'),
+            ].filter(element => !element.closest('[data-satin-covered="true"]'));
+            const screens = [
+                ...scope.querySelectorAll('[data-satin-screen-container][data-satin-covered="false"]'),
+            ];
+            const next = candidates.find(content) ??
+                screens.find(content) ??
+                candidates[0] ??
+                screens[0] ??
+                activeRoot;
+            const keys = new Set([...root.querySelectorAll('[data-satin-screen-key]')].map(element => element.dataset.satinScreenKey));
+            setPreparedSources(current => [...current.keys()].every(key => keys.has(key))
+                ? current
+                : new Map([...current].filter(([key]) => keys.has(key))));
+            setScroller(current => {
+                if (current === next)
+                    return current;
+                return next;
+            });
+        };
+        let frame = 0;
+        const schedule = () => {
+            if (frame)
+                return;
+            frame = requestAnimationFrame(() => {
+                frame = 0;
+                refresh();
+            });
+        };
+        const stopRevisions = observeTabSources(root);
+        root.addEventListener('satin:tab-activate', refresh);
+        refresh();
+        const observer = new MutationObserver(schedule);
+        observer.observe(root, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            attributeFilter: [
+                'data-satin-tab-active',
+                'data-satin-covered',
+                'data-satin-transition-active',
+            ],
+        });
+        return () => {
+            observer.disconnect();
+            stopRevisions();
+            root.removeEventListener('satin:tab-activate', refresh);
+            cancelAnimationFrame(frame);
+        };
+    }, [scene]);
+    // Unsupported legacy shapes are errors, never substituted materials.
+    const supported = !tabs || isSupportedTabCount(tabs.value.items.length);
+    useEffect(() => {
+        if (!supported)
+            reportGlassError('unsupported-configuration', 'The glass tab bar requires two to five tabs.', 'registration');
+    }, [supported]);
+    const hasRegions = regionCount > 0;
+    // A WebGPU source failure keeps the owner mounted for its bounded rebuild.
+    // Error visibility and launch readiness remain separate from ownership.
+    const diagnosticGlassOff = import.meta.env.SATIN_DIAGNOSTIC_GLASS_OFF === true;
+    const active = !diagnosticGlassOff && enabled && supported && scroller && chrome && (tabs || hasRegions);
+    // Navigation waits for glass sources only while they can still arrive: never after a
+    // failure with no rebuild in flight (a failed startup, or a failed rebuild). The error
+    // stays reported; navigation proceeds without glass sources.
+    const preparingSources = Boolean(!diagnosticGlassOff &&
+        (enabled || !capabilitySettled) &&
+        supported &&
+        (tabs || hasRegions) &&
+        (!failed || rebuilding));
+    // Capability alone is not paint readiness. The renderer reports only after
+    // it has submitted the retained source, material and rim to their presenters.
+    const launchReady = capabilitySettled &&
+        Boolean(chrome) &&
+        !failed &&
+        supported &&
+        (diagnosticGlassOff || !(tabs || hasRegions) || (enabled && ready));
+    useEffect(() => {
+        onLaunchReady?.(launchReady);
+    }, [launchReady, onLaunchReady]);
+    const value = useMemo(() => ({
+        backend,
+        regions,
+        ready: enabled && supported && !failed && ready,
+        preparingSources,
+        preparedScreenKey,
+        preparedAt,
+        preparedSources,
+        registerTabs,
+    }), [
+        backend,
+        regions,
+        enabled,
+        supported,
+        failed,
+        ready,
+        preparingSources,
+        preparedScreenKey,
+        preparedAt,
+        preparedSources,
+        registerTabs,
+    ]);
+    return (_jsxs(MaterialEffectContext, { value: value, children: [children, active
+                ? createPortal(_jsx(GlassPresentation, { consumer: {
+                        backend,
+                        regions,
+                        scroller,
+                        content: scroller,
+                        tabs: tabs?.value,
+                        onReady,
+                        onSourceReady,
+                        onError,
+                    } }), chrome)
+                : null] }));
+}

package/dist/glass/Menu.d.ts

@@ -0,0 +1,3 @@
+import { type MenuProps } from './menuPresenter.js';
+export type { MenuProps, MenuTriggerProps } from './menuPresenter.js';
+export declare function Menu({ label, actions, trigger, disabled }: MenuProps): import("react").JSX.Element;

package/dist/glass/Menu.js

@@ -0,0 +1,35 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { bindMenuTriggerHold } from '../menu/menuTriggerHold.js';
+import { useContext, useEffect, useRef } from 'react';
+import { ListContext } from '../list-form/listContext.js';
+import { Row } from '../list-form/ListForm.js';
+import { Pressable } from '../press/Pressable.js';
+import { useMenuPresenter } from './menuPresenter.js';
+export function Menu({ label, actions, trigger, disabled = false }) {
+    const list = useContext(ListContext);
+    const anchor = useRef(null);
+    const presenter = useMenuPresenter({ label, actions, disabled });
+    const latest = useRef(presenter);
+    latest.current = presenter;
+    useEffect(() => {
+        if (!anchor.current || disabled)
+            return;
+        const element = anchor.current;
+        return bindMenuTriggerHold(element, contact => latest.current.show({ kind: 'trigger', element, contact }));
+    }, [disabled]);
+    const props = {
+        disabled,
+        onPress: () => anchor.current && presenter.show({ kind: 'trigger', element: anchor.current }),
+        'aria-expanded': presenter.open,
+        'aria-haspopup': 'menu',
+        'aria-controls': presenter.open ? presenter.id : undefined,
+    };
+    return (_jsxs(_Fragment, { children: [_jsx("span", { ref: anchor, "data-satin-menu-label": "true", "data-satin-menu-row": list && !trigger ? 'true' : undefined, "data-satin-keep-keyboard": "true", onPointerDownCapture: event => {
+                    const active = document.activeElement;
+                    if (active instanceof HTMLElement &&
+                        active.matches('input, textarea, [contenteditable="true"]'))
+                        event.preventDefault();
+                    if (event.isPrimary && event.button === 0 && anchor.current)
+                        presenter.prepare({ kind: 'trigger', element: anchor.current }, event.pointerId);
+                }, onPointerCancelCapture: event => presenter.cancelPreparation(event.pointerId), onPointerUp: event => presenter.cancelPreparation(event.pointerId), children: trigger ? (trigger(props)) : list ? (_jsx(Row, { label: label, onPress: props.onPress, disabled: disabled, buttonProps: props, className: "satin-list-button" })) : (_jsx(Pressable, { ...props, "data-satin-glass-button": "glass", children: label })) }), presenter.presentation] }));
+}

package/dist/glass/MenuStack.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode, type RefObject } from 'react';
+import type { Action, ActionItem } from '../actions/types.js';
+import { type Frame } from './submenuMotion.js';
+/**
+ * A menu and the submenus open above it, drawn as one stack. The root level is drawn inside the
+ * menu's own glass (`children` receives its rows); each submenu is a platter of its own. On
+ * iPhone a submenu covers its parent, which shrinks and dims behind it; its title row leads back.
+ * On iPad submenus cascade beside their parents, which stay live: choosing the open row again
+ * closes its submenu, and choosing another row of the parent replaces it.
+ */
+export declare function MenuStack({ actions, select, idiom, closing, cornerRadius, readBounds, backRef, children, }: {
+    actions: readonly Action[];
+    select: (action: ActionItem) => void;
+    idiom: 'phone' | 'pad';
+    /** The whole menu is closing: every submenu leaves with it. */
+    closing: boolean;
+    cornerRadius: number;
+    /** Where submenus may be placed, in viewport coordinates. */
+    readBounds: () => Frame;
+    /** Leaves the top submenu (Escape); reports whether there was one to leave. */
+    backRef: RefObject<(() => boolean) | undefined>;
+    children: (rootRows: ReactNode) => ReactNode;
+}): import("react").JSX.Element;