@kortix/ui 0.0.0-bootstrap.0 → 0.14.3

package/dist/lib/dotmatrix-hooks.d.ts

@@ -0,0 +1,28 @@
+import type { DotMatrixPhase } from './dotmatrix-core.js';
+export declare function usePrefersReducedMotion(): boolean;
+interface UseCyclePhaseOptions {
+    active: boolean;
+    cycleMsBase: number;
+    speed?: number;
+}
+export declare function useCyclePhase({ active, cycleMsBase, speed }: UseCyclePhaseOptions): number;
+interface UseSteppedCycleOptions {
+    active: boolean;
+    cycleMsBase: number;
+    steps: number;
+    speed?: number;
+    idleStep?: number;
+}
+export declare function useSteppedCycle({ active, cycleMsBase, steps, speed, idleStep, }: UseSteppedCycleOptions): number;
+interface UseDotMatrixPhasesOptions {
+    animated?: boolean;
+    hoverAnimated?: boolean;
+    speed?: number;
+}
+interface DotMatrixPhasesResult {
+    phase: DotMatrixPhase;
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+}
+export declare function useDotMatrixPhases({ animated, hoverAnimated, speed, }: UseDotMatrixPhasesOptions): DotMatrixPhasesResult;
+export {};

package/dist/lib/dotmatrix-hooks.js

@@ -0,0 +1,151 @@
+'use client';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+export function usePrefersReducedMotion() {
+    const [prefersReducedMotion, setPrefersReducedMotion] = useState(false);
+    useEffect(() => {
+        const query = window.matchMedia('(prefers-reduced-motion: reduce)');
+        const update = () => {
+            setPrefersReducedMotion(query.matches);
+        };
+        update();
+        query.addEventListener('change', update);
+        return () => {
+            query.removeEventListener('change', update);
+        };
+    }, []);
+    return prefersReducedMotion;
+}
+export function useCyclePhase({ active, cycleMsBase, speed = 1 }) {
+    const [phase, setPhase] = useState(0);
+    useEffect(() => {
+        if (!active) {
+            setPhase(0);
+            return;
+        }
+        const safeSpeed = speed > 0 ? speed : 1;
+        const raw = cycleMsBase / safeSpeed;
+        const cycleMs = raw > 0 && Number.isFinite(raw) ? raw : 1000;
+        const start = performance.now();
+        let rafId = 0;
+        const tick = (now) => {
+            const elapsed = (((now - start) % cycleMs) + cycleMs) % cycleMs;
+            setPhase(elapsed / cycleMs);
+            rafId = requestAnimationFrame(tick);
+        };
+        rafId = requestAnimationFrame(tick);
+        return () => cancelAnimationFrame(rafId);
+    }, [active, cycleMsBase, speed]);
+    return phase;
+}
+const listeners = new Set();
+let rafId = null;
+function emit(now) {
+    listeners.forEach((listener) => {
+        listener(now);
+    });
+}
+function tick(now) {
+    emit(now);
+    if (listeners.size > 0) {
+        rafId = window.requestAnimationFrame(tick);
+    }
+    else {
+        rafId = null;
+    }
+}
+function subscribeFrame(listener) {
+    listeners.add(listener);
+    if (rafId === null) {
+        rafId = window.requestAnimationFrame(tick);
+    }
+    return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0 && rafId !== null) {
+            window.cancelAnimationFrame(rafId);
+            rafId = null;
+        }
+    };
+}
+export function useSteppedCycle({ active, cycleMsBase, steps, speed = 1, idleStep = 0, }) {
+    const safeSteps = Math.max(1, Math.floor(steps));
+    const safeSpeed = speed > 0 ? speed : 1;
+    const rawCycleMs = cycleMsBase / safeSpeed;
+    const rawStepMs = rawCycleMs / safeSteps;
+    const stepMs = rawStepMs > 0 && Number.isFinite(rawStepMs) ? rawStepMs : 1;
+    const cycleMs = stepMs * safeSteps;
+    const [step, setStep] = useState(() => (active ? 0 : idleStep));
+    const startMsRef = useRef(0);
+    const activeRef = useRef(false);
+    const currentStepRef = useRef(idleStep);
+    useEffect(() => {
+        if (!active) {
+            activeRef.current = false;
+            currentStepRef.current = idleStep;
+            setStep(idleStep);
+            return;
+        }
+        const updateStep = (now) => {
+            if (!activeRef.current) {
+                startMsRef.current = now;
+                activeRef.current = true;
+            }
+            const elapsed = Math.max(0, now - startMsRef.current);
+            const nextStep = Math.floor((elapsed % cycleMs) / stepMs) % safeSteps;
+            if (nextStep !== currentStepRef.current) {
+                currentStepRef.current = nextStep;
+                setStep(nextStep);
+            }
+        };
+        updateStep(performance.now());
+        return subscribeFrame(updateStep);
+    }, [active, cycleMs, idleStep, safeSteps, stepMs]);
+    return active ? step : idleStep;
+}
+export function useDotMatrixPhases({ animated = false, hoverAnimated = false, speed = 1, }) {
+    const safeSpeed = speed > 0 ? speed : 1;
+    const autoRun = Boolean(animated && !hoverAnimated);
+    const [hoverPhase, setHoverPhase] = useState('idle');
+    const timeouts = useRef([]);
+    const hoverGen = useRef(0);
+    const clearTimers = useCallback(() => {
+        for (let i = 0; i < timeouts.current.length; i += 1) {
+            window.clearTimeout(timeouts.current[i]);
+        }
+        timeouts.current = [];
+    }, []);
+    useEffect(() => {
+        hoverGen.current += 1;
+        clearTimers();
+        return clearTimers;
+    }, [autoRun, hoverAnimated, clearTimers]);
+    const onMouseEnter = useCallback(() => {
+        if (!hoverAnimated || autoRun) {
+            return;
+        }
+        clearTimers();
+        const gen = ++hoverGen.current;
+        setHoverPhase('collapse');
+        const collapseMs = Math.max(1, Math.round(300 / safeSpeed));
+        const id = window.setTimeout(() => {
+            if (hoverGen.current !== gen) {
+                return;
+            }
+            setHoverPhase('hoverRipple');
+        }, collapseMs);
+        timeouts.current.push(id);
+    }, [hoverAnimated, autoRun, safeSpeed, clearTimers]);
+    const onMouseLeave = useCallback(() => {
+        if (!hoverAnimated || autoRun) {
+            return;
+        }
+        hoverGen.current += 1;
+        clearTimers();
+        setHoverPhase('idle');
+    }, [hoverAnimated, autoRun, clearTimers]);
+    const phase = autoRun ? 'loadingRipple' : hoverAnimated ? hoverPhase : 'idle';
+    return useMemo(() => ({
+        phase,
+        onMouseEnter,
+        onMouseLeave,
+    }), [phase, onMouseEnter, onMouseLeave]);
+}

package/dist/lib/favicon.d.ts

@@ -0,0 +1,4 @@
+export declare function faviconUrlForHostname(hostname: string): string;
+export declare function faviconUrlForUrl(url: string): string | null;
+/** Resolve a full URL or bare domain (e.g. google.com) to a favicon URL. */
+export declare function faviconUrlForValue(value: string): string | null;

package/dist/lib/favicon.js

@@ -0,0 +1,21 @@
+export function faviconUrlForHostname(hostname) {
+    const clean = hostname.replace(/^www\./, '');
+    return `https://www.google.com/s2/favicons?domain=${clean}&sz=128`;
+}
+export function faviconUrlForUrl(url) {
+    try {
+        return faviconUrlForHostname(new URL(url).hostname);
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve a full URL or bare domain (e.g. google.com) to a favicon URL. */
+export function faviconUrlForValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.includes('://'))
+        return faviconUrlForUrl(trimmed);
+    return faviconUrlForHostname(trimmed);
+}

package/dist/lib/font-weight.d.ts

@@ -0,0 +1,6 @@
+export declare const fontWeights: {
+    readonly normal: "'wght' 400, 'opsz' 14";
+    readonly medium: "'wght' 450, 'opsz' 15";
+    readonly semibold: "'wght' 550, 'opsz' 20";
+    readonly bold: "'wght' 700, 'opsz' 25";
+};

package/dist/lib/font-weight.js

@@ -0,0 +1,6 @@
+export const fontWeights = {
+    normal: "'wght' 400, 'opsz' 14",
+    medium: "'wght' 450, 'opsz' 15",
+    semibold: "'wght' 550, 'opsz' 20",
+    bold: "'wght' 700, 'opsz' 25",
+};

package/dist/lib/icon-config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * THE icon weight for the whole app — dev and production alike.
+ *
+ * Change DEFAULT_ICON_WEIGHT, save, and every Phosphor icon in the app flips
+ * (thin | light | regular | bold | fill | duotone). Commit it and production
+ * renders the same weight. There is no runtime toggle and no environment
+ * branching: this constant is the single source of truth.
+ *
+ * How it reaches icons — you never pass a weight prop:
+ *   • Client components  → IconProvider (src/components/ui/icon-provider.tsx)
+ *     feeds it to Phosphor's IconContext.
+ *   • Server components  → icons imported from '@phosphor-icons/react/ssr' have it
+ *     pre-bound (RSC cannot use React context, so the weight is bound there).
+ *
+ * The only intentional exception is weight="fill" on solid/status icons
+ * (status tiles, success checks, destructive actions), which stay filled
+ * whatever this constant is set to.
+ *
+ * Compare the shipped weights side by side at /design-system → Icons.
+ */
+import type { IconWeight } from '@phosphor-icons/react';
+export declare const DEFAULT_ICON_WEIGHT: IconWeight;
+export declare const ICON_WEIGHTS: readonly IconWeight[];
+/**
+ * The weights the browser bundle carries. Phosphor ships all six weights of
+ * every icon in one module; `scripts/phosphor-weights-loader.cjs` (wired in
+ * next.config.ts) drops the rest, ~1/3 of every icon's bytes. An icon asked
+ * for a weight outside this list renders an empty <svg>, so
+ * icon-config.test.ts fails on any such weight literal in src/.
+ *
+ * Always contains DEFAULT_ICON_WEIGHT, so changing the default still works.
+ */
+export declare const SHIPPED_ICON_WEIGHTS: readonly IconWeight[];

package/dist/lib/icon-config.js

@@ -0,0 +1,22 @@
+export const DEFAULT_ICON_WEIGHT = 'bold';
+export const ICON_WEIGHTS = [
+    'thin',
+    'light',
+    'regular',
+    'bold',
+    'fill',
+    'duotone',
+];
+/**
+ * The weights the browser bundle carries. Phosphor ships all six weights of
+ * every icon in one module; `scripts/phosphor-weights-loader.cjs` (wired in
+ * next.config.ts) drops the rest, ~1/3 of every icon's bytes. An icon asked
+ * for a weight outside this list renders an empty <svg>, so
+ * icon-config.test.ts fails on any such weight literal in src/.
+ *
+ * Always contains DEFAULT_ICON_WEIGHT, so changing the default still works.
+ */
+export const SHIPPED_ICON_WEIGHTS = ICON_WEIGHTS.filter((weight) => weight === DEFAULT_ICON_WEIGHT ||
+    weight === 'regular' ||
+    weight === 'fill' ||
+    weight === 'duotone');

package/dist/lib/icon-context.d.ts

@@ -0,0 +1,34 @@
+import { type ComponentType, type ReactNode } from 'react';
+import { type IconProps } from '@phosphor-icons/react';
+/**
+ * Phosphor's own prop contract — `size`, `color`, `weight`, `mirrored`, plus
+ * every `<svg>` attribute. Icons never take a `weight` here: the app-wide
+ * constant reaches them through Phosphor's IconContext, which
+ * the host's icon provider installs at the root (see `./icon-config.ts`).
+ *
+ * Phosphor fills a solid path rather than stroking an outline, so `strokeWidth`
+ * type-checks (it is a legal SVG attribute) but paints nothing.
+ */
+export type IconComponentProps = IconProps;
+export type IconComponent = ComponentType<IconComponentProps>;
+export type IconName = 'chevron-right' | 'chevron-down' | 'x' | 'copy' | 'menu' | 'dot' | 'monitor' | 'sun' | 'moon' | 'rectangle-horizontal' | 'circle' | 'square-library' | 'clock' | 'star' | 'settings' | 'plus' | 'arrow-left' | 'arrow-right' | 'arrow-up' | 'search' | 'users' | 'lock' | 'mail' | 'bell' | 'shield' | 'palette' | 'lightbulb' | 'rocket' | 'heart' | 'paintbrush' | 'brain' | 'globe' | 'user' | 'image' | 'link' | 'check' | 'rotate-ccw' | 'play' | 'pause' | 'pipette' | 'home' | 'message-circle' | 'inbox' | 'pencil' | 'skip-forward' | 'corner-down-right';
+export declare const defaultIcons: Record<IconName, IconComponent>;
+/**
+ * Returns a single icon component for the given name.
+ * Falls back to the default (Phosphor) set if no provider is present.
+ */
+declare function useIcon(name: IconName): IconComponent;
+/**
+ * Returns the full icon map.
+ * Falls back to the default (Phosphor) set if no provider is present.
+ */
+declare function useIcons(): Record<IconName, IconComponent>;
+/**
+ * Swap some or all icons for components from another library.
+ * Names left out of `icons` keep their default (Phosphor) component.
+ */
+declare function IconProvider({ children, icons, }: {
+    children: ReactNode;
+    icons?: Partial<Record<IconName, IconComponent>>;
+}): import("react").JSX.Element;
+export { IconProvider, useIcon, useIcons };

package/dist/lib/icon-context.js

@@ -0,0 +1,81 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { ArrowCounterClockwiseIcon, ArrowElbowDownRightIcon, ArrowLeftIcon, ArrowRightIcon, ArrowUpIcon, BellIcon, BooksIcon, BrainIcon, CaretDownIcon, CaretRightIcon, ChatCircleIcon, CheckIcon, CircleIcon, ClockIcon, CopyIcon, DotIcon, EnvelopeIcon, EyedropperIcon, GearIcon, GlobeIcon, HeartIcon, HouseIcon, ImageIcon, LightbulbIcon, LinkIcon, ListIcon, LockIcon, MagnifyingGlassIcon, MonitorIcon, MoonIcon, PaintBrushIcon, PaletteIcon, PauseIcon, PencilIcon, PlayIcon, PlusIcon, RectangleIcon, RocketIcon, ShieldIcon, SkipForwardIcon, StarIcon, SunIcon, TrayIcon, UserIcon, UsersIcon, XIcon, } from '@phosphor-icons/react';
+/* There is deliberately no "loader" entry. `Loading`
+   (@/components/ui/loading) is the codebase's only spinner, and no icon may
+   stand in for it. */
+export const defaultIcons = {
+    'chevron-right': CaretRightIcon,
+    'chevron-down': CaretDownIcon,
+    pipette: EyedropperIcon,
+    x: XIcon,
+    copy: CopyIcon,
+    menu: ListIcon,
+    dot: DotIcon,
+    monitor: MonitorIcon,
+    sun: SunIcon,
+    moon: MoonIcon,
+    'rectangle-horizontal': RectangleIcon,
+    circle: CircleIcon,
+    'square-library': BooksIcon,
+    clock: ClockIcon,
+    star: StarIcon,
+    settings: GearIcon,
+    plus: PlusIcon,
+    'arrow-left': ArrowLeftIcon,
+    'arrow-right': ArrowRightIcon,
+    'arrow-up': ArrowUpIcon,
+    search: MagnifyingGlassIcon,
+    users: UsersIcon,
+    lock: LockIcon,
+    mail: EnvelopeIcon,
+    bell: BellIcon,
+    shield: ShieldIcon,
+    palette: PaletteIcon,
+    lightbulb: LightbulbIcon,
+    rocket: RocketIcon,
+    heart: HeartIcon,
+    paintbrush: PaintBrushIcon,
+    brain: BrainIcon,
+    globe: GlobeIcon,
+    user: UserIcon,
+    image: ImageIcon,
+    link: LinkIcon,
+    check: CheckIcon,
+    'rotate-ccw': ArrowCounterClockwiseIcon,
+    play: PlayIcon,
+    pause: PauseIcon,
+    home: HouseIcon,
+    'message-circle': ChatCircleIcon,
+    inbox: TrayIcon,
+    pencil: PencilIcon,
+    'skip-forward': SkipForwardIcon,
+    'corner-down-right': ArrowElbowDownRightIcon,
+};
+const IconContext = createContext(null);
+/**
+ * Returns a single icon component for the given name.
+ * Falls back to the default (Phosphor) set if no provider is present.
+ */
+function useIcon(name) {
+    const icons = useContext(IconContext);
+    return (icons ?? defaultIcons)[name];
+}
+/**
+ * Returns the full icon map.
+ * Falls back to the default (Phosphor) set if no provider is present.
+ */
+function useIcons() {
+    const icons = useContext(IconContext);
+    return icons ?? defaultIcons;
+}
+/**
+ * Swap some or all icons for components from another library.
+ * Names left out of `icons` keep their default (Phosphor) component.
+ */
+function IconProvider({ children, icons, }) {
+    const value = useMemo(() => ({ ...defaultIcons, ...icons }), [icons]);
+    return _jsx(IconContext.Provider, { value: value, children: children });
+}
+export { IconProvider, useIcon, useIcons };

package/dist/lib/portal-root.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a stable dedicated portal root for UI overlays.
+ *
+ * Avoids mounting dialogs directly into document.body, which can be fragile
+ * when multiple portals mount/unmount during redirects, modal nesting, or
+ * browser DOM mutations. A single dedicated root makes portal ordering stable.
+ */
+export declare function getPortalRoot(): HTMLElement | null;

package/dist/lib/portal-root.js

@@ -0,0 +1,26 @@
+'use client';
+let portalRoot = null;
+/**
+ * Returns a stable dedicated portal root for UI overlays.
+ *
+ * Avoids mounting dialogs directly into document.body, which can be fragile
+ * when multiple portals mount/unmount during redirects, modal nesting, or
+ * browser DOM mutations. A single dedicated root makes portal ordering stable.
+ */
+export function getPortalRoot() {
+    if (typeof document === 'undefined')
+        return null;
+    if (portalRoot && document.body.contains(portalRoot))
+        return portalRoot;
+    const existing = document.getElementById('kortix-portal-root');
+    if (existing) {
+        portalRoot = existing;
+        return portalRoot;
+    }
+    const el = document.createElement('div');
+    el.id = 'kortix-portal-root';
+    el.setAttribute('data-kortix-portal-root', 'true');
+    document.body.appendChild(el);
+    portalRoot = el;
+    return portalRoot;
+}

package/dist/lib/settle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * How long a streaming block's text must hold still before it is rendered in
+ * full: highlighted for code, drawn for a Mermaid diagram.
+ *
+ * The block that is still arriving changes on every paced render, and
+ * tokenizing it each time was the dominant cost of streaming a code answer
+ * (Shiki re-ran over the whole block per delta batch, and its cache never hit
+ * because the key moved with the text). A diagram re-ran `mermaid.render` per
+ * batch and flickered between its placeholder, an error card for each
+ * half-written prefix, and the SVG. A block renders its plain form while it
+ * grows and its full form once it stops — when its fence closes and the
+ * message moves on, or at once when the stream ends.
+ */
+export declare const CODE_SETTLE_MS = 400;
+/** `value` once it has held still for `delayMs` while `active`; `value` when not active; else null. */
+export declare function useSettledValue(value: string, active: boolean, delayMs: number): string | null;

package/dist/lib/settle.js

@@ -0,0 +1,29 @@
+'use client';
+import { useEffect, useState } from 'react';
+/**
+ * How long a streaming block's text must hold still before it is rendered in
+ * full: highlighted for code, drawn for a Mermaid diagram.
+ *
+ * The block that is still arriving changes on every paced render, and
+ * tokenizing it each time was the dominant cost of streaming a code answer
+ * (Shiki re-ran over the whole block per delta batch, and its cache never hit
+ * because the key moved with the text). A diagram re-ran `mermaid.render` per
+ * batch and flickered between its placeholder, an error card for each
+ * half-written prefix, and the SVG. A block renders its plain form while it
+ * grows and its full form once it stops — when its fence closes and the
+ * message moves on, or at once when the stream ends.
+ */
+export const CODE_SETTLE_MS = 400;
+/** `value` once it has held still for `delayMs` while `active`; `value` when not active; else null. */
+export function useSettledValue(value, active, delayMs) {
+    const [settled, setSettled] = useState(null);
+    useEffect(() => {
+        if (!active)
+            return;
+        const timer = setTimeout(() => setSettled(value), delayMs);
+        return () => clearTimeout(timer);
+    }, [value, active, delayMs]);
+    if (!active)
+        return value;
+    return settled === value ? value : null;
+}

package/dist/lib/springs.d.ts

@@ -0,0 +1,31 @@
+export declare const spring: {
+    readonly fast: {
+        readonly type: "spring";
+        readonly duration: 0.08;
+        readonly bounce: 0;
+        readonly exit: {
+            readonly duration: 0.06;
+        };
+    };
+    readonly moderate: {
+        readonly type: "spring";
+        readonly duration: 0.16;
+        readonly bounce: 0;
+        readonly exit: {
+            readonly duration: 0.12;
+        };
+    };
+    readonly slow: {
+        readonly type: "spring";
+        readonly duration: 0.24;
+        readonly bounce: 0.12;
+        readonly exit: {
+            readonly duration: 0.16;
+        };
+    };
+};
+export declare const exitFallbackMs: (tier: {
+    exit: {
+        duration: number;
+    };
+}) => number;

package/dist/lib/springs.js

@@ -0,0 +1,29 @@
+export const spring = {
+    fast: {
+        type: 'spring',
+        duration: 0.08,
+        bounce: 0,
+        exit: { duration: 0.06 },
+    },
+    // Critically damped: same perceived speed as a bouncier tier, but lands
+    // exactly with no overshoot — for short travel and panels/sheets that must
+    // settle precisely (dropdowns, tabs, drawers, merged selection backgrounds).
+    moderate: {
+        type: 'spring',
+        duration: 0.16,
+        bounce: 0,
+        exit: { duration: 0.12 },
+    },
+    slow: {
+        type: 'spring',
+        duration: 0.24,
+        bounce: 0.12,
+        exit: { duration: 0.16 },
+    },
+};
+// Fallback delay (ms) for deferred-unmount timers that guard an exit tween:
+// popups keep their portal mounted until onAnimationComplete fires, but a
+// throttled/background tab can stall the animation, so a timer force-unmounts
+// after the tier's exit duration plus a safety buffer. Deriving it here keeps
+// the timers in step with the tokens above.
+export const exitFallbackMs = (tier) => Math.round(tier.exit.duration * 1000) + 100;

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/lib/z-stack.d.ts

@@ -0,0 +1,55 @@
+import * as React from 'react';
+export declare function DialogDepthProvider({ depth, children, }: {
+    depth: number;
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useDialogDepth(): number;
+/** Level held by `id`, or 0 when unregistered. Kept after close on purpose. */
+export declare function dialogLayerLevel(id: string): number;
+/**
+ * Mark `id` open and return its level. A layer that is already open keeps its
+ * level (it only rises to `minLevel`, its React-tree floor), so a sibling
+ * opening above it never reshuffles it. A layer that is opening takes the next
+ * level above every other open layer.
+ */
+export declare function openDialogLayer(id: string, minLevel: number): number;
+/**
+ * Mark `id` closed. Its level is kept so the exit animation stays above the
+ * layer beneath it; it just stops raising layers that open afterwards.
+ */
+export declare function closeDialogLayer(id: string): void;
+export declare function removeDialogLayer(id: string): void;
+/**
+ * Depth for a layer that is `open`: its runtime level, never below the depth
+ * its React ancestors imply. Provide the result through `DialogDepthProvider`
+ * so nested selects, menus, and modals stack above it.
+ */
+export declare function useDialogLayerDepth(open: boolean): number;
+type DialogRootOpenProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+/**
+ * `useDialogLayerDepth` for a Radix dialog root. The stack needs the open state
+ * of uncontrolled roots too, so this owns it and hands Radix a controlled
+ * `open` / `onOpenChange` pair — observable behaviour is unchanged.
+ */
+export declare function useDialogRootLayer({ open, defaultOpen, onOpenChange }: DialogRootOpenProps): {
+    depth: number;
+    open: boolean;
+    onOpenChange: (next: boolean) => void;
+};
+export declare function dialogOverlayZ(depth: number): number;
+export declare function dialogContentZ(depth: number): number;
+export declare function floatingZ(depth: number): number;
+/** Portaled popovers/menus/selects rendered outside dialog DOM. */
+export declare const FLOATING_LAYER_SELECTOR = "[role=\"menu\"],[role=\"listbox\"],[role=\"tooltip\"],[data-radix-popper-content-wrapper]";
+export declare function isFloatingLayerTarget(target: EventTarget | null): boolean;
+export declare function hasOpenFloatingLayer(): boolean;
+/** Nested modals/sheets opened above the customize panel (or any parent dialog).
+ *  Radix gives alerts `role="alertdialog"`, so confirm dialogs only count here
+ *  if that role is matched too — miss it and Escape aimed at a confirm tears
+ *  down the panel behind it. */
+export declare function hasOpenNestedDialog(): boolean;
+export {};