@vobs/dict 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vobs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# @vobs/dict
+
+Business dictionaries (value/label lists) with TTL caching, per-name request dedup, and revision-based race protection.
+
+## Install
+
+```bash
+npm install @vobs/dict
+```
+
+## Quick start
+
+```ts
+import { createDict } from '@vobs/dict'
+
+const dict = createDict({
+  data: { user_status: [{ value: 'active', label: 'Active' }] },
+  loader: async (name, signal) => {
+    const response = await fetch(`/api/dicts/${name}`, { signal })
+    return response.json()
+  },
+  staleTime: 60_000
+})
+
+dict.label('user_status', 'active') // 'Active'
+
+const query = dict.query('roles')
+await query.load()
+query.items.value // [{ value, label, ... }]
+```
+
+## API
+
+| Signature | Description |
+| --- | --- |
+| `createDict(options?: DictOptions): DictContext` | Creates a dict context with optional static `data`, `loader`, `staleTime` (default 5 min), and `onError`. |
+| `dict.data: Signal<DictData>` | Reactive map of dict name to items. |
+| `dict.loading: Signal<boolean>` / `dict.error: Signal<Error | null>` | Global loading and error state. |
+| `dict.get(name: DictName): DictItems` | Current items, or an empty array when unknown. |
+| `dict.find(name: DictName, value: DictValue): DictItem | undefined` | Finds one item by value. |
+| `dict.label(name: DictName, value: DictValue, fallback?): string` | Label for a value; falls back to the given string, then `String(value)`. |
+| `dict.query(name: DictName): DictQuery` | Per-name view with `items`, `loading`, `error`, `updatedAt` signals plus `load()` and `invalidate()`. |
+| `dict.load(name: DictName, options?): Promise<DictItems>` | Loads through the `loader`; skips while fresh unless `{ force: true }`. |
+| `dict.set(name: DictName, items: DictItems): void` | Writes items directly and aborts any in-flight load. |
+| `dict.invalidate(name?: DictName): void` | Marks one or all dicts stale and aborts in-flight requests. |
+| `dict.dehydrate()` / `dict.hydrate(snapshot)` | Serializes and restores cached entries for SSR. |
+| `dict.dispose(): void` | Aborts requests and disposes all signals. |
+| `dictPlugin(options?): VobsPlugin` | Provides the context through `DICT_KEY`. |
+| `useDict(): DictContext` | Injects the dict context inside components. |
+
+Loads are deduplicated per name, and every load carries a revision: `invalidate()` or `set()` aborts the in-flight request through the `AbortSignal` and a late response from a superseded request can never overwrite newer data. Failed loads keep the previous items and surface a `DictError` on `query().error`.
+
+## Types
+
+`DictName`, `DictValue`, `DictItem`, `DictItems`, `DictData`, `DictLoader`, `DictQuery`, `DictOptions`, `DictPluginOptions`, `DictContext`, `DictDehydratedEntry`, `DictDehydratedState`, `DictErrorCode`

package/package.json

@@ -0,0 +1,25 @@
+{
+  "license": "MIT",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "name": "@vobs/dict",
+  "version": "1.0.0",
+  "description": "Reactive business dictionary sources and SSR snapshots for Vobs.",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@vobs/reactivity": "1.0.0",
+    "@vobs/vobs": "1.0.0"
+  },
+  "scripts": {
+    "test": "vitest --environment jsdom"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it, vi } from 'vitest'
+import { createText, createVobs } from '@vobs/vobs'
+import {
+  DICT_KEY,
+  DictError,
+  createDict,
+  dictPlugin,
+  useDict
+} from './index'
+
+const statusItems = [
+  { value: 'active', label: 'Active' },
+  { value: 'disabled', label: 'Disabled', disabled: true }
+] as const
+
+describe('@vobs/dict', () => {
+  it('支持静态业务字典、查询、value 查找和 label 回退，不依赖 i18n', () => {
+    const dict = createDict({ data: { user_status: statusItems } })
+    const query = dict.query('user_status')
+
+    expect(dict.get('user_status')).toEqual(statusItems)
+    expect(query.items.value).toEqual(statusItems)
+    expect(dict.find('user_status', 'disabled')).toMatchObject({ disabled: true })
+    expect(dict.label('user_status', 'active')).toBe('Active')
+    expect(dict.label('user_status', 'missing', 'Unknown')).toBe('Unknown')
+    dict.set('user_status', [{ value: 1, label: 'One' }])
+    expect(query.items.value).toEqual([{ value: 1, label: 'One' }])
+    dict.dispose()
+  })
+
+  it('按字典名去重请求、遵守 TTL，并在失效后重新加载', async () => {
+    let time = 1_000
+    const loader = vi.fn(async (name: string) => [{ value: `${name}-${loader.mock.calls.length}`, label: 'Loaded' }])
+    const dict = createDict({ loader, staleTime: 100, now: () => time })
+    const query = dict.query('roles')
+
+    const [first, second] = await Promise.all([dict.load('roles'), query.load()])
+    expect(first).toEqual(second)
+    expect(loader).toHaveBeenCalledTimes(1)
+    expect(query.loading.value).toBe(false)
+    await dict.load('roles')
+    expect(loader).toHaveBeenCalledTimes(1)
+    time += 100
+    await dict.load('roles')
+    expect(loader).toHaveBeenCalledTimes(2)
+    dict.invalidate('roles')
+    await dict.load('roles')
+    expect(loader).toHaveBeenCalledTimes(3)
+    dict.dispose()
+  })
+
+  it('加载失败保留旧字典、暴露错误并报告观察者', async () => {
+    const onError = vi.fn()
+    const dict = createDict({
+      data: { user_status: statusItems },
+      loader: async () => { throw new Error('network unavailable') },
+      onError,
+      staleTime: 0
+    })
+
+    await expect(dict.load('user_status')).rejects.toMatchObject({ code: 'DICT_LOAD_FAILED' })
+    expect(dict.get('user_status')).toEqual(statusItems)
+    expect(dict.query('user_status').error.value).toMatchObject({ code: 'DICT_LOAD_FAILED' })
+    expect(onError).toHaveBeenCalledWith(expect.objectContaining({ code: 'DICT_LOAD_FAILED' }), 'user_status')
+    dict.dispose()
+  })
+
+  it('失效会中止在途请求，并阻止慢请求结果覆盖缓存', async () => {
+    let resolveLoader: ((items: readonly { value: string; label: string }[]) => void) | undefined
+    let aborted = false
+    const dict = createDict({
+      loader: (_name, signal) => new Promise(resolve => {
+        resolveLoader = resolve
+        signal.addEventListener('abort', () => { aborted = true }, { once: true })
+      })
+    })
+    const query = dict.query('roles')
+    const pending = dict.load('roles')
+    await vi.waitFor(() => expect(query.loading.value).toBe(true))
+    dict.invalidate('roles')
+    resolveLoader?.([{ value: 'stale', label: 'Stale' }])
+    await pending
+
+    expect(aborted).toBe(true)
+    expect(query.loading.value).toBe(false)
+    expect(dict.get('roles')).toEqual([])
+    dict.dispose()
+  })
+
+  it('序列化并恢复 SSR 状态，恢复后的缓存不会重复调用 loader', async () => {
+    let time = 10_000
+    const source = createDict({
+      data: { user_status: statusItems },
+      now: () => time,
+      staleTime: 5_000
+    })
+    const snapshot = source.dehydrate()
+    const loader = vi.fn(async () => [{ value: 'unexpected', label: 'Unexpected' }])
+    const target = createDict({ loader, now: () => time, staleTime: 5_000 })
+    target.hydrate(JSON.stringify(snapshot))
+
+    expect(target.get('user_status')).toEqual(statusItems)
+    await expect(target.load('user_status')).resolves.toEqual(statusItems)
+    expect(loader).not.toHaveBeenCalled()
+    expect(() => target.hydrate({ version: 2, entries: [] })).toThrowError(
+      expect.objectContaining({ code: 'INVALID_DEHYDRATED_STATE' })
+    )
+    source.dispose()
+    target.dispose()
+  })
+
+  it('dictPlugin 注入上下文并在应用销毁后释放自有状态', () => {
+    let injected: ReturnType<typeof createDict> | undefined
+    const app = createVobs({
+      render: () => createText('dict'),
+      plugins: [
+        dictPlugin({ data: { user_status: statusItems } }),
+        { name: 'consumer', install(context) { injected = context.inject(DICT_KEY) } }
+      ]
+    })
+    expect(injected?.label('user_status', 'active')).toBe('Active')
+    app.destroy()
+    expect(() => injected?.get('user_status')).toThrow('已销毁')
+  })
+
+  it('未安装插件与无 loader 的加载给出明确错误', async () => {
+    const noLoader = createDict()
+    await expect(noLoader.load('roles')).rejects.toMatchObject({ code: 'DICT_LOADER_MISSING' })
+    noLoader.dispose()
+    const app = createVobs({ render: () => {
+      useDict()
+      return createText('')
+    } })
+    expect(() => app.mount(document.createElement('div'))).toThrowError(
+      expect.objectContaining({ code: 'DICT_CONTEXT_MISSING' })
+    )
+    expect(DictError).toBeDefined()
+  })
+})

package/src/index.ts

@@ -0,0 +1,421 @@
+import { getCurrentOwner, onDispose, state, type Signal } from '@vobs/reactivity'
+import { createInjectionKey, inject, type InjectionKey, type VobsPlugin } from '@vobs/vobs'
+
+export type DictName = string
+export type DictValue = string | number
+
+export interface DictItem {
+  readonly value: DictValue
+  readonly label: string
+  readonly disabled?: boolean
+  readonly [key: string]: unknown
+}
+
+export type DictItems = readonly DictItem[]
+export type DictData = Readonly<Record<DictName, DictItems>>
+export type DictLoader = (name: DictName, signal: AbortSignal) => DictItems | PromiseLike<DictItems>
+
+export interface DictQuery {
+  readonly name: DictName
+  readonly items: Signal<DictItems>
+  readonly loading: Signal<boolean>
+  readonly error: Signal<Error | null>
+  readonly updatedAt: Signal<number>
+  load(options?: { readonly force?: boolean }): Promise<DictItems>
+  invalidate(): void
+}
+
+export interface DictDehydratedEntry {
+  readonly name: DictName
+  readonly items: DictItems
+  readonly updatedAt: number
+}
+
+export interface DictDehydratedState {
+  readonly version: 1
+  readonly entries: readonly DictDehydratedEntry[]
+}
+
+export interface DictOptions {
+  readonly data?: DictData
+  readonly loader?: DictLoader
+  readonly staleTime?: number
+  readonly now?: () => number
+  readonly onError?: (error: DictError, name: DictName) => void
+}
+
+export interface DictPluginOptions extends DictOptions {
+  readonly dict?: DictContext
+}
+
+export interface DictContext {
+  readonly data: Signal<DictData>
+  readonly loading: Signal<boolean>
+  readonly error: Signal<Error | null>
+  readonly staleTime: number
+  get(name: DictName): DictItems
+  find(name: DictName, value: DictValue): DictItem | undefined
+  label(name: DictName, value: DictValue, fallback?: string): string
+  query(name: DictName): DictQuery
+  load(name: DictName, options?: { readonly force?: boolean }): Promise<DictItems>
+  set(name: DictName, items: DictItems): void
+  invalidate(name?: DictName): void
+  dehydrate(): DictDehydratedState
+  hydrate(snapshot: unknown): void
+  dispose(): void
+}
+
+export type DictErrorCode =
+  | 'DICT_CONTEXT_MISSING'
+  | 'DICT_CONTEXT_DISPOSED'
+  | 'INVALID_DICT_NAME'
+  | 'INVALID_DICT_ITEMS'
+  | 'DICT_LOADER_MISSING'
+  | 'DICT_LOAD_FAILED'
+  | 'INVALID_DEHYDRATED_STATE'
+
+export class DictError extends Error {
+  readonly code: DictErrorCode
+  readonly cause: unknown
+
+  constructor(code: DictErrorCode, message: string, cause?: unknown) {
+    super(message)
+    this.name = 'DictError'
+    this.code = code
+    this.cause = cause
+  }
+}
+
+export const DICT_KEY: InjectionKey<DictContext> = createInjectionKey<DictContext>('vobs.dict')
+
+const EMPTY_ITEMS: DictItems = Object.freeze([])
+
+interface DictEntry extends DictQuery {
+  controller: AbortController | null
+  inFlight: Promise<DictItems> | null
+  revision: number
+}
+
+export function createDict(options: DictOptions = {}): DictContext {
+  const staleTime = validateStaleTime(options.staleTime ?? 5 * 60 * 1000)
+  const now = options.now ?? Date.now
+  const initial = normalizeData(options.data ?? {})
+  const data = state<DictData>(initial)
+  const loading = state(false)
+  const error = state<Error | null>(null)
+  const entries = new Map<DictName, DictEntry>()
+  let disposed = false
+
+  for (const [name, items] of Object.entries(initial)) {
+    const entry = createEntry(name, items, now())
+    entries.set(name, entry)
+  }
+
+  const context: DictContext = {
+    data,
+    loading,
+    error,
+    staleTime,
+
+    get(name): DictItems {
+      ensureActive()
+      return data.value[validateName(name)] ?? EMPTY_ITEMS
+    },
+
+    find(name, value): DictItem | undefined {
+      ensureActive()
+      return context.get(name).find(item => item.value === value)
+    },
+
+    label(name, value, fallback): string {
+      ensureActive()
+      return context.find(name, value)?.label ?? fallback ?? String(value)
+    },
+
+    query(name): DictQuery {
+      ensureActive()
+      return getEntry(validateName(name))
+    },
+
+    load(name, loadOptions = {}): Promise<DictItems> {
+      ensureActive()
+      const entry = getEntry(validateName(name))
+      if (!loadOptions.force && isFresh(entry)) return Promise.resolve(entry.items.value)
+      if (entry.inFlight) return entry.inFlight
+      if (!options.loader) {
+        const loadError = new DictError('DICT_LOADER_MISSING', `Vobs Dict: ${entry.name} 未配置 loader`)
+        entry.error.value = loadError
+        error.value = loadError
+        report(loadError, entry.name)
+        return Promise.reject(loadError)
+      }
+
+      const revision = ++entry.revision
+      const controller = new AbortController()
+      entry.controller = controller
+      entry.loading.value = true
+      refreshLoading()
+      const request = Promise.resolve()
+        .then(() => options.loader!(entry.name, controller.signal))
+        .then(items => {
+          if (disposed || revision !== entry.revision) return entry.items.value
+          const normalized = normalizeItems(items)
+          commit(entry, normalized, now(), false)
+          return normalized
+        })
+        .catch(reason => {
+          if (disposed || revision !== entry.revision || isAbortError(reason)) return entry.items.value
+          const loadError = reason instanceof DictError
+            ? reason
+            : new DictError('DICT_LOAD_FAILED', `Vobs Dict: ${entry.name} 加载失败`, reason)
+          entry.error.value = loadError
+          error.value = loadError
+          report(loadError, entry.name)
+          throw loadError
+        })
+        .finally(() => {
+          if (revision !== entry.revision) return
+          entry.inFlight = null
+          entry.controller = null
+          entry.loading.value = false
+          refreshLoading()
+        })
+      entry.inFlight = request
+      return request
+    },
+
+    set(name, items): void {
+      ensureActive()
+      commit(getEntry(validateName(name)), normalizeItems(items), now())
+    },
+
+    invalidate(name): void {
+      ensureActive()
+      if (name === undefined) {
+        for (const entry of entries.values()) invalidateEntry(entry)
+        return
+      }
+      invalidateEntry(getEntry(validateName(name)))
+    },
+
+    dehydrate(): DictDehydratedState {
+      ensureActive()
+      return {
+        version: 1,
+        entries: Object.freeze([...entries.values()]
+          .filter(entry => entry.updatedAt.value > 0)
+          .map(entry => Object.freeze({
+            name: entry.name,
+            items: entry.items.value,
+            updatedAt: entry.updatedAt.value
+          })))
+      }
+    },
+
+    hydrate(snapshot): void {
+      ensureActive()
+      const restored = parseDehydratedState(snapshot)
+      const nextData: Record<DictName, DictItems> = {}
+      const restoredNames = new Set<DictName>()
+      for (const item of restored.entries) {
+        const entry = getEntry(item.name)
+        entry.revision++
+        entry.controller?.abort()
+        entry.controller = null
+        entry.inFlight = null
+        entry.loading.value = false
+        entry.items.value = item.items
+        entry.error.value = null
+        entry.updatedAt.value = item.updatedAt
+        nextData[item.name] = item.items
+        restoredNames.add(item.name)
+      }
+      for (const [name, entry] of entries) {
+        if (restoredNames.has(name)) continue
+        entry.revision++
+        entry.controller?.abort()
+        entry.controller = null
+        entry.inFlight = null
+        entry.loading.value = false
+        entry.items.value = EMPTY_ITEMS
+        entry.error.value = null
+        entry.updatedAt.value = 0
+      }
+      data.value = Object.freeze(nextData)
+      error.value = null
+      refreshLoading()
+    },
+
+    dispose(): void {
+      if (disposed) return
+      disposed = true
+      for (const entry of entries.values()) {
+        entry.controller?.abort()
+        entry.items.dispose()
+        entry.loading.dispose()
+        entry.error.dispose()
+        entry.updatedAt.dispose()
+      }
+      entries.clear()
+      data.dispose()
+      loading.dispose()
+      error.dispose()
+    }
+  }
+
+  if (getCurrentOwner()) onDispose(context.dispose)
+  return context
+
+  function getEntry(name: DictName): DictEntry {
+    const existing = entries.get(name)
+    if (existing) return existing
+    const entry = createEntry(name, data.value[name] ?? EMPTY_ITEMS, 0)
+    entries.set(name, entry)
+    return entry
+  }
+
+  function createEntry(name: DictName, items: DictItems, updatedAt: number): DictEntry {
+    const entry = {
+      name,
+      items: state(items),
+      loading: state(false),
+      error: state<Error | null>(null),
+      updatedAt: state(updatedAt),
+      controller: null,
+      inFlight: null,
+      revision: 0,
+      load: (loadOptions?: { readonly force?: boolean }) => context.load(name, loadOptions),
+      invalidate: () => context.invalidate(name)
+    } as DictEntry
+    return entry
+  }
+
+  function commit(entry: DictEntry, items: DictItems, updatedAt: number, replaceRequest = true): void {
+    if (replaceRequest) {
+      entry.revision++
+      entry.controller?.abort()
+      entry.controller = null
+      entry.inFlight = null
+    }
+    entry.items.value = items
+    entry.error.value = null
+    entry.updatedAt.value = updatedAt
+    data.value = Object.freeze({ ...data.value, [entry.name]: items })
+    error.value = null
+    refreshLoading()
+  }
+
+  function invalidateEntry(entry: DictEntry): void {
+    entry.revision++
+    entry.controller?.abort()
+    entry.controller = null
+    entry.inFlight = null
+    entry.loading.value = false
+    entry.updatedAt.value = 0
+    refreshLoading()
+  }
+
+  function isFresh(entry: DictEntry): boolean {
+    return entry.updatedAt.value > 0 && now() - entry.updatedAt.value < staleTime
+  }
+
+  function refreshLoading(): void {
+    loading.value = [...entries.values()].some(entry => entry.loading.value)
+  }
+
+  function report(dictError: DictError, name: DictName): void {
+    try { options.onError?.(dictError, name) } catch { /* observers cannot break dictionary state */ }
+  }
+
+  function ensureActive(): void {
+    if (disposed) throw new DictError('DICT_CONTEXT_DISPOSED', 'Vobs Dict: 上下文已销毁')
+  }
+}
+
+export function dictPlugin(options: DictPluginOptions = {}): VobsPlugin {
+  return {
+    name: '@vobs/dict',
+    version: '0.1.0',
+    install(context) {
+      const ownedDict = options.dict ? undefined : createDict(options)
+      context.provide(DICT_KEY, options.dict ?? ownedDict!)
+      return () => ownedDict?.dispose()
+    }
+  }
+}
+
+export function useDict(): DictContext {
+  const dict = inject(DICT_KEY)
+  if (!dict) throw new DictError('DICT_CONTEXT_MISSING', 'Vobs Dict: 找不到上下文，请安装 dictPlugin')
+  return dict
+}
+
+function validateName(name: string): DictName {
+  if (typeof name !== 'string' || name.trim() === '') {
+    throw new DictError('INVALID_DICT_NAME', 'Vobs Dict: 字典名必须是非空字符串')
+  }
+  return name
+}
+
+function validateStaleTime(value: number): number {
+  if (!Number.isFinite(value) || value < 0) {
+    throw new DictError('INVALID_DICT_ITEMS', 'Vobs Dict: staleTime 必须是大于等于 0 的有限数字')
+  }
+  return value
+}
+
+function normalizeData(data: DictData): DictData {
+  const normalized: Record<DictName, DictItems> = {}
+  for (const [name, items] of Object.entries(data)) normalized[validateName(name)] = normalizeItems(items)
+  return Object.freeze(normalized)
+}
+
+function normalizeItems(items: unknown): DictItems {
+  if (!Array.isArray(items)) throw new DictError('INVALID_DICT_ITEMS', 'Vobs Dict: 字典项必须是数组')
+  return Object.freeze(items.map((item, index) => {
+    if (!item || typeof item !== 'object'
+      || (typeof (item as DictItem).value !== 'string' && typeof (item as DictItem).value !== 'number')
+      || typeof (item as DictItem).label !== 'string') {
+      throw new DictError('INVALID_DICT_ITEMS', `Vobs Dict: 第 ${index + 1} 个字典项必须包含 value 和 label`)
+    }
+    return Object.freeze({ ...item }) as DictItem
+  }))
+}
+
+function parseDehydratedState(snapshot: unknown): DictDehydratedState {
+  let value: unknown = snapshot
+  if (typeof snapshot === 'string') {
+    try { value = JSON.parse(snapshot) } catch {
+      throw new DictError('INVALID_DEHYDRATED_STATE', 'Vobs Dict: 初始状态不是有效 JSON')
+    }
+  }
+  if (!value || typeof value !== 'object') {
+    throw new DictError('INVALID_DEHYDRATED_STATE', 'Vobs Dict: 初始状态格式无效')
+  }
+  const candidate = value as Partial<DictDehydratedState>
+  if (candidate.version !== 1 || !Array.isArray(candidate.entries)) {
+    throw new DictError('INVALID_DEHYDRATED_STATE', 'Vobs Dict: 初始状态版本或 entries 无效')
+  }
+  const seen = new Set<string>()
+  const entries = candidate.entries.map(entry => {
+    if (!entry || typeof entry !== 'object') {
+      throw new DictError('INVALID_DEHYDRATED_STATE', 'Vobs Dict: 初始状态条目无效')
+    }
+    const name = validateName((entry as Partial<DictDehydratedEntry>).name as string)
+    const updatedAt = (entry as Partial<DictDehydratedEntry>).updatedAt
+    if (seen.has(name) || typeof updatedAt !== 'number' || !Number.isFinite(updatedAt) || updatedAt < 0) {
+      throw new DictError('INVALID_DEHYDRATED_STATE', 'Vobs Dict: 初始状态条目字段无效')
+    }
+    seen.add(name)
+    return Object.freeze({
+      name,
+      items: normalizeItems((entry as Partial<DictDehydratedEntry>).items),
+      updatedAt
+    })
+  })
+  return { version: 1, entries: Object.freeze(entries) }
+}
+
+function isAbortError(value: unknown): boolean {
+  return Boolean(value) && typeof value === 'object' && (value as { name?: unknown }).name === 'AbortError'
+}