@bug-on/m3-expressive 1.3.0 → 1.3.2

package/dist/layout.js

@@ -4,7 +4,7 @@
 var reactSlot = require('@radix-ui/react-slot');
 var classVarianceAuthority = require('class-variance-authority');
 var react = require('motion/react');
-var React18 = require('react');
+var React23 = require('react');
 var clsx = require('clsx');
 var tailwindMerge = require('tailwind-merge');
 var jsxRuntime = require('react/jsx-runtime');
@@ -32,7 +32,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React18__namespace = /*#__PURE__*/_interopNamespace(React18);
+var React23__namespace = /*#__PURE__*/_interopNamespace(React23);
 var RadixScrollArea__namespace = /*#__PURE__*/_interopNamespace(RadixScrollArea);
 
 var __defProp = Object.defineProperty;
@@ -77,7 +77,7 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 function cn(...inputs) {
   return tailwindMerge.twMerge(clsx.clsx(inputs));
 }
-var RippleItem = React18__namespace.memo(function RippleItem2({
+var RippleItem = React23__namespace.memo(function RippleItem2({
   ripple,
   onDone
 }) {
@@ -121,8 +121,8 @@ function Ripple({
 }
 function useRippleState(options = {}) {
   const { disabled = false } = options;
-  const [ripples, setRipples] = React18__namespace.useState([]);
-  const onPointerDown = React18__namespace.useCallback(
+  const [ripples, setRipples] = React23__namespace.useState([]);
+  const onPointerDown = React23__namespace.useCallback(
     (e) => {
       if (disabled) return;
       const rect = e.currentTarget.getBoundingClientRect();
@@ -139,21 +139,36 @@ function useRippleState(options = {}) {
     },
     [disabled]
   );
-  const removeRipple = React18__namespace.useCallback((id) => {
+  const removeRipple = React23__namespace.useCallback((id) => {
     setRipples((prev) => prev.filter((r) => r.id !== id));
   }, []);
   return { ripples, onPointerDown, removeRipple };
 }
+
+// src/ui/cards/card/card-tokens.ts
 var SHADOW = {
   level0: "none",
   level1: "0px 1px 2px 0px rgba(0,0,0,.3), 0px 1px 3px 1px rgba(0,0,0,.15)",
-  level2: "0px 1px 2px 0px rgba(0,0,0,.3), 0px 2px 6px 2px rgba(0,0,0,.15)"
+  level2: "0px 1px 2px 0px rgba(0,0,0,.3), 0px 2px 6px 2px rgba(0,0,0,.15)",
+  level3: "0px 4px 8px 3px rgba(0,0,0,.15), 0px 1px 3px 0px rgba(0,0,0,.3)",
+  level4: "0px 6px 10px 4px rgba(0,0,0,.15), 0px 2px 3px 0px rgba(0,0,0,.3)",
+  level5: "0px 8px 12px 6px rgba(0,0,0,.15), 0px 4px 4px 0px rgba(0,0,0,.3)"
 };
+function resolveElevationShadow(level) {
+  var _a;
+  if (level === void 0) return void 0;
+  if (typeof level === "number") {
+    const key = `level${level}`;
+    return (_a = SHADOW[key]) != null ? _a : SHADOW.level0;
+  }
+  return level;
+}
 var VARIANT_ELEVATION = {
   elevated: {
     rest: SHADOW.level1,
     hover: SHADOW.level2,
     pressed: SHADOW.level1,
+    dragged: SHADOW.level3,
     disabled: SHADOW.level1
     // ElevatedCardTokens.DisabledContainerElevation = Level1
   },
@@ -161,78 +176,177 @@ var VARIANT_ELEVATION = {
     rest: SHADOW.level0,
     hover: SHADOW.level1,
     pressed: SHADOW.level0,
+    dragged: SHADOW.level3,
     disabled: SHADOW.level0
   },
   outlined: {
     rest: SHADOW.level0,
     hover: SHADOW.level1,
     pressed: SHADOW.level0,
+    dragged: SHADOW.level3,
     disabled: SHADOW.level0
   }
 };
+function useCardElevation({
+  variant = "elevated",
+  disabled = false,
+  draggable = false,
+  elevation,
+  disableElevation = false,
+  hoverEffect = true
+}) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const defaultLevels = VARIANT_ELEVATION[variant] || VARIANT_ELEVATION.elevated;
+  let restShadow = defaultLevels.rest;
+  let hoverShadow = defaultLevels.hover;
+  let pressedShadow = defaultLevels.pressed;
+  let draggedShadow = defaultLevels.dragged;
+  if (disableElevation) {
+    restShadow = SHADOW.level0;
+    hoverShadow = SHADOW.level0;
+    pressedShadow = SHADOW.level0;
+    draggedShadow = SHADOW.level0;
+  } else if (typeof elevation === "number") {
+    const resolved = (_a = resolveElevationShadow(elevation)) != null ? _a : SHADOW.level0;
+    restShadow = resolved;
+    const hoverLevel = hoverEffect ? Math.min(elevation + 1, 5) : elevation;
+    hoverShadow = (_b = resolveElevationShadow(hoverLevel)) != null ? _b : resolved;
+    pressedShadow = resolved;
+    draggedShadow = (_c = resolveElevationShadow(
+      Math.min(elevation + 2, 5)
+    )) != null ? _c : resolved;
+  } else if (elevation && typeof elevation === "object") {
+    if (elevation.rest !== void 0) {
+      restShadow = (_d = resolveElevationShadow(elevation.rest)) != null ? _d : restShadow;
+    }
+    if (elevation.hover !== void 0) {
+      hoverShadow = (_e = resolveElevationShadow(elevation.hover)) != null ? _e : hoverShadow;
+    }
+    if (elevation.pressed !== void 0) {
+      pressedShadow = (_f = resolveElevationShadow(elevation.pressed)) != null ? _f : pressedShadow;
+    }
+    if (elevation.dragged !== void 0) {
+      draggedShadow = (_g = resolveElevationShadow(elevation.dragged)) != null ? _g : draggedShadow;
+    }
+  }
+  if (!hoverEffect) {
+    hoverShadow = restShadow;
+  }
+  const animateShadow = disabled ? disableElevation ? SHADOW.level0 : defaultLevels.disabled : restShadow;
+  return {
+    animate: { boxShadow: animateShadow },
+    whileHover: disabled || !hoverEffect ? void 0 : { boxShadow: hoverShadow },
+    whileTap: disabled ? void 0 : { boxShadow: pressedShadow },
+    whileFocus: disabled || !hoverEffect ? void 0 : { boxShadow: hoverShadow },
+    whileDrag: !disabled && draggable ? { boxShadow: draggedShadow } : void 0,
+    transition: {
+      boxShadow: {
+        // Incoming: 120ms (from Elevation.kt DefaultIncomingSpec)
+        duration: 0.12,
+        ease: [0.4, 0, 0.2, 1]
+      }
+    }
+  };
+}
 var cardVariants = classVarianceAuthority.cva(
-  "rounded-m3-lg flex flex-col relative overflow-hidden transition-colors duration-200",
+  "rounded-m3-lg flex flex-col relative overflow-hidden transition-all duration-200",
   {
     variants: {
       variant: {
         // ElevatedCardTokens.ContainerColor = SurfaceContainerLow
-        elevated: "bg-m3-surface-container-low",
+        elevated: "bg-m3-surface-container-low text-m3-on-surface",
         // FilledCardTokens.ContainerColor = SurfaceContainerHighest
-        filled: "bg-m3-surface-container-highest",
+        filled: "bg-m3-surface-container-highest text-m3-on-surface",
         // OutlinedCardTokens.ContainerColor = Surface, OutlineColor = OutlineVariant
-        outlined: "bg-m3-surface border border-m3-outline-variant"
+        outlined: "bg-m3-surface text-m3-on-surface border border-m3-outline-variant"
       }
     },
     defaultVariants: { variant: "elevated" }
   }
 );
-function useCardElevation(variant, disabled) {
-  const levels = VARIANT_ELEVATION[variant];
-  return {
-    animate: { boxShadow: disabled ? levels.disabled : levels.rest },
-    whileHover: disabled ? void 0 : { boxShadow: levels.hover },
-    whileTap: disabled ? void 0 : { boxShadow: levels.pressed },
-    whileFocus: disabled ? void 0 : { boxShadow: levels.hover },
-    transition: {
-      boxShadow: {
-        // Incoming: 120ms (from Elevation.kt DefaultIncomingSpec)
-        duration: 0.12,
-        ease: [0.4, 0, 0.2, 1]
-      }
-    }
-  };
-}
-var CardImpl = React18__namespace.forwardRef(
+var CardImpl = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       className,
       variant = "elevated",
+      elevation,
+      disableElevation = false,
+      ripple = true,
+      disableRipple = false,
+      hoverEffect = true,
+      disableHoverEffect = false,
+      stateLayer = true,
+      disableStateLayer = false,
       disabled = false,
       interactive = false,
+      draggable = false,
       href,
       target,
       rel: relProp,
       onClick,
+      onPointerDown: userOnPointerDown,
+      whileHover,
+      whileTap,
+      whileFocus,
+      whileDrag,
+      transition,
       asChild = false,
       children
     } = _b, props = __objRest(_b, [
       "className",
       "variant",
+      "elevation",
+      "disableElevation",
+      "ripple",
+      "disableRipple",
+      "hoverEffect",
+      "disableHoverEffect",
+      "stateLayer",
+      "disableStateLayer",
       "disabled",
       "interactive",
+      "draggable",
       "href",
       "target",
       "rel",
       "onClick",
+      "onPointerDown",
+      "whileHover",
+      "whileTap",
+      "whileFocus",
+      "whileDrag",
+      "transition",
       "asChild",
       "children"
     ]);
-    const safeVariant = variant;
+    const safeVariant = variant || "elevated";
     const isInteractive = !!onClick || !!href || interactive || asChild;
-    const elevationProps = useCardElevation(safeVariant, disabled);
-    const { ripples, onPointerDown, removeRipple } = useRippleState();
+    const isHoverEnabled = hoverEffect !== false && !disableHoverEffect;
+    const isRippleEnabled = ripple !== false && !disableRipple && isInteractive && !disabled;
+    const isStateLayerEnabled = stateLayer !== false && !disableStateLayer && isInteractive && !disabled;
+    const elevationProps = useCardElevation({
+      variant: safeVariant,
+      disabled,
+      draggable,
+      elevation,
+      disableElevation,
+      hoverEffect: isHoverEnabled
+    });
+    const {
+      ripples,
+      onPointerDown: rippleOnPointerDown,
+      removeRipple
+    } = useRippleState();
+    const handlePointerDown = (event) => {
+      if (isRippleEnabled) {
+        rippleOnPointerDown(event);
+      }
+      userOnPointerDown == null ? void 0 : userOnPointerDown(
+        event
+      );
+    };
     const baseClass = cn(
-      cardVariants({ variant }),
+      cardVariants({ variant: safeVariant }),
       // Disabled state:
       // - pointer-events-none → disable interactions completely
       // - opacity-[0.38] → MD3 DisabledContainerOpacity
@@ -242,17 +356,25 @@ var CardImpl = React18__namespace.forwardRef(
     const interactiveClass = cn(
       // Remove default outline, use MD3 state overlay & elevation for focus
       "focus-visible:outline-none focus:outline-none group",
-      // Base pseudo-element overlay layer
-      "before:absolute before:inset-0 before:pointer-events-none before:bg-m3-on-surface before:opacity-0 before:transition-opacity before:duration-200",
-      // Interactive state opacities
-      "hover:before:opacity-[0.08] focus-visible:before:opacity-[0.10] active:before:opacity-[0.10]",
-      // Outlined interactive card: change border color to m3-outline on focus/press/hover
-      variant === "outlined" && "hover:border-m3-outline focus-visible:border-m3-outline active:border-m3-outline"
+      // Base pseudo-element overlay layer (when stateLayer is enabled)
+      isStateLayerEnabled && [
+        "before:absolute before:inset-0 before:pointer-events-none before:bg-m3-on-surface before:opacity-0 before:transition-opacity before:duration-200",
+        isHoverEnabled && "hover:before:opacity-[0.08]",
+        "focus-visible:before:opacity-[0.10] active:before:opacity-[0.10]",
+        draggable && "active:before:opacity-[0.16]"
+      ],
+      // Outlined interactive card: smooth transition of border color to m3-outline on hover/focus/press
+      safeVariant === "outlined" && "transition-colors duration-200 hover:border-m3-outline focus-visible:border-m3-outline active:border-m3-outline"
     );
+    const mergedWhileHover = elevationProps.whileHover || whileHover ? __spreadValues(__spreadValues({}, elevationProps.whileHover), typeof whileHover === "object" ? whileHover : {}) : void 0;
+    const mergedWhileTap = elevationProps.whileTap || whileTap ? __spreadValues(__spreadValues({}, elevationProps.whileTap), typeof whileTap === "object" ? whileTap : {}) : void 0;
+    const mergedWhileFocus = elevationProps.whileFocus || whileFocus ? __spreadValues(__spreadValues({}, elevationProps.whileFocus), typeof whileFocus === "object" ? whileFocus : {}) : void 0;
+    const mergedWhileDrag = elevationProps.whileDrag || whileDrag ? __spreadValues(__spreadValues({}, elevationProps.whileDrag), typeof whileDrag === "object" ? whileDrag : {}) : void 0;
+    const mergedTransition = elevationProps.transition || transition ? __spreadValues(__spreadValues({}, elevationProps.transition), typeof transition === "object" ? transition : {}) : void 0;
     if (asChild) {
-      const child = React18__namespace.Children.only(children);
+      const child = React23__namespace.Children.only(children);
       const innerContent = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-        /* @__PURE__ */ jsxRuntime.jsx(Ripple, { ripples, onRippleDone: removeRipple }),
+        isRippleEnabled && /* @__PURE__ */ jsxRuntime.jsx(Ripple, { ripples, onRippleDone: removeRipple }),
         child.props.children
       ] });
       return /* @__PURE__ */ jsxRuntime.jsx(react.LazyMotion, { features: react.domMax, strict: true, children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -262,22 +384,26 @@ var CardImpl = React18__namespace.forwardRef(
           className: cn(baseClass, interactiveClass),
           "aria-disabled": disabled ? true : void 0,
           tabIndex: disabled ? -1 : 0,
-          onPointerDown,
+          onPointerDown: handlePointerDown,
           onClick
         }, props), {
-          children: React18__namespace.cloneElement(child, { children: innerContent })
+          children: React23__namespace.cloneElement(child, { children: innerContent })
         })
       ) });
     }
     if (!isInteractive) {
       return /* @__PURE__ */ jsxRuntime.jsx(
         "div",
-        {
+        __spreadProps(__spreadValues({
           ref,
           className: baseClass,
-          "aria-disabled": disabled ? true : void 0,
+          style: __spreadValues({
+            boxShadow: elevationProps.animate.boxShadow
+          }, props.style || {}),
+          "aria-disabled": disabled ? true : void 0
+        }, props), {
           children
-        }
+        })
       );
     }
     const safeRel = href ? relProp != null ? relProp : target === "_blank" ? "noreferrer" : void 0 : void 0;
@@ -292,10 +418,16 @@ var CardImpl = React18__namespace.forwardRef(
           className: cn(baseClass, interactiveClass),
           "aria-disabled": disabled ? true : void 0,
           tabIndex: disabled ? -1 : 0,
-          onPointerDown
-        }, elevationProps), {
+          onPointerDown: handlePointerDown,
+          animate: elevationProps.animate,
+          whileHover: mergedWhileHover,
+          whileTap: mergedWhileTap,
+          whileFocus: mergedWhileFocus,
+          whileDrag: mergedWhileDrag,
+          transition: mergedTransition
+        }, props), {
           children: [
-            /* @__PURE__ */ jsxRuntime.jsx(Ripple, { ripples, onRippleDone: removeRipple }),
+            isRippleEnabled && /* @__PURE__ */ jsxRuntime.jsx(Ripple, { ripples, onRippleDone: removeRipple }),
             children
           ]
         })
@@ -303,7 +435,7 @@ var CardImpl = React18__namespace.forwardRef(
     }
     return /* @__PURE__ */ jsxRuntime.jsx(react.LazyMotion, { features: react.domMax, strict: true, children: /* @__PURE__ */ jsxRuntime.jsxs(
       react.m.button,
-      __spreadProps(__spreadValues(__spreadValues({
+      __spreadProps(__spreadValues({
         ref,
         type: "button",
         disabled,
@@ -311,10 +443,16 @@ var CardImpl = React18__namespace.forwardRef(
         className: cn(baseClass, interactiveClass),
         "aria-disabled": disabled ? true : void 0,
         tabIndex: disabled ? -1 : 0,
-        onPointerDown
-      }, elevationProps), props), {
+        onPointerDown: handlePointerDown,
+        animate: elevationProps.animate,
+        whileHover: mergedWhileHover,
+        whileTap: mergedWhileTap,
+        whileFocus: mergedWhileFocus,
+        whileDrag: mergedWhileDrag,
+        transition: mergedTransition
+      }, props), {
         children: [
-          /* @__PURE__ */ jsxRuntime.jsx(Ripple, { ripples, onRippleDone: removeRipple }),
+          isRippleEnabled && /* @__PURE__ */ jsxRuntime.jsx(Ripple, { ripples, onRippleDone: removeRipple }),
           children
         ]
       })
@@ -322,7 +460,1132 @@ var CardImpl = React18__namespace.forwardRef(
   }
 );
 CardImpl.displayName = "Card";
-var Card = React18__namespace.memo(CardImpl);
+var Card = React23__namespace.memo(CardImpl);
+var CardHeader = React23__namespace.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className, avatar, title, subheader, action, children } = _b, props = __objRest(_b, ["className", "avatar", "title", "subheader", "action", "children"]);
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      __spreadProps(__spreadValues({
+        ref,
+        className: cn(
+          "flex items-center gap-4 px-6 pt-6 pb-2 relative z-1",
+          className
+        )
+      }, props), {
+        children: [
+          avatar && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "shrink-0 flex items-center", children: avatar }),
+          title || subheader ? /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1 min-w-0", children: [
+            title && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-base font-medium text-m3-on-surface truncate", children: title }),
+            subheader && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-sm text-m3-on-surface-variant truncate", children: subheader })
+          ] }) : null,
+          children,
+          action && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "shrink-0 ml-auto flex items-center", children: action })
+        ]
+      })
+    );
+  }
+);
+CardHeader.displayName = "CardHeader";
+var ASPECT_RATIO_CLASSES = {
+  video: "aspect-video",
+  square: "aspect-square",
+  wide: "aspect-[21/9]",
+  auto: ""
+};
+var CardMedia = React23__namespace.forwardRef(
+  (_a, ref) => {
+    var _b = _a, {
+      className,
+      src,
+      alt = "",
+      aspectRatio = "video",
+      component,
+      children
+    } = _b, props = __objRest(_b, [
+      "className",
+      "src",
+      "alt",
+      "aspectRatio",
+      "component",
+      "children"
+    ]);
+    const ratioClass = aspectRatio in ASPECT_RATIO_CLASSES ? ASPECT_RATIO_CLASSES[aspectRatio] : "";
+    const Component = component || (src && !children ? "img" : "div");
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      __spreadProps(__spreadValues({
+        ref,
+        className: cn(
+          "relative w-full overflow-hidden shrink-0",
+          ratioClass,
+          className
+        )
+      }, props), {
+        children: children ? children : src ? /* @__PURE__ */ jsxRuntime.jsx(
+          Component,
+          {
+            src,
+            alt,
+            className: "w-full h-full object-cover"
+          }
+        ) : null
+      })
+    );
+  }
+);
+CardMedia.displayName = "CardMedia";
+var CardContent = React23__namespace.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className, children } = _b, props = __objRest(_b, ["className", "children"]);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      __spreadProps(__spreadValues({
+        ref,
+        className: cn(
+          "px-6 py-4 text-sm text-m3-on-surface-variant flex-1 relative z-1",
+          className
+        )
+      }, props), {
+        children
+      })
+    );
+  }
+);
+CardContent.displayName = "CardContent";
+var ALIGN_CLASSES = {
+  start: "justify-start",
+  center: "justify-center",
+  end: "justify-end",
+  between: "justify-between"
+};
+var CardFooter = React23__namespace.forwardRef(
+  (_a, ref) => {
+    var _b = _a, { className, align = "end", children } = _b, props = __objRest(_b, ["className", "align", "children"]);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      __spreadProps(__spreadValues({
+        ref,
+        className: cn(
+          "flex items-center gap-2 px-6 pb-6 pt-2 relative z-1",
+          ALIGN_CLASSES[align],
+          className
+        )
+      }, props), {
+        children
+      })
+    );
+  }
+);
+CardFooter.displayName = "CardFooter";
+function CarouselGrid(_a) {
+  var _b = _a, {
+    children,
+    items,
+    renderItem,
+    preferredItemWidth = 240,
+    className,
+    style
+  } = _b, props = __objRest(_b, [
+    "children",
+    "items",
+    "renderItem",
+    "preferredItemWidth",
+    "className",
+    "style"
+  ]);
+  const gridStyle = __spreadValues({
+    display: "grid",
+    gridTemplateColumns: `repeat(auto-fill, minmax(${preferredItemWidth}px, 1fr))`,
+    gap: "8px",
+    padding: "8px 16px",
+    width: "100%",
+    boxSizing: "border-box"
+  }, style);
+  const itemStyle = {
+    position: "relative",
+    width: "100%",
+    minHeight: "180px",
+    borderRadius: "28px",
+    overflow: "hidden"
+  };
+  if (items && renderItem) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "section",
+      __spreadProps(__spreadValues({
+        className,
+        style: gridStyle,
+        "aria-label": "Expanded carousel grid"
+      }, props), {
+        children: items.map((item, index) => {
+          const itemKey = typeof item === "object" && item !== null && "id" in item ? item.id : typeof item === "object" && item !== null && "key" in item ? item.key : index;
+          return /* @__PURE__ */ jsxRuntime.jsx("div", { style: itemStyle, children: renderItem(item, index) }, itemKey);
+        })
+      })
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "section",
+    __spreadProps(__spreadValues({
+      className,
+      style: gridStyle,
+      "aria-label": "Expanded carousel grid"
+    }, props), {
+      children: React23__namespace.Children.map(children, (child, index) => {
+        const childKey = React23__namespace.isValidElement(child) && child.key != null ? child.key : index;
+        return /* @__PURE__ */ jsxRuntime.jsx("div", { style: itemStyle, children: child }, childKey);
+      })
+    })
+  );
+}
+var CarouselItem = React23__namespace.forwardRef(
+  function CarouselItem2(_a, ref) {
+    var _b = _a, {
+      index,
+      totalItems,
+      layout = "multi-browse",
+      width,
+      minContentWidth,
+      maskClipPercent = 0,
+      parallaxOffset = 0,
+      isFocused = false,
+      isScrolling = false,
+      disabled = false,
+      className,
+      style,
+      children,
+      onClick,
+      onPointerDown
+    } = _b, props = __objRest(_b, [
+      "index",
+      "totalItems",
+      "layout",
+      "width",
+      "minContentWidth",
+      "maskClipPercent",
+      "parallaxOffset",
+      "isFocused",
+      "isScrolling",
+      "disabled",
+      "className",
+      "style",
+      "children",
+      "onClick",
+      "onPointerDown"
+    ]);
+    const {
+      ripples,
+      onPointerDown: handleRipplePointerDown,
+      removeRipple
+    } = useRippleState();
+    const itemNumber = index + 1;
+    const ariaLabel = props["aria-label"] || `Item ${itemNumber} of ${totalItems}`;
+    const isFullScreen = layout === "full-screen";
+    const isCenterHero = layout === "center-aligned-hero";
+    const combinedStyle = __spreadValues({
+      width: isFullScreen ? "100%" : width ? `${width}px` : void 0,
+      height: isFullScreen ? "100%" : void 0,
+      flexShrink: 0
+    }, style);
+    const handlePointerDown = (e) => {
+      if (!disabled) {
+        handleRipplePointerDown(e);
+      }
+      onPointerDown == null ? void 0 : onPointerDown(e);
+    };
+    const handleKeyDown = (e) => {
+      var _a2;
+      if (!disabled && (e.key === "Enter" || e.key === " ")) {
+        e.preventDefault();
+        onClick == null ? void 0 : onClick(e);
+      }
+      (_a2 = props.onKeyDown) == null ? void 0 : _a2.call(props, e);
+    };
+    return (
+      // biome-ignore lint/a11y/useSemanticElements: ARIA carousel pattern requires role="group" for slide items
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        __spreadProps(__spreadValues({
+          ref,
+          role: "group",
+          "aria-roledescription": "slide",
+          "aria-label": ariaLabel,
+          tabIndex: disabled ? -1 : isFocused ? 0 : -1,
+          className: cn(
+            // Base item styles: overflow-hidden + rounded 28px acts as MD3 keyline mask
+            "relative flex flex-col overflow-hidden rounded-[28px] cursor-pointer select-none box-border outline-none shrink-0",
+            // GPU Composition & Layout Containment
+            "will-change-[transform,clip-path] contain-[layout_paint_style] [user-select:none] [-webkit-user-drag:none] [&_img]:pointer-events-none [&_img]:select-none [&_img]:[-webkit-user-drag:none]",
+            // Scroll snap: center-aligned hero snaps to center, all others snap start
+            isCenterHero ? "snap-center" : "snap-start",
+            // Full-screen: no rounding, fill height
+            isFullScreen && "rounded-none",
+            // State layers via ::after pseudo-element
+            "after:absolute after:inset-0 after:rounded-[inherit] after:bg-black after:opacity-0 after:pointer-events-none after:z-2 after:transition-opacity after:duration-150 after:motion-reduce:transition-none",
+            "hover:after:opacity-[0.08]",
+            "active:after:opacity-[0.10]",
+            // Focus ring
+            "focus-visible:outline-[3px] focus-visible:outline-(--md-sys-color-secondary,#625b71) focus-visible:outline-offset-2 focus-visible:z-3",
+            // Disabled
+            disabled && "opacity-[0.38] pointer-events-none",
+            className
+          ),
+          style: combinedStyle,
+          onPointerDown: handlePointerDown,
+          onKeyDown: handleKeyDown,
+          onClick: disabled ? void 0 : onClick
+        }, props), {
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                className: "w-full flex-1 flex flex-col will-change-transform select-none",
+                style: {
+                  width: isFullScreen ? "100%" : minContentWidth ? `${minContentWidth}px` : "100%",
+                  minWidth: isFullScreen ? "100%" : minContentWidth ? `${minContentWidth}px` : void 0,
+                  transform: parallaxOffset !== 0 ? `translateX(${parallaxOffset}px)` : void 0
+                },
+                children
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(Ripple, { ripples, onRippleDone: removeRipple })
+          ]
+        })
+      )
+    );
+  }
+);
+CarouselItem.displayName = "CarouselItem";
+function useCarouselA11y({
+  totalItems,
+  onItemSelect,
+  onExitNavigation,
+  scrollToIndex
+}) {
+  const [focusedIndex, setFocusedIndex] = React23.useState(0);
+  const handleKeyDown = React23.useCallback(
+    (event) => {
+      if (totalItems === 0) return;
+      switch (event.key) {
+        case "ArrowRight":
+        case "ArrowDown": {
+          if (event.key === "ArrowDown" && onExitNavigation) {
+            onExitNavigation();
+            return;
+          }
+          event.preventDefault();
+          setFocusedIndex((prev) => {
+            const next = Math.min(totalItems - 1, prev + 1);
+            scrollToIndex == null ? void 0 : scrollToIndex(next);
+            return next;
+          });
+          break;
+        }
+        case "ArrowLeft":
+        case "ArrowUp": {
+          if (event.key === "ArrowUp" && onExitNavigation) {
+            onExitNavigation();
+            return;
+          }
+          event.preventDefault();
+          setFocusedIndex((prev) => {
+            const next = Math.max(0, prev - 1);
+            scrollToIndex == null ? void 0 : scrollToIndex(next);
+            return next;
+          });
+          break;
+        }
+        case "Home": {
+          event.preventDefault();
+          setFocusedIndex(0);
+          scrollToIndex == null ? void 0 : scrollToIndex(0);
+          break;
+        }
+        case "End": {
+          event.preventDefault();
+          const lastIndex = totalItems - 1;
+          setFocusedIndex(lastIndex);
+          scrollToIndex == null ? void 0 : scrollToIndex(lastIndex);
+          break;
+        }
+        case " ":
+        case "Enter": {
+          event.preventDefault();
+          onItemSelect == null ? void 0 : onItemSelect(focusedIndex);
+          break;
+        }
+      }
+    },
+    [totalItems, focusedIndex, onItemSelect, onExitNavigation, scrollToIndex]
+  );
+  const getItemA11yProps = React23.useCallback(
+    (index, customLabel) => {
+      const itemNumber = index + 1;
+      const defaultLabel = `Item ${itemNumber} of ${totalItems}`;
+      return {
+        role: "group",
+        "aria-roledescription": "slide",
+        "aria-label": customLabel ? `${customLabel} (${itemNumber} of ${totalItems})` : defaultLabel,
+        tabIndex: index === focusedIndex ? 0 : -1,
+        onFocus: () => setFocusedIndex(index)
+      };
+    },
+    [focusedIndex, totalItems]
+  );
+  return {
+    focusedIndex,
+    setFocusedIndex,
+    handleKeyDown,
+    getItemA11yProps
+  };
+}
+
+// src/ui/carousel/carousel.tokens.ts
+var CarouselTokens = {
+  /** Corner radius shape (M3 extraLarge shape: 28dp) */
+  containerRadius: 28,
+  /** Small item dimension limits (dp) */
+  smallItemMin: 40,
+  smallItemMax: 56,
+  /** Layout defaults (dp) */
+  itemSpacing: 8,
+  contentPadding: 16,
+  verticalPadding: 8,
+  /** Interactive state overlays */
+  hoverOpacity: 0.08,
+  focusOpacity: 0.1,
+  pressedOpacity: 0.1,
+  disabledOpacity: 0.38,
+  /** Focus indicator dimensions */
+  focusThickness: 3,
+  focusOffset: 2,
+  /** Touch target minimum size for accessibility (WCAG 2.1 AAA / M3) */
+  minTouchTargetSize: 48,
+  /** CSS Custom Property token maps for fallback and runtime injection */
+  cssVars: {
+    shape: "--carousel-item-shape",
+    spacing: "--carousel-item-spacing",
+    contentPadding: "--carousel-content-padding",
+    verticalPadding: "--carousel-vertical-padding",
+    smallMin: "--carousel-small-item-min",
+    smallMax: "--carousel-small-item-max",
+    hoverOpacity: "--carousel-hover-opacity",
+    focusThickness: "--carousel-focus-thickness",
+    focusOffset: "--carousel-focus-offset",
+    pressedOpacity: "--carousel-pressed-opacity",
+    disabledOpacity: "--carousel-disabled-opacity"
+  }
+};
+
+// src/ui/carousel/hooks/useCarouselKeylines.ts
+function useCarouselKeylines({
+  containerWidth,
+  preferredItemWidth = 300,
+  layout = "multi-browse",
+  itemSpacing = CarouselTokens.itemSpacing,
+  contentPadding = CarouselTokens.contentPadding,
+  totalItems,
+  scrollX: _scrollX = 0
+}) {
+  return React23.useMemo(() => {
+    const safeContainerWidth = Math.max(containerWidth, 100);
+    const smallWidth = Math.min(
+      Math.max(
+        CarouselTokens.smallItemMin,
+        Math.round(safeContainerWidth * 0.1)
+      ),
+      CarouselTokens.smallItemMax
+    );
+    let largeWidth = preferredItemWidth;
+    let mediumWidth = Math.round(preferredItemWidth * 0.65);
+    switch (layout) {
+      case "hero": {
+        const availableWidth = safeContainerWidth - contentPadding * 2 - smallWidth - itemSpacing;
+        largeWidth = Math.max(160, availableWidth);
+        mediumWidth = largeWidth;
+        break;
+      }
+      case "center-aligned-hero": {
+        const availableWidth = safeContainerWidth - contentPadding * 2 - smallWidth * 2 - itemSpacing * 2;
+        largeWidth = Math.max(160, availableWidth);
+        mediumWidth = largeWidth;
+        break;
+      }
+      case "uncontained":
+      case "uncontained-multi-aspect": {
+        largeWidth = Math.min(
+          preferredItemWidth,
+          safeContainerWidth - contentPadding * 2
+        );
+        mediumWidth = largeWidth;
+        break;
+      }
+      case "full-screen": {
+        largeWidth = safeContainerWidth;
+        mediumWidth = safeContainerWidth;
+        break;
+      }
+      default: {
+        const maxLargeWidth = safeContainerWidth - contentPadding * 2 - smallWidth - itemSpacing;
+        largeWidth = Math.min(preferredItemWidth, Math.max(160, maxLargeWidth));
+        mediumWidth = Math.max(smallWidth + 16, Math.round(largeWidth * 0.65));
+        break;
+      }
+    }
+    const keylines = [];
+    if (layout === "hero") {
+      const smallMask = Math.max(
+        0,
+        Math.min(
+          100,
+          Math.round((largeWidth - smallWidth) / largeWidth * 100)
+        )
+      );
+      keylines.push(
+        {
+          offset: contentPadding,
+          width: largeWidth,
+          type: "large",
+          maskClip: 0
+        },
+        {
+          offset: contentPadding + largeWidth + itemSpacing,
+          width: smallWidth,
+          type: "small",
+          maskClip: smallMask
+        }
+      );
+    } else if (layout === "center-aligned-hero") {
+      const smallMask = Math.max(
+        0,
+        Math.min(
+          100,
+          Math.round((largeWidth - smallWidth) / largeWidth * 100)
+        )
+      );
+      keylines.push(
+        {
+          offset: contentPadding,
+          width: smallWidth,
+          type: "small",
+          maskClip: smallMask
+        },
+        {
+          offset: contentPadding + smallWidth + itemSpacing,
+          width: largeWidth,
+          type: "large",
+          maskClip: 0
+        },
+        {
+          offset: contentPadding + smallWidth + itemSpacing + largeWidth + itemSpacing,
+          width: smallWidth,
+          type: "small",
+          maskClip: smallMask
+        }
+      );
+    } else if (layout === "multi-browse") {
+      const mediumMask = Math.max(
+        0,
+        Math.min(
+          100,
+          Math.round((largeWidth - mediumWidth) / largeWidth * 100)
+        )
+      );
+      const smallMask = Math.max(
+        0,
+        Math.min(
+          100,
+          Math.round((largeWidth - smallWidth) / largeWidth * 100)
+        )
+      );
+      const availableWidth = safeContainerWidth - contentPadding * 2;
+      const numLarge = Math.max(
+        1,
+        Math.floor((availableWidth + itemSpacing) / (largeWidth + itemSpacing))
+      );
+      let offset = contentPadding;
+      for (let k = 0; k < numLarge; k++) {
+        keylines.push({
+          offset,
+          width: largeWidth,
+          type: "large",
+          maskClip: 0
+        });
+        offset += largeWidth + itemSpacing;
+      }
+      keylines.push({
+        offset,
+        width: mediumWidth,
+        type: "medium",
+        maskClip: mediumMask
+      });
+      offset += mediumWidth + itemSpacing;
+      keylines.push({
+        offset,
+        width: smallWidth,
+        type: "small",
+        maskClip: smallMask
+      });
+    } else {
+      keylines.push({
+        offset: contentPadding,
+        width: largeWidth,
+        type: "large",
+        maskClip: 0
+      });
+    }
+    const getItemRestWidth = (i) => {
+      if (layout === "full-screen") return safeContainerWidth;
+      if (layout === "uncontained") return largeWidth;
+      if (layout === "uncontained-multi-aspect") {
+        const ratios = [1.77, 1.33, 1, 0.56];
+        const ratio = ratios[i % ratios.length];
+        return Math.round(Math.min(largeWidth, 220 * ratio));
+      }
+      if (layout === "hero") return i === 0 ? largeWidth : smallWidth;
+      if (layout === "center-aligned-hero")
+        return i === 0 || i === totalItems - 1 ? smallWidth : largeWidth;
+      const pattern = [largeWidth, largeWidth, mediumWidth, smallWidth];
+      return pattern[i % pattern.length];
+    };
+    const snapPositions = [];
+    let currentOffset = 0;
+    const itemLayoutWidth = layout === "full-screen" ? safeContainerWidth : largeWidth;
+    for (let i = 0; i < totalItems; i++) {
+      snapPositions.push(currentOffset);
+      currentOffset += itemLayoutWidth + itemSpacing;
+    }
+    const getItemWidth = (_index) => {
+      if (layout === "full-screen") return safeContainerWidth;
+      return largeWidth;
+    };
+    const getItemMaskClip = (index) => {
+      if (layout === "full-screen" || layout === "uncontained" || layout === "uncontained-multi-aspect") {
+        return 0;
+      }
+      const itemW = getItemRestWidth(index);
+      if (itemW >= largeWidth || largeWidth <= 0) return 0;
+      return Math.max(
+        0,
+        Math.min(100, Math.round((largeWidth - itemW) / largeWidth * 100))
+      );
+    };
+    const getItemParallaxOffset = (index) => {
+      const maskClip = getItemMaskClip(index);
+      if (maskClip <= 0) return 0;
+      return calculateParallaxOffset(0, maskClip, largeWidth);
+    };
+    let maxAccumulatedShift = 0;
+    if (layout === "hero") {
+      maxAccumulatedShift = Math.max(
+        0,
+        (totalItems - 1) * (largeWidth - smallWidth)
+      );
+    } else if (layout === "center-aligned-hero") {
+      maxAccumulatedShift = Math.max(
+        0,
+        Math.min(totalItems, 2) * (largeWidth - smallWidth)
+      );
+    } else if (layout === "multi-browse") {
+      const availableWidth = safeContainerWidth - contentPadding * 2;
+      const numLarge = Math.max(
+        1,
+        Math.floor((availableWidth + itemSpacing) / (largeWidth + itemSpacing))
+      );
+      const nonLargeItems = Math.max(0, totalItems - numLarge);
+      if (nonLargeItems > 0) {
+        const mediumClipped = largeWidth - mediumWidth;
+        const smallClipped = largeWidth - smallWidth;
+        const numSmall = Math.max(0, nonLargeItems - 1);
+        maxAccumulatedShift = mediumClipped + numSmall * smallClipped;
+      }
+    }
+    return {
+      largeWidth,
+      mediumWidth,
+      smallWidth,
+      keylines,
+      snapPositions,
+      maxAccumulatedShift,
+      getItemWidth,
+      getItemMaskClip,
+      getItemParallaxOffset
+    };
+  }, [
+    containerWidth,
+    preferredItemWidth,
+    layout,
+    itemSpacing,
+    contentPadding,
+    totalItems
+  ]);
+}
+function calculateMaskClipForOffset(itemLeftInViewport, containerWidth, largeWidth, mediumWidth, smallWidth, contentPadding = 16, layout = "multi-browse") {
+  if (layout === "full-screen" || layout === "uncontained" || layout === "uncontained-multi-aspect" || largeWidth <= 0) {
+    return 0;
+  }
+  const mediumMask = Math.max(
+    0,
+    Math.min(100, (largeWidth - mediumWidth) / largeWidth * 100)
+  );
+  const smallMask = Math.max(
+    0,
+    Math.min(100, (largeWidth - smallWidth) / largeWidth * 100)
+  );
+  const trailingFocalThreshold = containerWidth - contentPadding - mediumWidth - (largeWidth - mediumWidth);
+  const trailingMediumThreshold = containerWidth - contentPadding - smallWidth;
+  const trailingEndThreshold = containerWidth - contentPadding;
+  const leadingThreshold = contentPadding;
+  if (itemLeftInViewport < leadingThreshold) {
+    const dist = leadingThreshold - itemLeftInViewport;
+    const progress = Math.min(1, Math.max(0, dist / largeWidth));
+    return Math.min(100, Math.max(0, progress * smallMask));
+  }
+  if (itemLeftInViewport > trailingFocalThreshold) {
+    if (itemLeftInViewport < trailingMediumThreshold) {
+      const range2 = Math.max(
+        1,
+        trailingMediumThreshold - trailingFocalThreshold
+      );
+      const progress2 = Math.min(
+        1,
+        Math.max(0, (itemLeftInViewport - trailingFocalThreshold) / range2)
+      );
+      return progress2 * mediumMask;
+    }
+    const range = Math.max(1, trailingEndThreshold - trailingMediumThreshold);
+    const progress = Math.min(
+      1,
+      Math.max(0, (itemLeftInViewport - trailingMediumThreshold) / range)
+    );
+    return mediumMask + progress * (smallMask - mediumMask);
+  }
+  return 0;
+}
+function calculateParallaxOffset(_itemLeftInViewport, maskClipPercent, largeWidth) {
+  if (maskClipPercent <= 0 || largeWidth <= 0) return 0;
+  return -Math.round(maskClipPercent / 100 * (largeWidth * 0.2));
+}
+function CarouselScrollClient(_a) {
+  var _b = _a, {
+    children,
+    items,
+    renderItem,
+    layout = "multi-browse",
+    preferredItemWidth = 300,
+    itemSpacing = 8,
+    contentPadding = 16,
+    verticalPadding = 8,
+    userScrollEnabled = true,
+    totalItemsCount,
+    className,
+    style
+  } = _b, props = __objRest(_b, [
+    "children",
+    "items",
+    "renderItem",
+    "layout",
+    "preferredItemWidth",
+    "itemSpacing",
+    "contentPadding",
+    "verticalPadding",
+    "userScrollEnabled",
+    "totalItemsCount",
+    "className",
+    "style"
+  ]);
+  const trackRef = React23__namespace.useRef(null);
+  const [containerWidth, setContainerWidth] = React23__namespace.useState(600);
+  const rafIdRef = React23__namespace.useRef(null);
+  const isDraggingRef = React23__namespace.useRef(false);
+  const hasMovedRef = React23__namespace.useRef(false);
+  const startPosRef = React23__namespace.useRef(0);
+  const startScrollRef = React23__namespace.useRef(0);
+  const keylines = useCarouselKeylines({
+    containerWidth,
+    preferredItemWidth,
+    layout,
+    itemSpacing,
+    contentPadding,
+    totalItems: totalItemsCount
+  });
+  const handleScroll = React23__namespace.useCallback(() => {
+    if (rafIdRef.current !== null) return;
+    rafIdRef.current = requestAnimationFrame(() => {
+      var _a2, _b2;
+      const track = trackRef.current;
+      if (track) {
+        const scrollVal = layout === "full-screen" ? track.scrollTop : track.scrollLeft;
+        track.style.setProperty("--carousel-scroll-left", `${scrollVal}px`);
+        if (layout !== "full-screen") {
+          const prefersReducedMotion = typeof window !== "undefined" && ((_b2 = (_a2 = window.matchMedia) == null ? void 0 : _a2.call(window, "(prefers-reduced-motion: reduce)")) == null ? void 0 : _b2.matches);
+          let accumulatedShift = 0;
+          const items2 = track.children;
+          for (let i = 0; i < items2.length; i++) {
+            const itemEl = items2[i];
+            if (!itemEl || itemEl.getAttribute("role") !== "group") continue;
+            if (prefersReducedMotion) {
+              itemEl.style.clipPath = "none";
+              itemEl.style.transform = "none";
+              const innerContent2 = itemEl.firstElementChild;
+              if (innerContent2) innerContent2.style.transform = "none";
+              continue;
+            }
+            const nativeOffset = itemEl.offsetLeft - scrollVal;
+            const visualOffset = nativeOffset - accumulatedShift;
+            const maskPercent = calculateMaskClipForOffset(
+              visualOffset,
+              containerWidth,
+              keylines.largeWidth,
+              keylines.mediumWidth,
+              keylines.smallWidth,
+              contentPadding,
+              layout
+            );
+            const clippedPixels = maskPercent / 100 * keylines.largeWidth;
+            itemEl.style.transform = accumulatedShift > 0 ? `translateX(${-accumulatedShift}px)` : "none";
+            itemEl.style.clipPath = maskPercent > 0 ? `inset(0px ${maskPercent}% 0px 0px round 28px)` : "none";
+            const innerContent = itemEl.firstElementChild;
+            if (innerContent) {
+              const parallaxX = calculateParallaxOffset(
+                visualOffset,
+                maskPercent,
+                keylines.largeWidth
+              );
+              innerContent.style.transform = parallaxX !== 0 ? `translateX(${parallaxX}px)` : "none";
+            }
+            accumulatedShift += clippedPixels;
+          }
+        }
+      }
+      rafIdRef.current = null;
+    });
+  }, [
+    layout,
+    containerWidth,
+    keylines.largeWidth,
+    keylines.mediumWidth,
+    keylines.smallWidth,
+    contentPadding
+  ]);
+  React23__namespace.useEffect(() => {
+    const track = trackRef.current;
+    if (!track) return;
+    const updateWidth = () => {
+      if (track.clientWidth > 0) {
+        setContainerWidth(track.clientWidth);
+      }
+    };
+    updateWidth();
+    const observer = new ResizeObserver(updateWidth);
+    observer.observe(track);
+    return () => observer.disconnect();
+  }, []);
+  React23__namespace.useEffect(() => {
+    handleScroll();
+  }, [handleScroll]);
+  React23__namespace.useEffect(() => {
+    return () => {
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+      }
+    };
+  }, []);
+  const handlePointerDown = React23__namespace.useCallback(
+    (e) => {
+      var _a2, _b2;
+      if (!userScrollEnabled || e.button !== 0) return;
+      const track = trackRef.current;
+      if (!track) return;
+      isDraggingRef.current = true;
+      hasMovedRef.current = false;
+      startPosRef.current = layout === "full-screen" ? e.clientY : e.clientX;
+      startScrollRef.current = layout === "full-screen" ? track.scrollTop : track.scrollLeft;
+      try {
+        (_b2 = (_a2 = e.target).setPointerCapture) == null ? void 0 : _b2.call(_a2, e.pointerId);
+      } catch (e2) {
+      }
+    },
+    [userScrollEnabled, layout]
+  );
+  const handlePointerMove = React23__namespace.useCallback(
+    (e) => {
+      if (!isDraggingRef.current || !trackRef.current) return;
+      const currentPos = layout === "full-screen" ? e.clientY : e.clientX;
+      const delta = currentPos - startPosRef.current;
+      if (Math.abs(delta) > 4) {
+        hasMovedRef.current = true;
+      }
+      if (hasMovedRef.current) {
+        if (layout === "full-screen") {
+          trackRef.current.scrollTop = startScrollRef.current - delta;
+        } else {
+          trackRef.current.scrollLeft = startScrollRef.current - delta;
+        }
+      }
+    },
+    [layout]
+  );
+  const handlePointerUp = React23__namespace.useCallback(
+    (e) => {
+      var _a2, _b2;
+      if (!isDraggingRef.current) return;
+      isDraggingRef.current = false;
+      try {
+        (_b2 = (_a2 = e.target).releasePointerCapture) == null ? void 0 : _b2.call(_a2, e.pointerId);
+      } catch (e2) {
+      }
+    },
+    []
+  );
+  const handleClickCapture = React23__namespace.useCallback((e) => {
+    if (hasMovedRef.current) {
+      e.stopPropagation();
+      e.preventDefault();
+      hasMovedRef.current = false;
+    }
+  }, []);
+  const scrollToIndex = React23__namespace.useCallback(
+    (index) => {
+      const track = trackRef.current;
+      if (!track) return;
+      const itemEl = track.children[index];
+      if (!itemEl) return;
+      const targetPos = Math.max(0, itemEl.offsetLeft - contentPadding);
+      track.scrollTo({
+        left: targetPos,
+        behavior: "smooth"
+      });
+    },
+    [contentPadding]
+  );
+  const { focusedIndex, handleKeyDown, getItemA11yProps } = useCarouselA11y({
+    totalItems: totalItemsCount,
+    scrollToIndex
+  });
+  const isFullScreen = layout === "full-screen";
+  const isHero = layout === "hero" || layout === "center-aligned-hero";
+  const trackClasses = cn(
+    // Base layout & GPU containment
+    "relative box-border select-none [contain:layout_style]",
+    userScrollEnabled && "cursor-grab active:cursor-grabbing",
+    // Scrollbar hide
+    "[scrollbar-width:none] [&::-webkit-scrollbar]:hidden",
+    // Full-screen: vertical snap column
+    isFullScreen ? "flex flex-col flex-1 min-h-0 overflow-x-hidden overflow-y-auto p-0 gap-0 [scroll-snap-type:y_mandatory] [touch-action:pan-y]" : "flex flex-row items-stretch overflow-x-auto overflow-y-hidden [-webkit-overflow-scrolling:touch] [touch-action:pan-x]",
+    // Snap for hero/center-aligned-hero
+    isHero && !isFullScreen && "[scroll-snap-type:x_mandatory]",
+    // Disabled
+    !userScrollEnabled && "overflow-x-hidden pointer-events-none [touch-action:none]",
+    className
+  );
+  const trackStyle = isFullScreen ? __spreadValues({}, style) : __spreadValues({
+    paddingLeft: `${contentPadding}px`,
+    paddingRight: layout === "uncontained" || layout === "uncontained-multi-aspect" ? 0 : `${contentPadding}px`,
+    scrollPaddingLeft: `${contentPadding}px`,
+    scrollPaddingRight: `${contentPadding}px`,
+    paddingTop: `${verticalPadding}px`,
+    paddingBottom: `${verticalPadding}px`,
+    gap: `${itemSpacing}px`
+  }, style);
+  const renderSlides = () => {
+    if (items && renderItem) {
+      return items.map((item, index) => {
+        const itemWidth = keylines.largeWidth;
+        const maskClip = keylines.getItemMaskClip(index);
+        const parallax = keylines.getItemParallaxOffset(index);
+        const a11yProps = getItemA11yProps(index);
+        const itemKey = typeof item === "object" && item !== null && "id" in item ? item.id : typeof item === "object" && item !== null && "key" in item ? item.key : index;
+        return /* @__PURE__ */ jsxRuntime.jsx(
+          CarouselItem,
+          __spreadProps(__spreadValues({
+            index,
+            totalItems: totalItemsCount,
+            layout,
+            width: itemWidth,
+            minContentWidth: keylines.largeWidth,
+            maskClipPercent: maskClip,
+            parallaxOffset: parallax,
+            isFocused: focusedIndex === index
+          }, a11yProps), {
+            children: renderItem(item, index)
+          }),
+          itemKey
+        );
+      });
+    }
+    return React23__namespace.Children.map(children, (child, index) => {
+      if (!React23__namespace.isValidElement(child)) return child;
+      const itemWidth = keylines.largeWidth;
+      const maskClip = keylines.getItemMaskClip(index);
+      const parallax = keylines.getItemParallaxOffset(index);
+      const a11yProps = getItemA11yProps(index);
+      const childKey = child.key != null ? child.key : index;
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        CarouselItem,
+        __spreadProps(__spreadValues({
+          index,
+          totalItems: totalItemsCount,
+          layout,
+          width: itemWidth,
+          minContentWidth: keylines.largeWidth,
+          maskClipPercent: maskClip,
+          parallaxOffset: parallax,
+          isFocused: focusedIndex === index
+        }, a11yProps), {
+          children: child
+        }),
+        childKey
+      );
+    });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "section",
+    __spreadProps(__spreadValues({
+      ref: trackRef,
+      "aria-roledescription": "carousel",
+      "aria-label": props["aria-label"] || "Content carousel",
+      tabIndex: 0,
+      className: trackClasses,
+      style: trackStyle,
+      onScroll: handleScroll,
+      onPointerDown: handlePointerDown,
+      onPointerMove: handlePointerMove,
+      onPointerUp: handlePointerUp,
+      onPointerCancel: handlePointerUp,
+      onClickCapture: handleClickCapture,
+      onKeyDown: handleKeyDown
+    }, props), {
+      children: [
+        renderSlides(),
+        !isFullScreen && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            "aria-hidden": "true",
+            className: "shrink-0 pointer-events-none",
+            style: {
+              width: 0,
+              marginRight: keylines.maxAccumulatedShift > 0 ? `-${keylines.maxAccumulatedShift}px` : void 0
+            }
+          }
+        )
+      ]
+    })
+  );
+}
+function Carousel(_a) {
+  var _b = _a, {
+    children,
+    items,
+    renderItem,
+    layout = "multi-browse",
+    preferredItemWidth = 300,
+    itemSpacing = 8,
+    contentPadding = 16,
+    verticalPadding = 8,
+    isExpanded: controlledExpanded,
+    onShowAllClick,
+    showAllLabel = "Show all",
+    userScrollEnabled = true,
+    className,
+    style
+  } = _b, props = __objRest(_b, [
+    "children",
+    "items",
+    "renderItem",
+    "layout",
+    "preferredItemWidth",
+    "itemSpacing",
+    "contentPadding",
+    "verticalPadding",
+    "isExpanded",
+    "onShowAllClick",
+    "showAllLabel",
+    "userScrollEnabled",
+    "className",
+    "style"
+  ]);
+  const [internalExpanded, setInternalExpanded] = React23__namespace.useState(false);
+  const isExpanded = controlledExpanded != null ? controlledExpanded : internalExpanded;
+  const totalItemsCount = React23__namespace.useMemo(() => {
+    if (items) return items.length;
+    return React23__namespace.Children.count(children);
+  }, [items, children]);
+  const handleShowAllToggle = React23__namespace.useCallback(() => {
+    if (onShowAllClick) {
+      onShowAllClick();
+    } else {
+      setInternalExpanded((prev) => !prev);
+    }
+  }, [onShowAllClick]);
+  const isFullScreen = layout === "full-screen";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: cn(
+        "relative w-full flex flex-col gap-3 box-border min-h-0",
+        // Full-screen: propagate height to track
+        isFullScreen && "flex-1",
+        className
+      ),
+      style,
+      children: [
+        !isFullScreen && /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            className: "flex items-center justify-between",
+            style: { padding: `0 ${contentPadding}px` },
+            children: [
+              props["aria-label"] && /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "m-0 text-(length:--md-sys-typescale-title-medium-size,1.125rem) font-medium text-(--md-sys-color-on-surface,currentColor)", children: props["aria-label"] }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  type: "button",
+                  className: cn(
+                    "inline-flex items-center justify-center min-h-12 min-w-12 px-4 py-2",
+                    "rounded-[20px] border border-(--md-sys-color-outline-variant,rgba(121,116,126,0.3))",
+                    "bg-transparent text-(--md-sys-color-primary,#6750a4) font-medium text-[0.875rem]",
+                    "cursor-pointer outline-none transition-colors duration-200",
+                    "hover:bg-(--md-sys-color-surface-container-high,rgba(103,80,164,0.08))",
+                    "focus-visible:outline-[3px] focus-visible:outline-(--md-sys-color-secondary,#625b71) focus-visible:outline-offset-2"
+                  ),
+                  onClick: handleShowAllToggle,
+                  "aria-expanded": isExpanded,
+                  "aria-label": isExpanded ? "Collapse carousel view" : `${showAllLabel} (${totalItemsCount} items)`,
+                  children: isExpanded ? "Show carousel" : showAllLabel
+                }
+              )
+            ]
+          }
+        ),
+        isExpanded ? /* @__PURE__ */ jsxRuntime.jsx(
+          CarouselGrid,
+          {
+            items,
+            renderItem,
+            preferredItemWidth,
+            children
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx(
+          CarouselScrollClient,
+          __spreadProps(__spreadValues({
+            items,
+            renderItem,
+            layout,
+            preferredItemWidth,
+            itemSpacing,
+            contentPadding,
+            verticalPadding,
+            userScrollEnabled,
+            totalItemsCount
+          }, props), {
+            children
+          })
+        )
+      ]
+    }
+  );
+}
 var SHAPE_KEY_TIMES = "0; 0.14; 0.14; 0.29; 0.29; 0.43; 0.43; 0.57; 0.57; 0.71; 0.71; 0.86; 0.86; 1";
 var SHAPE_KEY_SPLINES = [
   "0.5 0.2 0 0.8",
@@ -368,11 +1631,11 @@ var ROTATE_KEY_SPLINES = [
 var ROTATE_VALUES = "0 24 24; 154 24 24; 309 24 24; 463 24 24; 617 24 24; 771 24 24; 926 24 24; 1080 24 24";
 var DETERMINATE_CIRCLE = "M24 7 C34.49 7 41 13.51 41 24 C41 34.49 34.49 41 24 41 C13.51 41 7 34.49 7 24 C7 13.51 13.51 7 24 7 Z";
 var DETERMINATE_SOFT_BURST = "M20.9 10.4 21.4 9.5 21.9 8.7 22.5 7.8 23.2 7.2 24.2 7 25.1 7.4 25.7 8.1 26.2 9 26.8 9.8 27.3 10.6 28.1 11.2 29 11.3 30 11 30.9 10.6 31.8 10.3 32.8 9.9 33.7 10 34.5 10.6 34.9 11.5 34.8 12.5 34.8 13.5 34.7 14.5 34.7 15.5 35.2 16.3 36 16.8 37 17.1 37.9 17.3 38.9 17.5 39.8 17.9 40.4 18.7 40.5 19.7 40 20.5 39.4 21.3 38.7 22 38.1 22.8 37.6 23.7 37.7 24.6 38.3 25.5 38.9 26.2 39.6 27 40.2 27.7 40.5 28.7 40.3 29.6 39.5 30.3 38.6 30.6 37.6 30.8 36.7 31 35.7 31.3 35 31.9 34.6 32.8 34.7 33.8 34.8 34.8 34.9 35.8 34.8 36.8 34.3 37.6 33.4 38.1 32.4 38 31.5 37.6 30.6 37.2 29.7 36.9 28.7 36.6 27.8 36.9 27.1 37.6 26.6 38.5 26.1 39.3 25.5 40.2 24.8 40.8 23.8 41 22.9 40.6 22.3 39.9 21.8 39 21.2 38.2 20.7 37.4 19.9 36.8 19 36.7 18 37 17.1 37.4 16.2 37.7 15.2 38.1 14.3 38 13.5 37.4 13.1 36.5 13.2 35.5 13.2 34.5 13.3 33.5 13.3 32.5 12.8 31.7 12 31.2 11 31 10.1 30.7 9.1 30.5 8.2 30.1 7.6 29.3 7.5 28.3 8 27.5 8.7 26.7 9.3 26 9.9 25.2 10.4 24.3 10.3 23.4 9.7 22.5 9.1 21.8 8.4 21 7.8 20.3 7.5 19.3 7.7 18.4 8.5 17.7 9.4 17.4 10.4 17.2 11.3 17 12.3 16.7 13 16.1 13.4 15.2 13.3 14.2 13.2 13.2 13.1 12.2 13.2 11.2 13.7 10.4 14.6 9.9 15.6 10 16.5 10.4 17.4 10.8 18.3 11.1 19.3 11.4 20.2 11.1Z";
-var IndeterminateSvg = React18__namespace.memo(function IndeterminateSvg2({
+var IndeterminateSvg = React23__namespace.memo(function IndeterminateSvg2({
   size
 }) {
-  const [ready, setReady] = React18__namespace.useState(false);
-  React18__namespace.useEffect(() => {
+  const [ready, setReady] = React23__namespace.useState(false);
+  React23__namespace.useEffect(() => {
     const raf = requestAnimationFrame(() => setReady(true));
     return () => cancelAnimationFrame(raf);
   }, []);
@@ -417,7 +1680,7 @@ var IndeterminateSvg = React18__namespace.memo(function IndeterminateSvg2({
     }
   );
 });
-var DeterminateSvg = React18__namespace.memo(function DeterminateSvg2({
+var DeterminateSvg = React23__namespace.memo(function DeterminateSvg2({
   size,
   progress
 }) {
@@ -442,7 +1705,7 @@ var DeterminateSvg = React18__namespace.memo(function DeterminateSvg2({
     }
   );
 });
-var LoadingIndicator = React18__namespace.forwardRef(
+var LoadingIndicator = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       variant = "uncontained",
@@ -510,7 +1773,7 @@ LoadingIndicator.displayName = "LoadingIndicator";
 function easeInOutCubic(x) {
   return x < 0.5 ? 4 * x * x * x : 1 - (-2 * x + 2) ** 3 / 2;
 }
-function generateWavyCircularPath(center, radius, amplitude, wavelength) {
+function generateWavyCircularPath(center, radius, amplitude, wavelength, phase = 0) {
   const circumference = 2 * Math.PI * radius;
   const numWaves = Math.max(
     3,
@@ -518,8 +1781,8 @@ function generateWavyCircularPath(center, radius, amplitude, wavelength) {
   );
   const steps = numWaves * 4;
   const dt = 2 * Math.PI / steps;
-  const rAt = (t) => radius + amplitude * Math.sin(numWaves * t);
-  const drAt = (t) => amplitude * numWaves * Math.cos(numWaves * t);
+  const rAt = (t) => radius + amplitude * Math.sin(numWaves * t + phase);
+  const drAt = (t) => amplitude * numWaves * Math.cos(numWaves * t + phase);
   const xAt = (t) => center + rAt(t) * Math.cos(t);
   const yAt = (t) => center + rAt(t) * Math.sin(t);
   const dxAt = (t) => drAt(t) * Math.cos(t) - rAt(t) * Math.sin(t);
@@ -577,22 +1840,25 @@ var ADDITIONAL_ROTATION_EASE_DURATION = 500;
 var DEFAULT_MIN_PROGRESS = 0.1;
 var DEFAULT_MAX_PROGRESS = 0.8;
 var PROGRESS_CYCLE_DURATION = 1500;
-var CircularProgress = React18__namespace.forwardRef(
+var CircularProgress = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       value,
       size = 48,
       trackHeight = 4,
       shape = "flat",
+      trackShape = "flat",
       amplitude,
       wavelength,
       gapSize = 4,
+      waveSpeed = 1,
       crawlerSpeed = 1,
       color,
       trackColor,
       showTrack = "auto",
       minProgress = DEFAULT_MIN_PROGRESS,
       maxProgress = DEFAULT_MAX_PROGRESS,
+      determinateAnimation = "md3",
       amplitudeRange,
       className,
       "aria-label": ariaLabel
@@ -601,15 +1867,18 @@ var CircularProgress = React18__namespace.forwardRef(
       "size",
       "trackHeight",
       "shape",
+      "trackShape",
       "amplitude",
       "wavelength",
       "gapSize",
+      "waveSpeed",
       "crawlerSpeed",
       "color",
       "trackColor",
       "showTrack",
       "minProgress",
       "maxProgress",
+      "determinateAnimation",
       "amplitudeRange",
       "className",
       "aria-label"
@@ -622,21 +1891,22 @@ var CircularProgress = React18__namespace.forwardRef(
     const bgTrackColor = trackColor || "var(--md-sys-color-indicator-track)";
     const isWavy = shape === "wavy";
     const shouldShowIndeterminateTrack = showTrack === "auto" ? isWavy : showTrack;
+    const shouldShowDeterminateTrack = showTrack === "auto" ? true : showTrack;
     const BASELINE_SIZE = 48;
     const scaleFactor = size / BASELINE_SIZE;
-    const effectiveAmplitude = React18__namespace.useMemo(
+    const effectiveAmplitude = React23__namespace.useMemo(
       () => amplitude != null ? amplitude : 1.6 * scaleFactor,
       [amplitude, scaleFactor]
     );
-    const effectiveWavelength = React18__namespace.useMemo(
+    const effectiveWavelength = React23__namespace.useMemo(
       () => wavelength != null ? wavelength : 15 * scaleFactor,
       [wavelength, scaleFactor]
     );
-    const resolvedAmplitudeRange = React18__namespace.useMemo(
+    const resolvedAmplitudeRange = React23__namespace.useMemo(
       () => amplitudeRange != null ? amplitudeRange : [0, effectiveAmplitude],
       [amplitudeRange, effectiveAmplitude]
     );
-    const wavyActivePath = React18__namespace.useMemo(
+    const wavyActivePath = React23__namespace.useMemo(
       () => isWavy ? generateWavyCircularPath(
         center,
         radius,
@@ -645,8 +1915,8 @@ var CircularProgress = React18__namespace.forwardRef(
       ) : null,
       [isWavy, center, radius, effectiveAmplitude, effectiveWavelength]
     );
-    const circumference = React18__namespace.useMemo(() => 2 * Math.PI * radius, [radius]);
-    const gapForTrack = React18__namespace.useMemo(
+    const circumference = React23__namespace.useMemo(() => 2 * Math.PI * radius, [radius]);
+    const gapForTrack = React23__namespace.useMemo(
       () => (gapSize + trackHeight) / circumference,
       [gapSize, trackHeight, circumference]
     );
@@ -654,19 +1924,50 @@ var CircularProgress = React18__namespace.forwardRef(
     const trackOffset = isDeterminate ? activeAngularFraction + gapForTrack : 0;
     const trackLength = isDeterminate ? Math.max(1e-3, 1 - activeAngularFraction - 2 * gapForTrack) : 1;
     const ActiveCircleElem = react.m.circle;
-    const ActivePathElem = react.m.path;
-    const indeterminateSvgRef = React18__namespace.useRef(null);
-    const indeterminateTrackRef = React18__namespace.useRef(null);
-    const indeterminateActiveRef = React18__namespace.useRef(null);
-    const indeterminateWavyTrackPathRef = React18__namespace.useRef(null);
-    const indeterminateWavyActivePathRef = React18__namespace.useRef(null);
-    const cachedPathLengthRef = React18__namespace.useRef(0);
-    React18__namespace.useLayoutEffect(() => {
+    const indeterminateSvgRef = React23__namespace.useRef(null);
+    const indeterminateTrackRef = React23__namespace.useRef(null);
+    const indeterminateActiveRef = React23__namespace.useRef(null);
+    const indeterminateWavyTrackPathRef = React23__namespace.useRef(null);
+    const indeterminateWavyActivePathRef = React23__namespace.useRef(null);
+    const determinateWavyActivePathRef = React23__namespace.useRef(null);
+    const determinateWavyTrackPathRef = React23__namespace.useRef(null);
+    const cachedPathLengthRef = React23__namespace.useRef(0);
+    const fractionMV = react.useMotionValue(isDeterminate ? clampedValue / 100 : 0);
+    const amplitudeMV = react.useMotionValue(isWavy ? effectiveAmplitude : 0);
+    React23__namespace.useEffect(() => {
+      if (isDeterminate) {
+        react.animate(fractionMV, clampedValue / 100, {
+          duration: 0.4,
+          ease: [0.2, 0, 0, 1]
+        });
+      }
+    }, [clampedValue, isDeterminate, fractionMV]);
+    React23__namespace.useEffect(() => {
+      if (!isDeterminate || !isWavy) return;
+      const fraction = clampedValue / 100;
+      let targetAmp = effectiveAmplitude;
+      if (determinateAnimation === "md3") {
+        targetAmp = fraction <= 0.1 || fraction >= 0.95 ? 0 : effectiveAmplitude;
+      }
+      react.animate(amplitudeMV, targetAmp, {
+        type: "spring",
+        bounce: 0,
+        duration: 0.5
+      });
+    }, [
+      clampedValue,
+      isDeterminate,
+      isWavy,
+      effectiveAmplitude,
+      amplitudeMV,
+      determinateAnimation
+    ]);
+    React23__namespace.useLayoutEffect(() => {
       if (!isWavy || !wavyActivePath) {
         cachedPathLengthRef.current = circumference;
         return;
       }
-      const el = indeterminateActiveRef.current;
+      const el = indeterminateActiveRef.current || determinateWavyActivePathRef.current;
       if (el && "getTotalLength" in el) {
         try {
           const len = el.getTotalLength();
@@ -680,7 +1981,65 @@ var CircularProgress = React18__namespace.forwardRef(
       cachedPathLengthRef.current = circumference;
     }, [isWavy, circumference, wavyActivePath]);
     react.useAnimationFrame((time) => {
-      if (isDeterminate) return;
+      const safeWaveSpeed = Math.max(0.1, waveSpeed);
+      const wavePhase = time / 1e3 * safeWaveSpeed * 2 * Math.PI;
+      if (isDeterminate) {
+        if (isWavy) {
+          const currentAmp = amplitudeMV.get();
+          const dynamicPath = generateWavyCircularPath(
+            center,
+            radius,
+            currentAmp,
+            effectiveWavelength,
+            wavePhase
+          );
+          if (determinateWavyActivePathRef.current) {
+            determinateWavyActivePathRef.current.setAttribute("d", dynamicPath);
+          }
+          if (trackShape === "wavy" && determinateWavyTrackPathRef.current) {
+            determinateWavyTrackPathRef.current.setAttribute("d", dynamicPath);
+          }
+          const pathEl = determinateWavyActivePathRef.current;
+          let totalLen = cachedPathLengthRef.current || circumference;
+          if (pathEl) {
+            try {
+              const len = pathEl.getTotalLength();
+              if (len > 0) totalLen = len;
+            } catch (e) {
+            }
+          }
+          const activeFrac = Math.max(0, Math.min(1, fractionMV.get()));
+          const activeLen = totalLen * activeFrac;
+          if (determinateWavyActivePathRef.current) {
+            determinateWavyActivePathRef.current.setAttribute(
+              "stroke-dasharray",
+              `${activeLen} ${totalLen}`
+            );
+            determinateWavyActivePathRef.current.setAttribute(
+              "stroke-dashoffset",
+              "0"
+            );
+          }
+          if (shouldShowDeterminateTrack && trackShape === "wavy" && determinateWavyTrackPathRef.current) {
+            const gapFrac = (gapSize + trackHeight) / totalLen;
+            const trackStartFrac = activeFrac + gapFrac;
+            const trackLen = Math.max(
+              1e-3,
+              totalLen * (1 - activeFrac - 2 * gapFrac)
+            );
+            const trackOff = -totalLen * trackStartFrac;
+            determinateWavyTrackPathRef.current.setAttribute(
+              "stroke-dasharray",
+              `${trackLen} ${totalLen}`
+            );
+            determinateWavyTrackPathRef.current.setAttribute(
+              "stroke-dashoffset",
+              `${trackOff}`
+            );
+          }
+        }
+        return;
+      }
       const safeCrawlerSpeed = Math.max(0.1, crawlerSpeed);
       const scaledTime = time * safeCrawlerSpeed;
       const globalCycle = scaledTime % GLOBAL_ROTATION_DURATION;
@@ -715,7 +2074,8 @@ var CircularProgress = React18__namespace.forwardRef(
           center,
           radius,
           currentAmplitude,
-          effectiveWavelength
+          effectiveWavelength,
+          wavePhase
         );
         if (indeterminateWavyActivePathRef.current) {
           indeterminateWavyActivePathRef.current.setAttribute("d", dynamicPath);
@@ -810,7 +2170,7 @@ var CircularProgress = React18__namespace.forwardRef(
         style: { width: size, height: size }
       }, restProps), {
         children: /* @__PURE__ */ jsxRuntime.jsxs(react.LazyMotion, { features: react.domMax, strict: true, children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(
+          /* @__PURE__ */ jsxRuntime.jsx(
             "svg",
             {
               width: size,
@@ -818,8 +2178,18 @@ var CircularProgress = React18__namespace.forwardRef(
               viewBox: `0 0 ${size} ${size}`,
               "aria-hidden": "true",
               style: { transform: "rotate(-90deg)", overflow: "visible" },
-              children: [
-                isDeterminate ? /* @__PURE__ */ jsxRuntime.jsx(
+              children: isDeterminate ? isWavy ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                shouldShowDeterminateTrack && (trackShape === "wavy" ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "path",
+                  {
+                    ref: determinateWavyTrackPathRef,
+                    d: wavyActivePath != null ? wavyActivePath : "",
+                    fill: "none",
+                    stroke: bgTrackColor,
+                    strokeWidth: trackHeight,
+                    strokeLinecap: "round"
+                  }
+                ) : /* @__PURE__ */ jsxRuntime.jsx(
                   react.m.circle,
                   {
                     cx: center,
@@ -828,28 +2198,52 @@ var CircularProgress = React18__namespace.forwardRef(
                     fill: "none",
                     stroke: bgTrackColor,
                     strokeWidth: trackHeight,
-                    initial: { pathLength: trackLength, pathOffset: trackOffset },
-                    animate: { pathLength: trackLength, pathOffset: trackOffset },
+                    initial: {
+                      pathLength: trackLength,
+                      pathOffset: trackOffset
+                    },
+                    animate: {
+                      pathLength: trackLength,
+                      pathOffset: trackOffset
+                    },
                     transition: { duration: 0.4, ease: [0.2, 0, 0, 1] },
                     strokeLinecap: "round"
                   }
-                ) : null,
-                isDeterminate && (isWavy ? /* @__PURE__ */ jsxRuntime.jsx(
-                  ActivePathElem,
+                )),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "path",
                   {
+                    ref: determinateWavyActivePathRef,
                     d: wavyActivePath != null ? wavyActivePath : "",
                     fill: "none",
                     stroke: activeColor,
                     strokeWidth: trackHeight,
-                    strokeLinecap: "round",
-                    initial: { pathLength: 0 },
-                    animate: { pathLength: clampedValue / 100 },
-                    transition: {
-                      duration: 0.4,
-                      ease: [0.2, 0, 0, 1]
-                    }
+                    strokeLinecap: "round"
                   }
-                ) : /* @__PURE__ */ jsxRuntime.jsx(
+                )
+              ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  react.m.circle,
+                  {
+                    cx: center,
+                    cy: center,
+                    r: radius,
+                    fill: "none",
+                    stroke: bgTrackColor,
+                    strokeWidth: trackHeight,
+                    initial: {
+                      pathLength: trackLength,
+                      pathOffset: trackOffset
+                    },
+                    animate: {
+                      pathLength: trackLength,
+                      pathOffset: trackOffset
+                    },
+                    transition: { duration: 0.4, ease: [0.2, 0, 0, 1] },
+                    strokeLinecap: "round"
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(
                   ActiveCircleElem,
                   {
                     cx: center,
@@ -866,8 +2260,8 @@ var CircularProgress = React18__namespace.forwardRef(
                       ease: [0.2, 0, 0, 1]
                     }
                   }
-                ))
-              ]
+                )
+              ] }) : null
             }
           ),
           !isDeterminate && /* @__PURE__ */ jsxRuntime.jsx(
@@ -945,9 +2339,9 @@ var CircularProgress = React18__namespace.forwardRef(
 );
 CircularProgress.displayName = "CircularProgress";
 function useContainerWidth() {
-  const [width, setWidth] = React18__namespace.useState(0);
-  const observerRef = React18__namespace.useRef(null);
-  const ref = React18__namespace.useCallback((node) => {
+  const [width, setWidth] = React23__namespace.useState(0);
+  const observerRef = React23__namespace.useRef(null);
+  const ref = React23__namespace.useCallback((node) => {
     if (observerRef.current) {
       observerRef.current.disconnect();
       observerRef.current = null;
@@ -961,7 +2355,7 @@ function useContainerWidth() {
       observerRef.current = obs;
     }
   }, []);
-  React18__namespace.useEffect(() => {
+  React23__namespace.useEffect(() => {
     return () => {
       if (observerRef.current) {
         observerRef.current.disconnect();
@@ -971,7 +2365,7 @@ function useContainerWidth() {
   return [ref, width];
 }
 function useMergedRef(...refs) {
-  return React18__namespace.useCallback(
+  return React23__namespace.useCallback(
     (node) => {
       for (const ref of refs) {
         if (typeof ref === "function") {
@@ -985,7 +2379,7 @@ function useMergedRef(...refs) {
     [refs]
   );
 }
-var FlatLinearTrack = React18__namespace.memo(function FlatLinearTrack2({
+var FlatLinearTrack = React23__namespace.memo(function FlatLinearTrack2({
   trackHeight,
   activeColor,
   trackColor,
@@ -1061,7 +2455,7 @@ var FlatLinearTrack = React18__namespace.memo(function FlatLinearTrack2({
     }
   );
 });
-var WavyLinearTrack = React18__namespace.memo(function WavyLinearTrack2({
+var WavyLinearTrack = React23__namespace.memo(function WavyLinearTrack2({
   trackHeight,
   svgHeight,
   amplitude,
@@ -1080,13 +2474,13 @@ var WavyLinearTrack = React18__namespace.memo(function WavyLinearTrack2({
 }) {
   const isDeterminate = typeof value === "number";
   const clampedValue = isDeterminate ? Math.max(0, Math.min(100, value)) : 100;
-  const titleId = React18__namespace.useId();
+  const titleId = React23__namespace.useId();
   const [containerRef, width] = useContainerWidth();
-  const activePathRef = React18__namespace.useRef(null);
-  const trackPathRef = React18__namespace.useRef(null);
+  const activePathRef = React23__namespace.useRef(null);
+  const trackPathRef = React23__namespace.useRef(null);
   const amplitudeMV = react.useMotionValue(amplitude);
   const fractionMV = react.useMotionValue(isDeterminate ? clampedValue / 100 : 1);
-  React18__namespace.useEffect(() => {
+  React23__namespace.useEffect(() => {
     if (isDeterminate) {
       const fraction = clampedValue / 100;
       let targetAmp = amplitude;
@@ -1274,7 +2668,7 @@ var WavyLinearTrack = React18__namespace.memo(function WavyLinearTrack2({
     }
   );
 });
-var LinearProgress = React18__namespace.forwardRef(
+var LinearProgress = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       value,
@@ -1315,10 +2709,10 @@ var LinearProgress = React18__namespace.forwardRef(
     ]);
     const isDeterminate = value !== void 0;
     const clampedValue = isDeterminate ? Math.min(100, Math.max(0, value)) : 0;
-    const containerRef = React18__namespace.useRef(null);
+    const containerRef = React23__namespace.useRef(null);
     const mergedRef = useMergedRef(ref, containerRef);
-    const [isRtl, setIsRtl] = React18__namespace.useState(false);
-    React18__namespace.useEffect(() => {
+    const [isRtl, setIsRtl] = React23__namespace.useState(false);
+    React23__namespace.useEffect(() => {
       if (containerRef.current) {
         const dir = getComputedStyle(containerRef.current).direction;
         setIsRtl(dir === "rtl");
@@ -1326,16 +2720,16 @@ var LinearProgress = React18__namespace.forwardRef(
     }, []);
     const resolvedTrackShape = trackShape != null ? trackShape : shape;
     const isWavy = shape === "wavy" || resolvedTrackShape === "wavy";
-    const effectiveAmplitude = React18__namespace.useMemo(() => amplitude != null ? amplitude : 3, [amplitude]);
-    const svgHeight = React18__namespace.useMemo(
+    const effectiveAmplitude = React23__namespace.useMemo(() => amplitude != null ? amplitude : 3, [amplitude]);
+    const svgHeight = React23__namespace.useMemo(
       () => isWavy ? trackHeight + effectiveAmplitude * 2 : trackHeight,
       [isWavy, trackHeight, effectiveAmplitude]
     );
-    const shouldShowStop = React18__namespace.useMemo(
+    const shouldShowStop = React23__namespace.useMemo(
       () => isDeterminate && resolvedTrackShape === "flat" && showStopIndicator !== false,
       [isDeterminate, resolvedTrackShape, showStopIndicator]
     );
-    const stopSize = React18__namespace.useMemo(
+    const stopSize = React23__namespace.useMemo(
       () => Math.max(2, trackHeight > 4 ? 4 : trackHeight / 2),
       [trackHeight]
     );
@@ -1410,7 +2804,7 @@ var LinearProgress = React18__namespace.forwardRef(
   }
 );
 LinearProgress.displayName = "LinearProgress";
-var ProgressIndicator = React18__namespace.forwardRef((props, ref) => {
+var ProgressIndicator = React23__namespace.forwardRef((props, ref) => {
   if (props.variant === "circular") {
     return /* @__PURE__ */ jsxRuntime.jsx(CircularProgress, __spreadValues({ ref }, props));
   }
@@ -1664,7 +3058,7 @@ function AnimatedIconSlot({
     }
   );
 }
-var ButtonComponent = React18__namespace.forwardRef(
+var ButtonComponent = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       className,
@@ -1730,9 +3124,9 @@ var ButtonComponent = React18__namespace.forwardRef(
       borderWidth: outlineWidth != null ? outlineWidth : colorStyle === "outlined" ? sizeTokens.outlineWidth : 0,
       borderStyle: colorStyle === "outlined" ? "solid" : void 0
     }, style);
-    const labelText = React18__namespace.useMemo(() => {
+    const labelText = React23__namespace.useMemo(() => {
       if (asChild) {
-        const child = React18__namespace.Children.only(children);
+        const child = React23__namespace.Children.only(children);
         return child.props.children;
       }
       return children;
@@ -1740,8 +3134,8 @@ var ButtonComponent = React18__namespace.forwardRef(
     const computedAriaLabel = ariaLabelProp || (typeof children === "string" ? children : void 0);
     const needsTouchTarget = size === "xs" || size === "sm";
     const motionRadius = react.useMotionValue(animateRadius);
-    const asChildRef = React18__namespace.useRef(null);
-    const mergedRef = React18__namespace.useCallback(
+    const asChildRef = React23__namespace.useRef(null);
+    const mergedRef = React23__namespace.useCallback(
       (node) => {
         asChildRef.current = node;
         if (typeof ref === "function") ref(node);
@@ -1750,14 +3144,14 @@ var ButtonComponent = React18__namespace.forwardRef(
       },
       [ref]
     );
-    React18__namespace.useEffect(() => {
+    React23__namespace.useEffect(() => {
       if (!asChild) return;
       return motionRadius.on("change", (v) => {
         if (asChildRef.current)
           asChildRef.current.style.borderRadius = `${v}px`;
       });
     }, [motionRadius, asChild]);
-    React18__namespace.useEffect(() => {
+    React23__namespace.useEffect(() => {
       if (!asChild) return;
       const controls = springAnimate(motionRadius, animateRadius);
       return () => controls.stop();
@@ -1765,14 +3159,14 @@ var ButtonComponent = React18__namespace.forwardRef(
     const { ripples, onPointerDown, removeRipple } = useRippleState({
       disabled: loading
     });
-    const handleClick = React18__namespace.useCallback(
+    const handleClick = React23__namespace.useCallback(
       (e) => {
         if (loading) return e.preventDefault();
         onClick == null ? void 0 : onClick(e);
       },
       [loading, onClick]
     );
-    const handleKeyDown = React18__namespace.useCallback(
+    const handleKeyDown = React23__namespace.useCallback(
       (e) => {
         if (loading) return;
         if (onClick && (e.key === "Enter" || e.key === " ")) {
@@ -1851,17 +3245,17 @@ var ButtonComponent = React18__namespace.forwardRef(
         isSelected && selectedIcon ? "selected-icon" : "icon"
       ) })
     ] });
-    const handleAsChildPointerDown = React18__namespace.useCallback(
+    const handleAsChildPointerDown = React23__namespace.useCallback(
       (e) => {
         springAnimate(motionRadius, pressedRadius);
         onPointerDown == null ? void 0 : onPointerDown(e);
       },
       [motionRadius, pressedRadius, onPointerDown]
     );
-    const handleAsChildPointerUp = React18__namespace.useCallback(() => {
+    const handleAsChildPointerUp = React23__namespace.useCallback(() => {
       springAnimate(motionRadius, animateRadius);
     }, [motionRadius, animateRadius]);
-    const handlePointerDown = React18__namespace.useCallback(
+    const handlePointerDown = React23__namespace.useCallback(
       (e) => {
         onPointerDown(e);
       },
@@ -1871,7 +3265,7 @@ var ButtonComponent = React18__namespace.forwardRef(
       const strippedProps = __spreadValues({}, restProps);
       for (const key of MOTION_PROP_KEYS) delete strippedProps[key];
       const htmlProps = strippedProps;
-      const child = React18__namespace.Children.only(children);
+      const child = React23__namespace.Children.only(children);
       return /* @__PURE__ */ jsxRuntime.jsx(react.LazyMotion, { features: react.domMax, strict: true, children: /* @__PURE__ */ jsxRuntime.jsx(
         reactSlot.Slot,
         __spreadProps(__spreadValues({
@@ -1888,7 +3282,7 @@ var ButtonComponent = React18__namespace.forwardRef(
           }),
           className: buttonClassName
         }, htmlProps), {
-          children: React18__namespace.cloneElement(child, { children: innerContent })
+          children: React23__namespace.cloneElement(child, { children: innerContent })
         })
       ) });
     }
@@ -1916,13 +3310,13 @@ var ButtonComponent = React18__namespace.forwardRef(
   }
 );
 ButtonComponent.displayName = "Button";
-var Button = React18__namespace.memo(ButtonComponent);
+var Button = React23__namespace.memo(ButtonComponent);
 var VARIANT_FONT = {
   outlined: "'Material Symbols Outlined'",
   rounded: "'Material Symbols Rounded'",
   sharp: "'Material Symbols Sharp'"
 };
-var IconComponent = React18__namespace.forwardRef(
+var IconComponent = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       name,
@@ -1988,8 +3382,8 @@ var IconComponent = React18__namespace.forwardRef(
   }
 );
 IconComponent.displayName = "Icon";
-var Icon = React18__namespace.memo(IconComponent);
-var ScrollArea = React18__namespace.forwardRef(
+var Icon = React23__namespace.memo(IconComponent);
+var ScrollArea = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       className,
@@ -2010,15 +3404,15 @@ var ScrollArea = React18__namespace.forwardRef(
       "viewportRef",
       "viewportProps"
     ]);
-    const [isTouchDevice, setIsTouchDevice] = React18__namespace.useState(false);
-    React18__namespace.useEffect(() => {
+    const [isTouchDevice, setIsTouchDevice] = React23__namespace.useState(false);
+    React23__namespace.useEffect(() => {
       if (typeof window !== "undefined") {
         setIsTouchDevice(
           "ontouchstart" in window || navigator.maxTouchPoints > 0
         );
       }
     }, []);
-    const resolvedType = React18__namespace.useMemo(() => {
+    const resolvedType = React23__namespace.useMemo(() => {
       if (type === "hover" && isTouchDevice) {
         return "scroll";
       }
@@ -2069,7 +3463,7 @@ var ScrollArea = React18__namespace.forwardRef(
   }
 );
 ScrollArea.displayName = "ScrollArea";
-var ScrollAreaScrollbar = React18__namespace.forwardRef((_a, ref) => {
+var ScrollAreaScrollbar = React23__namespace.forwardRef((_a, ref) => {
   var _b = _a, { className, orientation = "vertical" } = _b, props = __objRest(_b, ["className", "orientation"]);
   return /* @__PURE__ */ jsxRuntime.jsx(
     RadixScrollArea__namespace.Scrollbar,
@@ -2099,7 +3493,7 @@ var ScrollAreaScrollbar = React18__namespace.forwardRef((_a, ref) => {
   );
 });
 ScrollAreaScrollbar.displayName = RadixScrollArea__namespace.Scrollbar.displayName;
-var ScrollAreaCorner = React18__namespace.forwardRef((_a, ref) => {
+var ScrollAreaCorner = React23__namespace.forwardRef((_a, ref) => {
   var _b = _a, { className } = _b, props = __objRest(_b, ["className"]);
   return /* @__PURE__ */ jsxRuntime.jsx(
     RadixScrollArea__namespace.Corner,
@@ -2194,7 +3588,7 @@ function mapDomToReact(node, key) {
         props[propName] = attr.value;
       }
     }
-    return React18.createElement(
+    return React23.createElement(
       tagName,
       props,
       Array.from(el.childNodes).map((child, i) => mapDomToReact(child, i))
@@ -2203,8 +3597,8 @@ function mapDomToReact(node, key) {
   return null;
 }
 function CodeContent({ html, code }) {
-  const [parsedContent, setParsedContent] = React18.useState(null);
-  React18.useEffect(() => {
+  const [parsedContent, setParsedContent] = React23.useState(null);
+  React23.useEffect(() => {
     if (html) {
       const parser = new DOMParser();
       const doc = parser.parseFromString(html, "text/html");
@@ -2234,8 +3628,8 @@ function CodeBlock({
   className,
   html
 }) {
-  const [copied, setCopied] = React18.useState(false);
-  const handleCopy = React18.useCallback(async () => {
+  const [copied, setCopied] = React23.useState(false);
+  const handleCopy = React23.useCallback(async () => {
     try {
       await navigator.clipboard.writeText(code);
       setCopied(true);
@@ -2295,7 +3689,7 @@ function buildWavePath(startX, endX, amplitude = 2, wavelength = 32, yCenter = 4
   }
   return d;
 }
-var DividerImpl = React18__namespace.forwardRef(
+var DividerImpl = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       variant = "full-bleed",
@@ -2304,7 +3698,7 @@ var DividerImpl = React18__namespace.forwardRef(
       insetStart = "standard",
       waveConfig,
       decorative = false,
-      animate: animate3 = true,
+      animate: animate4 = true,
       className,
       style
     } = _b, props = __objRest(_b, [
@@ -2320,7 +3714,7 @@ var DividerImpl = React18__namespace.forwardRef(
     ]);
     var _a2, _b2, _c;
     const reducedMotion = react.useReducedMotion();
-    const shouldAnimate = animate3 && !reducedMotion;
+    const shouldAnimate = animate4 && !reducedMotion;
     const effectiveShape = shape === "wavy" && orientation === "vertical" ? "flat" : shape;
     if (shape === "wavy" && orientation === "vertical") {
       console.warn(
@@ -2415,9 +3809,9 @@ var DividerImpl = React18__namespace.forwardRef(
   }
 );
 DividerImpl.displayName = "Divider";
-var Divider = React18__namespace.memo(DividerImpl);
-var ListContext = React18__namespace.createContext(null);
-var useListContext = () => React18__namespace.useContext(ListContext);
+var Divider = React23__namespace.memo(DividerImpl);
+var ListContext = React23__namespace.createContext(null);
+var useListContext = () => React23__namespace.useContext(ListContext);
 var LIST_TOKENS = {
   oneLineHeight: 56,
   twoLineHeight: 72,
@@ -2482,9 +3876,9 @@ function resolveItemId(item) {
   return String(item);
 }
 function isListItem(child) {
-  return React18__namespace.isValidElement(child) && child.props != null && typeof child.props === "object" && "value" in child.props;
+  return React23__namespace.isValidElement(child) && child.props != null && typeof child.props === "object" && "value" in child.props;
 }
-var ListImpl = React18__namespace.forwardRef(
+var ListImpl = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       className,
@@ -2515,12 +3909,12 @@ var ListImpl = React18__namespace.forwardRef(
       "innerRadius",
       "children"
     ]);
-    const listRef = React18__namespace.useRef(null);
-    const [draggedOrder, setDraggedOrder] = React18__namespace.useState(
+    const listRef = React23__namespace.useRef(null);
+    const [draggedOrder, setDraggedOrder] = React23__namespace.useState(
       null
     );
-    React18__namespace.useImperativeHandle(ref, () => listRef.current);
-    const [selectedState, setSelectedState] = React18__namespace.useState(
+    React23__namespace.useImperativeHandle(ref, () => listRef.current);
+    const [selectedState, setSelectedState] = React23__namespace.useState(
       () => {
         var _a2;
         const initialValue = (_a2 = value != null ? value : defaultValue) != null ? _a2 : [];
@@ -2530,13 +3924,13 @@ var ListImpl = React18__namespace.forwardRef(
       }
     );
     const isControlled = value !== void 0;
-    const selectedValues = React18__namespace.useMemo(() => {
+    const selectedValues = React23__namespace.useMemo(() => {
       if (isControlled) {
         return new Set(Array.isArray(value) ? value : value ? [value] : []);
       }
       return selectedState;
     }, [isControlled, value, selectedState]);
-    const onItemChange = React18__namespace.useCallback(
+    const onItemChange = React23__namespace.useCallback(
       (itemValue, selected) => {
         const nextSet = new Set(selectedValues);
         if (selectionMode === "single-select") {
@@ -2568,11 +3962,11 @@ var ListImpl = React18__namespace.forwardRef(
         coordinateGetter: sortable.sortableKeyboardCoordinates
       })
     );
-    const itemIds = React18__namespace.useMemo(
+    const itemIds = React23__namespace.useMemo(
       () => items ? items.map(resolveItemId) : [],
       [items]
     );
-    const currentOrder = React18__namespace.useMemo(
+    const currentOrder = React23__namespace.useMemo(
       () => draggedOrder || itemIds,
       [draggedOrder, itemIds]
     );
@@ -2632,20 +4026,20 @@ var ListImpl = React18__namespace.forwardRef(
       }
       (_a2 = focusableItems[nextIndex]) == null ? void 0 : _a2.focus();
     };
-    const childrenArray = React18__namespace.Children.toArray(children);
+    const childrenArray = React23__namespace.Children.toArray(children);
     const listItemCount = childrenArray.filter(isListItem).length;
     let currentListItemIndex = 0;
-    const processedChildren = React18__namespace.Children.map(children, (child) => {
+    const processedChildren = React23__namespace.Children.map(children, (child) => {
       if (!isListItem(child)) return child;
       const childValue = child.props.value;
       const index = reorderable && currentOrder.length > 0 ? currentOrder.indexOf(String(childValue)) : currentListItemIndex;
       currentListItemIndex++;
-      return React18__namespace.cloneElement(
+      return React23__namespace.cloneElement(
         child,
         { _listIndex: index }
       );
     });
-    const contextValue = React18__namespace.useMemo(
+    const contextValue = React23__namespace.useMemo(
       () => ({
         selectionMode,
         variant,
@@ -2669,7 +4063,7 @@ var ListImpl = React18__namespace.forwardRef(
         innerRadius
       ]
     );
-    const dndId = React18__namespace.useId();
+    const dndId = React23__namespace.useId();
     const isListbox = selectionMode === "single-select" || selectionMode === "multi-select";
     const role = isListbox ? "listbox" : "list";
     const ariaMultiselectable = selectionMode === "multi-select" ? true : void 0;
@@ -2716,13 +4110,13 @@ var ListImpl = React18__namespace.forwardRef(
   }
 );
 ListImpl.displayName = "List";
-var List = React18__namespace.memo(ListImpl);
+var List = React23__namespace.memo(ListImpl);
 var INSET_CLASSES = {
   icon: "pl-[56px]",
   avatar: "pl-[72px]",
   custom: "pl-4"
 };
-var ListDividerImpl = React18__namespace.forwardRef(
+var ListDividerImpl = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, { className, inset = false, insetType = "avatar" } = _b, props = __objRest(_b, ["className", "inset", "insetType"]);
     const insetClass = inset ? INSET_CLASSES[insetType] : "";
@@ -2747,7 +4141,7 @@ var ListDividerImpl = React18__namespace.forwardRef(
   }
 );
 ListDividerImpl.displayName = "ListDivider";
-var ListDivider = React18__namespace.memo(ListDividerImpl);
+var ListDivider = React23__namespace.memo(ListDividerImpl);
 var MD3_STANDARD = [0.2, 0, 0, 1];
 var MD3_FAST_EFFECTS = [0.3, 0, 1, 1];
 var CHECKMARK_PATH = "M 4.5 9.5 L 7.5 12.5 L 13.5 5.5";
@@ -2761,7 +4155,7 @@ var NEXT_STATE = {
   checked: "indeterminate",
   indeterminate: "unchecked"
 };
-var CheckboxVisual = React18__namespace.memo(function CheckboxVisual2({
+var CheckboxVisual = React23__namespace.memo(function CheckboxVisual2({
   isSelected,
   isIndeterminate,
   containerBg,
@@ -2832,7 +4226,7 @@ var CheckboxVisual = React18__namespace.memo(function CheckboxVisual2({
   );
 });
 function useMergedRef2(externalRef, internalRef) {
-  return React18__namespace.useCallback(
+  return React23__namespace.useCallback(
     (node) => {
       internalRef.current = node;
       if (!externalRef) return;
@@ -2845,7 +4239,7 @@ function useMergedRef2(externalRef, internalRef) {
     [externalRef, internalRef]
   );
 }
-var CheckboxComponent = React18__namespace.forwardRef(
+var CheckboxComponent = React23__namespace.forwardRef(
   ({
     checked,
     defaultChecked = false,
@@ -2867,20 +4261,20 @@ var CheckboxComponent = React18__namespace.forwardRef(
   }, ref) => {
     var _a;
     const prefersReduced = (_a = react.useReducedMotion()) != null ? _a : false;
-    const generatedId = React18__namespace.useId();
+    const generatedId = React23__namespace.useId();
     const inputId = idProp != null ? idProp : label ? `checkbox-${generatedId}` : void 0;
-    const [internalState, setInternalState] = React18__namespace.useState(
+    const [internalState, setInternalState] = React23__namespace.useState(
       () => defaultChecked ? "checked" : "unchecked"
     );
     const isControlled = stateProp !== void 0 || checked !== void 0;
     const baseState = isControlled ? resolveState(checked, false, stateProp) : internalState;
     const effectiveState = indeterminate ? "indeterminate" : baseState;
-    const [ripples, setRipples] = React18__namespace.useState([]);
-    const removeRipple = React18__namespace.useCallback(
+    const [ripples, setRipples] = React23__namespace.useState([]);
+    const removeRipple = React23__namespace.useCallback(
       (id) => setRipples((prev) => prev.filter((r) => r.id !== id)),
       []
     );
-    const onPointerDown = React18__namespace.useCallback(
+    const onPointerDown = React23__namespace.useCallback(
       (e) => {
         if (disabled) return;
         const rect = e.currentTarget.getBoundingClientRect();
@@ -2894,7 +4288,7 @@ var CheckboxComponent = React18__namespace.forwardRef(
       },
       [disabled]
     );
-    const handleChange = React18__namespace.useCallback(
+    const handleChange = React23__namespace.useCallback(
       (e) => {
         if (disabled) return;
         if (stateProp !== void 0) {
@@ -2920,9 +4314,9 @@ var CheckboxComponent = React18__namespace.forwardRef(
         onCheckedChange
       ]
     );
-    const inputRef = React18__namespace.useRef(null);
+    const inputRef = React23__namespace.useRef(null);
     const mergedRef = useMergedRef2(ref, inputRef);
-    React18__namespace.useEffect(() => {
+    React23__namespace.useEffect(() => {
       if (inputRef.current) {
         inputRef.current.indeterminate = effectiveState === "indeterminate";
       }
@@ -3047,19 +4441,19 @@ var CheckboxComponent = React18__namespace.forwardRef(
   }
 );
 CheckboxComponent.displayName = "Checkbox";
-var Checkbox = React18__namespace.memo(CheckboxComponent);
-var TriStateCheckboxComponent = React18__namespace.forwardRef((_a, ref) => {
+var Checkbox = React23__namespace.memo(CheckboxComponent);
+var TriStateCheckboxComponent = React23__namespace.forwardRef((_a, ref) => {
   var _b = _a, { state, onStateChange } = _b, rest = __objRest(_b, ["state", "onStateChange"]);
   return /* @__PURE__ */ jsxRuntime.jsx(Checkbox, __spreadValues({ ref, state, onStateChange }, rest));
 });
 TriStateCheckboxComponent.displayName = "TriStateCheckbox";
-React18__namespace.memo(TriStateCheckboxComponent);
+React23__namespace.memo(TriStateCheckboxComponent);
 var MD3_FAST_EFFECTS2 = [0.3, 0, 1, 1];
-var RadioGroupContext = React18__namespace.createContext(
+var RadioGroupContext = React23__namespace.createContext(
   null
 );
 function useMergedRef3(externalRef, internalRef) {
-  return React18__namespace.useCallback(
+  return React23__namespace.useCallback(
     (node) => {
       internalRef.current = node;
       if (!externalRef) return;
@@ -3072,7 +4466,7 @@ function useMergedRef3(externalRef, internalRef) {
     [externalRef, internalRef]
   );
 }
-var RadioVisual = React18__namespace.memo(function RadioVisual2({
+var RadioVisual = React23__namespace.memo(function RadioVisual2({
   isSelected,
   disabled,
   error,
@@ -3125,7 +4519,7 @@ var RadioVisual = React18__namespace.memo(function RadioVisual2({
     }
   );
 });
-var RadioButtonComponent = React18__namespace.forwardRef(
+var RadioButtonComponent = React23__namespace.forwardRef(
   ({
     selected,
     defaultSelected = false,
@@ -3144,23 +4538,23 @@ var RadioButtonComponent = React18__namespace.forwardRef(
     required: requiredProp
   }, ref) => {
     var _a, _b;
-    const group = React18__namespace.useContext(RadioGroupContext);
+    const group = React23__namespace.useContext(RadioGroupContext);
     const prefersReduced = (_a = react.useReducedMotion()) != null ? _a : false;
-    const generatedId = React18__namespace.useId();
+    const generatedId = React23__namespace.useId();
     const inputId = idProp != null ? idProp : label ? `radio-${generatedId}` : void 0;
     const name = (_b = group == null ? void 0 : group.name) != null ? _b : nameProp;
     const disabled = (group == null ? void 0 : group.disabled) || disabledProp;
     const error = (group == null ? void 0 : group.error) || errorProp || color === "error";
     const required = (group == null ? void 0 : group.required) || requiredProp;
-    const [internalSelected, setInternalSelected] = React18__namespace.useState(defaultSelected);
+    const [internalSelected, setInternalSelected] = React23__namespace.useState(defaultSelected);
     const isControlled = selected !== void 0;
     const isSelected = group ? group.selectedValue === value : isControlled ? selected != null ? selected : false : internalSelected;
-    const [ripples, setRipples] = React18__namespace.useState([]);
-    const removeRipple = React18__namespace.useCallback(
+    const [ripples, setRipples] = React23__namespace.useState([]);
+    const removeRipple = React23__namespace.useCallback(
       (id) => setRipples((prev) => prev.filter((r) => r.id !== id)),
       []
     );
-    const onPointerDown = React18__namespace.useCallback(
+    const onPointerDown = React23__namespace.useCallback(
       (e) => {
         if (disabled) return;
         const rect = e.currentTarget.getBoundingClientRect();
@@ -3174,12 +4568,12 @@ var RadioButtonComponent = React18__namespace.forwardRef(
       },
       [disabled]
     );
-    const [isHovered, setIsHovered] = React18__namespace.useState(false);
-    const onPointerEnter = React18__namespace.useCallback(() => {
+    const [isHovered, setIsHovered] = React23__namespace.useState(false);
+    const onPointerEnter = React23__namespace.useCallback(() => {
       if (!disabled) setIsHovered(true);
     }, [disabled]);
-    const onPointerLeave = React18__namespace.useCallback(() => setIsHovered(false), []);
-    const handleChange = React18__namespace.useCallback(
+    const onPointerLeave = React23__namespace.useCallback(() => setIsHovered(false), []);
+    const handleChange = React23__namespace.useCallback(
       (_e) => {
         if (disabled || onClick === null) return;
         if (group) {
@@ -3193,7 +4587,7 @@ var RadioButtonComponent = React18__namespace.forwardRef(
       },
       [disabled, onClick, group, value, isControlled]
     );
-    const inputRef = React18__namespace.useRef(null);
+    const inputRef = React23__namespace.useRef(null);
     const mergedRef = useMergedRef3(ref, inputRef);
     const stateLayerBg = error ? "before:bg-m3-error" : "before:bg-m3-primary";
     const stateLayerClass = cn(
@@ -3304,8 +4698,8 @@ var RadioButtonComponent = React18__namespace.forwardRef(
   }
 );
 RadioButtonComponent.displayName = "RadioButton";
-var RadioButton = React18__namespace.memo(RadioButtonComponent);
-var RadioGroupComponent = React18__namespace.forwardRef(
+var RadioButton = React23__namespace.memo(RadioButtonComponent);
+var RadioGroupComponent = React23__namespace.forwardRef(
   ({
     name,
     value: valueProp,
@@ -3320,19 +4714,19 @@ var RadioGroupComponent = React18__namespace.forwardRef(
     children,
     className
   }, ref) => {
-    const [internalValue, setInternalValue] = React18__namespace.useState(defaultValue);
+    const [internalValue, setInternalValue] = React23__namespace.useState(defaultValue);
     const isControlled = valueProp !== void 0;
     const selectedValue = isControlled ? valueProp : internalValue;
-    const handleValueChange = React18__namespace.useCallback(
+    const handleValueChange = React23__namespace.useCallback(
       (val) => {
         if (!isControlled) setInternalValue(val);
         onValueChange == null ? void 0 : onValueChange(val);
       },
       [isControlled, onValueChange]
     );
-    const groupRef = React18__namespace.useRef(null);
+    const groupRef = React23__namespace.useRef(null);
     const mergedRef = useMergedRef3(ref, groupRef);
-    const onKeyDown = React18__namespace.useCallback(
+    const onKeyDown = React23__namespace.useCallback(
       (e) => {
         var _a, _b;
         if (disabled) return;
@@ -3356,7 +4750,7 @@ var RadioGroupComponent = React18__namespace.forwardRef(
       },
       [disabled, handleValueChange]
     );
-    const contextValue = React18__namespace.useMemo(
+    const contextValue = React23__namespace.useMemo(
       () => ({
         name,
         selectedValue,
@@ -3391,7 +4785,7 @@ var RadioGroupComponent = React18__namespace.forwardRef(
   }
 );
 RadioGroupComponent.displayName = "RadioGroup";
-React18__namespace.memo(RadioGroupComponent);
+React23__namespace.memo(RadioGroupComponent);
 
 // src/ui/switch/switch.tokens.ts
 var SwitchTokens = {
@@ -3469,7 +4863,7 @@ function isIconVisible(thumbContent, icons, showOnlySelectedIcon, checked) {
   if (icons) return true;
   return showOnlySelectedIcon && checked;
 }
-var SwitchVisual = React18__namespace.memo(function SwitchVisual2({
+var SwitchVisual = React23__namespace.memo(function SwitchVisual2({
   checked,
   disabled,
   isPressed,
@@ -3589,7 +4983,7 @@ var SwitchVisual = React18__namespace.memo(function SwitchVisual2({
     }
   );
 });
-var SwitchComponent = React18__namespace.forwardRef(
+var SwitchComponent = React23__namespace.forwardRef(
   ({
     checked,
     onCheckedChange,
@@ -3607,16 +5001,16 @@ var SwitchComponent = React18__namespace.forwardRef(
   }, ref) => {
     var _a;
     const prefersReduced = (_a = react.useReducedMotion()) != null ? _a : false;
-    const [isPressed, setIsPressed] = React18__namespace.useState(false);
-    const [isHovered, setIsHovered] = React18__namespace.useState(false);
-    const [isFocused, setIsFocused] = React18__namespace.useState(false);
-    const [ripples, setRipples] = React18__namespace.useState([]);
-    const generatedId = React18__namespace.useId();
+    const [isPressed, setIsPressed] = React23__namespace.useState(false);
+    const [isHovered, setIsHovered] = React23__namespace.useState(false);
+    const [isFocused, setIsFocused] = React23__namespace.useState(false);
+    const [ripples, setRipples] = React23__namespace.useState([]);
+    const generatedId = React23__namespace.useId();
     const switchId = label ? `switch-${generatedId}` : void 0;
-    const handleClick = React18__namespace.useCallback(() => {
+    const handleClick = React23__namespace.useCallback(() => {
       if (!disabled) onCheckedChange(!checked);
     }, [disabled, checked, onCheckedChange]);
-    const handleKeyDown = React18__namespace.useCallback(
+    const handleKeyDown = React23__namespace.useCallback(
       (e) => {
         if (disabled) return;
         if (e.key === " " || e.key === "Enter") {
@@ -3626,7 +5020,7 @@ var SwitchComponent = React18__namespace.forwardRef(
       },
       [disabled, checked, onCheckedChange]
     );
-    const handlePointerDown = React18__namespace.useCallback(
+    const handlePointerDown = React23__namespace.useCallback(
       (e) => {
         if (disabled) return;
         setIsPressed(true);
@@ -3641,19 +5035,19 @@ var SwitchComponent = React18__namespace.forwardRef(
       },
       [disabled]
     );
-    const handlePointerUp = React18__namespace.useCallback(() => {
+    const handlePointerUp = React23__namespace.useCallback(() => {
       setIsPressed(false);
     }, []);
-    const handlePointerEnter = React18__namespace.useCallback(() => {
+    const handlePointerEnter = React23__namespace.useCallback(() => {
       if (!disabled) setIsHovered(true);
     }, [disabled]);
-    const handlePointerLeave = React18__namespace.useCallback(() => {
+    const handlePointerLeave = React23__namespace.useCallback(() => {
       setIsHovered(false);
       setIsPressed(false);
     }, []);
-    const handleFocus = React18__namespace.useCallback(() => setIsFocused(true), []);
-    const handleBlur = React18__namespace.useCallback(() => setIsFocused(false), []);
-    const removeRipple = React18__namespace.useCallback(
+    const handleFocus = React23__namespace.useCallback(() => setIsFocused(true), []);
+    const handleBlur = React23__namespace.useCallback(() => setIsFocused(false), []);
+    const removeRipple = React23__namespace.useCallback(
       (id) => setRipples((prev) => prev.filter((r) => r.id !== id)),
       []
     );
@@ -3679,7 +5073,7 @@ var SwitchComponent = React18__namespace.forwardRef(
         onFocus: handleFocus,
         onBlur: handleBlur,
         className: cn(
-          "relative inline-flex items-center justify-center cursor-pointer select-none",
+          "relative inline-flex items-center justify-center cursor-pointer select-none shrink-0",
           // Touch target: 48×48 minimum (pad around 32px track)
           "min-w-12 min-h-12",
           // Focus ring — MD3 FocusIndicatorColor = secondary
@@ -3689,7 +5083,7 @@ var SwitchComponent = React18__namespace.forwardRef(
           disabled && "pointer-events-none cursor-not-allowed",
           !label && className
         ),
-        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative overflow-hidden rounded-full", children: [
+        children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative overflow-hidden rounded-full shrink-0", children: [
           /* @__PURE__ */ jsxRuntime.jsx(
             SwitchVisual,
             {
@@ -3738,7 +5132,7 @@ var SwitchComponent = React18__namespace.forwardRef(
   }
 );
 SwitchComponent.displayName = "Switch";
-var Switch = React18__namespace.memo(SwitchComponent);
+var Switch = React23__namespace.memo(SwitchComponent);
 
 // src/ui/lists/list-utils.ts
 function getListItemHeight(hasOverline, supportingTextLines) {
@@ -3878,7 +5272,7 @@ function renderSwitchTrailing({
   trailingClass
 }) {
   const isSelectingMode = selectionMode === "single-select" || selectionMode === "multi-select";
-  const switchElement = React18__namespace.isValidElement(trailingContent) ? (() => {
+  const switchElement = React23__namespace.isValidElement(trailingContent) ? (() => {
     const trailingProps = trailingContent.props;
     const checkedValue = !isSelectingMode && trailingProps.checked !== void 0 ? trailingProps.checked : isSelected;
     const disabledValue = trailingProps.disabled !== void 0 ? disabled || trailingProps.disabled : disabled;
@@ -3889,7 +5283,7 @@ function renderSwitchTrailing({
         onItemChange(value, checked);
       }
     };
-    return React18__namespace.cloneElement(
+    return React23__namespace.cloneElement(
       trailingContent,
       { checked: checkedValue, disabled: disabledValue, onCheckedChange }
     );
@@ -3914,7 +5308,7 @@ function renderSwitchTrailing({
     )
   );
 }
-var ListItemImpl = React18__namespace.forwardRef(
+var ListItemImpl = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, {
       className,
@@ -3970,9 +5364,9 @@ var ListItemImpl = React18__namespace.forwardRef(
     });
     const reorderable = (_e = context == null ? void 0 : context.reorderable) != null ? _e : false;
     const isSelected = selected !== void 0 ? selected : (_f = context == null ? void 0 : context.selectedValues.has(value)) != null ? _f : false;
-    const [isHovered, setIsHovered] = React18__namespace.useState(false);
-    const [isFocused, setIsFocused] = React18__namespace.useState(false);
-    const [isPressed, setIsPressed] = React18__namespace.useState(false);
+    const [isHovered, setIsHovered] = React23__namespace.useState(false);
+    const [isFocused, setIsFocused] = React23__namespace.useState(false);
+    const [isPressed, setIsPressed] = React23__namespace.useState(false);
     const { ripples, onPointerDown, removeRipple } = useRippleState({
       disabled
     });
@@ -3984,8 +5378,8 @@ var ListItemImpl = React18__namespace.forwardRef(
       transition,
       isDragging
     } = sortable.useSortable({ id: value, disabled: !reorderable });
-    const itemRef = React18__namespace.useRef(null);
-    const setRefs = React18__namespace.useCallback(
+    const itemRef = React23__namespace.useRef(null);
+    const setRefs = React23__namespace.useCallback(
       (node) => {
         itemRef.current = node;
         setNodeRef(node);
@@ -4438,7 +5832,7 @@ var ListItemImpl = React18__namespace.forwardRef(
   }
 );
 ListItemImpl.displayName = "ListItem";
-var ListItem = React18__namespace.memo(ListItemImpl);
+var ListItem = React23__namespace.memo(ListItemImpl);
 var typographyVariants = classVarianceAuthority.cva("m-0 p-0 text-m3-on-surface", {
   variants: {
     variant: {
@@ -4464,10 +5858,10 @@ var typographyVariants = classVarianceAuthority.cva("m-0 p-0 text-m3-on-surface"
     variant: "body-md"
   }
 });
-var Text = React18__namespace.forwardRef(
+var Text = React23__namespace.forwardRef(
   (_a, ref) => {
     var _b = _a, { className, variant, as: Component, color, weight, style } = _b, props = __objRest(_b, ["className", "variant", "as", "color", "weight", "style"]);
-    const defaultComponent = React18__namespace.useMemo(() => {
+    const defaultComponent = React23__namespace.useMemo(() => {
       const v = variant ? String(variant).toLowerCase() : "";
       if (v.startsWith("display") || v.startsWith("headline")) return "h1";
       if (v.startsWith("title")) return "h2";
@@ -4491,9 +5885,9 @@ function TableOfContents({
   className,
   scrollAreaProps
 }) {
-  const [activeId, setActiveId] = React18.useState("");
-  const itemIds = React18.useMemo(() => items.map((i) => i.id), [items]);
-  React18.useEffect(() => {
+  const [activeId, setActiveId] = React23.useState("");
+  const itemIds = React23.useMemo(() => items.map((i) => i.id), [items]);
+  React23.useEffect(() => {
     if (typeof IntersectionObserver === "undefined") return;
     const observer = new IntersectionObserver(
       (entries) => {
@@ -4510,7 +5904,7 @@ function TableOfContents({
     }
     return () => observer.disconnect();
   }, [itemIds]);
-  const handleClick = React18.useCallback(
+  const handleClick = React23.useCallback(
     (e, id) => {
       var _a;
       e.preventDefault();
@@ -5264,9 +6658,9 @@ var TOKEN_TO_PROP = {
 };
 var defaultTokens = new TypographyTokens();
 var defaultTypography = new Typography();
-var TypographyContext = React18.createContext(defaultTypography);
+var TypographyContext = React23.createContext(defaultTypography);
 function useTypography() {
-  return React18.useContext(TypographyContext);
+  return React23.useContext(TypographyContext);
 }
 function TypographyProvider({
   children,
@@ -5274,7 +6668,7 @@ function TypographyProvider({
   fontFamily,
   fontVariationAxes
 }) {
-  const value = React18.useMemo(() => {
+  const value = React23.useMemo(() => {
     if (typography) return typography;
     if (fontFamily || fontVariationAxes) {
       return new Typography(
@@ -5287,6 +6681,15 @@ function TypographyProvider({
 }
 
 exports.Card = Card;
+exports.CardContent = CardContent;
+exports.CardFooter = CardFooter;
+exports.CardHeader = CardHeader;
+exports.CardMedia = CardMedia;
+exports.Carousel = Carousel;
+exports.CarouselGrid = CarouselGrid;
+exports.CarouselItem = CarouselItem;
+exports.CarouselScrollClient = CarouselScrollClient;
+exports.CarouselTokens = CarouselTokens;
 exports.CodeBlock = CodeBlock;
 exports.DEFAULT_FONT_VARIATION_AXES = DEFAULT_FONT_VARIATION_AXES;
 exports.Divider = Divider;
@@ -5296,6 +6699,7 @@ exports.ListContext = ListContext;
 exports.ListDivider = ListDivider;
 exports.ListItem = ListItem;
 exports.MD3_EXPRESSIVE_FONT_VARIATION = MD3_EXPRESSIVE_FONT_VARIATION;
+exports.SHADOW = SHADOW;
 exports.ScrollArea = ScrollArea;
 exports.ScrollAreaScrollbar = ScrollAreaScrollbar;
 exports.TableOfContents = TableOfContents;
@@ -5306,12 +6710,18 @@ exports.TypographyContext = TypographyContext;
 exports.TypographyKeyTokens = TypographyKeyTokens;
 exports.TypographyProvider = TypographyProvider;
 exports.TypographyTokens = TypographyTokens;
+exports.VARIANT_ELEVATION = VARIANT_ELEVATION;
 exports.buildWavePath = buildWavePath;
+exports.cardVariants = cardVariants;
 exports.getExpressiveShape = getExpressiveShape;
 exports.getListItemHeight = getListItemHeight;
+exports.resolveElevationShadow = resolveElevationShadow;
 exports.serializeFontVariationAxes = serializeFontVariationAxes;
 exports.shouldTopAlign = shouldTopAlign;
 exports.typographyVariants = typographyVariants;
+exports.useCardElevation = useCardElevation;
+exports.useCarouselA11y = useCarouselA11y;
+exports.useCarouselKeylines = useCarouselKeylines;
 exports.useListContext = useListContext;
 exports.useTypography = useTypography;
 //# sourceMappingURL=layout.js.map