@astra-kit/ui 0.0.0-stage → 0.0.0

package/dist/motion/surface-keyframes.js

@@ -0,0 +1,141 @@
+import { MOTION_DIALOG_DISTANCE, MOTION_DIALOG_EXIT_DISTANCE, MOTION_EASE, MOTION_EASE_STANDARD, MOTION_EXIT_SCALE, MOTION_SURFACE_SCALE, MOTION_TIMING, SPRING_PANEL } from "./tokens.js";
+/** Fraction of Arc's drawer close after which the panel starts to fade. */
+const SHEET_EXIT_FADE_START = .65;
+const EASE_OUT = [...MOTION_EASE];
+const EASE_STANDARD = [...MOTION_EASE_STANDARD];
+const SIDES = [
+	"top",
+	"right",
+	"bottom",
+	"left"
+];
+/** Builds a transform with explicit identity parts, so Motion never reads a missing scale as zero. */
+function transform(x, y, scale = 1) {
+	const unit = (value) => typeof value === "number" ? `${value}px` : value;
+	return `translate(${unit(x)}, ${unit(y)}) scale(${scale})`;
+}
+/**
+* Arc's dialog leave: a short tween on the standard curve, so it never lingers and a reopen
+* retargets from wherever the panel is.
+*/
+const DIALOG_LEAVE = {
+	duration: MOTION_TIMING.fast,
+	ease: EASE_STANDARD
+};
+/** Edge-panel travel: fully off-screen on the side the sheet is attached to. */
+function sheetOffset(element) {
+	const side = element.getAttribute("data-side");
+	const resolved = SIDES.includes(side) ? side : "right";
+	if (resolved === "left") return {
+		x: "-100%",
+		y: "0%"
+	};
+	if (resolved === "top") return {
+		x: "0%",
+		y: "-100%"
+	};
+	if (resolved === "bottom") return {
+		x: "0%",
+		y: "100%"
+	};
+	return {
+		x: "100%",
+		y: "0%"
+	};
+}
+/** Entrance playback for each surface kind, on Arc's motion presets. */
+export function surfaceEnter(element, kind) {
+	if (kind === "overlay") {
+		return {
+			keyframes: { opacity: [0, 1] },
+			transition: {
+				duration: MOTION_TIMING.overlay,
+				ease: EASE_OUT
+			}
+		};
+	}
+	if (kind === "sheet") {
+		// Arc's drawer: the panel slides in from its edge on the smooth spring, at full opacity.
+		const offset = sheetOffset(element);
+		return {
+			// Opacity is listed at rest so a reopen during the close fades back from where the close left it.
+			keyframes: {
+				transform: [transform(offset.x, offset.y), transform("0%", "0%")],
+				opacity: [1, 1]
+			},
+			transition: SPRING_PANEL
+		};
+	}
+	// Arc's dialog: the panel rises and scales in on the smooth spring while it fades in quickly.
+	return {
+		keyframes: {
+			opacity: [0, 1],
+			transform: [transform(0, MOTION_DIALOG_DISTANCE, MOTION_SURFACE_SCALE), transform(0, 0)]
+		},
+		transition: {
+			...SPRING_PANEL,
+			opacity: {
+				duration: MOTION_TIMING.fast,
+				ease: EASE_OUT
+			}
+		}
+	};
+}
+/**
+* Composes surface playback with the surface's resting transform and opacity, so a caller-owned
+* tilt, offset or translucency holds through the whole entrance and exit instead of being
+* replaced by identity and full opacity, then snapping back once playback restores it.
+*/
+export function withRestingStyle(keyframes, resting) {
+	const composed = { ...keyframes };
+	const { transform, opacity } = composed;
+	if (Array.isArray(transform) && resting.transform && resting.transform !== "none") {
+		composed.transform = transform.map((value) => `${String(value)} ${resting.transform}`);
+	}
+	if (Array.isArray(opacity) && Number.isFinite(resting.opacity) && resting.opacity !== 1) {
+		composed.opacity = opacity.map((value) => Number(value) * resting.opacity);
+	}
+	return composed;
+}
+/** Exit playback: brief and eased so dismissal never blocks the next interaction. */
+export function surfaceExit(element, kind) {
+	if (kind === "overlay") {
+		return {
+			keyframes: { opacity: [1, 0] },
+			transition: DIALOG_LEAVE
+		};
+	}
+	if (kind === "sheet") {
+		// Arc's drawer close: a tween on the standard curve that holds the panel opaque until it is mostly gone.
+		const offset = sheetOffset(element);
+		return {
+			keyframes: {
+				transform: [transform("0%", "0%"), transform(offset.x, offset.y)],
+				opacity: [
+					1,
+					1,
+					0
+				]
+			},
+			transition: {
+				duration: MOTION_TIMING.sheetExit,
+				ease: EASE_STANDARD,
+				opacity: {
+					duration: MOTION_TIMING.sheetExit,
+					times: [
+						0,
+						SHEET_EXIT_FADE_START,
+						1
+					]
+				}
+			}
+		};
+	}
+	return {
+		keyframes: {
+			opacity: [1, 0],
+			transform: [transform(0, 0), transform(0, MOTION_DIALOG_EXIT_DISTANCE, MOTION_EXIT_SCALE)]
+		},
+		transition: DIALOG_LEAVE
+	};
+}

package/dist/motion/tokens.d.ts

@@ -0,0 +1,81 @@
+export declare const MOTION_TIMING: {
+    /** Arc `duration.instant`: color answers and fades that must feel immediate. */
+    readonly instant: 0.12;
+    /** Arc `duration.fast`: small fades, the opacity of a spring entrance, and dialog exits. */
+    readonly fast: 0.16;
+    /** Arc `duration.standard`: entrance tweens. */
+    readonly enter: 0.24;
+    /** Arc `duration.standard`: tween length for a deliberate on-screen change. */
+    readonly standard: 0.24;
+    /** Arc `duration.considered`: the slowest tween, for large layout changes. */
+    readonly considered: 0.48;
+    /** Arc `duration.standard`: opacity of panels whose size moves on a spring. */
+    readonly panel: 0.24;
+    /** Arc `duration.standard`: scrims fading in behind dialogs and sheets. */
+    readonly overlay: 0.24;
+    /** Arc `duration.exit`: leaving is faster than arriving. */
+    readonly exit: 0.18;
+    /** Arc `duration.standard`: a check mark drawing its stroke. */
+    readonly checkDraw: 0.24;
+    /** Arc `stagger.item`. */
+    readonly listStagger: 0.035;
+    /** Arc `duration.standard`: edge panels leaving the viewport. */
+    readonly sheetExit: 0.24;
+    /** Blink period of the typing cursor, the one loop that shows live status. */
+    readonly cursorBlink: 1;
+};
+/** Arc staggers at most the first four items of a list; the rest share the last delay, so long lists never lag. */
+export declare const MOTION_LIST_STAGGER_LIMIT = 4;
+/** Arc `ease.enter`: strong ease-out for entrances; weak defaults such as `ease-out` feel sluggish. */
+export declare const MOTION_EASE: readonly [0.16, 1, 0.3, 1];
+/** Arc `ease.exit`: accelerates away, for elements leaving the screen. */
+export declare const MOTION_EASE_EXIT: readonly [0.7, 0, 0.84, 0];
+/** Arc `ease.standard`: color and opacity changes, and quick exits that must not linger. */
+export declare const MOTION_EASE_STANDARD: readonly [0.22, 1, 0.36, 1];
+/** Arc `ease.inOut`: elements that move while already on screen, and looping effects. */
+export declare const MOTION_EASE_IN_OUT: readonly [0.65, 0, 0.35, 1];
+/** Arc `spring.snappy`: press feedback on buttons and other tappable surfaces. */
+export declare const SPRING_PRESS: {
+    readonly type: "spring";
+    readonly visualDuration: 0.26;
+    readonly bounce: 0.12;
+};
+/** Arc `spring.smooth`: panels, heights and overlay entrances; never overshoots. */
+export declare const SPRING_PANEL: {
+    readonly type: "spring";
+    readonly visualDuration: 0.4;
+    readonly bounce: 0;
+};
+/** Arc `spring.morph`: shared-layout glides, indicators and highlights moving between items. */
+export declare const SPRING_LAYOUT: {
+    readonly type: "spring";
+    readonly visualDuration: 0.42;
+    readonly bounce: 0.16;
+};
+/** Arc `spring.snappy`: disclosure chevrons turning toward their new state. */
+export declare const SPRING_CHEVRON: {
+    readonly type: "spring";
+    readonly visualDuration: 0.26;
+    readonly bounce: 0.12;
+};
+/** Arc `spring.snappy`: small, confident pops for counters, badges and swapped icons. */
+export declare const SPRING_POP: {
+    readonly type: "spring";
+    readonly visualDuration: 0.26;
+    readonly bounce: 0.12;
+};
+/** Arc's press: about 0.97, so every pressable reads as the same push. */
+export declare const MOTION_PRESS_SCALE = 0.97;
+/** Arc's calendar title slides just enough to show the direction of navigation. */
+export declare const MOTION_MONTH_DISTANCE = 12;
+/** Arc's dialog panel scale on entrance. */
+export declare const MOTION_SURFACE_SCALE = 0.96;
+/** Scale a dialog shrinks to while it leaves (Arc). */
+export declare const MOTION_EXIT_SCALE = 0.98;
+/** Arc's dialog rise on entrance, in pixels. */
+export declare const MOTION_DIALOG_DISTANCE = 8;
+/** Arc's dialog drop while it leaves, in pixels. */
+export declare const MOTION_DIALOG_EXIT_DISTANCE = 4;
+/** Time after an item loses its active state during which a new active item still glides from it. */
+export declare const GLIDE_CONTINUITY_MS = 300;
+export type MotionKind = "rotate" | "item-check" | "icon-swap" | "message" | "reveal" | "dialog" | "sheet" | "overlay";

package/dist/motion/tokens.js

@@ -0,0 +1,67 @@
+/**
+* Defines the timing, curves and physics shared by Motion animations. Every value is one of Arc's motion presets
+* (https://uiarc.dev, `components/arc/lib/motion-tokens.ts`): `snappy` for presses and small indicators, `smooth` for
+* panels and anything that reports state, `morph` for shared highlights. Motion explains cause and effect; it does not
+* decorate. Public: consumers animate their own product surfaces with these tokens so they move like the library.
+*/
+import { ARC_DURATION, ARC_EASE, ARC_SPRING_MORPH, ARC_SPRING_SMOOTH, ARC_SPRING_SNAPPY, ARC_STAGGER } from "./arc-tokens.js";
+export const MOTION_TIMING = {
+	/** Arc `duration.instant`: color answers and fades that must feel immediate. */
+	instant: ARC_DURATION.instant,
+	/** Arc `duration.fast`: small fades, the opacity of a spring entrance, and dialog exits. */
+	fast: ARC_DURATION.fast,
+	/** Arc `duration.standard`: entrance tweens. */
+	enter: ARC_DURATION.standard,
+	/** Arc `duration.standard`: tween length for a deliberate on-screen change. */
+	standard: ARC_DURATION.standard,
+	/** Arc `duration.considered`: the slowest tween, for large layout changes. */
+	considered: ARC_DURATION.considered,
+	/** Arc `duration.standard`: opacity of panels whose size moves on a spring. */
+	panel: ARC_DURATION.standard,
+	/** Arc `duration.standard`: scrims fading in behind dialogs and sheets. */
+	overlay: ARC_DURATION.standard,
+	/** Arc `duration.exit`: leaving is faster than arriving. */
+	exit: ARC_DURATION.exit,
+	/** Arc `duration.standard`: a check mark drawing its stroke. */
+	checkDraw: ARC_DURATION.standard,
+	/** Arc `stagger.item`. */
+	listStagger: ARC_STAGGER.item,
+	/** Arc `duration.standard`: edge panels leaving the viewport. */
+	sheetExit: ARC_DURATION.standard,
+	/** Blink period of the typing cursor, the one loop that shows live status. */
+	cursorBlink: 1
+};
+/** Arc staggers at most the first four items of a list; the rest share the last delay, so long lists never lag. */
+export const MOTION_LIST_STAGGER_LIMIT = 4;
+/** Arc `ease.enter`: strong ease-out for entrances; weak defaults such as `ease-out` feel sluggish. */
+export const MOTION_EASE = ARC_EASE.enter;
+/** Arc `ease.exit`: accelerates away, for elements leaving the screen. */
+export const MOTION_EASE_EXIT = ARC_EASE.exit;
+/** Arc `ease.standard`: color and opacity changes, and quick exits that must not linger. */
+export const MOTION_EASE_STANDARD = ARC_EASE.standard;
+/** Arc `ease.inOut`: elements that move while already on screen, and looping effects. */
+export const MOTION_EASE_IN_OUT = ARC_EASE.inOut;
+/** Arc `spring.snappy`: press feedback on buttons and other tappable surfaces. */
+export const SPRING_PRESS = ARC_SPRING_SNAPPY;
+/** Arc `spring.smooth`: panels, heights and overlay entrances; never overshoots. */
+export const SPRING_PANEL = ARC_SPRING_SMOOTH;
+/** Arc `spring.morph`: shared-layout glides, indicators and highlights moving between items. */
+export const SPRING_LAYOUT = ARC_SPRING_MORPH;
+/** Arc `spring.snappy`: disclosure chevrons turning toward their new state. */
+export const SPRING_CHEVRON = ARC_SPRING_SNAPPY;
+/** Arc `spring.snappy`: small, confident pops for counters, badges and swapped icons. */
+export const SPRING_POP = ARC_SPRING_SNAPPY;
+/** Arc's press: about 0.97, so every pressable reads as the same push. */
+export const MOTION_PRESS_SCALE = .97;
+/** Arc's calendar title slides just enough to show the direction of navigation. */
+export const MOTION_MONTH_DISTANCE = 12;
+/** Arc's dialog panel scale on entrance. */
+export const MOTION_SURFACE_SCALE = .96;
+/** Scale a dialog shrinks to while it leaves (Arc). */
+export const MOTION_EXIT_SCALE = .98;
+/** Arc's dialog rise on entrance, in pixels. */
+export const MOTION_DIALOG_DISTANCE = 8;
+/** Arc's dialog drop while it leaves, in pixels. */
+export const MOTION_DIALOG_EXIT_DISTANCE = 4;
+/** Time after an item loses its active state during which a new active item still glides from it. */
+export const GLIDE_CONTINUITY_MS = 300;

package/dist/motion/use-attached-element.d.ts

@@ -0,0 +1,7 @@
+/** Tracks the DOM node rendered through a Slot while forwarding it to the caller's ref. */
+import { type Ref } from "react";
+/**
+ * Returns the attached element and a callback ref that also feeds the caller's ref,
+ * honoring React 19 ref cleanups.
+ */
+export declare function useAttachedElement<T extends HTMLElement>(ref: Ref<T> | undefined): readonly [T | null, (node: T | null) => () => void];

package/dist/motion/use-attached-element.js

@@ -0,0 +1,22 @@
+"use client";
+/** Tracks the DOM node rendered through a Slot while forwarding it to the caller's ref. */
+import { useCallback, useState } from "react";
+/**
+* Returns the attached element and a callback ref that also feeds the caller's ref,
+* honoring React 19 ref cleanups.
+*/
+export function useAttachedElement(ref) {
+	const [element, setElement] = useState(null);
+	const attach = useCallback((node) => {
+		setElement(node);
+		const cleanup = typeof ref === "function" ? ref(node) : undefined;
+		if (ref && typeof ref !== "function") ref.current = node;
+		return () => {
+			setElement(null);
+			if (typeof cleanup === "function") cleanup();
+			else if (typeof ref === "function") ref(null);
+			else if (ref) ref.current = null;
+		};
+	}, [ref]);
+	return [element, attach];
+}

package/dist/motion/use-morph-width.d.ts

@@ -0,0 +1,13 @@
+import type { RefObject } from "react";
+import type { MotionValue } from "motion/react";
+/**
+ * Springs a label slot to the natural width of its content when the label changes, so new text never snaps the
+ * layout. Other resizes (a late web font, a parent reflow) jump straight to the new width, so nothing wobbles on
+ * first paint. While it springs, the slot carries `data-morphing` so it can clip overflowing glyphs.
+ *
+ * @param contentRef - Content measured by a `ResizeObserver`; its parent element is the slot that gets the width.
+ * @param labelKey - Identity of the current label: a change opens the window in which resizes spring.
+ * @param reduceMotion - Whether the user prefers reduced motion, which makes every resize jump.
+ * @returns Width to bind to the slot's `style.width`.
+ */
+export declare function useMorphWidth(contentRef: RefObject<HTMLElement | null>, labelKey: string, reduceMotion: boolean): MotionValue<number | "auto">;

package/dist/motion/use-morph-width.js

@@ -0,0 +1,59 @@
+/**
+* Label width spring adapted from Arc (https://uiarc.dev), Copyright (c) 2026 Elia Kuratli, MIT License.
+* The full license text ships in THIRD_PARTY_NOTICES.md. Internal: shared by `Button` and `ActionButton`.
+*/
+import { useEffect, useLayoutEffect, useRef } from "react";
+import { animate, useMotionValue } from "motion/react";
+import { BUTTON_MORPH_WINDOW_MS } from "../constants/button.js";
+import { ARC_SPRING_MORPH } from "./arc-tokens.js";
+/**
+* Springs a label slot to the natural width of its content when the label changes, so new text never snaps the
+* layout. Other resizes (a late web font, a parent reflow) jump straight to the new width, so nothing wobbles on
+* first paint. While it springs, the slot carries `data-morphing` so it can clip overflowing glyphs.
+*
+* @param contentRef - Content measured by a `ResizeObserver`; its parent element is the slot that gets the width.
+* @param labelKey - Identity of the current label: a change opens the window in which resizes spring.
+* @param reduceMotion - Whether the user prefers reduced motion, which makes every resize jump.
+* @returns Width to bind to the slot's `style.width`.
+*/
+export function useMorphWidth(contentRef, labelKey, reduceMotion) {
+	const width = useMotionValue("auto");
+	const lastLabelKey = useRef(labelKey);
+	const morphDeadline = useRef(0);
+	useLayoutEffect(() => {
+		if (lastLabelKey.current === labelKey) return;
+		lastLabelKey.current = labelKey;
+		morphDeadline.current = performance.now() + BUTTON_MORPH_WINDOW_MS;
+	}, [labelKey]);
+	useEffect(() => {
+		const content = contentRef.current;
+		const slot = content?.parentElement;
+		if (!content || !slot || typeof ResizeObserver === "undefined") return;
+		let hasMeasured = false;
+		const observer = new ResizeObserver(([entry]) => {
+			if (!entry) return;
+			const nextWidth = entry.contentRect.width;
+			const shouldJump = !nextWidth || !hasMeasured || reduceMotion || performance.now() > morphDeadline.current;
+			if (shouldJump) {
+				hasMeasured = nextWidth > 0;
+				width.jump(nextWidth || "auto");
+				delete slot.dataset.morphing;
+				return;
+			}
+			slot.dataset.morphing = "";
+			animate(width, nextWidth, {
+				...ARC_SPRING_MORPH,
+				onComplete: () => {
+					delete slot.dataset.morphing;
+				}
+			});
+		});
+		observer.observe(content);
+		return () => observer.disconnect();
+	}, [
+		contentRef,
+		reduceMotion,
+		width
+	]);
+	return width;
+}

package/dist/next.d.ts

@@ -0,0 +1,14 @@
+/** Isolates optional Next.js imports from the framework-neutral package entrypoint. */
+import { type ReactNode } from "react";
+import { type AstraUIProviderProps as BaseAstraUIProviderProps } from "./providers/astra-ui-provider.js";
+/** Configures Next adapters without forcing image host configuration on existing apps. */
+export interface AstraUIProviderProps {
+    children: ReactNode;
+    /** Enables the image optimizer; configure allowed image hosts in the application. */
+    optimizeImages?: boolean;
+    /** Keeps speculative navigation opt-in, matching LaTribu's existing behavior. */
+    prefetch?: boolean;
+    themeOptions?: BaseAstraUIProviderProps["themeOptions"];
+}
+/** Activates Next.js navigation and images for every descendant using shared primitives. */
+export declare function AstraUIProvider({ children, optimizeImages, prefetch, themeOptions }: AstraUIProviderProps): import("react").JSX.Element;

package/dist/next.js

@@ -0,0 +1,79 @@
+"use client";
+import { c as _c } from "react/compiler-runtime";
+import NextImageModule from "next/image.js";
+import NextLinkModule from "next/link.js";
+import { AstraUIProvider as BaseAstraUIProvider } from "./providers/astra-ui-provider.js";
+import { imageDimension } from "./lib/image-dimensions.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+/** Supports both native ESM loading of Next's CommonJS modules and bundler interop. */
+const NextImage = NextImageModule.default ?? NextImageModule;
+const NextLink = NextLinkModule.default ?? NextLinkModule;
+/** Activates Next.js navigation and images for every descendant using shared primitives. */
+export function AstraUIProvider(t0) {
+	const $ = _c(11);
+	const { children, optimizeImages: t1, prefetch: t2, themeOptions } = t0;
+	const optimizeImages = t1 === undefined ? false : t1;
+	const prefetch = t2 === undefined ? false : t2;
+	let t3;
+	if ($[0] !== prefetch) {
+		t3 = function NextRoutingAdapter(t4) {
+			const { prefetch: linkPrefetch, ...props } = t4;
+			return /* @__PURE__ */ _jsx(NextLink, {
+				...props,
+				prefetch: linkPrefetch ?? prefetch
+			});
+		};
+		$[0] = prefetch;
+		$[1] = t3;
+	} else {
+		t3 = $[1];
+	}
+	let t4;
+	if ($[2] !== optimizeImages) {
+		t4 = function NextImageAdapter(props_0) {
+			if (!props_0.src) {
+				return /* @__PURE__ */ _jsx("img", { ...props_0 });
+			}
+			return /* @__PURE__ */ _jsx(NextImage, {
+				...props_0,
+				alt: props_0.alt ?? "",
+				src: props_0.src,
+				width: imageDimension(props_0.width),
+				height: imageDimension(props_0.height),
+				unoptimized: !optimizeImages
+			});
+		};
+		$[2] = optimizeImages;
+		$[3] = t4;
+	} else {
+		t4 = $[3];
+	}
+	let t5;
+	if ($[4] !== t3 || $[5] !== t4) {
+		t5 = {
+			Link: t3,
+			Image: t4
+		};
+		$[4] = t3;
+		$[5] = t4;
+		$[6] = t5;
+	} else {
+		t5 = $[6];
+	}
+	const components = t5;
+	let t6;
+	if ($[7] !== children || $[8] !== components || $[9] !== themeOptions) {
+		t6 = /* @__PURE__ */ _jsx(BaseAstraUIProvider, {
+			components,
+			themeOptions,
+			children
+		});
+		$[7] = children;
+		$[8] = components;
+		$[9] = themeOptions;
+		$[10] = t6;
+	} else {
+		t6 = $[10];
+	}
+	return t6;
+}

package/dist/providers/astra-ui-provider.d.ts

@@ -0,0 +1,27 @@
+/** Shares optional rendering adapters without importing a framework into the core. */
+import { type ComponentProps, type ComponentType, type ReactNode } from "react";
+import { type ThemeProviderProps } from "next-themes";
+/** Defines the native link contract accepted by routing adapters. */
+export type AstraLinkProps = ComponentProps<"a"> & {
+    href: string;
+    /** Optional navigation hint consumed by framework adapters, never by native anchors. */
+    prefetch?: boolean;
+};
+/** Defines the native image contract accepted by image adapters. */
+export type AstraImageProps = ComponentProps<"img">;
+/** Lets each application select only the adapters it needs. */
+export interface AstraUIComponents {
+    Link?: ComponentType<AstraLinkProps>;
+    Image?: ComponentType<AstraImageProps>;
+}
+/** Configures descendants while leaving theme and application state to the consumer. */
+export interface AstraUIProviderProps {
+    children: ReactNode;
+    components?: AstraUIComponents;
+    /** Shares light/dark/system behavior; the theme is written as a class and as Arc's `data-theme` attribute. */
+    themeOptions?: Omit<ThemeProviderProps, "children" | "attribute">;
+}
+/** Merges nested overrides while preserving stable adapter identities. */
+export declare function AstraUIProvider({ children, components, themeOptions }: AstraUIProviderProps): import("react").JSX.Element;
+/** Reads adapters internally; native components work without a provider. */
+export declare function useAstraUIComponents(): AstraUIComponents;

package/dist/providers/astra-ui-provider.js

@@ -0,0 +1,100 @@
+"use client";
+import { c as _c } from "react/compiler-runtime";
+/** Shares optional rendering adapters without importing a framework into the core. */
+import { createContext, useContext, useSyncExternalStore } from "react";
+import { MotionConfig } from "motion/react";
+import { ThemeProvider } from "next-themes";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+* Arc's foundation selects dark tokens with `data-theme`; the class keeps Tailwind's `dark` variant and
+* consumer styles written for it.
+*/
+const THEME_ATTRIBUTES = ["class", "data-theme"];
+/**
+* next-themes renders an inline script that applies the stored theme before hydration. It only
+* runs when it arrives in server HTML; a script created by a client render never executes, and
+* React 19 warns about it. Client-only renders mark it as a data block, which React accepts.
+*/
+const CLIENT_RENDER_THEME_SCRIPT_PROPS = { type: "application/json" };
+/** Nothing to subscribe to: the value only distinguishes server/hydration from client renders. */
+function subscribeToRenderEnvironment() {
+	return () => {};
+}
+/** Native elements remain the implicit fallback for unconfigured adapters. */
+const EMPTY_COMPONENTS = {};
+const AdapterContext = createContext(EMPTY_COMPONENTS);
+/** Merges nested overrides while preserving stable adapter identities. */
+export function AstraUIProvider(t0) {
+	const $ = _c(13);
+	const { children, components: t1, themeOptions } = t0;
+	const components = t1 === undefined ? EMPTY_COMPONENTS : t1;
+	const parent = useContext(AdapterContext);
+	let t2;
+	if ($[0] !== components || $[1] !== parent) {
+		t2 = {
+			...parent,
+			...components
+		};
+		$[0] = components;
+		$[1] = parent;
+		$[2] = t2;
+	} else {
+		t2 = $[2];
+	}
+	const value = t2;
+	const isClientOnlyRender = useSyncExternalStore(subscribeToRenderEnvironment, _temp, _temp2);
+	let t3;
+	if ($[3] !== isClientOnlyRender || $[4] !== themeOptions?.scriptProps) {
+		t3 = isClientOnlyRender ? {
+			...CLIENT_RENDER_THEME_SCRIPT_PROPS,
+			...themeOptions?.scriptProps
+		} : themeOptions?.scriptProps;
+		$[3] = isClientOnlyRender;
+		$[4] = themeOptions?.scriptProps;
+		$[5] = t3;
+	} else {
+		t3 = $[5];
+	}
+	const scriptProps = t3;
+	let t4;
+	if ($[6] !== children || $[7] !== value) {
+		t4 = /* @__PURE__ */ _jsx(MotionConfig, {
+			reducedMotion: "user",
+			children: /* @__PURE__ */ _jsx(AdapterContext.Provider, {
+				value,
+				children
+			})
+		});
+		$[6] = children;
+		$[7] = value;
+		$[8] = t4;
+	} else {
+		t4 = $[8];
+	}
+	let t5;
+	if ($[9] !== scriptProps || $[10] !== t4 || $[11] !== themeOptions) {
+		t5 = /* @__PURE__ */ _jsx(ThemeProvider, {
+			attribute: THEME_ATTRIBUTES,
+			...themeOptions,
+			scriptProps,
+			children: t4
+		});
+		$[9] = scriptProps;
+		$[10] = t4;
+		$[11] = themeOptions;
+		$[12] = t5;
+	} else {
+		t5 = $[12];
+	}
+	return t5;
+}
+function _temp2() {
+	return false;
+}
+function _temp() {
+	return true;
+}
+/** Reads adapters internally; native components work without a provider. */
+export function useAstraUIComponents() {
+	return useContext(AdapterContext);
+}

package/dist/providers/native-provider.d.ts

@@ -0,0 +1,4 @@
+import { type AstraUIProviderProps } from "./astra-ui-provider.js";
+export type { AstraUIProviderProps } from "./astra-ui-provider.js";
+/** Combines native navigation, responsive Unpic images and the shared theme provider. */
+export declare function AstraUIProvider({ components, ...props }: AstraUIProviderProps): import("react").JSX.Element;

package/dist/providers/native-provider.js

@@ -0,0 +1,45 @@
+"use client";
+import { c as _c } from "react/compiler-runtime";
+import { AstraUIProvider as BaseAstraUIProvider } from "./astra-ui-provider.js";
+import { UnpicImageAdapter } from "../adapters/unpic-image.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+/** Combines native navigation, responsive Unpic images and the shared theme provider. */
+export function AstraUIProvider(t0) {
+	const $ = _c(8);
+	let components;
+	let props;
+	if ($[0] !== t0) {
+		({components, ...props} = t0);
+		$[0] = t0;
+		$[1] = components;
+		$[2] = props;
+	} else {
+		components = $[1];
+		props = $[2];
+	}
+	let t1;
+	if ($[3] !== components) {
+		t1 = {
+			Image: UnpicImageAdapter,
+			...components
+		};
+		$[3] = components;
+		$[4] = t1;
+	} else {
+		t1 = $[4];
+	}
+	const nativeComponents = t1;
+	let t2;
+	if ($[5] !== nativeComponents || $[6] !== props) {
+		t2 = /* @__PURE__ */ _jsx(BaseAstraUIProvider, {
+			...props,
+			components: nativeComponents
+		});
+		$[5] = nativeComponents;
+		$[6] = props;
+		$[7] = t2;
+	} else {
+		t2 = $[7];
+	}
+	return t2;
+}

package/dist/sonner.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Exposes the shared notification implementation and its public types. `Toaster` is @astra-kit/ui's own, which keeps
+ * Sonner's look and props but lets toasts work while a modal is open; this local export takes precedence over the
+ * one `export *` would bring from Sonner.
+ */
+export * from "sonner";
+export { Toaster } from "./components/toaster.js";