basalt-ui 1.41.0 → 2.0.1

package/src/provider/lab-theme.ts

@@ -44,6 +44,7 @@ import { useMemo } from 'react'
 import { useDeriveControlsState, toDeriveOverride } from '../theme-lab/derive-state'
 import type { DeriveOverride } from '../theme-lab/derive-state'
 import { baseTheme, createBasaltTheme } from '../theme'
+import type { BasaltDensityLevel, BasaltRadiusLevel } from '../theme'
 
 type Plain = Record<string, unknown>
 
@@ -115,8 +116,8 @@ export function applyLabOverride(
   if (override === null) return theme
   const labTheme = createBasaltTheme(undefined, {
     derive: override.config,
-    radius: override.radiusLevel,
-    density: override.densityLevel,
+    radius: override.radiusLevel as BasaltRadiusLevel,
+    density: override.densityLevel as BasaltDensityLevel,
   })
   // An all-defaults override resolves back to `baseTheme` itself, so the delta is empty and this
   // merge is a no-op — the "Apply" switch on at level 0 changes nothing, as it should.

package/src/provider/route-transition.ts

@@ -0,0 +1,199 @@
+/**
+ * Route view transitions (V2-SPEC § 5): the direction of a navigation, read off `BasaltShell` nav
+ * order, plus the guard that keeps the router's discarded `ViewTransition` promises quiet.
+ *
+ * The router owns the call (`router-core` `startViewTransition`, router.js:490-508): it passes
+ * `{ update, types }` to `document.startViewTransition` when the browser supports
+ * `:active-view-transition-type()`, a bare callback otherwise, and returns only `updateCallbackDone`,
+ * so `ready` and `finished` are dropped on the floor.
+ */
+import type { AnyRouter } from '@tanstack/react-router'
+import { flattenNav, getActiveNav } from '../router-tanstack/nav'
+
+/** The three `:active-view-transition-type()` names `styles.css` animates. Namespaced: a consumer's own cannot collide. */
+export const ROUTE_TRANSITION_TYPES = {
+  forward: 'basalt-forward',
+  back: 'basalt-back',
+  sibling: 'basalt-sibling',
+} as const
+
+/** The argument of the router's `types` callback, derived from its own option type. */
+type RouterLocationChange = Parameters<
+  Extract<
+    Extract<AnyRouter['options']['defaultViewTransition'], object>['types'],
+    (...args: never[]) => unknown
+  >
+>[0]
+
+/** The part of it the direction reads: two pathnames and whether the path changed. */
+type LocationChange = Pick<RouterLocationChange, 'pathChanged'> & {
+  fromLocation?: Pick<NonNullable<RouterLocationChange['fromLocation']>, 'pathname'>
+  toLocation: Pick<RouterLocationChange['toLocation'], 'pathname'>
+}
+
+type ActiveNav = NonNullable<ReturnType<typeof getActiveNav>>
+type NavItem = ReturnType<typeof flattenNav>[number]
+
+const trimTrailingSlash = (path: string): string =>
+  path.length > 1 && path.endsWith('/') ? path.slice(0, -1) : path
+
+const segmentsOf = (path: string): string[] => path.split('/').filter(Boolean)
+
+/** A pattern segment: a path literal (case-insensitive), a given param value (case-sensitive), or a wildcard. */
+type Part = { kind: 'literal' | 'value'; text: string } | { kind: 'param' | 'optional' | 'splat' }
+
+/** `to` as parts, with the item's own `params` interpolated; the unspecified stay wildcards. */
+function patternOf(item: NavItem): Part[] {
+  const params: unknown = item.link.params
+  const given = (typeof params === 'object' && params !== null ? params : {}) as Record<
+    string,
+    unknown
+  >
+  return segmentsOf(item.link.to).map((segment): Part => {
+    if (segment === '$') return { kind: 'splat' }
+    const param = /^\{?(-?)\$([\w-]+)\}?$/.exec(segment)
+    if (param === null) return { kind: 'literal', text: segment.toLowerCase() }
+    const value = given[param[2] ?? '']
+    if (value !== undefined) return { kind: 'value', text: String(value) }
+    return { kind: param[1] === '-' ? 'optional' : 'param' }
+  })
+}
+
+/** The path, once: each segment as written and lower-cased. */
+type PathSegment = { raw: string; lower: string }
+
+function matchParts(parts: Part[], path: PathSegment[], at: number, fuzzy: boolean): boolean {
+  const [part, ...rest] = parts
+  if (part === undefined) return fuzzy || at === path.length
+  if (part.kind === 'splat') return true
+  if (part.kind === 'optional' && matchParts(rest, path, at, fuzzy)) return true
+  const actual = path[at]
+  if (actual === undefined) return false
+  if (part.kind === 'literal' && part.text !== actual.lower) return false
+  if (part.kind === 'value' && part.text !== actual.raw) return false
+  return matchParts(rest, path, at + 1, fuzzy)
+}
+
+/**
+ * Whether the path is on `item`: the sidebar's rule (`use-nav.ts` `matchOf`: `matchRoute` with
+ * `fuzzy: exact !== true && to !== '/'`, the item's `params` applied, case-insensitive) as a pure
+ * string match, because the router's own matcher only answers for its current location.
+ */
+function onItem(item: NavItem, path: PathSegment[]): boolean {
+  const fuzzy = item.exact !== true && item.link.to !== '/'
+  return matchParts(patternOf(item), path, 0, fuzzy)
+}
+
+/**
+ * The flattened-nav index of the item that owns `pathname`, picked as the sidebar picks its active
+ * item: of the matches, the most specific (most non-empty segments in `link.to`) wins and the first
+ * in definition order takes a tie. `-1` when nothing matches.
+ *
+ * @internal exported for the corpus test against the router's real `matchRoute`.
+ */
+export function navIndexOf(flat: ReadonlyArray<NavItem>, pathname: string): number {
+  const path = segmentsOf(trimTrailingSlash(pathname)).map((raw) => ({
+    raw,
+    lower: raw.toLowerCase(),
+  }))
+  let winner = -1
+  let winnerSpecificity = -1
+  for (const [index, item] of flat.entries()) {
+    const specificity = segmentsOf(item.link.to).length
+    if (specificity > winnerSpecificity && onItem(item, path)) {
+      winner = index
+      winnerSpecificity = specificity
+    }
+  }
+  return winner
+}
+
+/**
+ * The `types` callback for the router's `defaultViewTransition`. Pure: the nav is a parameter.
+ *
+ * - No `fromLocation`: the first load. The router also runs it through `startViewTransition`
+ *   (load-client.js:916), but there is no previous page to animate from, so `false`.
+ * - Same path (search or hash only): `false`, the page does not change.
+ * - A later nav item than the one you left: `forward`; an earlier one: `back`.
+ * - Same item (a detail beneath it), or either side outside the nav: `sibling`, a plain crossfade.
+ */
+export function routeTransitionTypes(
+  { fromLocation, toLocation, pathChanged }: LocationChange,
+  nav: ActiveNav | undefined,
+): string[] | false {
+  if (!fromLocation || !pathChanged) return false
+  const flat = nav ? flattenNav(nav) : []
+  const fromIndex = navIndexOf(flat, fromLocation.pathname)
+  const toIndex = navIndexOf(flat, toLocation.pathname)
+  if (fromIndex === -1 || toIndex === -1 || fromIndex === toIndex)
+    return [ROUTE_TRANSITION_TYPES.sibling]
+  return [toIndex > fromIndex ? ROUTE_TRANSITION_TYPES.forward : ROUTE_TRANSITION_TYPES.back]
+}
+
+/**
+ * The router's own gate for passing `types` (router.js:495): without it the callback is never
+ * called and every navigation, first load and filter changes included, gets the UA's full-page
+ * crossfade. So below this support line there is no route transition at all. Server: none.
+ */
+export function supportsViewTransitionTypes(): boolean {
+  if (typeof window === 'undefined') return false
+  const css: { supports?: (condition: string) => boolean } | undefined = window.CSS
+  return css?.supports?.('selector(:active-view-transition-type(a))') === true
+}
+
+/** What `createBasaltRouter` hands the router as `defaultViewTransition`. */
+export const routeViewTransition = {
+  types: (change: LocationChange) => routeTransitionTypes(change, getActiveNav()),
+}
+
+// ── rejection guard ──────────────────────────────────────────────────────────────────────────────
+
+/** The three ways a transition ends early: superseded (`AbortError`), document hidden/detached, timed out. */
+const SKIP_NAMES = new Set(['AbortError', 'InvalidStateError', 'TimeoutError'])
+
+const isTransitionSkip = (reason: unknown): boolean =>
+  reason instanceof DOMException && SKIP_NAMES.has(reason.name)
+
+/** Hands a non-skip to the page's error handlers once (`window` `error`, which `BasaltProvider` forwards). */
+const reportOnce = (reason: unknown): void => {
+  if (isTransitionSkip(reason)) return
+  if (typeof reportError === 'function') reportError(reason)
+}
+
+/** `finished` repeats whatever `ready` or `updateCallbackDone` already reported; never report it twice. */
+const ignore = (): void => {}
+
+const guarded = new WeakSet<object>()
+
+/**
+ * Attaches a catch to `ready` and `finished` of every `document.startViewTransition` call, once per
+ * installed function (idempotent across routers). Router-core drops both (it returns only
+ * `updateCallbackDone`), and a superseded transition rejects them with `AbortError: Transition was
+ * skipped` (router discussion #7733), which `window` `unhandledrejection` — and so basalt's
+ * telemetry sink — would report.
+ *
+ * - `ready`: a skip is swallowed; any other reason goes to `reportError`, so it surfaces once, there
+ *   (a throwing handler would create a second, unowned rejection).
+ * - `finished`: always swallowed. A non-skip reason is the update callback's error, which `ready`
+ *   (and, for the router, its own `await updateCallbackDone`) already carries.
+ * - `updateCallbackDone` is left alone: the router awaits it, and a catch here would re-raise a
+ *   real error from a derived promise nobody owns.
+ *
+ * Chosen over an `unhandledrejection` filter because it removes the rejection at its source: it
+ * never becomes unhandled, so no listener (basalt's, a consumer's, devtools) sees it, and
+ * `preventDefault()` on a shared event would hide real rejections from the others. The wrapper
+ * returns the original `ViewTransition`. A no-op where the API is absent, and on the server.
+ */
+export function guardViewTransitionRejections(): void {
+  if (typeof document === 'undefined' || typeof document.startViewTransition !== 'function') return
+  if (guarded.has(document.startViewTransition)) return
+  const original = document.startViewTransition.bind(document)
+  const wrapped: Document['startViewTransition'] = (...args) => {
+    const transition = original(...args)
+    transition.ready.catch(reportOnce)
+    transition.finished.catch(ignore)
+    return transition
+  }
+  guarded.add(wrapped)
+  document.startViewTransition = wrapped
+}

package/src/provider/spotlight-actions.tsx

@@ -0,0 +1,69 @@
+/**
+ * The provider's Spotlight list: the `defineCommands` registry, then the `defineNav` destinations
+ * (via `flattenNav`), then the three dev-dock commands in dev. A snapshot rebuilt each time Spotlight
+ * opens, so a command's `when()` is current. Not for use during render (`detectMac` reads `navigator`).
+ */
+import type { SpotlightActionData } from '@mantine/spotlight'
+import type { AnyRouter } from '@tanstack/react-router'
+import { getActiveCommands } from '../commands/define-commands'
+import { detectMac, formatShortcutDisplay } from '../commands/shortcut-format'
+import { flattenNav, getActiveNav } from '../router-tanstack/nav'
+import type { BasaltDevDockTool } from '../dev-dock'
+import { runCommandSafely } from './hotkeys'
+
+const DEV_TOOLS: ReadonlyArray<{ tool: BasaltDevDockTool; label: string }> = [
+  { tool: 'router', label: 'Router devtools' },
+  { tool: 'query', label: 'Query devtools' },
+  { tool: 'theme', label: 'Theme lab' },
+]
+
+export function buildSpotlightActions(
+  router: AnyRouter,
+  openDevTool: (tool: BasaltDevDockTool) => void,
+): SpotlightActionData[] {
+  const actions: SpotlightActionData[] = []
+
+  for (const [id, cmd] of Object.entries(getActiveCommands())) {
+    if (cmd.when !== undefined && !cmd.when()) continue
+    actions.push({
+      id,
+      label: cmd.label,
+      leftSection: cmd.icon,
+      keywords: [cmd.group ?? '', id].join(' ').trim(),
+      ...(cmd.group !== undefined && { group: cmd.group }),
+      ...(cmd.shortcut !== undefined && {
+        description: formatShortcutDisplay(cmd.shortcut, detectMac()),
+      }),
+      onClick: () => runCommandSafely(cmd),
+    })
+  }
+
+  const nav = getActiveNav()
+  if (nav !== undefined) {
+    for (const item of flattenNav(nav)) {
+      if (item.disabled === true) continue
+      actions.push({
+        id: `nav.${item.id}`,
+        label: item.label,
+        group: item.groupLabel,
+        leftSection: item.icon,
+        // `link` is the destination's own `linkOptions`, so a store-backed `search` thunk restores
+        // the last selection exactly as the sidebar link does.
+        onClick: () => void router.navigate(item.link as never),
+      })
+    }
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    for (const { tool, label } of DEV_TOOLS) {
+      actions.push({
+        id: `dev.${tool}`,
+        label,
+        group: 'Dev',
+        onClick: () => openDevTool(tool),
+      })
+    }
+  }
+
+  return actions
+}

package/src/provider/test-router.tsx

@@ -0,0 +1,25 @@
+/**
+ * Test helper — a real `createBasaltRouter` over a one-component root route plus an `/other` leaf,
+ * so provider tests mount the actual tree (QueryClient in context, RouterProvider, overlays).
+ */
+import { Outlet, createRootRoute, createRoute } from '@tanstack/react-router'
+import type { AnyRouter } from '@tanstack/react-router'
+import { createBasaltRouter } from './create-router'
+import type { BasaltRouterContext } from './create-router'
+
+/** The router's QueryClient — a plain root route declares no context type, so read it untyped. */
+export const queryClientOf = (router: AnyRouter): BasaltRouterContext['queryClient'] =>
+  (router.options.context as BasaltRouterContext).queryClient
+
+export function testRouter(text = 'content') {
+  const root = createRootRoute({
+    component: () => (
+      <>
+        <div>{text}</div>
+        <Outlet />
+      </>
+    ),
+  })
+  const other = createRoute({ getParentRoute: () => root, path: '/other', component: () => null })
+  return createBasaltRouter({ routeTree: root.addChildren([other]) })
+}

package/src/query-client.ts

@@ -1,15 +1,10 @@
 /**
- * `createBasaltQueryClient` + `unwrap` — the two TanStack Query primitives basalt ships. Folded
- * onto the root barrel (C1 consolidation, dropping the `./query` subpath): the root already
- * requires `@tanstack/react-query` as a peer, so a dedicated Mantine-free subpath bought nothing —
- * and it re-exported 10 raw TanStack symbols no consumer imported through it.
- * Optional peer: @tanstack/react-query.
+ * `unwrap` plus the QueryClient factory `createBasaltRouter` owns (V2-SPEC § 2): one client per
+ * router, so an SSR entry gets one per request. Optional peer: @tanstack/react-query.
  */
 import { QueryClient } from '@tanstack/react-query'
 import type { QueryClientConfig } from '@tanstack/react-query'
 
-// ── createBasaltQueryClient ───────────────────────────────────────────────────────────────────────
-
 const BASALT_QUERY_DEFAULTS = {
   staleTime: 30_000,
   gcTime: 5 * 60 * 1000,
@@ -17,21 +12,8 @@ const BASALT_QUERY_DEFAULTS = {
   refetchOnWindowFocus: false,
 } as const
 
-/**
- * Wraps QueryClient with basalt dashboard defaults. All options are mergeable — consumer
- * overrides win per-query, framework defaults are the fallback.
- *
- * @example
- * import { createBasaltQueryClient } from 'basalt-ui'
- * import { QueryClientProvider } from '@tanstack/react-query'
- * import { useState } from 'react'
- *
- * function Root({ children }: { children: React.ReactNode }) {
- *   const [client] = useState(() => createBasaltQueryClient())
- *   return <QueryClientProvider client={client}>{children}</QueryClientProvider>
- * }
- */
-export function createBasaltQueryClient(config?: QueryClientConfig): QueryClient {
+/** QueryClient with the basalt dashboard defaults; consumer `config` wins per-query. */
+export function makeQueryClient(config?: QueryClientConfig): QueryClient {
   return new QueryClient({
     ...config,
     defaultOptions: {

package/src/router-tanstack/index.ts

@@ -1,62 +1,21 @@
 /**
- * ./router-tanstack — headless TanStack Router bridge for the app shell.
- * Optional peer: @tanstack/react-router.
- * Carries the typed navigation definition (`defineNav`/`navGroup`/`navTarget`/`flattenNav`) and
- * `useNav`, which resolves it into `BasaltShell`'s `sections` + `mobileNav` props; plus the
- * StaticDataRouteOption augmentation (title/icon/navSection) for router-derived breadcrumbs, plus
- * `createSearchStore` + the `field.*` vocabulary — no Mantine, no JSX.
+ * ./router-tanstack — headless TanStack Router bridge. The nav half (`defineNav`, `navGroup`,
+ * `navTarget`, `flattenNav`, `useBasaltNav`, `NavItemId`) moves to the root barrel in 2.0 and the
+ * store half (`createSearchStore`) to `./state`, which re-exports it from `./search-store` directly.
+ * The shell's active-state resolver lives in `use-nav.ts` and is not a public export.
+ * Optional peer: @tanstack/react-router. No Mantine, no JSX.
  */
+import type { ReactNode } from 'react'
+import { useLocation } from '@tanstack/react-router'
 
-export { createSearchStore, type CreateSearchStoreOptions, type SearchStore } from './search-store'
-export { field } from '../state'
-export type {
-  AnyField,
-  BooleanField,
-  EnumField,
-  FieldFallback,
-  FieldHandle,
-  FieldLane,
-  FieldOption,
-  FieldSetOptions,
-  FieldValue,
-  MultiField,
-  NumberField,
-  RangeField,
-  RangeParams,
-  RangePresets,
-  RangeValue,
-  RangeWindow,
-  RangeWindows,
-  ResolvedLane,
-  SearchValues,
-  StoredValues,
-  StringField,
-} from '../state'
 export { defineNav, navGroup, navTarget, flattenNav } from './nav'
-export type {
-  NavItemMeta,
-  NavGroupMeta,
-  AnyNavItem,
-  AnyNavGroup,
-  AnyNavLink,
-  FlatNavItem,
-  NavConfig,
-  NavItemId,
-  NavGroupId,
-  NavTabId,
-  NavIndex,
-} from './nav'
-export { useNav } from './use-nav'
-export type { UseNavOptions, NavBinding } from './use-nav'
-export type { NavAnchor, NavAnchorProps, NavMobilePlacement } from '../shell/nav-types'
-import type { ReactNode } from 'react'
-import { useLocation, useMatches } from '@tanstack/react-router'
+export type { NavItemId } from './nav'
 
 // ── StaticDataRouteOption augmentation ───────────────────────────────────────────────────────────
 
 declare module '@tanstack/react-router' {
   interface StaticDataRouteOption {
-    /** Page/section title — drives breadcrumbs via useRouterBreadcrumbs(). */
+    /** Page/section title. */
     title?: string
     /** Nav icon — ReactNode passed through to the shell SidebarItem. */
     icon?: ReactNode
@@ -67,33 +26,19 @@ declare module '@tanstack/react-router' {
 
 // ── useBasaltNav ──────────────────────────────────────────────────────────────────────────────────
 
-/** Reactive nav-active state derived from the current TanStack Router location. */
-export type BasaltNav = {
-  /** Current pathname (reactive, updates on every navigation). */
-  currentPath: string
-  /**
-   * True when `href` matches the current route.
-   * Default: prefix match so a parent nav item stays active on child routes.
-   * Pass `{ exact: true }` for exact-only matching.
-   * The root `'/'` always matches exactly regardless of the option.
-   */
-  isActive: (href: string, opts?: { exact?: boolean }) => boolean
-}
-
 /**
- * Returns the current path and an `isActive` predicate for nav highlighting.
- * Reads only `useLocation` — no navigate, no typed-route `to` casts.
- * Navigation stays with TanStack's own typed `<Link>` / `useNavigate`.
+ * The current path and an `isActive` predicate for nav highlighting. `isActive(href)` is a prefix
+ * match so a parent stays active on child routes; `{ exact: true }` matches exactly, and `'/'` is
+ * always exact. Reads only `useLocation` — navigation stays with TanStack's own `<Link>`.
  *
  * @example
- * import { useBasaltNav } from 'basalt-ui/router-tanstack'
- *
- * function NavItem({ href, label }: { href: string; label: string }) {
- *   const { isActive } = useBasaltNav()
- *   return <NavLink href={href} active={isActive(href)}>{label}</NavLink>
- * }
+ * const { isActive } = useBasaltNav()
+ * <NavLink href={href} active={isActive(href)}>{label}</NavLink>
  */
-export function useBasaltNav(): BasaltNav {
+export function useBasaltNav(): {
+  currentPath: string
+  isActive: (href: string, opts?: { exact?: boolean }) => boolean
+} {
   const currentPath = useLocation({ select: (l) => l.pathname })
 
   const isActive = (href: string, opts?: { exact?: boolean }): boolean => {
@@ -104,42 +49,3 @@ export function useBasaltNav(): BasaltNav {
 
   return { currentPath, isActive }
 }
-
-// ── useRouterBreadcrumbs ──────────────────────────────────────────────────────────────────────────
-
-/** A single breadcrumb entry projected from route staticData. */
-export type BasaltBreadcrumb = {
-  /** The route's `staticData.title`. */
-  title: string
-  /** The matched pathname for this ancestor (usable as `<Link to={href}>` target). */
-  href: string
-}
-
-/**
- * Returns the ancestor→deepest breadcrumb trail derived from `staticData.title` on each match.
- * Routes without a `staticData.title` are silently omitted.
- * Uses the `select` form of `useMatches` for re-render gating — only re-renders when the
- * projected breadcrumb array actually changes shape.
- *
- * @example
- * import { useRouterBreadcrumbs } from 'basalt-ui/router-tanstack'
- *
- * function AppBreadcrumbs() {
- *   const crumbs = useRouterBreadcrumbs()
- *   return (
- *     <nav aria-label="breadcrumb">
- *       {crumbs.map((c) => <a key={c.href} href={c.href}>{c.title}</a>)}
- *     </nav>
- *   )
- * }
- */
-export function useRouterBreadcrumbs(): BasaltBreadcrumb[] {
-  return useMatches({
-    select: (matches) =>
-      matches.flatMap((m) =>
-        typeof m.staticData?.title === 'string'
-          ? [{ title: m.staticData.title, href: m.pathname }]
-          : [],
-      ),
-  })
-}

package/src/router-tanstack/nav.ts

@@ -11,6 +11,7 @@
  *
  * No JSX and no Mantine in this module — `./router-tanstack` is a headless barrel by contract.
  */
+import type { RegisteredRouter } from '@tanstack/react-router'
 import type { ReactNode } from 'react'
 import type { NavMobilePlacement, NavSectionMobile } from '../shell/nav-types'
 
@@ -154,8 +155,33 @@ export function navGroup<const M extends NavGroupMeta, const T extends ReadonlyA
 export function defineNav<
   const G extends ReadonlyArray<AnyNavGroup>,
   const T extends ReadonlyArray<NavTabId<G>>,
->(config: NavConfig<G, T>): NavConfig<G, T> {
-  return config
+>(config: RegisteredOr<NavConfig<G, T>>): NavConfig<G, T> {
+  const nav = config as unknown as NavConfig<G, T>
+  activeNav = nav
+  return nav
+}
+
+/**
+ * Without the `Register` augmentation `RegisteredRouter` is `AnyRouter`, every `to` widens to
+ * `string` and the definition validates nothing — so the parameter becomes an unsatisfiable string
+ * literal whose text is the fix (V2-SPEC § 3).
+ */
+type RegisteredOr<T> = 0 extends 1 & RegisteredRouter['routeTree']
+  ? 'basalt: declare Register { router }'
+  : T
+
+/**
+ * The runtime stash `defineNav` fills (the last call wins, like `defineCommands`), read by
+ * `BasaltProvider` to project the nav into Spotlight. Type augmentation is erased, so this is the
+ * live source.
+ *
+ * @internal
+ */
+let activeNav: { groups: ReadonlyArray<AnyNavGroup> } | undefined
+
+/** @internal */
+export function getActiveNav(): { groups: ReadonlyArray<AnyNavGroup> } | undefined {
+  return activeNav
 }
 
 // ── readers ──────────────────────────────────────────────────────────────────────────────────────

package/src/router-tanstack/search-store.ts

@@ -31,8 +31,15 @@
  */
 import { useNavigate, useSearch } from '@tanstack/react-router'
 import { createStoreCore } from '../state/fields'
-import type { FieldWrite, StoreEntry } from '../state/fields'
-import type { AnyField, FieldHandle, FieldSetOptions, SearchValues, StoredValues } from '../state'
+import type {
+  AnyField,
+  FieldHandle,
+  FieldSetOptions,
+  FieldWrite,
+  SearchValues,
+  StoreEntry,
+  StoredValues,
+} from '../state/fields'
 
 // ── Types ──────────────────────────────────────────────────────────────────