@talelk/newui-data 0.0.0-stage → 1.1.0

package/src/aggregate.test.ts

@@ -0,0 +1,231 @@
+import { describe, expect, it } from 'vitest'
+import { type AggregateRow, aggregate, rollup, timeBucket } from './aggregate'
+
+/** Local-time dates so the buckets do not depend on the runner's zone. */
+const date = (year: number, month: number, day: number, hour = 0, min = 0) =>
+  new Date(year, month - 1, day, hour, min)
+
+describe('aggregate', () => {
+  const rows: AggregateRow[] = [
+    { region: 'north', amount: 10, tag: 'a' },
+    { region: 'north', amount: 20, tag: 'a' },
+    { region: 'south', amount: 5, tag: 'b' },
+  ]
+
+  it('groups by one column and computes sum and count', () => {
+    const out = aggregate(rows, {
+      by: 'region',
+      metrics: {
+        total: { field: 'amount', metric: 'sum' },
+        n: { field: 'amount', metric: 'count' },
+      },
+    })
+    expect(out).toEqual([
+      { region: 'north', total: 30, n: 2 },
+      { region: 'south', total: 5, n: 1 },
+    ])
+  })
+
+  it('groups by several columns', () => {
+    const out = aggregate(
+      [
+        { region: 'north', tag: 'a', amount: 1 },
+        { region: 'north', tag: 'b', amount: 2 },
+        { region: 'north', tag: 'a', amount: 3 },
+      ],
+      {
+        by: ['region', 'tag'],
+        metrics: { total: { field: 'amount', metric: 'sum' } },
+      },
+    )
+    expect(out).toEqual([
+      { region: 'north', tag: 'a', total: 4 },
+      { region: 'north', tag: 'b', total: 2 },
+    ])
+  })
+
+  it('computes min, max and extent', () => {
+    const out = aggregate(rows, {
+      by: 'region',
+      metrics: {
+        low: { field: 'amount', metric: 'min' },
+        high: { field: 'amount', metric: 'max' },
+        range: { field: 'amount', metric: 'extent' },
+      },
+    })
+    expect(out[0]).toEqual({
+      region: 'north',
+      low: 10,
+      high: 20,
+      range: [10, 20],
+    })
+  })
+
+  it('computes mean and median over numeric values only', () => {
+    const out = aggregate(
+      [
+        { g: 'x', amount: 10 },
+        { g: 'x', amount: 'nope' },
+        { g: 'x', amount: 30 },
+      ],
+      {
+        by: 'g',
+        metrics: {
+          avg: { field: 'amount', metric: 'mean' },
+          mid: { field: 'amount', metric: 'median' },
+        },
+      },
+    )
+    expect(out[0]?.['avg']).toBe(20)
+    expect(out[0]?.['mid']).toBe(20)
+
+    const even = aggregate(
+      [
+        { g: 'x', amount: 1 },
+        { g: 'x', amount: 3 },
+      ],
+      { by: 'g', metrics: { mid: { field: 'amount', metric: 'median' } } },
+    )
+    expect(even[0]?.['mid']).toBe(2)
+  })
+
+  it('computes unique and uniqueCount in first-seen order', () => {
+    const out = aggregate(rows, {
+      by: 'region',
+      metrics: {
+        tags: { field: 'tag', metric: 'unique' },
+        tagCount: { field: 'tag', metric: 'uniqueCount' },
+      },
+    })
+    expect(out[0]?.['tags']).toEqual(['a'])
+    expect(out[0]?.['tagCount']).toBe(1)
+    const all = aggregate(rows, {
+      by: [],
+      metrics: { tagCount: { field: 'tag', metric: 'uniqueCount' } },
+    })
+    expect(all).toHaveLength(1)
+    expect(all[0]?.['tagCount']).toBe(2)
+  })
+
+  it('takes first and last values in row order', () => {
+    const out = aggregate(rows, {
+      by: 'region',
+      metrics: {
+        opener: { field: 'tag', metric: 'first' },
+        closer: { field: 'tag', metric: 'last' },
+      },
+    })
+    expect(out[0]?.['opener']).toBe('a')
+    expect(out[0]?.['closer']).toBe('a')
+    expect(out[1]?.['opener']).toBe('b')
+  })
+
+  it('groups dates by their instant, not their object identity', () => {
+    const out = aggregate(
+      [
+        { day: date(2026, 1, 5), amount: 1 },
+        { day: new Date(date(2026, 1, 5).getTime()), amount: 2 },
+      ],
+      { by: 'day', metrics: { total: { field: 'amount', metric: 'sum' } } },
+    )
+    expect(out).toHaveLength(1)
+    expect(out[0]?.['total']).toBe(3)
+  })
+
+  it('handles empty input and missing fields', () => {
+    expect(
+      aggregate([], { by: 'a', metrics: { s: { field: 'b', metric: 'sum' } } }),
+    ).toEqual([])
+    const out = aggregate([{ g: 'x' }], {
+      by: 'g',
+      metrics: {
+        sum: { field: 'missing', metric: 'sum' },
+        min: { field: 'missing', metric: 'min' },
+        count: { field: 'missing', metric: 'count' },
+      },
+    })
+    expect(out[0]?.['sum']).toBe(0)
+    expect(out[0]?.['min']).toBeUndefined()
+    expect(out[0]?.['count']).toBe(1)
+  })
+})
+
+describe('timeBucket', () => {
+  const noon = date(2026, 3, 12, 14, 37) // Thursday afternoon
+
+  it('floors to the hour and the day', () => {
+    expect(timeBucket(noon, 'hour')).toEqual(date(2026, 3, 12, 14))
+    expect(timeBucket(noon, 'day')).toEqual(date(2026, 3, 12))
+  })
+
+  it('starts weeks on Monday', () => {
+    expect(timeBucket(noon, 'week')).toEqual(date(2026, 3, 9))
+    expect(timeBucket(date(2026, 3, 8, 3), 'week')).toEqual(date(2026, 3, 2))
+  })
+
+  it('starts months, quarters and years on their first day', () => {
+    expect(timeBucket(noon, 'month')).toEqual(date(2026, 3, 1))
+    expect(timeBucket(noon, 'quarter')).toEqual(date(2026, 1, 1))
+    expect(timeBucket(date(2026, 5, 20), 'quarter')).toEqual(date(2026, 4, 1))
+    expect(timeBucket(noon, 'year')).toEqual(date(2026, 1, 1))
+  })
+
+  it('accepts ISO strings and epochs, and stays Invalid when unparseable', () => {
+    const ms = date(2026, 3, 12, 14).getTime()
+    expect(timeBucket(new Date(ms).toISOString(), 'day')).toEqual(
+      date(2026, 3, 12),
+    )
+    expect(timeBucket(ms, 'day')).toEqual(date(2026, 3, 12))
+    expect(Number.isNaN(timeBucket('not a date', 'day').getTime())).toBe(true)
+  })
+})
+
+describe('rollup', () => {
+  const rows = [
+    { createdAt: date(2026, 1, 3, 9), amount: 5 },
+    { createdAt: date(2026, 1, 3, 17), amount: 10 },
+    { createdAt: date(2026, 1, 4, 9), amount: 7 },
+    { createdAt: 'yesterday', amount: 1 },
+  ]
+
+  it('counts rows per bucket, ascending, skipping unparseable dates', () => {
+    const series = rollup(rows, { field: 'createdAt', unit: 'day' })
+    expect(series).toEqual([
+      { bucket: date(2026, 1, 3), value: 2 },
+      { bucket: date(2026, 1, 4), value: 1 },
+    ])
+  })
+
+  it('applies a value metric per bucket', () => {
+    const series = rollup(rows, {
+      field: 'createdAt',
+      unit: 'day',
+      metric: { field: 'amount', metric: 'sum' },
+    })
+    expect(series.map((point) => point.value)).toEqual([15, 7])
+  })
+
+  it('buckets by month with a bare metric name', () => {
+    const series = rollup(rows, {
+      field: 'createdAt',
+      unit: 'month',
+      metric: 'count',
+    })
+    expect(series).toEqual([{ bucket: date(2026, 1, 1), value: 3 }])
+  })
+
+  it('keeps input order for first and last within a bucket', () => {
+    const series = rollup(
+      [
+        { createdAt: date(2026, 1, 3, 17), label: 'late' },
+        { createdAt: date(2026, 1, 3, 9), label: 'early' },
+      ],
+      {
+        field: 'createdAt',
+        unit: 'day',
+        metric: { field: 'label', metric: 'first' },
+      },
+    )
+    expect(series[0]?.value).toBe('late')
+  })
+})

package/src/aggregate.ts

@@ -0,0 +1,320 @@
+/**
+ * Pure transforms over rows the app already fetched.
+ *
+ * `aggregate` groups rows with the same eleven metric names table aggregation
+ * uses, so one vocabulary spans tables and transforms; `timeBucket` and
+ * `rollup` produce chart series from a time column. These are plain functions
+ * — no signals, no query, no components — and past their size the answer is
+ * server-side, per server mode's own doctrine.
+ */
+
+/** The kit's eleven aggregation metrics, shared with table aggregation. */
+export type Metric =
+  | 'sum'
+  | 'count'
+  | 'min'
+  | 'max'
+  | 'extent'
+  | 'mean'
+  | 'median'
+  | 'unique'
+  | 'uniqueCount'
+  | 'first'
+  | 'last'
+
+/** The bucket units {@link timeBucket} and {@link rollup} understand. */
+export type TimeUnit = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year'
+
+/** A metric applied to one field. `count` ignores the field's values. */
+export interface MetricSpec {
+  field: string
+  metric: Metric
+}
+
+/** A row is whatever the app's query returned. */
+export type AggregateRow = Record<string, unknown>
+
+/** Options for {@link aggregate}. */
+export interface AggregateOptions {
+  /** Group-by columns. The output row carries each group's value. */
+  by: string | readonly string[]
+  /** Output column → the field to aggregate and the metric to apply. */
+  metrics: Record<string, MetricSpec>
+}
+
+/** A bucketed series point, shaped for a chart's `{ x, y }` series. */
+export interface RollupPoint {
+  /** The start of the bucket, in local time. */
+  bucket: Date
+  value: unknown
+}
+
+/** Options for {@link rollup}. */
+export interface RollupOptions {
+  /** The row's date column. */
+  field: string
+  unit: TimeUnit
+  /**
+   * What to compute per bucket. A bare metric name counts rows (its field is
+   * the date column, which is what a count of a time series means); pass a
+   * {@link MetricSpec} to aggregate a value column per bucket.
+   */
+  metric?: Metric | MetricSpec
+}
+
+/** A date, an ISO string, or an epoch — anything a chart hands back. */
+export type DateLike = Date | string | number
+
+function toDate(value: unknown): Date {
+  if (value instanceof Date) return value
+  if (typeof value === 'number') return new Date(value)
+  if (typeof value === 'string') return new Date(value)
+  return new Date(Number.NaN)
+}
+
+/** Coerce to a number for the numeric metrics; `undefined` when not numeric. */
+function numeric(value: unknown): number | undefined {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : undefined
+  }
+  if (value instanceof Date) return value.getTime()
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value)
+    return Number.isFinite(parsed) ? parsed : undefined
+  }
+  return undefined
+}
+
+/** Identity for `unique`/`uniqueCount`: JSON so objects compare by shape. */
+function identity(value: unknown): string {
+  if (value === undefined) return 'undefined'
+  try {
+    return JSON.stringify(value) ?? String(value)
+  } catch {
+    return String(value)
+  }
+}
+
+function uniqueValues(values: readonly unknown[]): unknown[] {
+  const seen = new Set<string>()
+  const out: unknown[] = []
+  for (const value of values) {
+    const key = identity(value)
+    if (!seen.has(key)) {
+      seen.add(key)
+      out.push(value)
+    }
+  }
+  return out
+}
+
+function median(values: readonly number[]): number | undefined {
+  if (values.length === 0) return undefined
+  const sorted = [...values].sort((a, b) => a - b)
+  const middle = Math.floor(sorted.length / 2)
+  if (sorted.length % 2 === 1) return sorted[middle]
+  const low = sorted[middle - 1]
+  const high = sorted[middle]
+  if (low === undefined || high === undefined) return undefined
+  return (low + high) / 2
+}
+
+/** Apply one metric to a group's rows. Internal to the transform module. */
+function applyMetric(rows: readonly AggregateRow[], spec: MetricSpec): unknown {
+  const values = rows.map((row) => row[spec.field])
+  switch (spec.metric) {
+    case 'count':
+      return rows.length
+    case 'sum': {
+      let total = 0
+      for (const value of values) total += numeric(value) ?? 0
+      return total
+    }
+    case 'min': {
+      let best: number | undefined
+      for (const value of values) {
+        const n = numeric(value)
+        if (n !== undefined && (best === undefined || n < best)) best = n
+      }
+      return best
+    }
+    case 'max': {
+      let best: number | undefined
+      for (const value of values) {
+        const n = numeric(value)
+        if (n !== undefined && (best === undefined || n > best)) best = n
+      }
+      return best
+    }
+    case 'extent': {
+      let low: number | undefined
+      let high: number | undefined
+      for (const value of values) {
+        const n = numeric(value)
+        if (n === undefined) continue
+        if (low === undefined || n < low) low = n
+        if (high === undefined || n > high) high = n
+      }
+      if (low === undefined || high === undefined) return undefined
+      return [low, high]
+    }
+    case 'mean': {
+      const numbers = values
+        .map(numeric)
+        .filter((n): n is number => n !== undefined)
+      if (numbers.length === 0) return undefined
+      return (
+        numbers.reduce((total, n) => total + n, 0) / (numbers.length as number)
+      )
+    }
+    case 'median': {
+      const numbers = values
+        .map(numeric)
+        .filter((n): n is number => n !== undefined)
+      return median(numbers)
+    }
+    case 'unique':
+      return uniqueValues(values)
+    case 'uniqueCount':
+      return uniqueValues(values).length
+    case 'first':
+      return values[0]
+    case 'last':
+      return values[values.length - 1]
+  }
+}
+
+/** A stable group key for a row's `by` values; dates group by their instant. */
+function groupKey(row: AggregateRow, by: readonly string[]): string {
+  return JSON.stringify(
+    by.map((key) => {
+      const value = row[key]
+      return value instanceof Date ? value.toISOString() : value
+    }),
+  )
+}
+
+/**
+ * Group rows by `by` and compute each named metric per group.
+ *
+ * The output rows carry the group columns plus one column per metrics key,
+ * in the order groups first appear. `min`/`max`/`extent`/`mean`/`median`
+ * ignore non-numeric values (and empty groups yield `undefined`); `count`
+ * counts rows, and `first`/`last` keep the row's own value.
+ */
+export function aggregate(
+  rows: readonly AggregateRow[],
+  options: AggregateOptions,
+): AggregateRow[] {
+  const by = typeof options.by === 'string' ? [options.by] : options.by
+  const groups = new Map<string, AggregateRow[]>()
+  const groupValues = new Map<string, unknown[]>()
+  for (const row of rows) {
+    const key = groupKey(row, by)
+    const bucket = groups.get(key)
+    if (bucket) {
+      bucket.push(row)
+    } else {
+      groups.set(key, [row])
+      groupValues.set(
+        key,
+        by.map((column) => {
+          const value = row[column]
+          return value instanceof Date ? new Date(value.getTime()) : value
+        }),
+      )
+    }
+  }
+
+  const out: AggregateRow[] = []
+  for (const [key, bucket] of groups) {
+    const result: AggregateRow = {}
+    const values = groupValues.get(key) ?? []
+    by.forEach((column, index) => {
+      result[column] = values[index]
+    })
+    for (const [id, spec] of Object.entries(options.metrics)) {
+      result[id] = applyMetric(bucket, spec)
+    }
+    out.push(result)
+  }
+  return out
+}
+
+/**
+ * Floor a date to the start of its bucket, in local time.
+ *
+ * Weeks start on Monday; months, quarters and years start on their first day
+ * at midnight. An unparseable date yields an Invalid Date, so a chart can
+ * still map it — `rollup` skips those rows instead.
+ */
+export function timeBucket(date: DateLike, unit: TimeUnit): Date {
+  const value = toDate(date)
+  if (Number.isNaN(value.getTime())) return new Date(Number.NaN)
+  const bucket = new Date(value.getTime())
+  switch (unit) {
+    case 'hour':
+      bucket.setMinutes(0, 0, 0)
+      return bucket
+    case 'day':
+      bucket.setHours(0, 0, 0, 0)
+      return bucket
+    case 'week': {
+      bucket.setHours(0, 0, 0, 0)
+      // getDay(): Sunday is 0; shift back to the Monday that starts the week.
+      const shift = (bucket.getDay() + 6) % 7
+      bucket.setDate(bucket.getDate() - shift)
+      return bucket
+    }
+    case 'month':
+      bucket.setHours(0, 0, 0, 0)
+      bucket.setDate(1)
+      return bucket
+    case 'quarter':
+      bucket.setHours(0, 0, 0, 0)
+      bucket.setDate(1)
+      bucket.setMonth(Math.floor(bucket.getMonth() / 3) * 3)
+      return bucket
+    case 'year':
+      bucket.setHours(0, 0, 0, 0)
+      bucket.setDate(1)
+      bucket.setMonth(0)
+      return bucket
+  }
+}
+
+/**
+ * Turn a time column into a chart series: bucket the rows by `unit`, apply
+ * `metric` per bucket, and return the buckets in ascending order.
+ *
+ * Rows whose date column does not parse are skipped — a chart wants the
+ * series it can place, not a hole. Rows are read in the given order, so
+ * `first`/`last` follow the input's order, not the timeline's.
+ */
+export function rollup(
+  rows: readonly AggregateRow[],
+  options: RollupOptions,
+): RollupPoint[] {
+  const spec: MetricSpec =
+    typeof options.metric === 'string'
+      ? { field: options.field, metric: options.metric }
+      : (options.metric ?? { field: options.field, metric: 'count' })
+  const groups = new Map<number, AggregateRow[]>()
+  for (const row of rows) {
+    const bucket = timeBucket(row[options.field] as DateLike, options.unit)
+    if (Number.isNaN(bucket.getTime())) continue
+    const key = bucket.getTime()
+    const bucketRows = groups.get(key)
+    if (bucketRows) {
+      bucketRows.push(row)
+    } else {
+      groups.set(key, [row])
+    }
+  }
+  return [...groups.entries()]
+    .sort((a, b) => a[0] - b[0])
+    .map(([time, bucketRows]) => ({
+      bucket: new Date(time),
+      value: applyMetric(bucketRows, spec),
+    }))
+}

package/src/config-store.test.ts

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  CONFIG_DOCUMENT_LIMIT,
+  type ConfigStorage,
+  createConfigStore,
+} from './config-store'
+
+/** A Map-backed storage that records what was written. */
+function memoryStorage(): ConfigStorage & { map: Map<string, string> } {
+  const map = new Map<string, string>()
+  return {
+    map,
+    getItem: (key) => map.get(key) ?? null,
+    setItem: (key, value) => void map.set(key, value),
+    removeItem: (key) => void map.delete(key),
+    keys: () => [...map.keys()],
+  }
+}
+
+describe('createConfigStore', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-03-01T10:00:00Z'))
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  it('wraps saves in a versioned envelope and loads them back', () => {
+    const storage = memoryStorage()
+    const store = createConfigStore({ key: 'acme.views', storage })
+
+    expect(store.save('revenue', { columns: ['date', 'usd'] })).toBe(true)
+    const loaded = store.load<{ columns: string[] }>('revenue')
+    expect(loaded?.v).toBe(1)
+    expect(loaded?.name).toBe('revenue')
+    expect(loaded?.updatedAt).toBe('2026-03-01T10:00:00.000Z')
+    expect(loaded?.doc).toEqual({ columns: ['date', 'usd'] })
+
+    // The store namespaces its keys, so a sibling store cannot collide.
+    expect([...storage.map.keys()]).toEqual(['acme.views:revenue'])
+  })
+
+  it('carries the type discriminator through save and list', () => {
+    const store = createConfigStore({
+      key: 'acme',
+      storage: memoryStorage(),
+    })
+    store.save('week-only', { filters: [] }, { type: 'saved-view' })
+    store.save('layout', { widgets: [] }, { type: 'dashboard-config' })
+
+    const listed = store.list()
+    expect(listed).toHaveLength(2)
+    expect(listed.map((row) => row.type).sort()).toEqual([
+      'dashboard-config',
+      'saved-view',
+    ])
+  })
+
+  it('lists documents newest first and skips unreadable entries', () => {
+    const storage = memoryStorage()
+    const store = createConfigStore({ key: 'acme', storage })
+    store.save('old', { n: 1 })
+    vi.setSystemTime(new Date('2026-03-02T10:00:00Z'))
+    store.save('new', { n: 2 })
+    storage.map.set('acme:garbage', '{not json')
+
+    expect(store.list().map((row) => row.name)).toEqual(['new', 'old'])
+    expect(store.load('garbage')).toBeUndefined()
+  })
+
+  it('removes and renames, reporting whether the document existed', () => {
+    const storage = memoryStorage()
+    const store = createConfigStore({ key: 'acme', storage })
+    store.save('draft', { n: 1 })
+
+    expect(store.remove('draft')).toBe(true)
+    expect(store.remove('draft')).toBe(false)
+    expect(store.load('draft')).toBeUndefined()
+
+    store.save('draft', { n: 1 })
+    vi.setSystemTime(new Date('2026-03-03T10:00:00Z'))
+    expect(store.rename('draft', 'keeper')).toBe(true)
+    expect(store.rename('draft', 'ghost')).toBe(false)
+
+    const keeper = store.load<{ n: number }>('keeper')
+    expect(keeper?.name).toBe('keeper')
+    expect(keeper?.updatedAt).toBe('2026-03-03T10:00:00.000Z')
+    expect(keeper?.doc).toEqual({ n: 1 })
+    expect(storage.map.has('acme:draft')).toBe(false)
+  })
+
+  it('migrates older envelopes instead of reading them wrong', () => {
+    const storage = memoryStorage()
+    storage.map.set(
+      'acme:old',
+      JSON.stringify({ v: 0, name: 'old', updatedAt: 'x', doc: { a: 1 } }),
+    )
+
+    const migrated = createConfigStore({
+      key: 'acme',
+      storage,
+      migrate: (doc) => ({ ...(doc as object), migrated: true }),
+    })
+    const loaded = migrated.load<{ a: number; migrated: boolean }>('old')
+    expect(loaded?.v).toBe(1)
+    expect(loaded?.doc).toEqual({ a: 1, migrated: true })
+
+    // Without a migrate, a version mismatch is unreadable, not corrupted.
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const strict = createConfigStore({ key: 'acme', storage })
+    expect(strict.load('old')).toBeUndefined()
+    expect(warn).toHaveBeenCalled()
+  })
+
+  it('caps documents at 64KB with a loud dev warning', () => {
+    const storage = memoryStorage()
+    const store = createConfigStore({ key: 'acme', storage })
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const huge = 'x'.repeat(CONFIG_DOCUMENT_LIMIT + 1)
+    expect(store.save('huge', { data: huge })).toBe(false)
+    expect(storage.map.has('acme:huge')).toBe(false)
+    expect(warn).toHaveBeenCalledTimes(1)
+
+    // Just under the cap still saves.
+    expect(store.save('big', { data: 'y' })).toBe(true)
+    expect(store.load('big')).toBeDefined()
+  })
+
+  it('drops writes when the backend fails, warning once per failure site', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const failing: ConfigStorage = {
+      getItem: () => null,
+      setItem: () => {
+        throw new Error('QuotaExceeded')
+      },
+      removeItem: () => {},
+      keys: () => [],
+    }
+    const store = createConfigStore({ key: 'acme', storage: failing })
+    expect(store.save('one', { n: 1 })).toBe(false)
+    expect(warn).toHaveBeenCalled()
+  })
+
+  it('falls back to memory under SSR, where localStorage is absent', () => {
+    vi.stubGlobal('localStorage', undefined)
+    try {
+      const store = createConfigStore({ key: 'acme' })
+      expect(store.save('page', { n: 1 })).toBe(true)
+      expect(store.load<{ n: number }>('page')?.doc.n).toBe(1)
+    } finally {
+      vi.unstubAllGlobals()
+    }
+  })
+})