qdadm 1.13.0 → 1.19.2

package/src/i18n/__tests__/I18n.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect } from 'vitest'
+
+import { I18n } from '../I18n'
+import type { TranslationProvider } from '../types'
+
+describe('I18n — bootstrap and lookup', () => {
+  it('ships default core EN bundle', async () => {
+    const i18n = new I18n()
+    await i18n.bootstrap()
+    expect(i18n.t('core.actions.save')).toBe('Save')
+    expect(i18n.t('core.errors.required')).toBe('Required')
+  })
+
+  it('disableDefaultCoreBundle skips default core', async () => {
+    const i18n = new I18n({ disableDefaultCoreBundle: true })
+    await i18n.bootstrap()
+    expect(i18n.t('core.actions.save')).toBe('core.actions.save')
+  })
+
+  it('addMessages from kernel options', async () => {
+    const i18n = new I18n({
+      messages: {
+        en: { entities: { books: { fields: { title: 'Title' } } } },
+      },
+    })
+    await i18n.bootstrap()
+    expect(i18n.t('entities.books.fields.title')).toBe('Title')
+  })
+
+  it('addMessages after bootstrap is immediately visible', async () => {
+    const i18n = new I18n()
+    await i18n.bootstrap()
+    i18n.addMessages('en', { entities: { books: { fields: { author: 'Author' } } } })
+    expect(i18n.t('entities.books.fields.author')).toBe('Author')
+  })
+})
+
+describe('I18n — global strategy (default)', () => {
+  it('routes entities.*.actions.* to core.actions.*', async () => {
+    const i18n = new I18n()
+    await i18n.bootstrap()
+    expect(i18n.t('entities.books.actions.save')).toBe('Save')
+    expect(i18n.t('entities.users.actions.delete')).toBe('Delete')
+  })
+
+  it('routes entities.*.fields.created_at to core.fields.created_at', async () => {
+    const i18n = new I18n()
+    await i18n.bootstrap()
+    expect(i18n.t('entities.books.fields.created_at')).toBe('Created at')
+  })
+})
+
+describe('I18n — module strategy', () => {
+  it('routes entities.<entity>.* to modules.<module>.* with fallback to core', async () => {
+    const i18n = new I18n({ keyStrategy: 'module' })
+    i18n.registerEntityModule('books', 'BooksModule')
+    await i18n.bootstrap()
+    i18n.addMessages('en', {
+      modules: {
+        BooksModule: { actions: { delete: 'Discard' } },
+      },
+    })
+    // Module override wins
+    expect(i18n.t('entities.books.actions.delete')).toBe('Discard')
+    // Fallback through module → core
+    expect(i18n.t('entities.books.actions.save')).toBe('Save')
+  })
+})
+
+describe('I18n — locale change', () => {
+  it('emits locale:changed signal', async () => {
+    const events: Array<{ signal: string; data: unknown }> = []
+    const signals = {
+      emit: (signal: string, data: unknown) => {
+        events.push({ signal, data })
+      },
+      on: () => () => {},
+    }
+    const i18n = new I18n({ defaultLocale: 'en' }, { signals })
+    await i18n.bootstrap()
+    i18n.addMessages('fr', { core: { actions: { save: 'Enregistrer' } } })
+    await i18n.changeLocale('fr')
+    expect(i18n.locale.value).toBe('fr')
+    expect(i18n.t('core.actions.save')).toBe('Enregistrer')
+    const emitted = events.find((e) => e.signal === 'locale:changed')
+    expect(emitted).toBeDefined()
+    expect(emitted?.data).toBe('fr')
+  })
+
+  it('falls back to fallbackLocale for missing keys', async () => {
+    // disableDefaultCoreBundle so we can assert pure fallback behavior without
+    // the shipped FR bundle filling `core.actions.save` first.
+    const i18n = new I18n({
+      defaultLocale: 'en',
+      fallbackLocale: 'en',
+      disableDefaultCoreBundle: true,
+    })
+    i18n.addMessages('en', { core: { actions: { save: 'Save' } } })
+    i18n.addMessages('fr', { entities: { books: { fields: { title: 'Titre' } } } })
+    await i18n.bootstrap()
+    await i18n.changeLocale('fr')
+    expect(i18n.t('entities.books.fields.title')).toBe('Titre')
+    // 'core.actions.save' not declared in fr → falls back to en
+    expect(i18n.t('core.actions.save')).toBe('Save')
+  })
+})
+
+describe('I18n — providers', () => {
+  it('loads from a custom TranslationProvider during bootstrap', async () => {
+    const provider: TranslationProvider = {
+      name: 'mock',
+      load: (locale) => {
+        if (locale === 'en') {
+          return { entities: { tasks: { fields: { name: 'Task name' } } } }
+        }
+        return {}
+      },
+      availableLocales: () => ['en'],
+    }
+    const i18n = new I18n({ providers: [provider] })
+    await i18n.bootstrap()
+    expect(i18n.t('entities.tasks.fields.name')).toBe('Task name')
+  })
+
+  it('async provider load works', async () => {
+    const provider: TranslationProvider = {
+      name: 'async-mock',
+      load: async (locale) => {
+        await new Promise((r) => setTimeout(r, 5))
+        if (locale === 'en') {
+          return { foo: { bar: 'Async value' } }
+        }
+        return {}
+      },
+    }
+    const i18n = new I18n({ providers: [provider] })
+    await i18n.bootstrap()
+    expect(i18n.t('foo.bar')).toBe('Async value')
+  })
+
+  it('availableLocales unions across providers', async () => {
+    const a: TranslationProvider = {
+      name: 'a',
+      load: () => ({}),
+      availableLocales: () => ['en', 'fr'],
+    }
+    const b: TranslationProvider = {
+      name: 'b',
+      load: () => ({}),
+      availableLocales: async () => ['de', 'fr'],
+    }
+    const i18n = new I18n({ providers: [a, b] })
+    const locales = await i18n.availableLocales()
+    expect(new Set(locales)).toEqual(new Set(['en', 'fr', 'de']))
+  })
+})
+
+describe('I18n — dump', () => {
+  it('returns the inline bundle (app-level messages only, not framework defaults)', async () => {
+    const i18n = new I18n()
+    await i18n.bootstrap()
+    i18n.addMessages('en', { entities: { books: { fields: { title: 'Title' } } } })
+    const dumped = i18n.dump('en')
+    expect(dumped.entities?.books?.fields?.title).toBe('Title')
+    // Framework defaults (core.*) ship via DefaultCoreProvider, not the inline
+    // provider, so they don't show up in dump().
+    expect(dumped.core).toBeUndefined()
+  })
+})

package/src/i18n/__tests__/IncrementalDomainProvider.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi } from 'vitest'
+
+import { I18n } from '../I18n'
+import { IncrementalDomainProvider, type DomainLoader } from '../IncrementalDomainProvider'
+
+function makeSignals() {
+  const events: Array<{ signal: string; data: unknown }> = []
+  const handlers = new Map<string, Array<(e: { data: unknown }) => void>>()
+  return {
+    events,
+    bus: {
+      emit: (signal: string, data: unknown) => {
+        events.push({ signal, data })
+        for (const h of handlers.get(signal) ?? []) h({ data })
+      },
+      on: (signal: string, handler: (e: { data: unknown }) => void) => {
+        const list = handlers.get(signal) ?? []
+        list.push(handler)
+        handlers.set(signal, list)
+        return () => {}
+      },
+    },
+  }
+}
+
+describe('IncrementalDomainProvider — lazy-by-domain', () => {
+  it('only loads eagerDomains during bootstrap; lazy domains stay dormant', async () => {
+    const coreLoader = vi.fn(async () => ({ actions: { save: 'Save' } }))
+    const shopLoader = vi.fn(async () => ({ cart: { title: 'Cart' } }))
+
+    const provider = new IncrementalDomainProvider({
+      domains: { core: coreLoader, shop: shopLoader },
+      eagerDomains: ['core'],
+      locales: ['en'],
+    })
+
+    const i18n = new I18n({ disableDefaultCoreBundle: true, providers: [provider] })
+    await i18n.bootstrap()
+
+    expect(coreLoader).toHaveBeenCalledTimes(1)
+    expect(shopLoader).not.toHaveBeenCalled()
+    expect(i18n.t('core.actions.save')).toBe('Save')
+  })
+
+  it('t() on an unloaded domain triggers a lazy load + emits i18n:domain-loaded', async () => {
+    const shopLoader = vi.fn(async () => ({ cart: { title: 'Cart' } }))
+
+    const provider = new IncrementalDomainProvider({
+      domains: { shop: shopLoader },
+      locales: ['en'],
+    })
+
+    const sig = makeSignals()
+    const i18n = new I18n(
+      { disableDefaultCoreBundle: true, providers: [provider] },
+      { signals: sig.bus }
+    )
+    await i18n.bootstrap()
+
+    // First call: shop not loaded yet → returns the raw key, kicks off load
+    const first = i18n.t('shop.cart.title')
+    expect(first).toBe('shop.cart.title')
+
+    // Wait one microtask tick for the async load to settle
+    await vi.waitFor(() => {
+      expect(sig.events.find((e) => e.signal === 'i18n:domain-loaded')).toBeDefined()
+    })
+
+    expect(shopLoader).toHaveBeenCalledTimes(1)
+
+    // Second call: domain is in the registry now
+    expect(i18n.t('shop.cart.title')).toBe('Cart')
+
+    // Signal payload identifies the domain + locale
+    const loaded = sig.events.find((e) => e.signal === 'i18n:domain-loaded')
+    expect(loaded?.data).toEqual({ locale: 'en', domain: 'shop' })
+  })
+
+  it('dedupes concurrent lazy loads for the same (locale, domain)', async () => {
+    let resolveLoader: ((value: unknown) => void) | undefined
+    const shopLoader = vi.fn(
+      () =>
+        new Promise<{ cart: { title: string } }>((resolve) => {
+          resolveLoader = resolve as (v: unknown) => void
+        })
+    )
+
+    const provider = new IncrementalDomainProvider({
+      domains: { shop: shopLoader as DomainLoader },
+      locales: ['en'],
+    })
+
+    const i18n = new I18n({ disableDefaultCoreBundle: true, providers: [provider] })
+    await i18n.bootstrap()
+
+    // 50 concurrent lookups during the inflight window
+    for (let i = 0; i < 50; i++) i18n.t('shop.cart.title')
+
+    expect(shopLoader).toHaveBeenCalledTimes(1)
+    resolveLoader?.({ cart: { title: 'Cart' } })
+    await new Promise((r) => setTimeout(r, 0))
+
+    expect(i18n.t('shop.cart.title')).toBe('Cart')
+  })
+
+  it('loadDomain() lets the app pre-warm a domain explicitly', async () => {
+    const shopLoader = vi.fn(async () => ({ cart: { title: 'Cart' } }))
+
+    const provider = new IncrementalDomainProvider({
+      domains: { shop: shopLoader },
+      locales: ['en'],
+    })
+
+    const i18n = new I18n({ disableDefaultCoreBundle: true, providers: [provider] })
+    await i18n.bootstrap()
+
+    await i18n.loadDomain('shop')
+    // After explicit pre-warm, t() resolves immediately — no placeholder
+    expect(i18n.t('shop.cart.title')).toBe('Cart')
+    expect(shopLoader).toHaveBeenCalledTimes(1)
+  })
+
+  it('miss on a domain known to no provider stays a miss (no infinite trigger)', async () => {
+    const shopLoader = vi.fn(async () => ({ cart: { title: 'Cart' } }))
+    const provider = new IncrementalDomainProvider({
+      domains: { shop: shopLoader },
+      locales: ['en'],
+    })
+
+    const sig = makeSignals()
+    const i18n = new I18n(
+      { disableDefaultCoreBundle: true, providers: [provider] },
+      { signals: sig.bus }
+    )
+    await i18n.bootstrap()
+
+    // `legal.*` is unknown to every provider → no load attempt
+    i18n.t('legal.tos.title')
+    i18n.t('legal.tos.title')
+    i18n.t('legal.tos.title')
+    await new Promise((r) => setTimeout(r, 0))
+
+    expect(shopLoader).not.toHaveBeenCalled()
+    expect(sig.events.some((e) => e.signal === 'i18n:domain-loaded')).toBe(false)
+  })
+})

package/src/i18n/__tests__/LazyTranslationProvider.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest'
+
+import { I18n } from '../I18n'
+import { LazyTranslationProvider, type LazyLoader } from '../LazyTranslationProvider'
+
+describe('LazyTranslationProvider — domain cascade', () => {
+  it('merges partial bundles from multiple domain loaders', async () => {
+    const coreLoader: LazyLoader = async (locale) =>
+      locale === 'en'
+        ? { core: { actions: { save: 'Save', cancel: 'Cancel' } } }
+        : null
+    const shopLoader: LazyLoader = async (locale) =>
+      locale === 'en'
+        ? { shop: { cart: { title: 'Your cart', empty: 'Cart is empty' } } }
+        : null
+    const legalLoader: LazyLoader = async (locale) =>
+      locale === 'en' ? { legal: { tos: { title: 'Terms of Service' } } } : null
+
+    const provider = new LazyTranslationProvider({
+      name: 'composite',
+      loaders: [coreLoader, shopLoader, legalLoader],
+      locales: ['en'],
+    })
+
+    const i18n = new I18n({ disableDefaultCoreBundle: true, providers: [provider] })
+    await i18n.bootstrap()
+
+    expect(i18n.t('core.actions.save')).toBe('Save')
+    expect(i18n.t('shop.cart.title')).toBe('Your cart')
+    expect(i18n.t('shop.cart.empty')).toBe('Cart is empty')
+    expect(i18n.t('legal.tos.title')).toBe('Terms of Service')
+  })
+
+  it('later loaders override earlier ones (last-merge-wins)', async () => {
+    const baseLoader: LazyLoader = async () => ({
+      core: { actions: { save: 'Base save' } },
+      shop: { cart: { title: 'Base cart' } },
+    })
+    const overrideLoader: LazyLoader = async () => ({
+      core: { actions: { save: 'Override save' } },
+    })
+
+    const provider = new LazyTranslationProvider({
+      loaders: [baseLoader, overrideLoader],
+      locales: ['en'],
+    })
+
+    const i18n = new I18n({ disableDefaultCoreBundle: true, providers: [provider] })
+    await i18n.bootstrap()
+
+    // overridden by later loader
+    expect(i18n.t('core.actions.save')).toBe('Override save')
+    // untouched by override → still from base loader
+    expect(i18n.t('shop.cart.title')).toBe('Base cart')
+  })
+
+  it('loader returning null is skipped', async () => {
+    const presentLoader: LazyLoader = async () => ({
+      shop: { cart: { title: 'Cart' } },
+    })
+    const missingLoader: LazyLoader = async () => null
+
+    const provider = new LazyTranslationProvider({
+      loaders: [missingLoader, presentLoader, missingLoader],
+      locales: ['en'],
+    })
+
+    const i18n = new I18n({ disableDefaultCoreBundle: true, providers: [provider] })
+    await i18n.bootstrap()
+
+    expect(i18n.t('shop.cart.title')).toBe('Cart')
+  })
+
+  it('availableLocales reflects the configured locales', () => {
+    const provider = new LazyTranslationProvider({
+      loaders: [async () => ({})],
+      locales: ['en', 'fr', 'de'],
+    })
+    expect(new Set(provider.availableLocales())).toEqual(new Set(['en', 'fr', 'de']))
+  })
+
+  it('two providers chained: the later one in options.providers wins', async () => {
+    const baseProvider = new LazyTranslationProvider({
+      loaders: [async () => ({ shop: { cart: { title: 'Default cart' } } })],
+      locales: ['en'],
+    })
+    const overrideProvider = new LazyTranslationProvider({
+      loaders: [async () => ({ shop: { cart: { title: 'Override cart' } } })],
+      locales: ['en'],
+    })
+
+    const i18n = new I18n({
+      disableDefaultCoreBundle: true,
+      providers: [baseProvider, overrideProvider],
+    })
+    await i18n.bootstrap()
+
+    expect(i18n.t('shop.cart.title')).toBe('Override cart')
+  })
+})

package/src/i18n/__tests__/Resolver.test.ts

@@ -0,0 +1,271 @@
+import { describe, it, expect } from 'vitest'
+
+import { MessagesRegistry } from '../MessagesRegistry'
+import { Resolver, snakeCaseToTitle } from '../Resolver'
+import type { AliasPattern } from '../types'
+
+function makeResolver(opts: {
+  bundles?: Record<string, Parameters<MessagesRegistry['merge']>[1]>
+  globalAliases?: AliasPattern[]
+  defaultLocale?: string
+  fallbackLocale?: string
+  onMissing?: (key: string, locale: string) => void
+}) {
+  const reg = new MessagesRegistry()
+  for (const [locale, bundle] of Object.entries(opts.bundles ?? {})) {
+    reg.merge(locale, bundle)
+  }
+  const resolver = new Resolver(reg, {
+    defaultLocale: opts.defaultLocale ?? 'en',
+    fallbackLocale: opts.fallbackLocale ?? 'en',
+    globalAliases: opts.globalAliases,
+    onMissing: opts.onMissing,
+  })
+  return { reg, resolver }
+}
+
+describe('snakeCaseToTitle', () => {
+  it('handles snake_case', () => {
+    expect(snakeCaseToTitle('first_name')).toBe('First Name')
+  })
+  it('handles camelCase', () => {
+    expect(snakeCaseToTitle('firstName')).toBe('First Name')
+  })
+  it('handles kebab-case', () => {
+    expect(snakeCaseToTitle('first-name')).toBe('First Name')
+  })
+  it('handles single word', () => {
+    expect(snakeCaseToTitle('title')).toBe('Title')
+  })
+})
+
+describe('Resolver — convention lookup', () => {
+  it('returns the matching value from the active locale', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { entities: { books: { fields: { title: 'Title' } } } } },
+    })
+    expect(resolver.translate('entities.books.fields.title', 'en')).toBe('Title')
+  })
+
+  it('falls back to fallbackLocale on miss', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { entities: { books: { fields: { title: 'Title' } } } } },
+      defaultLocale: 'fr',
+      fallbackLocale: 'en',
+    })
+    // No 'fr' bundle — falls back to 'en'
+    expect(resolver.translate('entities.books.fields.title', 'fr')).toBe('Title')
+  })
+
+  it('reads _label from object node', () => {
+    const { resolver } = makeResolver({
+      bundles: {
+        en: {
+          entities: {
+            books: {
+              fields: {
+                genre: { _label: 'Genre', options: { fiction: 'Fiction' } },
+              },
+            },
+          },
+        },
+      },
+    })
+    expect(resolver.translate('entities.books.fields.genre', 'en')).toBe('Genre')
+    expect(
+      resolver.translate('entities.books.fields.genre.options.fiction', 'en')
+    ).toBe('Fiction')
+  })
+})
+
+describe('Resolver — interpolation', () => {
+  it('replaces {placeholder} params', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { core: { errors: { tooShort: 'Too short (min {min})' } } } },
+    })
+    expect(resolver.translate('core.errors.tooShort', 'en', { min: 3 })).toBe(
+      'Too short (min 3)'
+    )
+  })
+
+  it('leaves unknown placeholders untouched', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { foo: 'Hello {name}' } },
+    })
+    expect(resolver.translate('foo', 'en')).toBe('Hello {name}')
+  })
+})
+
+describe('Resolver — value-level @-aliases', () => {
+  it('follows a single @-alias', () => {
+    const { resolver } = makeResolver({
+      bundles: {
+        en: {
+          entities: { books: { actions: { save: '@core.actions.save' } } },
+          core: { actions: { save: 'Save' } },
+        },
+      },
+    })
+    expect(resolver.translate('entities.books.actions.save', 'en')).toBe('Save')
+  })
+
+  it('follows a chain of @-aliases', () => {
+    const { resolver } = makeResolver({
+      bundles: {
+        en: {
+          a: '@b',
+          b: '@c',
+          c: 'Bottom',
+        },
+      },
+    })
+    expect(resolver.translate('a', 'en')).toBe('Bottom')
+  })
+
+  it('detects cycles and falls through', () => {
+    const onMissing = vitestFn()
+    const { resolver } = makeResolver({
+      bundles: { en: { a: '@b', b: '@a' } },
+      onMissing,
+    })
+    // No final string → ends up as miss → returns raw key
+    expect(resolver.translate('a', 'en')).toBe('a')
+    expect(onMissing.calls.length).toBeGreaterThan(0)
+  })
+
+  it('escapes literal @ via @@ prefix', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { ping: '@@home' } },
+    })
+    expect(resolver.translate('ping', 'en')).toBe('@home')
+  })
+})
+
+describe('Resolver — pattern aliases', () => {
+  const globalAliases: AliasPattern[] = [
+    { pattern: 'entities.*.actions.*', target: 'core.actions.$2' },
+    { pattern: 'entities.*.fields.created_at', target: 'core.fields.created_at' },
+  ]
+
+  it('rewrites via wildcard pattern with $2 capture', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { core: { actions: { save: 'Save' } } } },
+      globalAliases,
+    })
+    expect(resolver.translate('entities.books.actions.save', 'en')).toBe('Save')
+  })
+
+  it('rewrites a specific exact pattern', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { core: { fields: { created_at: 'Created at' } } } },
+      globalAliases,
+    })
+    expect(resolver.translate('entities.books.fields.created_at', 'en')).toBe('Created at')
+  })
+
+  it('longest-match wins when multiple patterns match', () => {
+    const aliases: AliasPattern[] = [
+      { pattern: 'entities.*.actions.*', target: 'core.actions.$2' },
+      // More specific, should win
+      { pattern: 'entities.books.actions.delete', target: 'books.specialDelete' },
+    ]
+    const { resolver } = makeResolver({
+      bundles: {
+        en: {
+          core: { actions: { delete: 'Delete' } },
+          books: { specialDelete: 'Discard' },
+        },
+      },
+      globalAliases: aliases,
+    })
+    expect(resolver.translate('entities.books.actions.delete', 'en')).toBe('Discard')
+    // Other entities still go through the wildcard
+    expect(resolver.translate('entities.users.actions.delete', 'en')).toBe('Delete')
+  })
+
+  it('does not loop forever when patterns ping-pong', () => {
+    const aliases: AliasPattern[] = [
+      { pattern: 'a.*', target: 'b.$1' },
+      { pattern: 'b.*', target: 'a.$1' },
+    ]
+    const { resolver } = makeResolver({
+      bundles: { en: {} },
+      globalAliases: aliases,
+    })
+    // Should bail out — no actual value found anywhere
+    expect(resolver.translate('a.foo', 'en')).toBe('a.foo')
+  })
+})
+
+describe('Resolver — final fallbacks', () => {
+  it('humanizes field key via snakeCaseToTitle on miss', () => {
+    const { resolver } = makeResolver({ bundles: { en: {} } })
+    expect(resolver.translate('entities.books.fields.first_name', 'en')).toBe('First Name')
+  })
+
+  it('does NOT humanize non-field keys', () => {
+    const { resolver } = makeResolver({ bundles: { en: {} } })
+    expect(resolver.translate('core.actions.save', 'en')).toBe('core.actions.save')
+  })
+
+  it('emits onMissing on every miss', () => {
+    const onMissing = vitestFn<[string, string]>()
+    const { resolver } = makeResolver({ bundles: { en: {} }, onMissing })
+    resolver.translate('core.actions.save', 'en')
+    resolver.translate('entities.books.fields.title', 'en') // miss but humanized
+    expect(onMissing.calls.length).toBe(2)
+    expect(onMissing.calls[0]).toEqual(['core.actions.save', 'en'])
+    expect(onMissing.calls[1]).toEqual(['entities.books.fields.title', 'en'])
+  })
+})
+
+describe('Resolver — trace', () => {
+  it('returns lookup steps', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { entities: { books: { fields: { title: 'Title' } } } } },
+    })
+    const trace = resolver.resolve('entities.books.fields.title', 'en')
+    expect(trace.hit).toBe(true)
+    expect(trace.result).toBe('Title')
+    expect(trace.steps[0]).toEqual({
+      kind: 'lookup',
+      locale: 'en',
+      key: 'entities.books.fields.title',
+      found: true,
+    })
+  })
+
+  it('records the alias-pattern step on rewrite', () => {
+    const { resolver } = makeResolver({
+      bundles: { en: { core: { actions: { save: 'Save' } } } },
+      globalAliases: [{ pattern: 'entities.*.actions.*', target: 'core.actions.$2' }],
+    })
+    const trace = resolver.resolve('entities.books.actions.save', 'en')
+    expect(trace.hit).toBe(true)
+    const aliasStep = trace.steps.find((s) => s.kind === 'alias-pattern')
+    expect(aliasStep).toBeDefined()
+  })
+
+  it('records snake-case-fallback for missing field', () => {
+    const { resolver } = makeResolver({ bundles: { en: {} } })
+    const trace = resolver.resolve('entities.books.fields.first_name', 'en')
+    expect(trace.hit).toBe(false)
+    expect(trace.result).toBe('First Name')
+    const last = trace.steps[trace.steps.length - 1]
+    expect(last?.kind).toBe('snake-case-fallback')
+  })
+})
+
+// ----------------------------------------------------------------------------
+// Tiny mock helper (avoids import-order quirks with vi.fn() in some setups)
+// ----------------------------------------------------------------------------
+function vitestFn<A extends unknown[] = unknown[]>(): ((...args: A) => void) & {
+  calls: A[]
+} {
+  const calls: A[] = []
+  const fn = ((...args: A) => {
+    calls.push(args)
+  }) as ((...args: A) => void) & { calls: A[] }
+  fn.calls = calls
+  return fn
+}