basalt-ui 1.26.0 → 1.28.0

package/dist/commands/define-overlays.d.ts

@@ -27,6 +27,27 @@
  */
 import type { ReactNode } from 'react';
 import type { Slot } from '../register.js';
+/**
+ * Declare that a `@mantine/modals` `<ModalsProvider>` is mounted and serving, and get back the
+ * function that retracts it. `BasaltOverlays` calls this for its own provider; a consumer mounting
+ * the provider THEMSELVES (with `<BasaltOverlays modals={false} />`, or with no `BasaltOverlays` at
+ * all) calls it too, or `overlays.confirm` cannot tell their provider from no provider and rejects.
+ *
+ * There is no way to detect the provider from outside React — its context is only readable through
+ * `useModals()`, and `confirm` is an imperative call with no component to read it from. So the
+ * registration is explicit.
+ *
+ * @example
+ * useEffect(() => registerModalsProvider(), [])
+ * // …beside your own <ModalsProvider> mount.
+ */
+export declare function registerModalsProvider(): () => void;
+/**
+ * Internal — `BasaltOverlays` registers its OWN lazy `ModalsProvider` here, and only when it
+ * actually renders one. Deliberately NOT on the `./commands` barrel (internal wiring only, same as
+ * `notifications/mount-guard`); the consumer-facing half is {@link registerModalsProvider}.
+ */
+export declare function useModalsLayer(enabled: boolean): void;
 /**
  * A single registered overlay. The per-overlay props type P is the consumer's own payload.
  *
@@ -92,6 +113,68 @@ export declare function defineOverlays<const T extends OverlayMap>(spec: T): T;
  * // Then include it in a defineOverlays({ 'confirm:delete': deleteOverlay }) call to register it.
  */
 export declare function defineOverlay<P = Record<string, unknown>>(overlay: Overlay<P>): Overlay<P>;
+/** Options for {@link overlays.confirm} — a two-button dialog that resolves to the answer. */
+export type ConfirmOptions = {
+    /** Dialog title — the question itself ("Delete photo.jpg?"), not a category. */
+    title: ReactNode;
+    /** Optional body under the title. A plain string is fine; a ReactNode renders as-is. */
+    body?: ReactNode;
+    /** Confirm button label. Default: 'Confirm'. */
+    confirmLabel?: string;
+    /** Cancel button label. Default: 'Cancel'. */
+    cancelLabel?: string;
+    /** Paint the confirm button in the destructive tone (the theme's derived `red` family). */
+    danger?: boolean;
+    /** Runs once, before the promise resolves `true`. */
+    onConfirm: () => void;
+    /** Runs once on cancel, escape, click-outside or the close button — every non-confirm exit. */
+    onCancel?: () => void;
+};
+/** Options for {@link overlays.confirmDelete} — the delete idiom over {@link ConfirmOptions}. */
+export type ConfirmDeleteOptions = {
+    /**
+     * The singular noun for what is being deleted — `'item'`, `'photo'`, `'API key'`. Pluralised by
+     * appending `s` when `count` is not 1; a noun that does not pluralise that way calls
+     * {@link overlays.confirm} directly with its own title.
+     */
+    subject: string;
+    /** How many. Default: 1. */
+    count?: number;
+    /** Runs once, before the promise resolves `true`. */
+    onConfirm: () => void;
+};
+/**
+ * Open a confirm dialog and resolve to the user's answer — `true` on confirm, `false` on every
+ * other exit (cancel, escape, click-outside, the close button). `onConfirm`/`onCancel` fire exactly
+ * once each at most, before the promise settles.
+ *
+ * Rejects with a named `[basalt]` error when the modals layer cannot serve the dialog — the
+ * `@mantine/modals` peer is absent, or no `ModalsProvider` is registered as live (see
+ * {@link registerModalsProvider}). Both would otherwise leave the promise pending forever: the
+ * imperative API is a window event bus with nothing subscribed.
+ *
+ * @example
+ * if (await overlays.confirm({ title: 'Discard draft?', onConfirm: () => reset() })) navigate('/')
+ *
+ * @example
+ * await overlays.confirm({
+ *   title: 'Revoke access?',
+ *   body: 'The key stops working immediately.',
+ *   confirmLabel: 'Revoke',
+ *   danger: true,
+ *   onConfirm: () => revoke(),
+ * })
+ */
+declare function confirm(options: ConfirmOptions): Promise<boolean>;
+/**
+ * The delete confirmation every app writes — `confirm` with the destructive tone, the `Delete`
+ * label and a counted title already filled in.
+ *
+ * @example
+ * overlays.confirmDelete({ subject: 'item', count: 3, onConfirm: () => removeSelected() })
+ * // → "Delete 3 items?"
+ */
+declare function confirmDelete(options: ConfirmDeleteOptions): Promise<boolean>;
 /**
  * Extract the props type for a registered overlay key.
  * When Overlays is un-augmented ({}) this resolves to `never` so open() is uncallable.
@@ -106,8 +189,13 @@ type OverlayProps<K extends OverlayKey> = Overlays extends {
  * quick-edit panels). For shareable/back-button/refreshable overlays use route masks via
  * ./router-tanstack.
  *
+ * `open` needs a REGISTERED overlay; `confirm`/`confirmDelete` need none — they are the two-button
+ * dialog every app was hand-writing as a registry entry.
+ *
  * @example
  * overlays.open('confirm:delete', { name: 'photo.jpg' })
+ * await overlays.confirm({ title: 'Discard draft?', danger: true, onConfirm: () => reset() })
+ * overlays.confirmDelete({ subject: 'item', count: 3, onConfirm: () => removeSelected() })
  * overlays.close()
  */
 export declare const overlays: {
@@ -122,6 +210,20 @@ export declare const overlays: {
      * overlays.open('user:edit', { id: '42' })
      */
     open<K extends OverlayKey>(key: K, props: OverlayProps<K>): void;
+    /**
+     * Open a confirm dialog and resolve to the answer — see {@link confirm}.
+     *
+     * @example
+     * const ok = await overlays.confirm({ title: 'Discard draft?', onConfirm: () => reset() })
+     */
+    confirm: typeof confirm;
+    /**
+     * The one-line delete idiom over {@link confirm} — see {@link confirmDelete}.
+     *
+     * @example
+     * overlays.confirmDelete({ subject: 'item', count: 3, onConfirm: () => removeSelected() })
+     */
+    confirmDelete: typeof confirmDelete;
     /**
      * Close all open overlays (delegates to modals.closeAll()).
      *

package/dist/commands/define-overlays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define-overlays.d.ts","sourceRoot":"","sources":["../../src/commands/define-overlays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAmBvC;;;;;;;;GAQG;AAEH,MAAM,MAAM,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IACjD,yDAAyD;IACzD,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,iDAAiD;IACjD,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,SAAS,CAAA;CAChC,CAAA;AAED;;;;;;;GAOG;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAA;AAIrD,wEAAwE;AACxE,KAAK,QAAQ,GAAG,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;AAE5C;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,QAAQ,EAAE,MAAM,CAAC,CAAA;AAaxD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,KAAK,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAGrE;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE1F;AAID;;;;GAIG;AACH,KAAK,YAAY,CAAC,CAAC,SAAS,UAAU,IAAI,QAAQ,SAAS;KAAG,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAAE,GACtF,CAAC,GACD,KAAK,CAAA;AAET;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;;;;;;OASG;SACE,CAAC,SAAS,UAAU,OAAO,CAAC,SAAS,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;IAehE;;;;;OAKG;aACM,IAAI;CAGd,CAAA"}
+{"version":3,"file":"define-overlays.d.ts","sourceRoot":"","sources":["../../src/commands/define-overlays.ts"],"names":[],"mappings":"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"}

package/dist/commands/define-overlays.js

@@ -1,8 +1,27 @@
+import { useEffect } from "react";
+import { missingLayer } from "../common/errors.js";
+import { isDev } from "../utils/is-dev.js";
 let modalsPromise;
 function loadModals() {
   modalsPromise ??= import("@mantine/modals").then((m) => m.modals).catch(() => void 0);
   return modalsPromise;
 }
+let mountedModalsProviders = 0;
+function registerModalsProvider() {
+  mountedModalsProviders++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    mountedModalsProviders--;
+  };
+}
+function useModalsLayer(enabled) {
+  useEffect(() => {
+    if (!enabled) return;
+    return registerModalsProvider();
+  }, [enabled]);
+}
 let activeOverlays = {};
 function defineOverlays(spec) {
   activeOverlays = spec;
@@ -11,6 +30,71 @@ function defineOverlays(spec) {
 function defineOverlay(overlay) {
   return overlay;
 }
+async function confirm(options) {
+  const {
+    title,
+    body,
+    confirmLabel = "Confirm",
+    cancelLabel = "Cancel",
+    danger = false,
+    onConfirm,
+    onCancel
+  } = options;
+  const modals = await loadModals();
+  if (modals === void 0) {
+    throw new Error(
+      missingLayer(
+        "overlays.confirm",
+        "@mantine/modals",
+        "install the @mantine/modals peer and mount <BasaltOverlays>"
+      )
+    );
+  }
+  if (mountedModalsProviders === 0) {
+    throw new Error(
+      missingLayer(
+        "overlays.confirm",
+        "a mounted <ModalsProvider>",
+        "drop `modals={false}` from <BasaltOverlays>, or mount <ModalsProvider> yourself and call registerModalsProvider() from an effect for as long as it is up"
+      )
+    );
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = (confirmed) => {
+      if (settled) return;
+      settled = true;
+      try {
+        if (confirmed) onConfirm();
+        else onCancel?.();
+      } finally {
+        resolve(confirmed);
+      }
+    };
+    modals.openConfirmModal({
+      title,
+      ...body !== void 0 && { children: body },
+      labels: { confirm: confirmLabel, cancel: cancelLabel },
+      // The destructive tone is the theme's `red` family (derived from the palette, bound to the
+      // --vx-* status tokens by cssVariablesResolver) — never a raw color.
+      ...danger && { confirmProps: { color: "red" } },
+      onConfirm: () => settle(true),
+      onCancel: () => settle(false),
+      onClose: () => settle(false)
+    });
+  });
+}
+function confirmDelete(options) {
+  const { subject, count = 1, onConfirm } = options;
+  const what = count === 1 ? subject : `${count} ${subject}s`;
+  return confirm({
+    title: `Delete ${what}?`,
+    body: "This cannot be undone.",
+    confirmLabel: "Delete",
+    danger: true,
+    onConfirm
+  });
+}
 const overlays = {
   /**
    * Open a registered overlay by key. Resolves the Overlay spec from the runtime stash and calls
@@ -25,7 +109,7 @@ const overlays = {
   open(key, props) {
     const spec = activeOverlays[key];
     if (spec === void 0) {
-      if (process.env["NODE_ENV"] !== "production")
+      if (isDev())
         console.warn(`[basalt] overlays.open: no overlay registered for "${String(key)}"`);
       return;
     }
@@ -36,6 +120,20 @@ const overlays = {
       })
     );
   },
+  /**
+   * Open a confirm dialog and resolve to the answer — see {@link confirm}.
+   *
+   * @example
+   * const ok = await overlays.confirm({ title: 'Discard draft?', onConfirm: () => reset() })
+   */
+  confirm,
+  /**
+   * The one-line delete idiom over {@link confirm} — see {@link confirmDelete}.
+   *
+   * @example
+   * overlays.confirmDelete({ subject: 'item', count: 3, onConfirm: () => removeSelected() })
+   */
+  confirmDelete,
   /**
    * Close all open overlays (delegates to modals.closeAll()).
    *
@@ -49,5 +147,7 @@ const overlays = {
 export {
   defineOverlay,
   defineOverlays,
-  overlays
+  overlays,
+  registerModalsProvider,
+  useModalsLayer
 };

package/dist/commands/index.d.ts

@@ -28,12 +28,21 @@
  * import { runCommand } from 'basalt-ui/commands'
  * runCommand('file:save')
  *
+ * // usage.ts — the registry-free confirm dialog:
+ * import { overlays } from 'basalt-ui/commands'
+ * const ok = await overlays.confirm({ title: 'Discard draft?', onConfirm: () => reset() })
+ * overlays.confirmDelete({ subject: 'item', count: 3, onConfirm: () => removeSelected() })
+ *
+ * // Mounting ModalsProvider yourself instead of letting <BasaltOverlays> do it:
+ * import { registerModalsProvider } from 'basalt-ui/commands'
+ * useEffect(() => registerModalsProvider(), [])
+ *
  * // Open/close Spotlight programmatically:
  * import { openSpotlight, closeSpotlight } from 'basalt-ui/commands'
  * openSpotlight()
  */
 export { defineCommands, defineCommand, runCommand, type Command, type CommandMap, type CommandId, type CommandRunContext, } from './define-commands.js';
-export { defineOverlays, defineOverlay, overlays, type Overlay, type OverlayMap, type OverlayKey, } from './define-overlays.js';
+export { defineOverlays, defineOverlay, overlays, registerModalsProvider, type Overlay, type OverlayMap, type OverlayKey, type ConfirmOptions, type ConfirmDeleteOptions, } from './define-overlays.js';
 export { toSpotlightActions, toRouteActions, toShortcutList, toHotkeyBindings, type RouteActionItem, type RouteActionSection, type ToRouteActionsOptions, type ShortcutEntry, type HotkeyBinding, } from './projectors.js';
 export { parseShortcut, detectMac, formatShortcutDisplay } from './shortcut-format.js';
 export { useCommandHotkeys } from './useCommandHotkeys.js';

package/dist/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,EACL,cAAc,EACd,aAAa,EACb,UAAU,EACV,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EACL,cAAc,EACd,aAAa,EACb,QAAQ,EACR,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,UAAU,GAChB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAA;AAGrB,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAGnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAGvD,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGxE,OAAO,EACL,cAAc,EACd,KAAK,mBAAmB,EACxB,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,EACL,cAAc,EACd,aAAa,EACb,UAAU,EACV,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EACL,cAAc,EACd,aAAa,EACb,QAAQ,EACR,sBAAsB,EACtB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,cAAc,EACnB,KAAK,oBAAoB,GAC1B,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,cAAc,CAAA;AAGrB,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AAGnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAGvD,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAGxE,OAAO,EACL,cAAc,EACd,KAAK,mBAAmB,EACxB,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,kBAAkB,CAAA"}

package/dist/commands/index.js

@@ -6,7 +6,8 @@ import {
 import {
   defineOverlays,
   defineOverlay,
-  overlays
+  overlays,
+  registerModalsProvider
 } from "./define-overlays.js";
 import {
   toSpotlightActions,
@@ -37,6 +38,7 @@ export {
   openSpotlight,
   overlays,
   parseShortcut,
+  registerModalsProvider,
   runCommand,
   toHotkeyBindings,
   toRouteActions,

package/dist/commands/overlays-mount.d.ts

@@ -2,9 +2,16 @@
  * overlays-mount — composable overlay mount for basalt-ui apps.
  *
  * `BasaltOverlays` bundles ModalsProvider, Spotlight, and Notifications into a single mount point.
- * Put it inside BasaltProvider, before the router. It replaces the standalone `<BasaltNotifications />`
- * from `basalt-ui/notifications` — do NOT mount both `<BasaltOverlays notifications />` and
- * `<BasaltNotifications />` in the same tree (double-mount of `<Notifications />`).
+ * Put it inside BasaltProvider, before the router. It replaces the standalone
+ * `<BasaltNotifications />` from `basalt-ui/notifications` — do NOT mount both
+ * `<BasaltOverlays notifications />` and `<BasaltNotifications />` in the same tree (double-mount
+ * of `<Notifications />`).
+ *
+ * Every layer — ModalsProvider included — mounts as a SIBLING of `children`, never as a wrapper:
+ * see the comment in the component body (R1). `@mantine/modals`' imperative API (`modals.open*`,
+ * and so basalt's own `overlays.open`) is a window CustomEvent bus that ModalsProvider subscribes
+ * to, so nothing needs to be inside it; the one thing a sibling cannot serve is Mantine's
+ * `useModals()` context hook.
  *
  * Each overlay system is opt-in via props (all default to true). Use flags to disable layers the
  * app does not need — e.g. a charts-only app that has no commands can set `spotlight={false}`.
@@ -98,9 +105,9 @@ export type BasaltOverlaysProps = {
     children: ReactNode;
 };
 /**
- * Composable overlay mount — wraps children in ModalsProvider and renders Spotlight +
- * Notifications siblings. All three layers are enabled by default; pass `false` to disable.
- * A disabled layer's optional peer is never imported.
+ * Composable overlay mount — renders ModalsProvider, Spotlight and Notifications as siblings of
+ * `children`. All three layers are enabled by default; pass `false` to disable. A disabled layer's
+ * optional peer is never imported.
  *
  * Mount exactly ONE BasaltOverlays per app. Do NOT combine with a standalone
  * `<BasaltNotifications />` from `basalt-ui/notifications` — that would double-mount

package/dist/commands/overlays-mount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"overlays-mount.d.ts","sourceRoot":"","sources":["../../src/commands/overlays-mount.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAA;AAGrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAiC7D;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;gBAChB,IAAI;iBAGH,IAAI;kBAGH,IAAI;CAGjB,CAAA;AAID,0DAA0D;AAC1D,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAID,MAAM,MAAM,mBAAmB,GAAG;IAChC,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,yEAAyE;IACzE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,iJAAiJ;IACjJ,kBAAkB,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAA;IACzD;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,mBAAmB,EAAE,CAAA;IACxC;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,8BAA8B;IAC9B,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AA2FD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EAAE,YAAmB,EAC3B,SAAS,EAAE,eAAsB,EACjC,aAAa,EAAE,mBAA0B,EACzC,OAAO,EAAE,aAAoB,EAC7B,kBAAkB,EAClB,gBAAgB,EAChB,eAAsB,EACtB,QAAQ,GACT,EAAE,mBAAmB,+BAmCrB"}
+{"version":3,"file":"overlays-mount.d.ts","sourceRoot":"","sources":["../../src/commands/overlays-mount.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAA;AAGrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAmC7D;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;gBAChB,IAAI;iBAGH,IAAI;kBAGH,IAAI;CAGjB,CAAA;AAID,0DAA0D;AAC1D,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAED,2DAA2D;AAC3D,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAID,MAAM,MAAM,mBAAmB,GAAG;IAChC,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,yEAAyE;IACzE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,iJAAiJ;IACjJ,kBAAkB,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAA;IACzD;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,mBAAmB,EAAE,CAAA;IACxC;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,8BAA8B;IAC9B,QAAQ,EAAE,SAAS,CAAA;CACpB,CAAA;AAqHD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EAAE,YAAmB,EAC3B,SAAS,EAAE,eAAsB,EACjC,aAAa,EAAE,mBAA0B,EACzC,OAAO,EAAE,aAAoB,EAC7B,kBAAkB,EAClB,gBAAgB,EAChB,eAAsB,EACtB,QAAQ,GACT,EAAE,mBAAmB,+BAkCrB"}

package/dist/commands/overlays-mount.js

@@ -1,8 +1,10 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { lazy, Suspense } from "react";
 import { runCommand } from "./define-commands.js";
+import { useModalsLayer } from "./define-overlays.js";
 import { toSpotlightActions } from "./projectors.js";
 import { useCommandHotkeys } from "./useCommandHotkeys.js";
+import { useNotificationsMountGuard } from "../notifications/mount-guard.js";
 let spotlightHandlePromise;
 function loadSpotlightHandle() {
   spotlightHandlePromise ??= import("@mantine/spotlight").then(({ createSpotlight }) => {
@@ -34,6 +36,7 @@ function PassthroughFragment({ children }) {
 const LazyModalsProvider = lazy(
   () => import("@mantine/modals").then((m) => ({ default: m.ModalsProvider })).catch(() => ({ default: PassthroughFragment }))
 );
+Object.assign(LazyModalsProvider, { displayName: "LazyModalsProvider" });
 function NullFallback() {
   return null;
 }
@@ -63,12 +66,28 @@ const LazySpotlightMount = lazy(
     return { default: SpotlightMountInner };
   }).catch(() => ({ default: NullFallback }))
 );
+Object.assign(LazySpotlightMount, { displayName: "LazySpotlightMount" });
 function NotificationsFallback(_props) {
   return null;
 }
 const LazyNotifications = lazy(
   () => import("@mantine/notifications").then((m) => ({ default: m.Notifications })).catch(() => ({ default: NotificationsFallback }))
 );
+Object.assign(LazyNotifications, { displayName: "LazyNotifications" });
+function NotificationsLayer({
+  notificationsProps
+}) {
+  useNotificationsMountGuard();
+  return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+    LazyNotifications,
+    {
+      position: "bottom-right",
+      autoClose: 4e3,
+      limit: 5,
+      ...notificationsProps
+    }
+  ) });
+}
 function HotkeysMount() {
   useCommandHotkeys();
   return null;
@@ -83,7 +102,8 @@ function BasaltOverlays({
   projectCommands = true,
   children
 }) {
-  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
+  useModalsLayer(enableModals);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
     enableSpotlight && /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
       LazySpotlightMount,
       {
@@ -91,22 +111,11 @@ function BasaltOverlays({
         ...spotlightActions !== void 0 && { extraActions: spotlightActions }
       }
     ) }),
-    enableNotifications && /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
-      LazyNotifications,
-      {
-        position: "bottom-right",
-        autoClose: 4e3,
-        limit: 5,
-        ...notificationsProps
-      }
-    ) }),
+    enableNotifications && /* @__PURE__ */ jsx(NotificationsLayer, { notificationsProps }),
     enableHotkeys && /* @__PURE__ */ jsx(HotkeysMount, {}),
+    enableModals && /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(LazyModalsProvider, {}) }),
     children
   ] });
-  if (enableModals) {
-    return /* @__PURE__ */ jsx(Suspense, { fallback: /* @__PURE__ */ jsx(Fragment, { children: content }), children: /* @__PURE__ */ jsx(LazyModalsProvider, { children: content }) });
-  }
-  return /* @__PURE__ */ jsx(Fragment, { children: content });
 }
 export {
   BasaltOverlays,

package/dist/common/errors.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The message table (Blueprint audit §3). Every basalt diagnostic — thrown or logged — is built
+ * here, so the prefix, the `Component: …` shape and the em-dash-then-remedy rhythm are one decision
+ * instead of 60. It is the generalisation of `assertQueryStateLike`, which was the ONLY component
+ * in the library naming itself in its own failure (isomorphic finding F-ERR-1: the other 54 fail as
+ * raw `TypeError`s that `BasaltErrorBoundary` swallows into a blank subtree).
+ *
+ * Every builder returns a string; nothing here throws or logs. The caller decides which it is —
+ * `assertRequiredProps` throws, `useValidateProps` logs, the mount guards log.
+ */
+/** The one namespace every basalt message opens with. */
+export declare const BASALT_PREFIX = "[basalt]";
+/**
+ * A prop the component reads into and cannot render without. This is the F-ERR-1 message: the
+ * component names itself and the prop, instead of the read landing as
+ * `undefined is not an object (evaluating 'field.use')`.
+ */
+export declare function requiredProp(component: string, prop: string, hint?: string): string;
+/** A prop with a closed value set that got something outside it. */
+export declare function oneOf(component: string, prop: string, allowed: readonly string[], got: unknown): string;
+/**
+ * A prop still shipped and still working, with a named successor and the version it goes away in.
+ * Majors are banned here, so the deprecation notice IS the migration channel.
+ */
+export declare function deprecatedProp(component: string, oldProp: string, newProp: string, removeIn: string): string;
+/**
+ * An imperative call needs a layer that is not there — the optional peer is not installed, or the
+ * mount that subscribes to its event bus is disabled. Both halves are named because the remedy
+ * differs: install it, or stop turning it off.
+ */
+export declare function missingLayer(component: string, layer: string, remedy: string): string;
+/** A single-mount component found a second instance alive (`BasaltProvider`, `Notifications`). */
+export declare function duplicateMount(component: string): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/common/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/common/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,yDAAyD;AACzD,eAAO,MAAM,aAAa,aAAa,CAAA;AAMvC;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED,oEAAoE;AACpE,wBAAgB,KAAK,CACnB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,GAAG,EAAE,OAAO,GACX,MAAM,CAMR;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAErF;AAED,kGAAkG;AAClG,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxD"}

package/dist/common/errors.js

@@ -0,0 +1,36 @@
+const BASALT_PREFIX = "[basalt]";
+function message(component, body) {
+  return `${BASALT_PREFIX} ${component}: ${body}`;
+}
+function requiredProp(component, prop, hint) {
+  return message(component, `prop "${prop}" is required${hint === void 0 ? "." : ` \u2014 ${hint}`}`);
+}
+function oneOf(component, prop, allowed, got) {
+  return message(
+    component,
+    `prop "${prop}" must be one of ${allowed.map((value) => `'${value}'`).join(" | ")} \u2014 got ${JSON.stringify(got)}.`
+  );
+}
+function deprecatedProp(component, oldProp, newProp, removeIn) {
+  return message(
+    component,
+    `prop "${oldProp}" is deprecated \u2014 use "${newProp}" instead. "${oldProp}" is removed in ${removeIn}.`
+  );
+}
+function missingLayer(component, layer, remedy) {
+  return message(component, `needs ${layer}, which is not available \u2014 ${remedy}.`);
+}
+function duplicateMount(component) {
+  return message(
+    component,
+    "more than one instance is mounted at once \u2014 mount exactly one, at the app root."
+  );
+}
+export {
+  BASALT_PREFIX,
+  deprecatedProp,
+  duplicateMount,
+  missingLayer,
+  oneOf,
+  requiredProp
+};

package/dist/common/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `common` — the prop, ref, message and validation primitives every basalt component shares.
+ *
+ * Not a published subpath: the pieces are re-exported from the root barrel (`.`) so a consumer has
+ * one import, and `src/surfaces.ts` stays the SSOT for real subpaths. The module is Mantine-free by
+ * rule (`.oxlintrc.json`) and by test (`boundary.test.ts`), so the Mantine-free half of the library
+ * may reach it too.
+ */
+export { type BasaltProps, type SlotClassNames, type SlotStylesProps } from './props.js';
+export { type Tone, type ToneWithNeutral, type Tier, cx } from './props.js';
+export { assignRef, mergeRefs } from './refs.js';
+export { BASALT_PREFIX, requiredProp, oneOf, deprecatedProp, duplicateMount, missingLayer, } from './errors.js';
+export { useValidateProps, assertRequiredProps, resetValidatedProps } from './validate.js';
+export { scrollParentOf, SCROLLPORT_ATTRIBUTE } from './scroll-parent.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AACrF,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,eAAe,EAAE,KAAK,IAAI,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AACxE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAC7C,OAAO,EACL,aAAa,EACb,YAAY,EACZ,KAAK,EACL,cAAc,EACd,cAAc,EACd,YAAY,GACb,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AACvF,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/common/index.js

@@ -0,0 +1,29 @@
+import {} from "./props.js";
+import { cx } from "./props.js";
+import { assignRef, mergeRefs } from "./refs.js";
+import {
+  BASALT_PREFIX,
+  requiredProp,
+  oneOf,
+  deprecatedProp,
+  duplicateMount,
+  missingLayer
+} from "./errors.js";
+import { useValidateProps, assertRequiredProps, resetValidatedProps } from "./validate.js";
+import { scrollParentOf, SCROLLPORT_ATTRIBUTE } from "./scroll-parent.js";
+export {
+  BASALT_PREFIX,
+  SCROLLPORT_ATTRIBUTE,
+  assertRequiredProps,
+  assignRef,
+  cx,
+  deprecatedProp,
+  duplicateMount,
+  mergeRefs,
+  missingLayer,
+  oneOf,
+  requiredProp,
+  resetValidatedProps,
+  scrollParentOf,
+  useValidateProps
+};

package/dist/common/props.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The prop vocabulary every basalt component shares (Blueprint audit §1, isomorphic finding C8).
+ *
+ * The finding this file answers: 98 of 123 exported components drop `className`, so a consumer who
+ * needs one margin has to fork the component. Fixing that per component is 79 edits; fixing it once
+ * here is one — every component's props type extends `BasaltProps`, and the root element takes
+ * `cx(classes.root, className)` plus `style`.
+ *
+ * **`className` + per-slot `classNames`, and nothing else.** No `styles` object, no `vars`: basalt
+ * does not spread `...rest` onto the DOM (which is why the harness saw zero unknown-attribute
+ * warnings), and a `styles`/`vars` surface would re-open the styling seam Mantine already owns for
+ * the primitives underneath. A composite that needs more than its root styled declares its SLOT
+ * NAMES in its own props type — `SlotStylesProps<'root' | 'header' | 'body'>` — so the slot set is
+ * a documented, compiler-checked union rather than an open record.
+ *
+ * This module is **Mantine-free and React-type-only** so `./charts` and `./tokens` may reach it
+ * without breaching the layer boundary (`common/boundary.test.ts` pins that, and `.oxlintrc.json`
+ * bans `@mantine/*` here the same way it does for `state`/`query`/`guard`).
+ */
+import type { CSSProperties } from 'react';
+/**
+ * The base every basalt component accepts. `| undefined` is explicit on both members because
+ * `exactOptionalPropertyTypes` is on: a component destructuring `className` and forwarding it to a
+ * child would otherwise fail to type-check at every call site.
+ */
+export interface BasaltProps {
+    /** Appended to the root element's own class — never replaces it. */
+    readonly className?: string | undefined;
+    /** Merged onto the root element's own inline style, if it has one. */
+    readonly style?: CSSProperties | undefined;
+}
+/** One class per named slot. The slot union is the component's documented contract. */
+export type SlotClassNames<S extends string> = Partial<Record<S, string>>;
+/**
+ * The composite half of the contract: a container that paints more than one box publishes its slot
+ * names here. The set is small on purpose — `Section`, `StatCard`, `ChartCard`, `PageBar`,
+ * `PageAside`, `WidgetHeader`, `EmptyState`, `QueryState`, `BasaltDataTable`. A leaf takes
+ * `BasaltProps` alone.
+ */
+export interface SlotStylesProps<S extends string> {
+    readonly classNames?: SlotClassNames<S> | undefined;
+}
+/**
+ * The ONE status vocabulary (audit A13). Five forks exist today — `StatCardTone` and
+ * `SidebarBlockTone` are byte-identical to this, `CalloutKind` / `AccountBadgeTone` /
+ * `NotificationIntent` each differ — and they stay put for now: an adopter aliases its fork to this
+ * type, it does not get renamed out from under a consumer.
+ */
+export type Tone = 'good' | 'warn' | 'bad';
+/** `Tone` plus the un-toned state — a badge or a block with nothing to say yet. */
+export type ToneWithNeutral = Tone | 'neutral';
+/**
+ * The heading tier (`docs/CONTROLS-SPEC.md` §2.2). Re-exported from its owner rather than declared
+ * twice — `WidgetHeaderTier` stays the name on the public barrel; `Tier` is what `common`-aware
+ * code spells. Type-only, so this file emits no runtime edge into the Mantine-coupled half.
+ */
+export type { WidgetHeaderTier as Tier } from '../widget-header/widget-header.js';
+/**
+ * The class joiner. Replaces the `[a, b].filter(Boolean).join(' ')` spelled out in seven files
+ * today; falsy parts drop, so `cx(classes.root, open && classes.open, className)` is the idiom.
+ */
+export declare function cx(...parts: Array<string | false | null | undefined>): string;
+//# sourceMappingURL=props.d.ts.map

package/dist/common/props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props.d.ts","sourceRoot":"","sources":["../../src/common/props.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC,sEAAsE;IACtE,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CAC3C;AAED,uFAAuF;AACvF,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA;AAEzE;;;;;GAKG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM;IAC/C,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;CACpD;AAED;;;;;GAKG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAA;AAE1C,mFAAmF;AACnF,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,SAAS,CAAA;AAE9C;;;;GAIG;AACH,YAAY,EAAE,gBAAgB,IAAI,IAAI,EAAE,MAAM,gCAAgC,CAAA;AAE9E;;;GAGG;AACH,wBAAgB,EAAE,CAAC,GAAG,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,MAAM,CAE7E"}

package/dist/common/props.js

@@ -0,0 +1,6 @@
+function cx(...parts) {
+  return parts.filter((part) => typeof part === "string" && part !== "").join(" ");
+}
+export {
+  cx
+};