basalt-ui 1.40.3 → 2.0.0

package/src/forms/use-form-draft.ts

@@ -1,262 +0,0 @@
-/**
- * ./forms — useFormDraft: autosave/restore/clear draft persistence via createPersistedState.
- * Mantine-coupled (reads from UseFormReturnType). Optional peer: @mantine/form.
- *
- * AUTOSAVE: `autosave: true` and the hook owns its own subscription. It used to be a documented
- * ref dance — declare a `saveDraftRef`, pass `onValuesChange: () => saveDraftRef.current?.()` into
- * `useBasaltForm`, assign the ref after the hook returns — which was copied verbatim into the
- * playground, and a five-line init-order puzzle a consumer has to re-derive is a hook that has not
- * finished being written. The dance still works; it is no longer the recommended path.
- *
- * @example (automatic)
- * const form = useBasaltForm({ initialValues, schema })
- * const { clearDraft, hasDraft } = useFormDraft(form, { key: 'my-form', version: 1, autosave: true })
- *
- * @example (manual — a blur-only save, or a form not created by useBasaltForm)
- * const { clearDraft, saveDraft } = useFormDraft(form, { key: 'my-form', version: 1 })
- * <TextInput key={fieldKey(form, 'name')} {...inputProps(form, 'name')} onBlur={saveDraft} />
- */
-import { useCallback, useEffect, useRef } from 'react'
-import type { UseFormReturnType } from '@mantine/form'
-import { createPersistedState } from '../state'
-import type { StandardSchemaV1 } from '../register'
-
-// ── Types ────────────────────────────────────────────────────────────────────
-
-/** Options for useFormDraft. */
-export type UseFormDraftOptions<Values> = {
-  /**
-   * Stable localStorage key for the draft. Must not change between renders —
-   * changing the key recreates the storage instance and loses the draft.
-   * Will be stored under `basalt:form:<key>`.
-   */
-  key: string
-  /** Envelope version — increment when the values shape changes to discard stale drafts. */
-  version: number
-  /** Optional Standard Schema to validate the persisted draft before restoring. */
-  schema?: StandardSchemaV1<unknown, Values>
-  /**
-   * Persist on every value change, debounced. `true` uses {@link DEFAULT_AUTOSAVE_DEBOUNCE_MS};
-   * pass `{ debounceMs }` to tune it (`0` saves on the next macrotask).
-   *
-   * **The on/off decision and the watched key set are read ONCE, on mount.** The subscription is
-   * `form.watch` per top-level key, and `watch` calls `useEffect` internally, so both are a hook
-   * count and neither may move between renders. Flipping this prop later therefore neither starts
-   * nor stops autosaving; a form whose top-level SHAPE changes after mount needs `saveDraft` called
-   * by hand for the new keys. `debounceMs` is the exception — it is read at FIRE time, so a form
-   * that widens its window mid-edit gets the new one.
-   *
-   * Nested edits are covered: Mantine notifies a parent-path subscriber for a `a.b.c` change, so
-   * watching the top level watches the whole tree.
-   */
-  autosave?: boolean | { debounceMs?: number }
-}
-
-/** Long enough that a typed word is one write, short enough that a closed tab keeps the sentence. */
-export const DEFAULT_AUTOSAVE_DEBOUNCE_MS = 500
-
-/** Return value of useFormDraft. */
-export type UseFormDraftReturn = {
-  /** True when a draft different from the initial values is persisted. */
-  hasDraft: boolean
-  /** Persist the current form values to localStorage. Call on blur, onValuesChange, or submit failure. */
-  saveDraft: () => void
-  /** Clear the persisted draft (call in onSubmit success). */
-  clearDraft: () => void
-}
-
-// ── useFormDraft ─────────────────────────────────────────────────────────────
-
-/**
- * Autosave/restore/clear-on-submit draft persistence for Mantine forms.
- * Backed by `createPersistedState` (versioned, SSR-safe, cross-tab).
- *
- * MUST-HAVES:
- * - Restores the draft once on mount if a draft is persisted.
- * - `clearDraft()` removes the persisted draft (call in onSubmit success).
- * - `saveDraft()` snapshots current form values (call onBlur, or leave it to `autosave`).
- * - `autosave: true` subscribes for you — see {@link UseFormDraftOptions.autosave} for the two
- *   properties that are frozen at mount, and why.
- *
- * @example
- * import * as v from 'valibot'
- * import { useBasaltForm, inputProps, fieldKey, FormErrorSummary, useFormDraft } from 'basalt-ui/forms'
- *
- * const Schema = v.object({ name: v.pipe(v.string(), v.minLength(2)), amount: v.number() })
- * type Values = v.InferOutput<typeof Schema>
- * const INITIAL: Values = { name: '', amount: 0 }
- *
- * function MyForm() {
- *   const form = useBasaltForm({ initialValues: INITIAL, schema: Schema, mode: 'uncontrolled' })
- *   const { clearDraft, hasDraft } = useFormDraft(form, { key: 'my-form', version: 1, autosave: true })
- *   return (
- *     <form onSubmit={form.onSubmit((values) => { submit(values); clearDraft() })}>
- *       <FormErrorSummary form={form} />
- *       <TextInput key={fieldKey(form, 'name')} {...inputProps(form, 'name')} />
- *       {hasDraft && <Button onClick={clearDraft}>Clear draft</Button>}
- *     </form>
- *   )
- * }
- */
-export function useFormDraft<Values extends Record<string, unknown>>(
-  form: UseFormReturnType<Values>,
-  opts: UseFormDraftOptions<Values>,
-): UseFormDraftReturn {
-  const { key, version, schema, autosave } = opts
-
-  // Create ONE stable store instance per key. useRef + lazy init so it is never
-  // recreated on re-render. `key` MUST be stable (document this invariant above).
-  // The storage key becomes `basalt:form:<key>` (createPersistedState auto-namespaces `basalt:*`).
-  const storeRef = useRef<ReturnType<typeof createPersistedState<DraftEnvelope<Values>>> | null>(
-    null,
-  )
-  if (storeRef.current === null) {
-    const envelopeSchema = wrapEnvelopeSchema(schema)
-    storeRef.current = createPersistedState<DraftEnvelope<Values>>({
-      key: `form:${key}`,
-      version,
-      initial: null,
-      // exactOptionalPropertyTypes forbids `schema: undefined`, so it is spread or omitted.
-      ...(envelopeSchema !== undefined && { schema: envelopeSchema }),
-    })
-  }
-
-  const useDraft = storeRef.current
-  const [draft, setDraft] = useDraft()
-
-  // Track whether a draft exists — differs from null initial
-  const hasDraft = draft !== null
-
-  // RESTORE: once on mount, if a draft exists, restore it into the form.
-  // useEffect runs once (empty dep array); `form` and `draft` captured via ref to avoid
-  // re-running on subsequent renders. This is intentionally mount-only.
-  const restoredRef = useRef(false)
-  const formRef = useRef(form)
-  formRef.current = form
-  const draftOnMountRef = useRef(draft)
-
-  useEffect(() => {
-    if (restoredRef.current) return
-    restoredRef.current = true
-    const mountDraft = draftOnMountRef.current
-    if (mountDraft !== null) {
-      formRef.current.setValues(mountDraft.values as Partial<Values>)
-    }
-    // Intentionally empty deps — restore happens once on mount only.
-  }, [])
-
-  const saveDraft = (): void => {
-    const values = formRef.current.getValues()
-    setDraft({ values })
-  }
-
-  const clearDraft = (): void => {
-    setDraft(null)
-  }
-
-  useAutosave(form, autosave, saveDraft)
-
-  return { hasDraft, saveDraft, clearDraft }
-}
-
-// ── the two pieces the hook composes ─────────────────────────────────────────
-
-/** What `createPersistedState` stores: the values under one key, or nothing persisted at all. */
-type DraftEnvelope<Values> = { values: Values } | null
-
-/**
- * Lifts a `Values` schema into a `DraftEnvelope<Values>` one, through the `~standard` interface.
- *
- * Only the inner `values` field is validated, and every failure resolves to `null` rather than to an
- * issue list: a draft is a convenience, so a stale or hand-edited one is DROPPED, never surfaced as
- * a validation error against a form the user has not touched yet. The async arm resolves to `null`
- * for the same reason `useBasaltForm` pins `sync: true` — `createPersistedState` reads storage
- * synchronously and has nowhere to await.
- *
- * Outside the hook because it is pure, closes over nothing, and inside it read as a third
- * responsibility in a body that already owned the store, the restore and the autosave.
- */
-function wrapEnvelopeSchema<Values>(
-  schema: StandardSchemaV1<unknown, Values> | undefined,
-): StandardSchemaV1<unknown, DraftEnvelope<Values>> | undefined {
-  if (schema === undefined) return undefined
-  return {
-    '~standard': {
-      version: 1 as const,
-      vendor: 'basalt-form-draft',
-      validate: (raw: unknown) => {
-        if (typeof raw !== 'object' || raw === null || !('values' in raw)) return { value: null }
-        const result = schema['~standard'].validate((raw as { values: unknown }).values)
-        if (result instanceof Promise) return { value: null }
-        if (result.issues !== undefined) return { value: null }
-        return { value: { values: result.value } }
-      },
-    },
-  }
-}
-
-/**
- * The debounced `form.watch` subscription behind `autosave`.
- *
- * **It relies on `form.watch` calling exactly one `useEffect` per call**, which is why the watched
- * path set is frozen on the first render: `watch` registers that effect INSIDE itself (checked in
- * the installed `@mantine/form` 9.3.2 source, `use-form-watch.ts`), so the number of `watch` calls
- * IS a hook count and a set that changed between renders would trip React's hook-order invariant.
- * Freezing it is what makes the loop below legal.
- *
- * That is a load-bearing dependency on an implementation detail of a peer, so state it plainly: a
- * `@mantine/form` minor that moves `watch` off `useEffect` — or calls a second hook from it —
- * changes the shape of this file. The failure would be loud (a hook-order error in dev on the first
- * autosaving form), not silent, but it is a real upgrade risk and belongs in the upgrade's diff
- * review rather than in a consumer's bug report.
- *
- * Nested edits need no extra paths: Mantine notifies a parent-path subscriber for an `a.b.c` write,
- * so watching every top-level key watches the whole tree.
- */
-function useAutosave<Values extends Record<string, unknown>>(
-  form: UseFormReturnType<Values>,
-  autosave: UseFormDraftOptions<Values>['autosave'],
-  saveDraft: () => void,
-): void {
-  const watchedPathsRef = useRef<string[] | null>(null)
-  if (watchedPathsRef.current === null) {
-    watchedPathsRef.current =
-      autosave === undefined || autosave === false ? [] : Object.keys(form.getValues())
-  }
-
-  // Read at FIRE time, not at schedule time, so a window that opened three renders ago still writes
-  // the current values and the current debounce.
-  const debounceRef = useRef(DEFAULT_AUTOSAVE_DEBOUNCE_MS)
-  debounceRef.current =
-    typeof autosave === 'object'
-      ? (autosave.debounceMs ?? DEFAULT_AUTOSAVE_DEBOUNCE_MS)
-      : DEFAULT_AUTOSAVE_DEBOUNCE_MS
-  // `saveDraft` is a fresh closure each render and `watch`'s effect re-subscribes whenever its
-  // callback identity changes, so the callback handed to `watch` must be stable and read the ref.
-  const saveRef = useRef<() => void>(saveDraft)
-  saveRef.current = saveDraft
-
-  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const scheduleSave = useCallback(() => {
-    if (timerRef.current !== null) clearTimeout(timerRef.current)
-    timerRef.current = setTimeout(() => {
-      timerRef.current = null
-      saveRef.current()
-    }, debounceRef.current)
-  }, [])
-
-  // An unmount mid-window flushes the pending write rather than dropping it — a closed tab keeps
-  // the sentence.
-  useEffect(
-    () => () => {
-      if (timerRef.current !== null) {
-        clearTimeout(timerRef.current)
-        timerRef.current = null
-        saveRef.current()
-      }
-    },
-    [],
-  )
-
-  for (const path of watchedPathsRef.current) form.watch(path, scheduleSave)
-}

package/src/forms/use-form-submit.ts

@@ -1,199 +0,0 @@
-/**
- * ./forms — useFormSubmit: the submit lifecycle Mantine leaves to every call site.
- * Mantine-coupled. Optional peer: @mantine/form.
- *
- * The gap (audit B §4): `form.onSubmit` gives you validation and a `submitting` flag and nothing
- * else. A real submit also has to catch the handler's throw, turn it into a message a human can
- * read, route a server's per-FIELD errors back onto the fields, and put the caret on the first
- * thing that is wrong. Four jobs, re-written per form, and the last one is the one everybody skips.
- */
-import { useCallback, useRef, useState } from 'react'
-import type { SyntheticEvent } from 'react'
-import type { UseFormReturnType } from '@mantine/form'
-import { toErrorMessage } from '../common/errors'
-
-// ── The server field-error envelope ───────────────────────────────────────────
-
-/**
- * Per-field messages keyed by the same dotted paths `inputProps(form, path)` uses
- * (`'email'`, `'addresses.0.city'`). The shape a server returns for a 422, and the shape
- * `validateAsync` returns for a uniqueness check.
- */
-export type FormFieldErrors = Record<string, string>
-
-/**
- * Whether a thrown value carries `{ fieldErrors }` — the envelope `useFormSubmit` routes back onto
- * the fields instead of into one form-level message.
- *
- * Structural, not `instanceof`: the throw crosses a transport (Eden, `fetch`, a mutation wrapper)
- * and arrives as a plain object, so an `Error` subclass would only match the one shape basalt
- * itself constructed. The keys are checked to be STRINGS — a `{ fieldErrors: { email: 422 } }`
- * would otherwise reach `form.setErrors` and render a number under an input.
- *
- * @example
- * throw Object.assign(new Error('Validation failed'), { fieldErrors: { email: 'Already taken' } })
- */
-export function isFieldErrorEnvelope(err: unknown): err is { fieldErrors: FormFieldErrors } {
-  if (err === null || typeof err !== 'object') return false
-  const fieldErrors = (err as { fieldErrors?: unknown }).fieldErrors
-  if (fieldErrors === null || typeof fieldErrors !== 'object' || Array.isArray(fieldErrors)) {
-    return false
-  }
-  return Object.values(fieldErrors).every((message) => typeof message === 'string')
-}
-
-// ── Focus-first-error ─────────────────────────────────────────────────────────
-
-/**
- * Puts the caret on the first errored field. `form.getInputNode(path)` is Mantine v9's own lookup
- * (a `[data-path]` query over the attribute `getInputProps` writes, verified in the installed
- * 9.3.2 source); the `[name]` query is the fallback for a control that spreads its own props and
- * never got the attribute.
- *
- * Order is the ERROR RECORD's key order, not the DOM's: Mantine builds it from the schema, so it is
- * the order the fields were declared in — which for a form written top-to-bottom is the visual
- * order, and unlike a DOM sweep it costs no traversal.
- *
- * A no-op without a document (SSR), because `getInputNode` reaches straight for `document`.
- */
-function focusFirstError<Values extends Record<string, unknown>>(
-  form: UseFormReturnType<Values>,
-  errors: Record<string, unknown>,
-): void {
-  if (typeof document === 'undefined') return
-  for (const [path, message] of Object.entries(errors)) {
-    if (message === null || message === undefined || message === false) continue
-    const node =
-      form.getInputNode<HTMLElement, string>(path) ??
-      document.querySelector<HTMLElement>(`[name="${path}"]`)
-    if (node !== null) {
-      node.focus()
-      return
-    }
-  }
-}
-
-// ── useFormSubmit ─────────────────────────────────────────────────────────────
-
-export type UseFormSubmitOptions<Values extends Record<string, unknown>> = {
-  /** Ran after the handler resolves. The success path — close the modal, clear the draft, navigate. */
-  onSuccess?: (values: Values) => void
-  /** Ran on any throw, after `submitError` is set. For telemetry or a toast; not required for either. */
-  onError?: (err: unknown) => void
-  /**
-   * Turns a thrown value into the message `submitError` carries. Defaults to `toErrorMessage`
-   * (root barrel), which already unwraps `Error`, `{ message }` and Eden's `{ status, value }`.
-   * Override it to brand the copy or to branch on `errorStatus(err)`.
-   */
-  mapError?: (err: unknown) => string
-  /**
-   * The async half of validation, run AFTER the schema passes and BEFORE the handler — a uniqueness
-   * check, a server-side cross-field rule, anything that needs the network.
-   *
-   * It lives here rather than on `useBasaltForm` because that hook hard-codes
-   * `schemaResolver(schema, { sync: true })` so `validate()`/`isValid()` stay synchronous for every
-   * field-level read. Moving the async rule to submit time keeps that property AND gives the rule a
-   * home; the cost, stated plainly, is that it does not run on blur.
-   *
-   * Return `null` (or an empty record) for "valid". Anything else is set on the fields, the first
-   * one is focused, and the handler never runs.
-   */
-  validateAsync?: (values: Values) => Promise<FormFieldErrors | null>
-}
-
-export type UseFormSubmitReturn = {
-  /** Hand straight to `<form onSubmit={submit}>`, or call it from a button's `onClick`. */
-  submit: (event?: SyntheticEvent<HTMLFormElement>) => void
-  /** True from the moment a submit starts until the handler settles. Mantine's own `form.submitting`. */
-  isSubmitting: boolean
-  /** The form-level failure message, or `null`. Cleared at the start of every submit. */
-  submitError: string | null
-  /** Clears `submitError` without submitting — for a "dismiss" on the error banner. */
-  reset: () => void
-}
-
-/**
- * Wraps `form.onSubmit` with the four things a real submit needs: a busy flag, a caught and decoded
- * error, a server field-error envelope routed back onto the fields, and focus on the first thing
- * that is wrong.
- *
- * **`isSubmitting` IS `form.submitting`**, not a second piece of state beside it. Mantine already
- * flips that flag around a handler returning a promise, and this handler always does; duplicating it
- * would give a form two busy flags that can disagree, which is the failure a `FormStateProvider`
- * reading the wrong one produces.
- *
- * **Focus moves on BOTH failure paths** — a schema failure (through `onSubmit`'s own
- * `handleValidationFailure`) and a thrown `{ fieldErrors }` envelope. A server's 422 lands exactly
- * where a client-side error does.
- *
- * @example
- * const { submit, isSubmitting, submitError } = useFormSubmit(
- *   form,
- *   async (values) => { await unwrap(api.users.post({ body: values })) },
- *   { onSuccess: () => { clearDraft(); close() }, validateAsync: checkHandleFree },
- * )
- *
- * <form onSubmit={submit}>
- *   <FormStateProvider submitting={isSubmitting}>
- *     {submitError !== null && <Alert color="red">{submitError}</Alert>}
- *     …
- *   </FormStateProvider>
- * </form>
- */
-export function useFormSubmit<Values extends Record<string, unknown>>(
-  form: UseFormReturnType<Values>,
-  handler: (values: Values) => void | Promise<void>,
-  options: UseFormSubmitOptions<Values> = {},
-): UseFormSubmitReturn {
-  const [submitError, setSubmitError] = useState<string | null>(null)
-
-  // The handler and the callbacks are read at FIRE time, never captured into a memo: a submit
-  // handler closes over the freshest props by definition, and a stale one here would post the
-  // previous render's values.
-  const handlerRef = useRef(handler)
-  handlerRef.current = handler
-  const optionsRef = useRef(options)
-  optionsRef.current = options
-  const formRef = useRef(form)
-  formRef.current = form
-
-  const submit = form.onSubmit(
-    async (values) => {
-      const { onSuccess, onError, mapError, validateAsync } = optionsRef.current
-      setSubmitError(null)
-      try {
-        const fieldErrors = await validateAsync?.(values)
-        if (fieldErrors !== undefined && fieldErrors !== null && hasEntries(fieldErrors)) {
-          applyFieldErrors(formRef.current, fieldErrors)
-          return
-        }
-        await handlerRef.current(values)
-        onSuccess?.(values)
-      } catch (err) {
-        // Both, not either: the envelope's per-field messages go on the fields AND its decoded
-        // message goes in the banner. A 422 whose fields are all off-screen would otherwise report
-        // nothing at all where the user is looking.
-        if (isFieldErrorEnvelope(err)) applyFieldErrors(formRef.current, err.fieldErrors)
-        setSubmitError(mapError === undefined ? toErrorMessage(err) : mapError(err))
-        onError?.(err)
-      }
-    },
-    (errors) => focusFirstError(formRef.current, errors),
-  )
-
-  const reset = useCallback(() => setSubmitError(null), [])
-
-  return { submit, isSubmitting: form.submitting, submitError, reset }
-}
-
-function hasEntries(errors: FormFieldErrors): boolean {
-  return Object.keys(errors).length > 0
-}
-
-function applyFieldErrors<Values extends Record<string, unknown>>(
-  form: UseFormReturnType<Values>,
-  fieldErrors: FormFieldErrors,
-): void {
-  form.setErrors(fieldErrors)
-  focusFirstError(form, fieldErrors)
-}

package/src/notifications/index.ts

@@ -1,88 +0,0 @@
-/**
- * ./notifications — Mantine notification adapter battery.
- *
- * Provides notify helpers, a typed registry, a persisted history store, and a bell/center
- * component on top of @mantine/notifications. The overlay mount is `<BasaltOverlays notifications
- * />` (`basalt-ui/commands`) — this subpath no longer ships one of its own (C1 consolidation:
- * `BasaltNotifications` was superseded and is removed).
- *
- * Optional peer: @mantine/notifications ^9.3.0.
- *
- * Install with: bun add @mantine/notifications
- *
- * @example
- * // main.tsx — mount the overlay:
- * import { BasaltOverlays } from 'basalt-ui/commands'
- * <BasaltProvider><BasaltOverlays><App /></BasaltOverlays></BasaltProvider>
- *
- * // Usage:
- * import { notifySuccess, notifyError, notifyPromise, NotificationBell } from 'basalt-ui/notifications'
- * notifySuccess('Saved')
- * notifyError('Failed', { title: 'Upload error' })
- * notifyPromise(save(), { loading: 'Saving…', success: 'Saved', error: 'Failed' })
- *
- * // Optimistic mutation with an undo window (the toast's autoClose IS the window):
- * import { notifyUndo } from 'basalt-ui/notifications'
- * notifyUndo({ message: 'Item deleted', onUndo: () => restore(), onExpire: () => api.delete(id) })
- *
- * // Shell bell (globalActions slot):
- * <BasaltShell globalActions={[{ key: 'notifications', node: <NotificationBell />, mobile: 'bar' }]} ... />
- */
-
-// ── notify core ───────────────────────────────────────────────────────────────
-export {
-  notify,
-  notifySuccess,
-  notifyError,
-  notifyWarning,
-  notifyInfo,
-  notifyPromise,
-  notifyUndo,
-  notifyUndoable,
-} from './notify'
-export type {
-  NotifyOptions,
-  NotifyPromiseMessages,
-  NotifyUndoOptions,
-  NotifyUndoHandle,
-} from './notify'
-
-// ── defineNotification + defineNotifications + typed emit ─────────────────────
-export {
-  defineNotification,
-  defineNotifications,
-  emit,
-  resolveAction,
-  type NotificationAction,
-  type NotificationKind,
-  type NotificationSpec,
-  type NotificationSpecMap,
-  type NotificationIntent,
-} from './define-notifications'
-
-// ── history store ─────────────────────────────────────────────────────────────
-export {
-  add,
-  markRead,
-  markAllRead,
-  dismiss,
-  dismissAll,
-  remove,
-  clear,
-  needsAttention,
-  useNotificationHistory,
-} from './store'
-export type {
-  NotificationActionRef,
-  NotificationHistoryItem,
-  NotificationHistoryState,
-  UseNotificationHistoryReturn,
-} from './store'
-
-// ── NotificationBell ──────────────────────────────────────────────────────────
-export { NotificationBell } from './bell'
-export type { NotificationBellProps } from './bell'
-
-// ── NotificationCenter ────────────────────────────────────────────────────────
-export { NotificationCenter } from './center'
-export type { NotificationCenterProps } from './center'

package/src/notifications/mount-guard.ts

@@ -1,38 +0,0 @@
-/**
- * Duplicate-Notifications-mount guard (F15) — a shared module-level counter, not a per-caller ref,
- * because the whole point is detecting a SECOND, unrelated caller mounting `<BasaltOverlays
- * notifications />` (`commands/overlays-mount.tsx`) at once — nested/duplicate mounts double-render
- * Mantine's `<Notifications />` and neither instance can see the other.
- *
- * Lives here (`./notifications`), not `./commands`, so `commands` is the one importing a shared util
- * rather than the reverse — `./notifications` never depends on `./commands`. Zero `@mantine/*`
- * import, so pulling it into `commands` does not eagerly load `@mantine/notifications`.
- *
- * Not exported from the `./notifications` public barrel (`index.ts`) — internal wiring only, same
- * as `provider/lab-theme.ts`.
- */
-import { useEffect } from 'react'
-
-let mountedNotificationsCount = 0
-
-/**
- * Call from any component that renders a `<Notifications />` overlay. Warns in dev when a second
- * caller is mounted at the same time. Not a false positive under React 18 StrictMode's double-invoke
- * (that mounts/unmounts the SAME instance in sequence, so the count returns to 0 before a genuine
- * second instance could exist).
- */
-export function useNotificationsMountGuard(): void {
-  useEffect(() => {
-    mountedNotificationsCount++
-    if (mountedNotificationsCount > 1 && process.env.NODE_ENV !== 'production') {
-      console.warn(
-        '[basalt] more than one Notifications overlay is mounted at once — mount exactly ONE ' +
-          "<BasaltOverlays notifications /> (they all render Mantine's <Notifications />, so " +
-          'toasts would double-fire).',
-      )
-    }
-    return () => {
-      mountedNotificationsCount--
-    }
-  }, [])
-}