basalt-ui 1.25.0 → 1.27.0

package/src/state/persisted.test.ts

@@ -0,0 +1,91 @@
+/**
+ * `createPersistedState` — the in-tab notification contract.
+ *
+ * The versioned envelope and the cross-tab path are exercised through every store that persists
+ * (`fields.test.tsx`, `search-store.test.ts`); what only shows up here is TWO instances over ONE
+ * key, which is ordinary rather than exotic: a page's store and a widget's own state legitimately
+ * name the same key. Per-instance listener sets made a write through one invisible to the other in
+ * the SAME tab — while the cross-tab path worked, which is what made it read as a caching bug.
+ */
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { act, renderHook } from '@testing-library/react'
+import { createPersistedState, readPersistedValue } from './persisted'
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+describe('createPersistedState — one key, two instances', () => {
+  test('a write through A re-renders a hook on B with the new value', () => {
+    const useA = createPersistedState({ key: 'shared-draft', version: 1, initial: 'a' })
+    const useB = createPersistedState({ key: 'shared-draft', version: 1, initial: 'a' })
+
+    const a = renderHook(() => useA())
+    const b = renderHook(() => useB())
+    expect(b.result.current[0]).toBe('a')
+
+    act(() => {
+      a.result.current[1]('written-through-A')
+    })
+
+    expect(b.result.current[0]).toBe('written-through-A')
+    expect(a.result.current[0]).toBe('written-through-A')
+    expect(readPersistedValue('shared-draft', 1)).toBe('written-through-A')
+  })
+
+  test('the notification is per KEY — a second key is not woken', () => {
+    const useShared = createPersistedState({ key: 'k-one', version: 1, initial: 0 })
+    const useOther = createPersistedState({ key: 'k-two', version: 1, initial: 0 })
+
+    let otherRenders = 0
+    const shared = renderHook(() => useShared())
+    renderHook(() => {
+      otherRenders += 1
+      return useOther()
+    })
+    const before = otherRenders
+
+    act(() => {
+      shared.result.current[1](7)
+    })
+
+    expect(shared.result.current[0]).toBe(7)
+    expect(otherRenders).toBe(before)
+  })
+
+  test('unmounting one instance leaves the other subscribed', () => {
+    const useA = createPersistedState({ key: 'shared-unmount', version: 1, initial: 'a' })
+    const useB = createPersistedState({ key: 'shared-unmount', version: 1, initial: 'a' })
+
+    const a = renderHook(() => useA())
+    const b = renderHook(() => useB())
+    a.unmount()
+
+    const c = renderHook(() => useA())
+    act(() => {
+      c.result.current[1]('later')
+    })
+
+    expect(b.result.current[0]).toBe('later')
+  })
+
+  test('an object value stays referentially stable between writes (the snapshot cache)', () => {
+    const useDraft = createPersistedState<{ title: string }>({
+      key: 'shared-object',
+      version: 1,
+      initial: { title: '' },
+    })
+
+    const { result } = renderHook(() => useDraft())
+    const first = result.current[0]
+    act(() => {
+      result.current[1]({ title: 'one' })
+    })
+    const written = result.current[0]
+
+    expect(first).not.toBe(written)
+    expect(written).toEqual({ title: 'one' })
+    // Same raw string → same parsed reference, which is what keeps useSyncExternalStore quiet.
+    expect(renderHook(() => useDraft()).result.current[0]).toBe(written)
+  })
+})

package/src/state/persisted.ts

@@ -0,0 +1,261 @@
+/**
+ * createPersistedState — Mantine-free, React-only localStorage primitive.
+ *
+ * Versioned, Standard-Schema-validated state via useSyncExternalStore. SSR-safe.
+ * Cross-tab via the 'storage' event. Keys are namespaced 'basalt:*' so they never
+ * collide with the localstorage-theme guard pattern.
+ *
+ * One of the two halves behind the `basalt-ui/state` barrel (`../state.ts`); the field vocabulary
+ * and the two store factories built on this primitive live in `./fields`.
+ */
+import { useSyncExternalStore } from 'react'
+import type { StandardSchemaV1 } from '../register'
+
+// Shared noop subscribe — passed to useSyncExternalStore on the server so no window access occurs.
+const noopSubscribe =
+  (_cb: () => void): (() => void) =>
+  () => {}
+
+export type PersistedStateOptions<T> = {
+  /** localStorage key (will be namespaced as `basalt:<key>`). */
+  readonly key: string
+  /** Envelope version — increment when the shape changes. */
+  readonly version: number
+  /** Value to use when nothing is persisted, after migration fails, or on SSR. */
+  readonly initial: T
+  /** Migrate a previous-version persisted value forward to the current shape. */
+  readonly migrate?: (persisted: unknown, fromVersion: number) => T
+  /**
+   * Standard-Schema validate the (post-migrate) value. Invalid result OR a Promise (async schema)
+   * falls back to `initial` — sync storage can't await, so async validators are treated as invalid.
+   */
+  readonly schema?: StandardSchemaV1<unknown, T>
+}
+
+/**
+ * Every subscriber for ONE storage key, shared by every `createPersistedState` instance over that
+ * key — plus the single `storage` event listener the key needs.
+ *
+ * Module-level rather than per-instance because two instances of the same key are ordinary, not a
+ * mistake: a page's `createSearchStore` and a widget's `createPersistedState` legitimately name the
+ * same key, and a consumer re-exporting a store from two modules ends up there by accident. With
+ * per-instance listener sets a write through one instance updated localStorage and notified only
+ * its own hooks, so the other instance's components kept rendering the stale value until something
+ * else re-rendered them — in the SAME tab, while the cross-tab path (the `storage` event) worked.
+ *
+ * The map is keyed by the NAMESPACED key and holds no window reference; a channel is created on
+ * first subscribe, which only happens in the browser (`subscribe` is never passed on the server).
+ */
+type KeyChannel = {
+  readonly listeners: Set<() => void>
+  handler: ((e: StorageEvent) => void) | null
+}
+
+const channels = new Map<string, KeyChannel>()
+
+/** Wake every hook on a key, whichever instance holds it. */
+function notify(storageKey: string): void {
+  const channel = channels.get(storageKey)
+  if (channel === undefined) return
+  for (const listener of channel.listeners) listener()
+}
+
+function channelFor(storageKey: string): KeyChannel {
+  const existing = channels.get(storageKey)
+  if (existing !== undefined) return existing
+  const created: KeyChannel = { listeners: new Set(), handler: null }
+  channels.set(storageKey, created)
+  return created
+}
+
+/** The envelope stored in localStorage: `{ v: number, value: unknown }`. */
+type Envelope = { v: number; value: unknown }
+
+function isEnvelope(raw: unknown): raw is Envelope {
+  return (
+    typeof raw === 'object' &&
+    raw !== null &&
+    'v' in raw &&
+    typeof (raw as Record<string, unknown>)['v'] === 'number' &&
+    'value' in raw
+  )
+}
+
+/** Parse a raw localStorage string (or null) into a value, falling back to `initial` on any miss. */
+function parseStorage<T>(raw: string | null, opts: PersistedStateOptions<T>): T {
+  if (raw === null) return opts.initial
+  try {
+    const parsed: unknown = JSON.parse(raw)
+    if (!isEnvelope(parsed)) return opts.initial
+
+    let value: unknown = parsed.value
+
+    if (parsed.v !== opts.version) {
+      value = opts.migrate ? opts.migrate(parsed.value, parsed.v) : opts.initial
+    }
+
+    if (opts.schema) {
+      const result = opts.schema['~standard'].validate(value)
+      // Async schema — can't await in sync storage path; fall back to initial
+      if (result instanceof Promise) return opts.initial
+      if (result.issues !== undefined) return opts.initial
+      // Narrowed to SuccessResult<T> — value is T
+      return result.value
+    }
+
+    return value as T
+  } catch {
+    return opts.initial
+  }
+}
+
+function writeEnvelope(storageKey: string, version: number, value: unknown): void {
+  try {
+    const envelope: Envelope = { v: version, value }
+    window.localStorage.setItem(storageKey, JSON.stringify(envelope))
+  } catch {
+    // Silently fail (storage full, private browsing, etc.)
+  }
+}
+
+function writeStorage<T>(opts: PersistedStateOptions<T>, next: T): void {
+  writeEnvelope(`basalt:${opts.key}`, opts.version, next)
+}
+
+/**
+ * Versioned, Standard-Schema-validated localStorage state via useSyncExternalStore (no zustand).
+ * SSR-safe (getServerSnapshot returns `initial`). Cross-tab via the storage event.
+ *
+ * Returns a factory hook — call it once per module, then use the returned hook in components.
+ * Common case is 3 lines.
+ *
+ * @example
+ * export const useFilterDraft = createPersistedState({ key: 'filters', version: 1, initial: DEFAULT, schema: FilterSchema })
+ * // in a component:
+ * const [draft, setDraft] = useFilterDraft()
+ */
+export function createPersistedState<T>(
+  opts: PersistedStateOptions<T>,
+): () => readonly [T, (next: T) => void] {
+  const storageKey = `basalt:${opts.key}`
+
+  const subscribe = (cb: () => void): (() => void) => {
+    // The subscriber set is the KEY's, not this instance's — see `KeyChannel`.
+    const channel = channelFor(storageKey)
+    channel.listeners.add(cb)
+
+    // ONE 'storage' event listener per key, registered lazily on the first subscriber and removed
+    // when the last one leaves (cleanup semantics preserved).
+    if (channel.handler === null) {
+      channel.handler = (e: StorageEvent): void => {
+        if (e.key === storageKey) notify(storageKey)
+      }
+      window.addEventListener('storage', channel.handler)
+    }
+
+    return () => {
+      channel.listeners.delete(cb)
+      if (channel.listeners.size === 0 && channel.handler !== null) {
+        window.removeEventListener('storage', channel.handler)
+        channel.handler = null
+      }
+    }
+  }
+
+  // Snapshot cache — useSyncExternalStore requires getSnapshot to return a referentially STABLE
+  // value while the store is unchanged. parseStorage() allocates a fresh object/array on every
+  // call, so returning it raw makes React see an ever-changing snapshot for object/array state
+  // and loop until "Maximum update depth exceeded". We cache the parsed value keyed on the raw
+  // localStorage string: same string → same reference; a write (this tab or another) changes the
+  // string, so the next read re-parses exactly once. Primitive state was unaffected — this fixes
+  // the object/array case (chat history, form drafts).
+  let cachedRaw: string | null = null
+  let cachedValue: T = opts.initial
+  let primed = false
+
+  const getSnapshot = (): T => {
+    let raw: string | null
+    try {
+      raw = window.localStorage.getItem(storageKey)
+    } catch {
+      raw = null
+    }
+    if (primed && raw === cachedRaw) return cachedValue
+    cachedRaw = raw
+    cachedValue = parseStorage(raw, opts)
+    primed = true
+    return cachedValue
+  }
+  const getServerSnapshot = (): T => opts.initial
+
+  const setState = (next: T): void => {
+    writeStorage(opts, next)
+    // Notify every in-tab listener on this KEY — the 'storage' event fires in OTHER tabs only, and
+    // a second instance of the same key has its own hooks to wake.
+    notify(storageKey)
+  }
+
+  // Detect SSR once at creation time — the environment doesn't change between renders.
+  const isServer = typeof window === 'undefined'
+
+  return function usePersistedState(): readonly [T, (next: T) => void] {
+    const value = useSyncExternalStore<T>(
+      // SSR guard — subscribe must not reference `window` on the server.
+      isServer ? noopSubscribe : subscribe,
+      isServer ? getServerSnapshot : getSnapshot,
+      getServerSnapshot,
+    )
+
+    return [value, setState] as const
+  }
+}
+
+// ── readPersistedValue — plain function, no React required ─────────────────────────────────
+
+/**
+ * Read a value previously written by `createPersistedState` under the namespaced key
+ * `basalt:<key>`. Parses the versioned envelope shape `{ v, value }`. Returns `null` on
+ * miss, corruption, version mismatch, or SSR — no fallback is applied (call sites supply
+ * their own default).
+ *
+ * Primary use: `validateSearch` in TanStack Router (which runs outside React, so it can't
+ * call `usePersistedState`). Combine with a URL-param check to create a search-param store
+ * backed by localStorage.
+ *
+ * @param key  — un-namespaced key (the same one passed to `createPersistedState`)
+ * @param version — if provided, the envelope version must match; stale envelopes return `null`
+ *
+ * @example
+ * const stored = readPersistedValue('dashboard-range', 1)
+ * // stored is '1d' | '7d' | '30d' | null
+ */
+export function readPersistedValue(key: string, version?: number): unknown | null {
+  const storageKey = `basalt:${key}`
+  try {
+    const raw = localStorage.getItem(storageKey)
+    if (raw === null) return null
+    const envelope: unknown = JSON.parse(raw)
+    if (!isEnvelope(envelope)) return null
+    if (version !== undefined && envelope.v !== version) return null
+    return envelope.value
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Write a value under the namespaced key `basalt:<key>` in the same versioned envelope
+ * `createPersistedState` writes, and wake every hook on that key — the write half of
+ * `readPersistedValue`, and plain in the same way: no React required.
+ *
+ * The one call site is a store field's `clear()`, which has to DELETE its key from the store's
+ * record from an event handler, where the hook's setter is not in reach. Not exported from the
+ * `basalt-ui/state` barrel: the two store factories are the API, this is their seam.
+ *
+ * @internal
+ */
+export function writePersistedValue(key: string, version: number, value: unknown): void {
+  const storageKey = `basalt:${key}`
+  writeEnvelope(storageKey, version, value)
+  notify(storageKey)
+}

package/src/state.ts

@@ -1,246 +1,58 @@
 /**
- * createPersistedState — Mantine-free, React-only localStorage primitive.
+ * `basalt-ui/state` — the headless state surface: no Mantine, no router, no JSX.
  *
- * Versioned, Standard-Schema-validated state via useSyncExternalStore. SSR-safe.
- * Cross-tab via the 'storage' event. Keys are namespaced 'basalt:*' so they never
- * collide with the localstorage-theme guard pattern.
- */
-import { useSyncExternalStore } from 'react'
-import type { StandardSchemaV1 } from './register'
-
-// Shared noop subscribe — passed to useSyncExternalStore on the server so no window access occurs.
-const noopSubscribe =
-  (_cb: () => void): (() => void) =>
-  () => {}
-
-// ── useOnlineStatus ────────────────────────────────────────────────────────────────────────────────
-
-function subscribeOnline(cb: () => void): () => void {
-  window.addEventListener('online', cb)
-  window.addEventListener('offline', cb)
-  return () => {
-    window.removeEventListener('online', cb)
-    window.removeEventListener('offline', cb)
-  }
-}
-
-const getOnlineSnapshot = (): boolean => navigator.onLine
-const getOnlineServerSnapshot = (): boolean => true
-
-// Detect SSR once at module load — mirrors createPersistedState's isServer pattern.
-const isOnlineServer = typeof window === 'undefined'
-
-/**
- * Returns `true` when the browser reports an active network connection, `false` otherwise.
- * Backed by `useSyncExternalStore`: subscribes to window `online`/`offline` events.
- * SSR-safe — `getServerSnapshot` returns `true` (optimistic: assume online on the server).
+ * Two halves, one barrel:
  *
- * @deprecated Use `useConnectivity()` from `basalt-ui` instead — it aggregates browser,
- *   React Query, SSE, and health-ping signals into a richer `{ status, details }` object.
- *   `useOnlineStatus` remains for simple boolean needs without a provider dependency.
+ * - `./state/persisted` — `createPersistedState` / `readPersistedValue`, the versioned localStorage
+ *   primitive every other basalt module persists through.
+ * - `./state/fields` — the store field vocabulary (`field.*`, `FieldHandle`, the lanes) and
+ *   `createLocalStore`, the router-free store. `createSearchStore` (`basalt-ui/router-tanstack`)
+ *   is the router-coupled factory over the same fields.
  *
- * @example
- * const isOnline = useOnlineStatus()
- * if (!isOnline) return <OfflineBanner />
+ * The split is a file boundary, not a surface boundary: this barrel is what `package.json`'s
+ * `./state` export resolves to, and its named exports are pinned by `scripts/export-surface.json`.
  */
-export function useOnlineStatus(): boolean {
-  return useSyncExternalStore(
-    isOnlineServer ? noopSubscribe : subscribeOnline,
-    isOnlineServer ? getOnlineServerSnapshot : getOnlineSnapshot,
-    getOnlineServerSnapshot,
-  )
-}
-
-export type PersistedStateOptions<T> = {
-  /** localStorage key (will be namespaced as `basalt:<key>`). */
-  readonly key: string
-  /** Envelope version — increment when the shape changes. */
-  readonly version: number
-  /** Value to use when nothing is persisted, after migration fails, or on SSR. */
-  readonly initial: T
-  /** Migrate a previous-version persisted value forward to the current shape. */
-  readonly migrate?: (persisted: unknown, fromVersion: number) => T
-  /**
-   * Standard-Schema validate the (post-migrate) value. Invalid result OR a Promise (async schema)
-   * falls back to `initial` — sync storage can't await, so async validators are treated as invalid.
-   */
-  readonly schema?: StandardSchemaV1<unknown, T>
-}
-
-/** The envelope stored in localStorage: `{ v: number, value: unknown }`. */
-type Envelope = { v: number; value: unknown }
 
-function isEnvelope(raw: unknown): raw is Envelope {
-  return (
-    typeof raw === 'object' &&
-    raw !== null &&
-    'v' in raw &&
-    typeof (raw as Record<string, unknown>)['v'] === 'number' &&
-    'value' in raw
-  )
-}
-
-/** Parse a raw localStorage string (or null) into a value, falling back to `initial` on any miss. */
-function parseStorage<T>(raw: string | null, opts: PersistedStateOptions<T>): T {
-  if (raw === null) return opts.initial
-  try {
-    const parsed: unknown = JSON.parse(raw)
-    if (!isEnvelope(parsed)) return opts.initial
-
-    let value: unknown = parsed.value
-
-    if (parsed.v !== opts.version) {
-      value = opts.migrate ? opts.migrate(parsed.value, parsed.v) : opts.initial
-    }
-
-    if (opts.schema) {
-      const result = opts.schema['~standard'].validate(value)
-      // Async schema — can't await in sync storage path; fall back to initial
-      if (result instanceof Promise) return opts.initial
-      if (result.issues !== undefined) return opts.initial
-      // Narrowed to SuccessResult<T> — value is T
-      return result.value
-    }
-
-    return value as T
-  } catch {
-    return opts.initial
-  }
-}
-
-function writeStorage<T>(opts: PersistedStateOptions<T>, next: T): void {
-  const storageKey = `basalt:${opts.key}`
-  try {
-    const envelope: Envelope = { v: opts.version, value: next }
-    window.localStorage.setItem(storageKey, JSON.stringify(envelope))
-  } catch {
-    // Silently fail (storage full, private browsing, etc.)
-  }
-}
-
-/**
- * Versioned, Standard-Schema-validated localStorage state via useSyncExternalStore (no zustand).
- * SSR-safe (getServerSnapshot returns `initial`). Cross-tab via the storage event.
- *
- * Returns a factory hook — call it once per module, then use the returned hook in components.
- * Common case is 3 lines.
- *
- * @example
- * export const useFilterDraft = createPersistedState({ key: 'filters', version: 1, initial: DEFAULT, schema: FilterSchema })
- * // in a component:
- * const [draft, setDraft] = useFilterDraft()
- */
-export function createPersistedState<T>(
-  opts: PersistedStateOptions<T>,
-): () => readonly [T, (next: T) => void] {
-  const storageKey = `basalt:${opts.key}`
-
-  // One Set of subscriber callbacks — mirrors notifications/store.ts single-listener-to-Set pattern.
-  const listeners = new Set<() => void>()
-
-  // ONE module-scoped 'storage' event listener per key, registered lazily on first subscriber.
-  // Removed when the last subscriber unsubscribes (cleanup semantics preserved).
-  let storageHandler: ((e: StorageEvent) => void) | null = null
-
-  const subscribe = (cb: () => void): (() => void) => {
-    listeners.add(cb)
-
-    // Attach the shared window listener on the first subscriber.
-    if (storageHandler === null) {
-      storageHandler = (e: StorageEvent): void => {
-        if (e.key === storageKey) {
-          for (const listener of listeners) listener()
-        }
-      }
-      window.addEventListener('storage', storageHandler)
-    }
-
-    return () => {
-      listeners.delete(cb)
-      // Detach the shared window listener when the last subscriber unsubscribes.
-      if (listeners.size === 0 && storageHandler !== null) {
-        window.removeEventListener('storage', storageHandler)
-        storageHandler = null
-      }
-    }
-  }
-
-  // Snapshot cache — useSyncExternalStore requires getSnapshot to return a referentially STABLE
-  // value while the store is unchanged. parseStorage() allocates a fresh object/array on every
-  // call, so returning it raw makes React see an ever-changing snapshot for object/array state
-  // and loop until "Maximum update depth exceeded". We cache the parsed value keyed on the raw
-  // localStorage string: same string → same reference; a write (this tab or another) changes the
-  // string, so the next read re-parses exactly once. Primitive state was unaffected — this fixes
-  // the object/array case (chat history, form drafts).
-  let cachedRaw: string | null = null
-  let cachedValue: T = opts.initial
-  let primed = false
-
-  const getSnapshot = (): T => {
-    let raw: string | null
-    try {
-      raw = window.localStorage.getItem(storageKey)
-    } catch {
-      raw = null
-    }
-    if (primed && raw === cachedRaw) return cachedValue
-    cachedRaw = raw
-    cachedValue = parseStorage(raw, opts)
-    primed = true
-    return cachedValue
-  }
-  const getServerSnapshot = (): T => opts.initial
-
-  const setState = (next: T): void => {
-    writeStorage(opts, next)
-    // Notify in-tab listeners (the 'storage' event only fires in OTHER tabs)
-    for (const cb of listeners) cb()
-  }
-
-  // Detect SSR once at creation time — the environment doesn't change between renders.
-  const isServer = typeof window === 'undefined'
-
-  return function usePersistedState(): readonly [T, (next: T) => void] {
-    const value = useSyncExternalStore<T>(
-      // SSR guard — subscribe must not reference `window` on the server.
-      isServer ? noopSubscribe : subscribe,
-      isServer ? getServerSnapshot : getSnapshot,
-      getServerSnapshot,
-    )
-
-    return [value, setState] as const
-  }
-}
-
-// ── readPersistedValue — plain function, no React required ─────────────────────────────────
-
-/**
- * Read a value previously written by `createPersistedState` under the namespaced key
- * `basalt:<key>`. Parses the versioned envelope shape `{ v, value }`. Returns `null` on
- * miss, corruption, version mismatch, or SSR — no fallback is applied (call sites supply
- * their own default).
- *
- * Primary use: `validateSearch` in TanStack Router (which runs outside React, so it can't
- * call `usePersistedState`). Combine with a URL-param check to create a search-param store
- * backed by localStorage.
- *
- * @param key  — un-namespaced key (the same one passed to `createPersistedState`)
- * @param version — if provided, the envelope version must match; stale envelopes return `null`
- *
- * @example
- * const stored = readPersistedValue('dashboard-range', 1)
- * // stored is '1d' | '7d' | '30d' | null
- */
-export function readPersistedValue(key: string, version?: number): unknown | null {
-  const storageKey = `basalt:${key}`
-  try {
-    const raw = localStorage.getItem(storageKey)
-    if (raw === null) return null
-    const envelope: unknown = JSON.parse(raw)
-    if (!isEnvelope(envelope)) return null
-    if (version !== undefined && envelope.v !== version) return null
-    return envelope.value
-  } catch {
-    return null
-  }
-}
+export {
+  createPersistedState,
+  type PersistedStateOptions,
+  readPersistedValue,
+} from './state/persisted'
+
+export {
+  field,
+  createLocalStore,
+  type LocalStore,
+  // The field vocabulary
+  type FieldLane,
+  type ResolvedLane,
+  type ResolveLane,
+  type RangeValue,
+  type RangeParams,
+  type RangePresets,
+  type RangeWindow,
+  type RangeWindows,
+  type FieldFallback,
+  type FieldSetOptions,
+  type EnumField,
+  type MultiField,
+  type RangeField,
+  type NumberField,
+  type BooleanField,
+  type StringField,
+  type AnyField,
+  type FieldValue,
+  type FieldOption,
+  type FieldHandle,
+  type SearchValues,
+  type StoredValues,
+  // @internal — the seam `createSearchStore` is built on, not a consumer API.
+  type FieldCodec,
+  type StoreEntry,
+  type StoreCoreOptions,
+  type StoreCore,
+  type FieldUse,
+  type FieldWrite,
+  resolveFieldCodec,
+  createStoreCore,
+} from './state/fields'

package/src/styles.css

@@ -68,6 +68,19 @@
     font-size: max(16px, var(--input-fz, 1rem)) !important;
   }
 
+  /* `data-numeric` — one typographic law, every element. A number read as a MEASUREMENT (a preset
+     like `7d`/`30d`, a KPI value, a table cell, a count tag) is mono with tabular figures, so
+     digits line up column-wise and a changing value does not reflow its neighbours. Declared here,
+     unscoped, because the attribute is the contract: `theme/segmented-control.module.css` and
+     `controls/controls.module.css` were each carrying their own copy, which is why a plain
+     `<Text data-numeric>` in a consumer silently rendered in the sans face. Those two module rules
+     STAY — they additionally set `font-size` for their own component, which is a component
+     decision, not a law. */
+  [data-numeric] {
+    font-family: var(--basalt-font-mono);
+    font-variant-numeric: tabular-nums;
+  }
+
   /* Focus ring = the accent as INK, not as a fill. Mantine hardcodes the ring to
      `var(--mantine-primary-color-filled)` — the SURFACE token, which is deliberately deep in both
      schemes so a white label sits on it (see ACCENT in tokens/palette.ts). A ring is read against