@allxsmith/bestax-bulma 5.14.0 → 5.15.1

package/dist/index.cjs.js

@@ -1189,6 +1189,21 @@ const ColumnsComponent = ({ className, textColor, color: _fieldColor, bgColor, i
 };
 const Columns = withSubComponents(ColumnsComponent, { Column }, 'Columns');
 
+/**
+ * Whether an `as` target is a custom element rather than a built-in tag.
+ *
+ * HTML requires a custom element's name to contain a hyphen, and no built-in
+ * element name has one, so this is exact rather than a heuristic. It matters
+ * because a custom element is an intrinsic STRING — `typeof as === 'string'` is
+ * true — while its props are whatever a consumer declared through
+ * `React.JSX.IntrinsicElements`, the way this package declares `<ion-icon>`.
+ * A runtime backstop that filters built-in attributes must leave those alone,
+ * or it strips props the derived type just promised to forward.
+ */
+function isCustomElement(as) {
+    return typeof as === 'string' && as.includes('-');
+}
+
 const avatarColors = [
     'primary',
     'link',
@@ -1257,6 +1272,7 @@ function DefaultAvatarIcon() {
  *
  * @function
  * @param {AvatarProps} props - Props for the Avatar component.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered avatar element.
  *
  * @example
@@ -1264,7 +1280,8 @@ function DefaultAvatarIcon() {
  * @example
  * <Avatar name="Grace Hopper" />
  */
-const Avatar = ({ className, src, alt, name, initials, icon, size, shape = 'circle', color, as, href, target, rel, imageProps, style, ...props }) => {
+const Avatar = React.forwardRef(function Avatar(avatarProps, ref) {
+    const { className, src, alt, name, initials, icon, size, shape = 'circle', color, as, href, target, rel, imageProps, style, ...props } = avatarProps;
     // Tracks the src that failed to load. A src change clears the latch during
     // render (React's "reset state when props change" pattern) so a previously
     // failed src is retried when switched back to. The img is additionally
@@ -1316,10 +1333,10 @@ const Avatar = ({ className, src, alt, name, initials, icon, size, shape = 'circ
     // decorative (aria-hidden) and it could render nameless.
     const isInteractive = Tag === 'a' ||
         Tag === 'button' ||
-        (typeof Tag !== 'string' && href != null);
+        ((typeof Tag !== 'string' || isCustomElement(Tag)) && href != null);
     // Only forward link attributes when rendering an anchor or a custom (non-DOM)
     // component; a plain `as="div"` must not receive a stray `href`/`target`/`rel`.
-    const isLinkLike = Tag === 'a' || typeof Tag !== 'string';
+    const isLinkLike = Tag === 'a' || typeof Tag !== 'string' || isCustomElement(Tag);
     const linkProps = isLinkLike ? { href, target, rel } : {};
     // alt coalesces with ?? (not ||) so an explicit alt="" survives as the
     // standard decorative marker instead of being overridden by name.
@@ -1342,11 +1359,11 @@ const Avatar = ({ className, src, alt, name, initials, icon, size, shape = 'circ
     // A clickable avatar inside a form must not submit it; default the native
     // button type (an explicit type passed through rest still wins).
     const buttonTypeProps = Tag === 'button' ? { type: 'button' } : {};
-    return (jsxRuntime.jsxs(Tag, { className: combinedClasses, style: { ...sizeStyle, ...style }, ...buttonTypeProps, ...linkProps, ...a11yProps, ...rest, children: [showImage && (jsxRuntime.jsx("img", { ...imageProps, ref: imgRef, src: src, alt: accessibleName ?? '', onError: e => {
+    return (jsxRuntime.jsxs(Tag, { ref: ref, className: combinedClasses, style: { ...sizeStyle, ...style }, ...buttonTypeProps, ...linkProps, ...a11yProps, ...rest, children: [showImage && (jsxRuntime.jsx("img", { ...imageProps, ref: imgRef, src: src, alt: accessibleName ?? '', onError: e => {
                     imageProps?.onError?.(e);
                     setErroredSrc(src);
                 } }, src)), showInitials && (jsxRuntime.jsx("span", { className: initialsClass, children: resolvedInitials })), showIcon && icon, showDefaultIcon && jsxRuntime.jsx(DefaultAvatarIcon, {})] }));
-};
+});
 Avatar.displayName = 'Avatar';
 
 /**
@@ -1776,14 +1793,46 @@ const isBrowser$1 = (win, doc) => typeof win !== 'undefined' && typeof doc !== '
  *
  * @function
  * @param {DropdownProps} props - Props for the Dropdown component.
+ * @param {React.Ref<HTMLDivElement>} ref - Forwarded ref to the root dropdown element.
  * @returns {JSX.Element} The rendered dropdown.
  * @see {@link https://bulma.io/documentation/components/dropdown/ | Bulma Dropdown documentation}
  */
-const DropdownComponent = ({ label, children, className, menuClassName, active: activeProp, up, right, hoverable, disabled, onActiveChange, closeOnClick = true, id, ...props }) => {
+const DropdownComponent = React.forwardRef(function DropdownComponent({ label, children, className, menuClassName, active: activeProp, up, right, hoverable, disabled, onActiveChange, closeOnClick = true, id, ...props }, ref) {
     const [active, setActive] = React.useState(!!activeProp);
     const dropdownRef = React.useRef(null);
     const triggerRef = React.useRef(null);
     const pendingFocusRef = React.useRef(null);
+    // Cleanup returned by a consumer's callback ref on attach, held until detach.
+    const consumerCleanupRef = React.useRef(null);
+    const setRefs = React.useCallback((node) => {
+        dropdownRef.current =
+            node;
+        if (typeof ref === 'function') {
+            // React 19 lets a callback ref return a cleanup function and detaches
+            // by running it instead of calling the ref with `null`; React 18
+            // discards the return value entirely. Returning it from here would be
+            // a React-19-only contract, so instead we hold the cleanup and run it
+            // ourselves on detach — a consumer's cleanup ref then behaves the same
+            // on both majors of the CI matrix.
+            if (node === null) {
+                const consumerCleanup = consumerCleanupRef.current;
+                consumerCleanupRef.current = null;
+                if (consumerCleanup) {
+                    consumerCleanup();
+                }
+                else {
+                    ref(null);
+                }
+                return;
+            }
+            const cleanup = ref(node);
+            consumerCleanupRef.current =
+                typeof cleanup === 'function' ? cleanup : null;
+        }
+        else if (ref) {
+            ref.current = node;
+        }
+    }, [ref]);
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     // Generate Bulma classes with prefix
     const bulmaClasses = usePrefixedClassNames('dropdown', {
@@ -1951,8 +2000,8 @@ const DropdownComponent = ({ label, children, className, menuClassName, active:
         }
     };
     const dropdownClasses = classNames(bulmaClasses, bulmaHelperClasses, className);
-    return (jsxRuntime.jsxs("div", { className: dropdownClasses, ref: dropdownRef, id: id, "data-testid": "dropdown-root", ...rest, children: [jsxRuntime.jsx("div", { className: usePrefixedClassNames('dropdown-trigger'), children: jsxRuntime.jsxs("button", { ref: triggerRef, className: buttonClass, "aria-haspopup": "true", "aria-controls": id ? `${id}-menu` : undefined, "aria-expanded": active, onClick: handleToggle, onKeyDown: handleTriggerKeyDown, disabled: disabled, type: "button", children: [jsxRuntime.jsx("span", { children: label }), jsxRuntime.jsx("span", { className: usePrefixedClassNames('icon', 'is-small'), "aria-hidden": "true", children: jsxRuntime.jsx("i", { className: "fas fa-angle-down" }) })] }) }), jsxRuntime.jsx("div", { className: classNames(usePrefixedClassNames('dropdown-menu'), menuClassName), id: id ? `${id}-menu` : undefined, role: "menu", "data-testid": "dropdown-menu", onKeyDown: handleMenuKeyDown, children: jsxRuntime.jsx("div", { className: usePrefixedClassNames('dropdown-content'), onClick: handleMenuClick, tabIndex: -1, children: children }) })] }));
-};
+    return (jsxRuntime.jsxs("div", { className: dropdownClasses, ref: setRefs, id: id, "data-testid": "dropdown-root", ...rest, children: [jsxRuntime.jsx("div", { className: usePrefixedClassNames('dropdown-trigger'), children: jsxRuntime.jsxs("button", { ref: triggerRef, className: buttonClass, "aria-haspopup": "true", "aria-controls": id ? `${id}-menu` : undefined, "aria-expanded": active, onClick: handleToggle, onKeyDown: handleTriggerKeyDown, disabled: disabled, type: "button", children: [jsxRuntime.jsx("span", { children: label }), jsxRuntime.jsx("span", { className: usePrefixedClassNames('icon', 'is-small'), "aria-hidden": "true", children: jsxRuntime.jsx("i", { className: "fas fa-angle-down" }) })] }) }), jsxRuntime.jsx("div", { className: classNames(usePrefixedClassNames('dropdown-menu'), menuClassName), id: id ? `${id}-menu` : undefined, role: "menu", "data-testid": "dropdown-menu", onKeyDown: handleMenuKeyDown, children: jsxRuntime.jsx("div", { className: usePrefixedClassNames('dropdown-content'), onClick: handleMenuClick, tabIndex: -1, children: children }) })] }));
+});
 /**
  * Bulma Dropdown item.
  *
@@ -2027,13 +2076,23 @@ const MenuList = ({ className, children, ...props }) => {
  *
  * @function
  * @param {MenuItemProps} props - Props for the MenuItem component.
+ * @param {React.Ref} ref - Forwarded ref to the inner element `as` renders.
  * @returns {JSX.Element} The rendered menu item.
  */
-const MenuItem = ({ className, children, active, href, as: Component = 'a', 'data-testid': testId, ...rest }) => {
-    const { bulmaHelperClasses, rest: bulmaRest } = useBulmaClasses(rest);
+const MenuItem = React.forwardRef(function MenuItem(itemProps, ref) {
+    const { className, children, active, as: Component = 'a', 'data-testid': testId, style, id, title, role, tabIndex, ...rest } = itemProps;
+    const { bulmaHelperClasses, rest: forwarded } = useBulmaClasses(rest);
+    // `href` reaches an anchor or a custom component (which owns its own prop
+    // contract), but not another intrinsic tag — `<span href>` is invalid HTML.
+    // The same rule Avatar applies through `isLinkLike` and Button through its
+    // intrinsic-only strip. Before #641 `href` was an own prop re-applied only
+    // for `as="a"`; deriving it from `as` must not quietly widen that.
+    const isLinkLike = Component === 'a' ||
+        typeof Component !== 'string' ||
+        isCustomElement(Component);
+    const { href: _href, ...withoutHref } = forwarded;
+    const linkProps = isLinkLike ? forwarded : withoutHref;
     const itemClass = classNames({ [usePrefixedClassNames('is-active')]: active }, bulmaHelperClasses);
-    // Standard <li> props
-    const { style, id, title, role, tabIndex, ...linkProps } = bulmaRest;
     // Split children into label and nested MenuList(s)
     const labelChildren = [];
     const nestedMenuLists = [];
@@ -2045,15 +2104,9 @@ const MenuItem = ({ className, children, active, href, as: Component = 'a', 'dat
             labelChildren.push(child);
         }
     });
-    // href/to should go to the link component
-    if (Component === 'a' && href) {
-        linkProps.href = href;
-    }
-    if (Object.prototype.hasOwnProperty.call(rest, 'to')) {
-        linkProps.to = rest.to;
-    }
-    return (jsxRuntime.jsxs("li", { className: className, "data-testid": testId, style: style, id: id, title: title, role: role, tabIndex: tabIndex, children: [jsxRuntime.jsx(Component, { className: itemClass, ...linkProps, children: labelChildren }), nestedMenuLists] }));
-};
+    return (jsxRuntime.jsxs("li", { className: className, "data-testid": testId, style: style, id: id, title: title, role: role, tabIndex: tabIndex, children: [jsxRuntime.jsx(Component, { ref: ref, className: itemClass, ...linkProps, children: labelChildren }), nestedMenuLists] }));
+});
+MenuItem.displayName = 'MenuItem';
 // Attach static subcomponents
 const Menu = withSubComponents(MenuComponent, {
     Label: MenuLabel,
@@ -2108,6 +2161,105 @@ const Message = withSubComponents(MessageComponent, {
     Body: MessageBody,
 }, 'Message');
 
+// Ref-counted across every caller (e.g. a Dialog rendering its own Modal)
+// so overlapping/nested locks don't fight over which one restores `overflow`.
+// Every overlay that locks body scroll — Modal, Dialog, Sidebar, Loading —
+// goes through here; a component setting `document.body.style.overflow`
+// itself would clear a lock another overlay still needs.
+let lockCount = 0;
+let originalOverflow = '';
+/**
+ * Locks (and ref-counted-ly unlocks) `document.body` scrolling while `active`
+ * is true. Safe to call from multiple components at once — the body scroll
+ * is only restored once every active caller has released its lock.
+ *
+ * @function useScrollLock
+ * @param active - Whether this caller wants the body scroll locked.
+ */
+function useScrollLock(active) {
+    React.useEffect(() => {
+        if (!active)
+            return undefined;
+        lockCount++;
+        if (lockCount === 1) {
+            originalOverflow = document.body.style.overflow;
+            document.body.style.overflow = 'hidden';
+        }
+        return () => {
+            lockCount--;
+            if (lockCount === 0) {
+                document.body.style.overflow = originalOverflow;
+            }
+        };
+    }, [active]);
+}
+
+/**
+ * Resolves a portal target: an `HTMLElement` is used directly, a non-empty
+ * `string` is treated as a `document.querySelector` selector (falling back to
+ * `document.body` when it matches nothing), and any falsy value — `undefined`
+ * or the empty string — resolves to `document.body`.
+ *
+ * The empty string is deliberately treated as "no target" rather than passed
+ * through: `document.querySelector('')` throws a `SyntaxError`, and callers
+ * building a selector from state can easily hand us `''`.
+ *
+ * @function resolvePortalContainer
+ * @param container - The requested portal target, if any.
+ * @returns The resolved DOM node to portal into.
+ */
+function resolvePortalContainer(container) {
+    if (!container) {
+        return document.body;
+    }
+    if (typeof container === 'string') {
+        return (document.querySelector(container) ?? document.body);
+    }
+    return container;
+}
+
+// "Are we past hydration?" as a store that never changes: React reads the
+// server snapshot both while server-rendering and while hydrating, and the
+// client snapshot from the first post-hydration render onward.
+const subscribeToNothing = () => () => { };
+const getClientSnapshot = () => true;
+const getServerSnapshot = () => false;
+/**
+ * Reports whether the component has passed hydration.
+ *
+ * Returns `false` during server rendering and during the hydrating client
+ * render, then `true` from the commit that follows. Use it to defer
+ * DOM-only behaviour (such as portalling) past hydration so the first client
+ * render matches the server markup instead of tripping hydration recovery.
+ *
+ * @function useIsHydrated
+ * @returns `true` once the hydrating render has completed, otherwise `false`.
+ */
+function useIsHydrated() {
+    return React.useSyncExternalStore(subscribeToNothing, getClientSnapshot, getServerSnapshot);
+}
+
+/**
+ * Every currently active modal, in the order they opened. Only the last entry
+ * — the topmost modal — reacts to Escape and Tab, so one keypress can't
+ * dismiss a whole stack (e.g. a `Dialog` opened on top of a `Modal`).
+ */
+const activeModalStack = [];
+/**
+ * Controls the modal can hand focus to. Disabled and hidden controls are
+ * excluded because `focus()` on them is a no-op, which would leave focus
+ * outside the modal.
+ */
+const FOCUSABLE_SELECTOR$1 = 'button:not(:disabled), [href], input:not(:disabled):not([type="hidden"]), select:not(:disabled), textarea:not(:disabled), [tabindex]';
+/**
+ * The modal's tab stops, in document order. The selector alone is not the
+ * tabbable set — `[href]` and `button` match regardless of `tabindex`, so an
+ * `<a href tabIndex={-1}>` would otherwise be treated as a tab stop and let
+ * Tab escape the modal when it sorts last. `el.tabIndex` is the browser's own
+ * resolved value, so filtering on it drops every negative index (not just
+ * `-1`) without a second selector to keep in sync.
+ */
+const getTabbable = (node) => Array.from(node.querySelectorAll(FOCUSABLE_SELECTOR$1)).filter(el => el.tabIndex >= 0);
 /**
  * Modal.Background - Renders the modal background overlay.
  *
@@ -2238,7 +2390,7 @@ const ModalClose = ({ className, size = 'large', variant = 'delete', ...props })
  *
  * @see {@link https://bulma.io/documentation/components/modal/ | Bulma Modal documentation}
  */
-const ModalRoot = ({ active, isActive, onClose, className, textColor, bgColor, modalCardTitle, modalCardFoot, type, children, ...props }) => {
+const ModalRoot = React.forwardRef(function ModalRoot({ active, isActive, onClose, className, textColor, bgColor, modalCardTitle, modalCardFoot, type, children, closeOnEscape = true, lockScroll = true, portal = false, role, 'aria-modal': ariaModalProp, ...props }, ref) {
     const { classPrefix } = useConfig();
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
@@ -2247,6 +2399,133 @@ const ModalRoot = ({ active, isActive, onClose, className, textColor, bgColor, m
     });
     // Support both active and isActive props
     const isModalActive = active ?? isActive ?? false;
+    const modalRootRef = React.useRef(null);
+    // Cleanup returned by a consumer's callback ref on attach, held until detach.
+    const consumerCleanupRef = React.useRef(null);
+    // The forwarded ref and the internal one must both see the node: focus
+    // management, the scroll lock and the topmost-modal check all read
+    // `modalRootRef`, while consumers expect their own ref to resolve.
+    const combinedRef = React.useCallback((node) => {
+        modalRootRef.current =
+            node;
+        if (typeof ref === 'function') {
+            // React 19 lets a callback ref return a cleanup function and detaches
+            // by running it instead of calling the ref with `null`; React 18
+            // discards the return value entirely. Returning it from here would be
+            // a React-19-only contract, so instead we hold the cleanup and run it
+            // ourselves on detach — a consumer's cleanup ref then behaves the same
+            // on both majors of the CI matrix. Same shape as `Dropdown`.
+            if (node === null) {
+                const consumerCleanup = consumerCleanupRef.current;
+                consumerCleanupRef.current = null;
+                if (consumerCleanup) {
+                    consumerCleanup();
+                }
+                else {
+                    ref(null);
+                }
+                return;
+            }
+            const cleanup = ref(node);
+            consumerCleanupRef.current =
+                typeof cleanup === 'function' ? cleanup : null;
+        }
+        else if (ref) {
+            ref.current = node;
+        }
+    }, [ref]);
+    const previouslyFocusedRef = React.useRef(null);
+    const stackTokenRef = React.useRef({});
+    const generatedTitleId = React.useId();
+    // A portal has no server-rendered counterpart, so the server render and the
+    // hydrating render have to stay inline and only move into the portal once
+    // we're past hydration.
+    const onClient = useIsHydrated();
+    // Moving into the portal remounts the modal's subtree, so any effect holding
+    // a DOM node from before the move is holding a detached one. Effects that
+    // touch the modal's nodes key on this so they re-run against the new tree.
+    const isPortaled = Boolean(portal) && onClient;
+    useScrollLock(isModalActive && lockScroll);
+    // Record open order so keyboard handling only applies to the topmost modal.
+    React.useEffect(() => {
+        if (!isModalActive)
+            return undefined;
+        const token = stackTokenRef.current;
+        activeModalStack.push(token);
+        return () => {
+            const index = activeModalStack.indexOf(token);
+            if (index !== -1)
+                activeModalStack.splice(index, 1);
+        };
+    }, [isModalActive]);
+    // Escape closes; Tab cycles inside the modal. Both only for the topmost one.
+    React.useEffect(() => {
+        if (!isModalActive)
+            return undefined;
+        const handleKeyDown = (e) => {
+            const node = modalRootRef.current;
+            if (activeModalStack[activeModalStack.length - 1] !== stackTokenRef.current) {
+                return;
+            }
+            if (e.key === 'Escape') {
+                if (closeOnEscape)
+                    onClose?.();
+                return;
+            }
+            if (e.key !== 'Tab' || !node)
+                return;
+            // Keep Tab within the modal — `aria-modal` hides the rest of the page
+            // from assistive technology, so the keyboard order has to agree.
+            const focusable = getTabbable(node);
+            const activeElement = document.activeElement;
+            if (focusable.length === 0) {
+                e.preventDefault();
+                node.focus();
+                return;
+            }
+            const first = focusable[0];
+            const last = focusable[focusable.length - 1];
+            const outside = !node.contains(activeElement);
+            if (e.shiftKey) {
+                if (outside || activeElement === first) {
+                    e.preventDefault();
+                    last.focus();
+                }
+            }
+            else if (outside || activeElement === last) {
+                e.preventDefault();
+                first.focus();
+            }
+        };
+        document.addEventListener('keydown', handleKeyDown);
+        return () => document.removeEventListener('keydown', handleKeyDown);
+    }, [isModalActive, closeOnEscape, onClose]);
+    // Move focus into the modal on open, restore it on close
+    React.useEffect(() => {
+        if (!isModalActive)
+            return undefined;
+        previouslyFocusedRef.current = document.activeElement;
+        const node = modalRootRef.current;
+        const focusable = node ? getTabbable(node)[0] : undefined;
+        (focusable ?? node)?.focus();
+        return () => {
+            // Only hand focus back if this modal still owns it: closing a background
+            // modal must not pull focus out of one that is still open on top. A
+            // removed subtree leaves focus on <body>, which still counts as ours.
+            const activeElement = document.activeElement;
+            if (activeElement &&
+                activeElement !== document.body &&
+                !node?.contains(activeElement)) {
+                return;
+            }
+            previouslyFocusedRef.current?.focus?.();
+        };
+        // `isPortaled` flips once when a hydrated portal modal moves out of the
+        // inline tree; re-running rebinds focus onto the remounted nodes. The
+        // cleanup above restores focus to the pre-open element first (the detached
+        // subtree has left focus on <body>), so the re-run re-records the same
+        // element and restore-on-close still lands in the right place.
+    }, [isModalActive, isPortaled]);
     // Check if children contain compound components
     const hasCompoundComponents = React.Children.toArray(children).some(child => React.isValidElement(child) &&
         (child.type === ModalBackground ||
@@ -2259,20 +2538,35 @@ const ModalRoot = ({ active, isActive, onClose, className, textColor, bgColor, m
     });
     const deleteClass = usePrefixedClassNames('delete');
     const modalClasses = classNames(bulmaClasses, bulmaHelperClasses, className);
+    const resolvedRole = role ?? (isModalActive ? 'dialog' : undefined);
+    const resolvedAriaModal = ariaModalProp ??
+        (isModalActive && resolvedRole !== 'presentation' ? 'true' : undefined);
+    // A dialog needs an accessible name: the legacy card title is wired up
+    // automatically, compound users pass their own aria-label/aria-labelledby
+    // (both arrive in `rest`, which is spread last and so wins).
+    const titleId = modalCardTitle ? generatedTitleId : undefined;
+    let modalElement;
     // If using compound components, render children as-is
     if (hasCompoundComponents) {
-        return (jsxRuntime.jsx("div", { className: modalClasses, ...rest, "data-testid": "modal", children: children }));
+        modalElement = (jsxRuntime.jsx("div", { className: modalClasses, ref: combinedRef, role: resolvedRole, "aria-modal": resolvedAriaModal, tabIndex: -1, ...rest, "data-testid": "modal", children: children }));
     }
-    // Legacy API: EXPLICIT type wins; fallback to auto detection if not provided
-    let isModalCard;
-    if (type === 'card')
-        isModalCard = true;
-    else if (type === 'content')
-        isModalCard = false;
-    else
-        isModalCard = !!modalCardTitle || !!modalCardFoot;
-    return (jsxRuntime.jsxs("div", { className: modalClasses, ...rest, "data-testid": "modal", children: [jsxRuntime.jsx("div", { className: prefixedClassNames(classPrefix, 'modal-background'), onClick: onClose, "data-testid": "modal-background" }), isModalCard ? (jsxRuntime.jsxs("div", { className: prefixedClassNames(classPrefix, 'modal-card'), children: [modalCardTitle && (jsxRuntime.jsxs("header", { className: prefixedClassNames(classPrefix, 'modal-card-head'), children: [jsxRuntime.jsx("p", { className: prefixedClassNames(classPrefix, 'modal-card-title'), children: modalCardTitle }), onClose && (jsxRuntime.jsx("button", { className: deleteClass, "aria-label": "close", onClick: onClose, type: "button", "data-testid": "modal-close" }))] })), jsxRuntime.jsx("section", { className: prefixedClassNames(classPrefix, 'modal-card-body'), "data-testid": "modal-body", children: children }), modalCardFoot && (jsxRuntime.jsx("footer", { className: prefixedClassNames(classPrefix, 'modal-card-foot'), children: modalCardFoot }))] })) : (jsxRuntime.jsx("div", { className: prefixedClassNames(classPrefix, 'modal-content'), "data-testid": "modal-content", children: children })), (!isModalCard || (!modalCardTitle && onClose)) && onClose && (jsxRuntime.jsx("button", { className: prefixedClassNames(classPrefix, 'modal-close', 'is-large'), "aria-label": "close", onClick: onClose, type: "button", "data-testid": "modal-close-float" }))] }));
-};
+    else {
+        // Legacy API: EXPLICIT type wins; fallback to auto detection if not provided
+        let isModalCard;
+        if (type === 'card')
+            isModalCard = true;
+        else if (type === 'content')
+            isModalCard = false;
+        else
+            isModalCard = !!modalCardTitle || !!modalCardFoot;
+        modalElement = (jsxRuntime.jsxs("div", { className: modalClasses, ref: combinedRef, role: resolvedRole, "aria-modal": resolvedAriaModal, "aria-labelledby": titleId, tabIndex: -1, ...rest, "data-testid": "modal", children: [jsxRuntime.jsx("div", { className: prefixedClassNames(classPrefix, 'modal-background'), onClick: onClose, "data-testid": "modal-background" }), isModalCard ? (jsxRuntime.jsxs("div", { className: prefixedClassNames(classPrefix, 'modal-card'), children: [modalCardTitle && (jsxRuntime.jsxs("header", { className: prefixedClassNames(classPrefix, 'modal-card-head'), children: [jsxRuntime.jsx("p", { id: titleId, className: prefixedClassNames(classPrefix, 'modal-card-title'), children: modalCardTitle }), onClose && (jsxRuntime.jsx("button", { className: deleteClass, "aria-label": "close", onClick: onClose, type: "button", "data-testid": "modal-close" }))] })), jsxRuntime.jsx("section", { className: prefixedClassNames(classPrefix, 'modal-card-body'), "data-testid": "modal-body", children: children }), modalCardFoot && (jsxRuntime.jsx("footer", { className: prefixedClassNames(classPrefix, 'modal-card-foot'), children: modalCardFoot }))] })) : (jsxRuntime.jsx("div", { className: prefixedClassNames(classPrefix, 'modal-content'), "data-testid": "modal-content", children: children })), (!isModalCard || (!modalCardTitle && onClose)) && onClose && (jsxRuntime.jsx("button", { className: prefixedClassNames(classPrefix, 'modal-close', 'is-large'), "aria-label": "close", onClick: onClose, type: "button", "data-testid": "modal-close-float" }))] }));
+    }
+    if (isPortaled) {
+        const target = resolvePortalContainer(typeof portal === 'boolean' ? undefined : portal);
+        return reactDom.createPortal(modalElement, target);
+    }
+    return modalElement;
+});
 const Modal = withSubComponents(ModalRoot, {
     Background: ModalBackground,
     Content: ModalContent,
@@ -2286,10 +2580,11 @@ const NavbarDropdownContext = React.createContext(null);
  *
  * @function
  * @param {NavbarProps} props - Props for the Navbar component.
+ * @param {React.Ref<HTMLElement>} ref - Forwarded ref to the root `<nav>` element.
  * @returns {JSX.Element} The rendered navbar.
  * @see {@link https://bulma.io/documentation/components/navbar/ | Bulma Navbar documentation}
  */
-const NavbarComponent = ({ className, textColor, bgColor, color, transparent, fixed, children, ...props }) => {
+const NavbarComponent = React.forwardRef(function NavbarComponent({ className, textColor, bgColor, color, transparent, fixed, children, ...props }, ref) {
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
         backgroundColor: bgColor,
@@ -2302,8 +2597,8 @@ const NavbarComponent = ({ className, textColor, bgColor, color, transparent, fi
         [`is-fixed-${fixed}`]: fixed,
     });
     const navbarClasses = classNames(bulmaClasses, bulmaHelperClasses, className);
-    return (jsxRuntime.jsx("nav", { className: navbarClasses, role: "navigation", "aria-label": "main navigation", ...rest, children: children }));
-};
+    return (jsxRuntime.jsx("nav", { ref: ref, className: navbarClasses, role: "navigation", "aria-label": "main navigation", ...rest, children: children }));
+});
 /**
  * For logo and branding (left side)
  *
@@ -2323,33 +2618,38 @@ const NavbarBrand = ({ className, children, textColor, ...props }) => {
  *
  * @function
  * @param {NavbarItemProps} props - Props for the NavbarItem component.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered item.
  */
-const NavbarItem = ({ className, as: Component = 'a', active, textColor, bgColor, children, ...props }) => {
+const NavbarItem = React.forwardRef(function NavbarItem(itemProps, ref) {
+    const { className, as: Component = 'a', active, textColor, bgColor, children, ...props } = itemProps;
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
         backgroundColor: bgColor,
         ...props,
     });
-    return (jsxRuntime.jsx(Component, { className: classNames(usePrefixedClassNames('navbar-item', {
+    return (jsxRuntime.jsx(Component, { ref: ref, className: classNames(usePrefixedClassNames('navbar-item', {
             'is-active': active,
         }), bulmaHelperClasses, className), ...rest, children: children }));
-};
+});
+NavbarItem.displayName = 'NavbarItem';
 /**
  * Responsive menu toggle (mobile)
  *
  * @function
  * @param {NavbarBurgerProps} props - Props for the NavbarBurger component.
+ * @param {React.Ref<HTMLButtonElement>} ref - Forwarded ref to the burger button element.
  * @returns {JSX.Element} The rendered burger.
  */
-const NavbarBurger = ({ className, active, children, ...props }) => {
+const NavbarBurger = React.forwardRef(function NavbarBurger({ className, active, children, ...props }, ref) {
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         ...props,
     });
-    return (jsxRuntime.jsxs("button", { type: "button", className: classNames(usePrefixedClassNames('navbar-burger', {
+    return (jsxRuntime.jsxs("button", { ref: ref, type: "button", className: classNames(usePrefixedClassNames('navbar-burger', {
             'is-active': active,
         }), bulmaHelperClasses, className), "aria-label": props['aria-label'] || 'menu', "aria-expanded": props['aria-expanded'] ?? !!active, ...rest, children: [jsxRuntime.jsx("span", { "aria-hidden": "true" }), jsxRuntime.jsx("span", { "aria-hidden": "true" }), jsxRuntime.jsx("span", { "aria-hidden": "true" }), children] }));
-};
+});
+NavbarBurger.displayName = 'NavbarBurger';
 /**
  * Collapsible content (contains `Navbar.Start` and `Navbar.End`)
  *
@@ -2396,9 +2696,11 @@ const NavbarEnd = ({ className, children, ...props }) => {
  *
  * @function
  * @param {NavbarLinkProps} props - Props for the NavbarLink component.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered navbar link.
  */
-const NavbarLink = ({ className, as: Component = 'a', arrowless, textColor, bgColor, children, ...props }) => {
+const NavbarLink = React.forwardRef(function NavbarLink(linkProps, ref) {
+    const { className, as: Component = 'a', arrowless, textColor, bgColor, children, ...props } = linkProps;
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
         backgroundColor: bgColor,
@@ -2407,8 +2709,16 @@ const NavbarLink = ({ className, as: Component = 'a', arrowless, textColor, bgCo
     const dropdownContext = React.useContext(NavbarDropdownContext);
     const hasHref = rest.href !== undefined;
     const isNativeInteractive = Component === 'button' || hasHref;
+    // Guarded like Button's disabled blocker: these run on whatever `as` renders,
+    // and a custom target's callback need not take a DOM event. One declaring
+    // `onKeyDown: (k: {key: string}) => void` reaches `e.preventDefault()` and
+    // throws. Composing the caller's handler is unconditional; acting on the
+    // event is not ours to do when the payload is foreign.
+    const isDomEvent = (e) => typeof e?.preventDefault === 'function';
     const handleKeyDown = (e) => {
         rest.onKeyDown?.(e);
+        if (!isDomEvent(e))
+            return;
         if (!dropdownContext || e.defaultPrevented)
             return;
         if (e.key === 'Enter' || e.key === ' ') {
@@ -2427,11 +2737,13 @@ const NavbarLink = ({ className, as: Component = 'a', arrowless, textColor, bgCo
     // click semantics (navigation / the caller's handler).
     const handleClick = (e) => {
         rest.onClick?.(e);
+        if (!isDomEvent(e))
+            return;
         if (!dropdownContext || isNativeInteractive || e.defaultPrevented)
             return;
         dropdownContext.toggle();
     };
-    return (jsxRuntime.jsx(Component, { className: classNames(usePrefixedClassNames('navbar-link', {
+    return (jsxRuntime.jsx(Component, { ref: ref, className: classNames(usePrefixedClassNames('navbar-link', {
             'is-arrowless': arrowless,
         }), bulmaHelperClasses, className), ...rest, ...(dropdownContext && {
             'aria-haspopup': 'true',
@@ -2443,15 +2755,17 @@ const NavbarLink = ({ className, as: Component = 'a', arrowless, textColor, bgCo
                 onClick: handleClick,
             }),
         }), children: children }));
-};
+});
+NavbarLink.displayName = 'NavbarLink';
 /**
  * Dropdown parent (with options for hover, up, right, active)
  *
  * @function
  * @param {NavbarDropdownProps} props - Props for the NavbarDropdown component.
+ * @param {React.Ref<HTMLDivElement>} ref - Forwarded ref to the dropdown container element.
  * @returns {JSX.Element} The rendered dropdown.
  */
-const NavbarDropdown = ({ className, right, up, hoverable, active: activeProp, onActiveChange, children, ...props }) => {
+const NavbarDropdown = React.forwardRef(function NavbarDropdown({ className, right, up, hoverable, active: activeProp, onActiveChange, children, ...props }, ref) {
     const [active, setActive] = React.useState(!!activeProp);
     React.useEffect(() => {
         // eslint-disable-next-line react-hooks/set-state-in-effect -- syncing to controlled prop
@@ -2472,13 +2786,14 @@ const NavbarDropdown = ({ className, right, up, hoverable, active: activeProp, o
         setActive(false);
         onActiveChange?.(false);
     };
-    return (jsxRuntime.jsx(NavbarDropdownContext.Provider, { value: { active, toggle, close }, children: jsxRuntime.jsx("div", { className: classNames(usePrefixedClassNames('navbar-item', 'has-dropdown', {
+    return (jsxRuntime.jsx(NavbarDropdownContext.Provider, { value: { active, toggle, close }, children: jsxRuntime.jsx("div", { ref: ref, className: classNames(usePrefixedClassNames('navbar-item', 'has-dropdown', {
                 'has-dropdown-up': up,
                 'is-right': right,
                 'is-hoverable': hoverable,
                 'is-active': active,
             }), className), ...props, children: children }) }));
-};
+});
+NavbarDropdown.displayName = 'NavbarDropdown';
 /**
  * Dropdown menu container
  *
@@ -3248,16 +3563,10 @@ const Loading = ({ active = false, isFullPage = false, size, color, canCancel =
         document.addEventListener('keydown', handleKeyDown);
         return () => document.removeEventListener('keydown', handleKeyDown);
     }, [active, canCancel, onCancel]);
-    // Prevent body scroll when full page loading is active
-    React.useEffect(() => {
-        if (isFullPage && active) {
-            document.body.style.overflow = 'hidden';
-            return () => {
-                document.body.style.overflow = '';
-            };
-        }
-        return undefined;
-    }, [isFullPage, active]);
+    // Prevent body scroll when full page loading is active. Ref-counted through
+    // the shared helper so an overlapping Modal/Dialog/Sidebar doesn't have its
+    // lock cleared when this one releases.
+    useScrollLock(isFullPage && active);
     if (!active) {
         return null;
     }
@@ -3748,6 +4057,8 @@ const Steps = withSubComponents(StepsComponent, { Step }, 'Steps');
 const SidebarComponent = React.forwardRef(({ isOpen, onClose, position = 'left', width = '260px', isFullwidth, fullWidth, overlay = true, overlayClose = true, escapeClose = true, canCancel = true, children, inline = false, className, style, ...props }, ref) => {
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     const sidebarRef = React.useRef(null);
+    // Cleanup returned by a consumer's callback ref on attach, held until detach.
+    const consumerCleanupRef = React.useRef(null);
     const resolvedFullwidth = isFullwidth ?? fullWidth ?? false;
     // Close handler
     const handleClose = React.useCallback(() => {
@@ -3773,17 +4084,9 @@ const SidebarComponent = React.forwardRef(({ isOpen, onClose, position = 'left',
         document.addEventListener('keydown', handleKeyDown);
         return () => document.removeEventListener('keydown', handleKeyDown);
     }, [isOpen, escapeClose, handleClose]);
-    // Prevent body scroll when sidebar is open
-    React.useEffect(() => {
-        if (isOpen && overlay) {
-            const originalOverflow = document.body.style.overflow;
-            document.body.style.overflow = 'hidden';
-            return () => {
-                document.body.style.overflow = originalOverflow;
-            };
-        }
-        return undefined;
-    }, [isOpen, overlay]);
+    // Prevent body scroll when sidebar is open. Ref-counted through the shared
+    // helper so an overlapping Modal/Dialog/Loading doesn't unlock underneath.
+    useScrollLock(isOpen && overlay);
     // Focus trap (basic - focus sidebar when opened)
     React.useEffect(() => {
         if (isOpen) {
@@ -3805,7 +4108,28 @@ const SidebarComponent = React.forwardRef(({ isOpen, onClose, position = 'left',
         sidebarRef.current =
             node;
         if (typeof ref === 'function') {
-            ref(node);
+            // React 19 lets a callback ref return a cleanup function and detaches by
+            // running it instead of calling the ref with `null`; React 18 discards the
+            // return value entirely. Returning it from here would be a React-19-only
+            // contract, so we hold the cleanup and run it ourselves on detach — the
+            // same shape as `Dropdown`, `Modal`, `Dialog`, `Toast` and `Carousel`.
+            // The form controls that merge a forwarded ref still discard the cleanup
+            // and detach with `ref(null)`, so this is not yet library-wide — grep
+            // `typeof ref === 'function'` for the current split.
+            if (node === null) {
+                const consumerCleanup = consumerCleanupRef.current;
+                consumerCleanupRef.current = null;
+                if (consumerCleanup) {
+                    consumerCleanup();
+                }
+                else {
+                    ref(null);
+                }
+                return;
+            }
+            const cleanup = ref(node);
+            consumerCleanupRef.current =
+                typeof cleanup === 'function' ? cleanup : null;
         }
         else if (ref) {
             ref.current = node;
@@ -3922,6 +4246,8 @@ const Toast = React.forwardRef(({ message, type = 'default', actionType, positio
     const [isVisible, setIsVisible] = React.useState(true);
     const [isPaused, setIsPaused] = React.useState(false);
     const toastRef = React.useRef(null);
+    // Cleanup returned by a consumer's callback ref on attach, held until detach.
+    const consumerCleanupRef = React.useRef(null);
     const handleClose = React.useCallback(() => {
         setIsVisible(false);
         onClose?.();
@@ -3992,27 +4318,41 @@ const Toast = React.forwardRef(({ message, type = 'default', actionType, positio
     const toastActionClass = usePrefixedClassNames('toast-action');
     const toastButtonClass = usePrefixedClassNames('button');
     const toastCloseClass = usePrefixedClassNames('delete', 'is-small');
-    if (!isVisible) {
-        return null;
-    }
-    const resolveContainer = () => {
-        if (container) {
-            if (typeof container === 'string') {
-                return (document.querySelector(container) || document.body);
-            }
-            return container;
-        }
-        return document.body;
-    };
-    const setRef = (node) => {
+    const setRef = React.useCallback((node) => {
         toastRef.current = node;
         if (typeof ref === 'function') {
-            ref(node);
+            // React 19 lets a callback ref return a cleanup function and detaches by
+            // running it instead of calling the ref with `null`; React 18 discards the
+            // return value entirely. Returning it from here would be a React-19-only
+            // contract, so we hold the cleanup and run it ourselves on detach — the
+            // same shape as `Dropdown`, `Modal`, `Dialog`, `Sidebar` and `Carousel`.
+            // The form controls that merge a forwarded ref still discard the cleanup
+            // and detach with `ref(null)`, so this is not yet library-wide — grep
+            // `typeof ref === 'function'` for the current split. Memoized because an
+            // unstable ref identity makes React detach and re-attach on every render,
+            // which would run that cleanup each time.
+            if (node === null) {
+                const consumerCleanup = consumerCleanupRef.current;
+                consumerCleanupRef.current = null;
+                if (consumerCleanup) {
+                    consumerCleanup();
+                }
+                else {
+                    ref(null);
+                }
+                return;
+            }
+            const cleanup = ref(node);
+            consumerCleanupRef.current =
+                typeof cleanup === 'function' ? cleanup : null;
         }
         else if (ref) {
             ref.current = node;
         }
-    };
+    }, [ref]);
+    if (!isVisible) {
+        return null;
+    }
     const toastElement = (jsxRuntime.jsxs("div", { ref: setRef, className: combinedClasses, role: "alert", "aria-live": type === 'danger' || type === 'warning' ? 'assertive' : 'polite', onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, onClick: dismissible ? handleClose : undefined, ...rest, children: [jsxRuntime.jsx("span", { className: toastMessageClass, children: message }), (cancelText || actionText) && (jsxRuntime.jsxs("div", { className: toastActionsClass, children: [cancelText && (jsxRuntime.jsx("span", { className: toastCancelClass, children: jsxRuntime.jsx("button", { type: "button", className: toastButtonClass, onClick: e => {
                                 e.stopPropagation();
                                 handleClose();
@@ -4028,7 +4368,7 @@ const Toast = React.forwardRef(({ message, type = 'default', actionType, positio
     }
     const toastContent = jsxRuntime.jsx("div", { className: containerClasses, children: toastElement });
     if (typeof document !== 'undefined') {
-        return reactDom.createPortal(toastContent, resolveContainer());
+        return reactDom.createPortal(toastContent, resolvePortalContainer(container));
     }
     return null;
 });
@@ -4168,9 +4508,6 @@ const ToastContainer = ({ position = 'top-right', }) => {
         }) }), document.body);
 };
 
-// Ref-counted body scroll lock for chained/overlapping dialogs
-let _scrollLockCount = 0;
-let _originalOverflow = '';
 /**
  * The `Dialog` component provides ready-made confirm and alert dialogs, so a destructive action stays one `await dialog.confirm()` call away.
  *
@@ -4202,9 +4539,11 @@ let _originalOverflow = '';
  *   onCancel={() => setShowConfirm(false)}
  * />
  */
-const Dialog = React.forwardRef(({ isOpen, title, message, type = 'default', confirmText = 'OK', cancelText = 'Cancel', onConfirm, onCancel, showCancel = true, canCancel = true, focusCancel = false, icon, className, ...props }, ref) => {
+const Dialog = React.forwardRef(({ isOpen, title, message, type = 'default', confirmText = 'OK', cancelText = 'Cancel', onConfirm, onCancel, showCancel = true, canCancel = true, focusCancel = false, icon, portal, className, ...props }, ref) => {
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     const dialogRef = React.useRef(null);
+    // Cleanup returned by a consumer's callback ref on attach, held until detach.
+    const consumerCleanupRef = React.useRef(null);
     const confirmRef = React.useRef(null);
     const cancelRef = React.useRef(null);
     // Handle cancel
@@ -4223,48 +4562,47 @@ const Dialog = React.forwardRef(({ isOpen, title, message, type = 'default', con
             handleCancel();
         }
     }, [canCancel, handleCancel]);
-    // Handle escape key
-    React.useEffect(() => {
-        if (!isOpen || !canCancel)
-            return undefined;
-        const handleKeyDown = (e) => {
-            if (e.key === 'Escape') {
-                handleCancel();
-            }
-        };
-        document.addEventListener('keydown', handleKeyDown);
-        return () => document.removeEventListener('keydown', handleKeyDown);
-    }, [isOpen, canCancel, handleCancel]);
-    // Focus management
+    // Moving into the portal remounts the Modal's subtree — these buttons
+    // included — so the focus effect below has to re-run against the new
+    // nodes, exactly as the Modal's own focus effect does.
+    const isHydrated = useIsHydrated();
+    const isPortaled = Boolean(portal) && isHydrated;
+    // Focus management — Dialog picks a specific button rather than the
+    // Modal's default (first focusable/root); this effect runs after the
+    // inner Modal's own focus-on-open effect, so it wins.
     React.useEffect(() => {
         if (isOpen) {
             const buttonToFocus = focusCancel && showCancel ? cancelRef.current : confirmRef.current;
             buttonToFocus?.focus();
         }
-    }, [isOpen, focusCancel, showCancel]);
-    // Prevent body scroll (ref-counted so chained dialogs work correctly)
-    React.useEffect(() => {
-        if (isOpen) {
-            _scrollLockCount++;
-            if (_scrollLockCount === 1) {
-                _originalOverflow = document.body.style.overflow;
-                document.body.style.overflow = 'hidden';
-            }
-            return () => {
-                _scrollLockCount--;
-                if (_scrollLockCount === 0) {
-                    document.body.style.overflow = _originalOverflow;
-                }
-            };
-        }
-        return undefined;
-    }, [isOpen]);
+    }, [isOpen, focusCancel, showCancel, isPortaled]);
     // Use combined ref
     const combinedRef = React.useCallback((node) => {
         dialogRef.current =
             node;
         if (typeof ref === 'function') {
-            ref(node);
+            // React 19 lets a callback ref return a cleanup function and detaches by
+            // running it instead of calling the ref with `null`; React 18 discards the
+            // return value entirely. Returning it from here would be a React-19-only
+            // contract, so we hold the cleanup and run it ourselves on detach — the
+            // same shape as `Dropdown`, `Modal`, `Sidebar`, `Toast` and `Carousel`.
+            // The form controls that merge a forwarded ref still discard the cleanup
+            // and detach with `ref(null)`, so this is not yet library-wide — grep
+            // `typeof ref === 'function'` for the current split.
+            if (node === null) {
+                const consumerCleanup = consumerCleanupRef.current;
+                consumerCleanupRef.current = null;
+                if (consumerCleanup) {
+                    consumerCleanup();
+                }
+                else {
+                    ref(null);
+                }
+                return;
+            }
+            const cleanup = ref(node);
+            consumerCleanupRef.current =
+                typeof cleanup === 'function' ? cleanup : null;
         }
         else if (ref) {
             ref.current = node;
@@ -4307,7 +4645,7 @@ const Dialog = React.forwardRef(({ isOpen, title, message, type = 'default', con
     if (!isOpen) {
         return null;
     }
-    return (jsxRuntime.jsxs(Modal, { isActive: isOpen, children: [jsxRuntime.jsx(Modal.Background, { onClick: handleBackgroundClick }), jsxRuntime.jsxs("div", { ref: combinedRef, className: combinedClasses, role: "alertdialog", "aria-modal": "true", "aria-labelledby": title ? 'dialog-title' : undefined, "aria-describedby": "dialog-message", ...rest, children: [title && (jsxRuntime.jsxs("div", { className: headerClass, children: [displayIcon && jsxRuntime.jsx("span", { className: iconClass, children: displayIcon }), jsxRuntime.jsx("h3", { id: "dialog-title", className: titleClass, children: title })] })), jsxRuntime.jsx("div", { id: "dialog-message", className: bodyClass, children: message }), jsxRuntime.jsxs("div", { className: footerClass, children: [showCancel && (jsxRuntime.jsx("button", { ref: cancelRef, type: "button", className: cancelButtonClass, onClick: handleCancel, children: cancelText })), jsxRuntime.jsx("button", { ref: confirmRef, type: "button", className: confirmButtonClass, onClick: handleConfirm, children: confirmText })] })] })] }));
+    return (jsxRuntime.jsxs(Modal, { isActive: isOpen, onClose: handleCancel, role: "presentation", portal: portal, children: [jsxRuntime.jsx(Modal.Background, { onClick: handleBackgroundClick }), jsxRuntime.jsxs("div", { ref: combinedRef, className: combinedClasses, role: "alertdialog", "aria-modal": "true", "aria-labelledby": title ? 'dialog-title' : undefined, "aria-describedby": "dialog-message", ...rest, children: [title && (jsxRuntime.jsxs("div", { className: headerClass, children: [displayIcon && jsxRuntime.jsx("span", { className: iconClass, children: displayIcon }), jsxRuntime.jsx("h3", { id: "dialog-title", className: titleClass, children: title })] })), jsxRuntime.jsx("div", { id: "dialog-message", className: bodyClass, children: message }), jsxRuntime.jsxs("div", { className: footerClass, children: [showCancel && (jsxRuntime.jsx("button", { ref: cancelRef, type: "button", className: cancelButtonClass, onClick: handleCancel, children: cancelText })), jsxRuntime.jsx("button", { ref: confirmRef, type: "button", className: confirmButtonClass, onClick: handleConfirm, children: confirmText })] })] })] }));
 });
 Dialog.displayName = 'Dialog';
 let dialogListeners = new Set();
@@ -4390,14 +4728,16 @@ const validButtonColors = [...validColors, 'text', 'ghost'];
  *
  * @function
  * @param {ButtonProps} props - Props for the Button component.
- * @returns {JSX.Element} The rendered button or anchor element.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
+ * @returns {JSX.Element} The rendered button, anchor, or custom element.
  * @see {@link https://bulma.io/documentation/elements/button/ | Bulma Button documentation}
  */
-const Button = ({ color, size, isLight, isRounded, isLoading, isStatic, isFullwidth, isFullWidth, isOutlined, isInverted, isFocused, isActive, isHovered, isDisabled, className, children, textColor, bgColor, as: Component = 'button', href, onClick, target, rel, ...props }) => {
+const Button = React.forwardRef(function Button(props, ref) {
+    const { color, size, isLight, isRounded, isLoading, isStatic, isFullwidth, isFullWidth, isOutlined, isInverted, isFocused, isActive, isHovered, isDisabled, className, children, textColor, bgColor, as: Component = 'button', href, onClick, target, rel, ...bulmaProps } = props;
     const { bulmaHelperClasses, rest } = useBulmaClasses({
         color: textColor,
         backgroundColor: bgColor,
-        ...props,
+        ...bulmaProps,
     });
     // Generate Bulma classes with prefix
     const bulmaClasses = usePrefixedClassNames('button', {
@@ -4419,16 +4759,97 @@ const Button = ({ color, size, isLight, isRounded, isLoading, isStatic, isFullwi
     // Combine prefixed Bulma classes with unprefixed user className and prefixed helper classes
     const buttonClasses = classNames(bulmaClasses, bulmaHelperClasses, className);
     if (Component !== 'button') {
-        // Create anchor-specific props by excluding button-specific ones, so
-        // native/custom link-like elements (an <a>, a router Link, ...) don't
-        // receive button-only HTML attributes.
-        const { type: _type, disabled: _disabled, form: _form, formAction: _formAction, formEncType: _formEncType, formMethod: _formMethod, formNoValidate: _formNoValidate, formTarget: _formTarget, name: _name, value: _value, autoFocus: _autoFocus, ...anchorRest } = rest;
-        return (jsxRuntime.jsx(Component, { className: buttonClasses, href: href, target: target, rel: rel, "aria-disabled": isDisabled, tabIndex: isDisabled ? -1 : undefined, onClick: isDisabled
-                ? (e) => e.preventDefault()
-                : onClick, ...anchorRest, children: children }));
+        // Strip the form-control attributes a link-like element cannot carry, so a
+        // JavaScript consumer or a spread object doesn't put them on the DOM. The
+        // types no longer allow them through; this is the runtime backstop.
+        //
+        // Only for INTRINSIC tags. A custom component (a router Link, ...) owns its
+        // prop contract, and `ComponentPropsWithoutRef<T>` promises the caller that
+        // its props reach it. Stripping names by their spelling alone broke that
+        // promise silently: `<Button as={Custom} name="x" />` type-checked while
+        // `Custom` never received the `name` it requires.
+        //
+        // `autoFocus` and `type` are deliberately NOT stripped: both are valid on
+        // targets this list was filtering them from. `autoFocus` is a global
+        // attribute (React decides per element whether to honour it, which is not
+        // ours to pre-empt), and `type` on an anchor is the MIME hint that
+        // `ButtonProps<'a'>` now types it as.
+        //
+        // The types already answer this for a TypeScript caller: `ButtonProps<T>`
+        // derives from `ComponentPropsWithoutRef<T>`, so only what the target
+        // accepts can be passed. What is left is a runtime backstop for JavaScript
+        // consumers and spread objects.
+        //
+        // Keep it to the two cases where a stray attribute does something. The
+        // submit-overrides belong to a submit control and never make sense on the
+        // anchor path. `disabled` is the one that is VISIBLE: Bulma styles
+        // `.button[disabled]` (background, border, shadow, opacity), so letting it
+        // through to a `<span>` greys the element out — main stripped it, and not
+        // stripping it would be a silent visual change on a types-only release.
+        //
+        // Everything else (`name`, `value`, `form`) is inert where it does not
+        // belong, and enumerating which tags own it is what kept going wrong:
+        // first all nine names on every non-button tag (so `<Button as="input"
+        // name="query" value="Search">` submitted nothing), then a form-control
+        // allowlist that still lost `formAction` on an input and `value` on an
+        // option. Those now ride on the types instead.
+        //
+        // A custom component is exempt entirely — it owns its prop contract, and
+        // `ComponentPropsWithoutRef<T>` promises the caller its props arrive.
+        //
+        // The elements that own `disabled`, per the HTML spec. A closed set, unlike
+        // the open-ended question of which tag owns which attribute.
+        const SUBMIT_OVERRIDES = [
+            'formAction',
+            'formEncType',
+            'formMethod',
+            'formNoValidate',
+            'formTarget',
+        ];
+        const OWNS_DISABLED = [
+            'button',
+            'fieldset',
+            'input',
+            'optgroup',
+            'option',
+            'select',
+            'textarea',
+        ];
+        // Two independent filters. They are not exclusive — an `<a>` owns neither
+        // the submit-overrides nor `disabled`, so it takes both — and deriving them
+        // from one destructure, or from one if/else, is what broke each of them in
+        // turn: first the overrides came off every intrinsic (an `as="input"` lost
+        // `formAction`), then scoping them to the anchor let `disabled` back onto
+        // it.
+        const forwardedRest = { ...rest };
+        if (typeof Component === 'string' && !isCustomElement(Component)) {
+            // Meaningless anywhere but a submit control, and an anchor is not one.
+            if (Component === 'a') {
+                for (const key of SUBMIT_OVERRIDES)
+                    delete forwardedRest[key];
+            }
+            // Visible via Bulma's `.button[disabled]`, so withheld from any element
+            // that does not own it.
+            if (!OWNS_DISABLED.includes(Component))
+                delete forwardedRest.disabled;
+        }
+        return (jsxRuntime.jsx(Component, { ref: ref, className: buttonClasses, href: href, target: target, rel: rel, "aria-disabled": isDisabled, tabIndex: isDisabled ? -1 : undefined, onClick: isDisabled
+                ? // Guarded, because this handler is installed into whatever `as`
+                    // renders and a custom component's `onClick` need not be a DOM
+                    // event handler at all. One declaring `onClick: (v: string) =>
+                    // void` calls this with a string, and an unguarded
+                    // `e.preventDefault()` throws `is not a function`. Blocking the
+                    // real event is the point; a foreign payload is simply not ours
+                    // to act on.
+                    (e) => {
+                        if (typeof e?.preventDefault === 'function')
+                            e.preventDefault();
+                    }
+                : onClick, ...forwardedRest, children: children }));
     }
-    return (jsxRuntime.jsx("button", { className: buttonClasses, disabled: isDisabled, onClick: onClick, ...rest, children: children }));
-};
+    return (jsxRuntime.jsx("button", { ref: ref, className: buttonClasses, disabled: isDisabled, onClick: onClick, ...rest, children: children }));
+});
+Button.displayName = 'Button';
 
 /**
  * Individual carousel item/slide.
@@ -4487,6 +4908,8 @@ const DefaultNextIcon = () => (jsxRuntime.jsx("svg", { xmlns: "http://www.w3.org
 const Carousel = React.forwardRef(({ value: controlledValue, autoplay = false, interval = 5000, pauseOnHover = true, repeat = true, hasDrag = true, arrow = true, arrowHover = false, indicator = true, indicatorInside = false, indicatorPosition = 'bottom', indicatorStyle = 'dots', iconPrev, iconNext, iconLibrary, iconVariant, iconSize, iconFeatures, arrowBackground = true, arrowColor, ariaLabel = 'Image carousel', onChange, className, children, ...props }, ref) => {
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     const carouselRef = React.useRef(null);
+    // Cleanup returned by a consumer's callback ref on attach, held until detach.
+    const consumerCleanupRef = React.useRef(null);
     const containerRef = React.useRef(null);
     const [internalValue, setInternalValue] = React.useState(0);
     const [isPaused, setIsPaused] = React.useState(false);
@@ -4672,7 +5095,28 @@ const Carousel = React.forwardRef(({ value: controlledValue, autoplay = false, i
         carouselRef.current =
             node;
         if (typeof ref === 'function') {
-            ref(node);
+            // React 19 lets a callback ref return a cleanup function and detaches by
+            // running it instead of calling the ref with `null`; React 18 discards the
+            // return value entirely. Returning it from here would be a React-19-only
+            // contract, so we hold the cleanup and run it ourselves on detach — the
+            // same shape as `Dropdown`, `Modal`, `Dialog`, `Sidebar` and `Toast`.
+            // The form controls that merge a forwarded ref still discard the cleanup
+            // and detach with `ref(null)`, so this is not yet library-wide — grep
+            // `typeof ref === 'function'` for the current split.
+            if (node === null) {
+                const consumerCleanup = consumerCleanupRef.current;
+                consumerCleanupRef.current = null;
+                if (consumerCleanup) {
+                    consumerCleanup();
+                }
+                else {
+                    ref(null);
+                }
+                return;
+            }
+            const cleanup = ref(node);
+            consumerCleanupRef.current =
+                typeof cleanup === 'function' ? cleanup : null;
         }
         else if (ref) {
             ref.current = node;
@@ -4790,7 +5234,8 @@ function usePrefersReducedMotion() {
  *   ))}
  * </Reveal>
  */
-const Reveal = ({ animation = 'fade-up', delay = 0, duration = 600, threshold = 0.15, once = true, as: Component = 'div', cascade = false, cascadeInterval = 80, className, style, children, ...props }) => {
+function RevealImpl(revealProps) {
+    const { animation = 'fade-up', delay = 0, duration = 600, threshold = 0.15, once = true, as: Component = 'div', cascade = false, cascadeInterval = 80, className, style, children, ...props } = revealProps;
     const { bulmaHelperClasses, rest } = useBulmaClasses(props);
     const classPrefix = useClassPrefix();
     const prefersReducedMotion = usePrefersReducedMotion();
@@ -4867,12 +5312,16 @@ const Reveal = ({ animation = 'fade-up', delay = 0, duration = 600, threshold =
             return (jsxRuntime.jsx("span", { className: itemAnimationClasses, style: itemStyle, children: child }, index));
         })
         : children;
-    // Scroll observation needs a real DOM node. Intrinsic tags ('div',
-    // 'section', ...) always accept a ref directly. A custom component passed
-    // via `as` (Section, Card, ...) is rendered by this library as a plain
-    // React.FC with no ref forwarding, so the ref (and the animation classes
-    // that depend on it) go on a plain wrapper `div` instead, with `Component`
-    // rendered inside it.
+    // Scroll observation needs a DOM node this component OWNS — the observer and
+    // the animation classes both key off it. An intrinsic tag is that node, so
+    // the ref goes straight on it. A component passed via `as` is not: whatever
+    // it renders is its own business, and it may render several elements or
+    // none. So it gets wrapped in an observed `div`.
+    //
+    // Not a statement about ref forwarding. Several components in this library
+    // forward refs (#641 added four more), and that changes nothing here — a
+    // forwarded ref would still point at the target's node rather than at one
+    // this component controls.
     if (typeof Component === 'string') {
         // A plain createElement call sidesteps the combinatorial JSX prop types
         // for `ref` across every possible intrinsic tag `as` could be.
@@ -4884,7 +5333,9 @@ const Reveal = ({ animation = 'fade-up', delay = 0, duration = 600, threshold =
         }, content);
     }
     return (jsxRuntime.jsx("div", { ref: setNode, className: combinedClasses, style: wrapperStyle, children: jsxRuntime.jsx(Component, { ...rest, children: content }) }));
-};
+}
+const Reveal = RevealImpl;
+Reveal.displayName = 'Reveal';
 
 /**
  * The `Block` component renders a simple container with Bulma's `.block` class, adding vertical margin between sections of content.
@@ -4937,6 +5388,7 @@ const Box = ({ className, textColor, color, bgColor, hasShadow = true, children,
  *
  * @function
  * @param {LinkButtonProps} props - Props for the LinkButton component.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
  * @returns {JSX.Element} The rendered link-styled button element.
  *
  * @example
@@ -4947,11 +5399,18 @@ const Box = ({ className, textColor, color, bgColor, hasShadow = true, children,
  * // Underline variant with color
  * <LinkButton variant="underline" color="primary">Learn more</LinkButton>
  */
-const LinkButton = ({ variant = 'text', color, className, ...props }) => {
+const LinkButton = React.forwardRef(function LinkButton({ variant = 'text', color, className, ...props }, ref) {
     const buttonColor = variant === 'underline' ? 'text' : variant;
     const prefixedClasses = usePrefixedClassNames('link-button', color && `link-button-${color}`, variant === 'underline' && 'link-button-underline');
-    return (jsxRuntime.jsx(Button, { color: buttonColor, className: classNames(prefixedClasses, className), ...props }));
-};
+    return (jsxRuntime.jsx(Button
+    // LinkButton is polymorphic through to Button, which resolves the element
+    // from `as`. TS cannot infer that through the spread below.
+    , { 
+        // LinkButton is polymorphic through to Button, which resolves the element
+        // from `as`. TS cannot infer that through the spread below.
+        ref: ref, color: buttonColor, className: classNames(prefixedClasses, className), ...props }));
+});
+LinkButton.displayName = 'LinkButton';
 
 const validButtonsSizes = ['small', 'medium', 'large'];
 /**
@@ -5221,10 +5680,12 @@ const Image = ({ as, className, textColor, color, bgColor, size, isRounded, isRe
  *
  * @function
  * @param {LinkProps} props - Props for the Link component.
- * @returns {JSX.Element} The rendered anchor element.
+ * @param {React.Ref} ref - Forwarded ref to the element `as` renders.
+ * @returns {JSX.Element} The rendered anchor, or whatever `as` names.
  * @see {@link https://bulma.io/documentation/elements/content/ | Bulma Content documentation}
  */
-const Link = ({ className, textColor, bgColor, isActive, as: Component = 'a', children, ...props }) => {
+const Link = React.forwardRef(function Link(linkProps, ref) {
+    const { className, textColor, bgColor, isActive, as: Component = 'a', children, ...props } = linkProps;
     /**
      * Generates Bulma helper classes and separates out remaining props.
      */
@@ -5237,8 +5698,9 @@ const Link = ({ className, textColor, bgColor, isActive, as: Component = 'a', ch
         'is-active': isActive,
     });
     const linkClasses = classNames(bulmaClasses, bulmaHelperClasses, className);
-    return (jsxRuntime.jsx(Component, { className: linkClasses || undefined, ...rest, children: children }));
-};
+    return (jsxRuntime.jsx(Component, { ref: ref, className: linkClasses || undefined, ...rest, children: children }));
+});
+Link.displayName = 'Link';
 
 /**
  * The `ListItem` component renders a styled list item (`<li>`) element with Bulma helper class integration.