@jasonshimmy/vite-plugin-cer-app 0.23.1 → 0.24.0

package/src/__tests__/runtime/use-page-data.test.ts

@@ -1,298 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { AsyncLocalStorage } from 'node:async_hooks'
-
-// --- Module-level mock for @jasonshimmy/custom-elements-runtime ---
-// usePageData imports getCurrentComponentContext from the runtime. We mock the
-// module so unit tests can control which context (if any) is "active".
-let _mockContext: Record<string, unknown> | null = null
-
-vi.mock('@jasonshimmy/custom-elements-runtime', () => ({
-  getCurrentComponentContext: () => _mockContext,
-}))
-
-import { usePageData } from '../../runtime/composables/use-page-data.js'
-
-describe('usePageData', () => {
-  beforeEach(() => {
-    // Clean up global state between tests
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-    delete (globalThis as Record<string, unknown>)['__CER_DATA_STORE__']
-  })
-
-  afterEach(() => {
-    delete (globalThis as Record<string, unknown>)['__CER_DATA_STORE__']
-  })
-
-  it('returns null when no SSR data is present', () => {
-    expect(usePageData()).toBeNull()
-  })
-
-  it('returns the data when __CER_DATA__ is set on globalThis', () => {
-    const data = { id: '1', name: 'Laptop', price: 999 }
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = data
-    expect(usePageData()).toEqual(data)
-  })
-
-  it('does NOT clear __CER_DATA__ on read (cleared by app.ts after router.replace)', () => {
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { title: 'Hello' }
-    usePageData()
-    expect((globalThis as Record<string, unknown>)['__CER_DATA__']).toEqual({ title: 'Hello' })
-  })
-
-  it('returns the same data on subsequent calls (not consumed on first read)', () => {
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { title: 'Hello' }
-    usePageData()
-    expect(usePageData()).toEqual({ title: 'Hello' })
-  })
-
-  it('is generic and preserves the typed shape', () => {
-    interface Post { slug: string; title: string }
-    const post: Post = { slug: 'hello', title: 'Hello World' }
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = post
-    const result = usePageData<Post>()
-    expect(result?.slug).toBe('hello')
-    expect(result?.title).toBe('Hello World')
-  })
-
-  it('returns null when __CER_DATA__ is explicitly null', () => {
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = null
-    expect(usePageData()).toBeNull()
-  })
-})
-
-describe('usePageData — AsyncLocalStorage (server-side)', () => {
-  let store: AsyncLocalStorage<unknown>
-
-  beforeEach(() => {
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-    store = new AsyncLocalStorage()
-    ;(globalThis as Record<string, unknown>)['__CER_DATA_STORE__'] = store
-  })
-
-  afterEach(() => {
-    delete (globalThis as Record<string, unknown>)['__CER_DATA_STORE__']
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-  })
-
-  it('reads data from the ALS store when available', () => {
-    const data = { title: 'SSR Post', body: 'Hello from ALS' }
-    store.run(data, () => {
-      expect(usePageData()).toEqual(data)
-    })
-  })
-
-  it('returns null when ALS store is empty (null)', () => {
-    store.run(null, () => {
-      expect(usePageData()).toBeNull()
-    })
-  })
-
-  it('prefers ALS store over globalThis.__CER_DATA__', () => {
-    const alsData = { source: 'als' }
-    const globalData = { source: 'global' }
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = globalData
-    store.run(alsData, () => {
-      expect(usePageData()).toEqual(alsData)
-    })
-  })
-
-  it('does NOT delete __CER_DATA__ when returning ALS data', () => {
-    const globalData = { source: 'global' }
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = globalData
-    store.run({ source: 'als' }, () => {
-      usePageData()
-    })
-    // global data should still be present — ALS path doesn't consume it
-    expect((globalThis as Record<string, unknown>)['__CER_DATA__']).toEqual(globalData)
-  })
-
-  it('falls back to __CER_DATA__ when ALS store has no value outside run()', () => {
-    // Outside any store.run() context, getStore() returns undefined
-    const data = { fallback: true }
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = data
-    // store is set but we're outside a run() context → getStore() === undefined
-    expect(usePageData()).toEqual(data)
-  })
-
-  it('returns null when both ALS and __CER_DATA__ are absent', () => {
-    store.run(null, () => {
-      expect(usePageData()).toBeNull()
-    })
-  })
-
-  it('is safe to call multiple times inside same ALS context', () => {
-    const data = { count: 42 }
-    store.run(data, () => {
-      expect(usePageData()).toEqual(data)
-      // ALS data is NOT consumed on read, so a second call still returns it
-      expect(usePageData()).toEqual(data)
-    })
-  })
-})
-
-// ─── Component context caching ─────────────────────────────────────────────
-//
-// usePageData() caches the result on the component context (via Object.defineProperty)
-// so that re-renders of the same element instance return the same value even after
-// __CER_DATA__ is deleted by the post-hydration queueMicrotask cleanup.
-//
-// Background: renderFn passed to component() IS the render function — it runs on
-// every re-render, not just once as a setup phase. Without caching, calling
-// usePageData() on the second render after __CER_DATA__ is deleted returns null,
-// which flips `ssrData ? 'ssr' : 'client'` guards and re-triggers client fetches.
-
-describe('usePageData — component context caching', () => {
-  const _PAGE_DATA_KEY = '_cerPageData'
-
-  beforeEach(() => {
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-    delete (globalThis as Record<string, unknown>)['__CER_DATA_STORE__']
-    _mockContext = null
-  })
-
-  afterEach(() => {
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-    _mockContext = null
-  })
-
-  it('returns null and does not cache when context is null (no render in progress)', () => {
-    _mockContext = null
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { value: 42 }
-    const result = usePageData()
-    expect(result).toEqual({ value: 42 })
-    // No context to cache on — nothing to assert, just no crash
-  })
-
-  it('caches the result on the component context using Object.defineProperty', () => {
-    const ctx: Record<string, unknown> = {}
-    _mockContext = ctx
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { value: 42 }
-
-    usePageData()
-
-    // Should be defined on ctx via Object.defineProperty (non-enumerable)
-    expect(Object.prototype.hasOwnProperty.call(ctx, _PAGE_DATA_KEY)).toBe(true)
-    expect(ctx[_PAGE_DATA_KEY]).toEqual({ value: 42 })
-  })
-
-  it('cached property is non-enumerable (does not appear in Object.keys)', () => {
-    const ctx: Record<string, unknown> = {}
-    _mockContext = ctx
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { value: 42 }
-
-    usePageData()
-
-    expect(Object.keys(ctx)).not.toContain(_PAGE_DATA_KEY)
-  })
-
-  it('cached property is non-writable (reactive proxy set-trap cannot overwrite it)', () => {
-    const ctx: Record<string, unknown> = {}
-    _mockContext = ctx
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { value: 42 }
-
-    usePageData()
-
-    // Attempting to overwrite a writable:false property silently fails in non-strict mode
-    // and throws in strict mode. Verify the value doesn't change.
-    try { ctx[_PAGE_DATA_KEY] = { value: 999 } } catch { /* strict mode */ }
-    expect(ctx[_PAGE_DATA_KEY]).toEqual({ value: 42 })
-  })
-
-  it('returns cached value on second call even after __CER_DATA__ is deleted', () => {
-    const ctx: Record<string, unknown> = {}
-    _mockContext = ctx
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { value: 42 }
-
-    // First call (simulates initial render while __CER_DATA__ is present)
-    const first = usePageData()
-    expect(first).toEqual({ value: 42 })
-
-    // Simulate post-hydration cleanup: queueMicrotask(() => delete __CER_DATA__)
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-
-    // Second call (simulates re-render after cleanup) — must return cached value
-    const second = usePageData()
-    expect(second).toEqual({ value: 42 })
-  })
-
-  it('caches null result so repeated calls with no data do not re-read the deleted global', () => {
-    const ctx: Record<string, unknown> = {}
-    _mockContext = ctx
-    // No __CER_DATA__ — returns null and caches null
-
-    const first = usePageData()
-    expect(first).toBeNull()
-
-    // Set __CER_DATA__ AFTER first call — second call should return cached null
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { value: 99 }
-    const second = usePageData()
-    expect(second).toBeNull()
-  })
-
-  it('each component element instance has its own independent cache', () => {
-    const ctxA: Record<string, unknown> = {}
-    const ctxB: Record<string, unknown> = {}
-
-    // First component: has SSR data
-    _mockContext = ctxA
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { page: 'home' }
-    const resultA = usePageData()
-    expect(resultA).toEqual({ page: 'home' })
-
-    // Simulate navigation: delete home data, set blog data
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { page: 'blog' }
-
-    // Second component (different element, different context)
-    _mockContext = ctxB
-    const resultB = usePageData()
-    expect(resultB).toEqual({ page: 'blog' })
-
-    // First component re-rendered — still returns its cached value
-    _mockContext = ctxA
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-    const resultA2 = usePageData()
-    expect(resultA2).toEqual({ page: 'home' }) // cached, not stale blog data
-  })
-
-  it('ALS path takes precedence over context cache (server-side always uses ALS)', () => {
-    const store = new AsyncLocalStorage<unknown>()
-    ;(globalThis as Record<string, unknown>)['__CER_DATA_STORE__'] = store
-
-    const ctx: Record<string, unknown> = {}
-    // Pre-seed a stale client cache on the context
-    Object.defineProperty(ctx, _PAGE_DATA_KEY, { value: { stale: true }, writable: false, configurable: true, enumerable: false })
-    _mockContext = ctx
-
-    const alsData = { fresh: true }
-    store.run(alsData, () => {
-      const result = usePageData()
-      // ALS wins — context cache is not consulted for server-side renders
-      expect(result).toEqual(alsData)
-    })
-
-    delete (globalThis as Record<string, unknown>)['__CER_DATA_STORE__']
-  })
-
-  it('context cache survives across multiple renderFn() invocations (re-render stability)', () => {
-    const ctx: Record<string, unknown> = {}
-    _mockContext = ctx
-    ;(globalThis as Record<string, unknown>)['__CER_DATA__'] = { title: 'My Page' }
-
-    // Simulate 5 re-renders (e.g. reactive state updates)
-    for (let i = 0; i < 5; i++) {
-      const result = usePageData<{ title: string }>()
-      expect(result?.title).toBe('My Page')
-    }
-
-    // Delete __CER_DATA__ (post-hydration cleanup)
-    delete (globalThis as Record<string, unknown>)['__CER_DATA__']
-
-    // 5 more re-renders post-cleanup
-    for (let i = 0; i < 5; i++) {
-      const result = usePageData<{ title: string }>()
-      expect(result?.title).toBe('My Page')
-    }
-  })
-})
-

package/src/__tests__/runtime/use-route.test.ts

@@ -1,156 +0,0 @@
-/**
- * useRoute() composable tests.
- *
- * Covers:
- * - Server path: reads from __CER_ROUTE_STORE__ AsyncLocalStorage
- * - Client path: reads from globalThis.__cerRouter
- * - Fallback: returns default route when neither is present
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { useRoute } from '../../runtime/composables/use-route.js'
-
-const g = globalThis as Record<string, unknown>
-
-function makeRouteStore(info: unknown) {
-  const { AsyncLocalStorage } = require('node:async_hooks')
-  const store = new AsyncLocalStorage()
-  store.enterWith(info)
-  return store
-}
-
-// ─── Server path ──────────────────────────────────────────────────────────────
-
-describe('useRoute() — server path (__CER_ROUTE_STORE__)', () => {
-  let _orig: unknown
-
-  beforeEach(() => {
-    _orig = g['__CER_ROUTE_STORE__']
-  })
-
-  afterEach(() => {
-    g['__CER_ROUTE_STORE__'] = _orig
-    delete g['__cerRouter']
-  })
-
-  it('returns route info from the ALS store', () => {
-    const info = { path: '/posts/42', params: { id: '42' }, query: {}, meta: { title: 'Post' } }
-    g['__CER_ROUTE_STORE__'] = makeRouteStore(info)
-
-    const route = useRoute()
-    expect(route.path).toBe('/posts/42')
-    expect(route.params).toEqual({ id: '42' })
-    expect(route.meta).toEqual({ title: 'Post' })
-  })
-
-  it('falls through to client router when routeStore.getStore() returns null', () => {
-    // Store is present but no active context (getStore returns null)
-    const { AsyncLocalStorage } = require('node:async_hooks')
-    const emptyStore = new AsyncLocalStorage()
-    g['__CER_ROUTE_STORE__'] = emptyStore
-    // Provide a client router so we get a real result instead of the fallback
-    g['__cerRouter'] = {
-      getCurrent: () => ({ path: '/client-path', query: {} }),
-      matchRoute: () => ({ route: { meta: null }, params: {} }),
-    }
-
-    const route = useRoute()
-    expect(route.path).toBe('/client-path')
-  })
-
-  it('returns query params from route info', () => {
-    const info = { path: '/search', params: {}, query: { q: 'hello' }, meta: null }
-    g['__CER_ROUTE_STORE__'] = makeRouteStore(info)
-
-    const route = useRoute()
-    expect(route.query).toEqual({ q: 'hello' })
-  })
-
-  it('returns null meta when not set', () => {
-    g['__CER_ROUTE_STORE__'] = makeRouteStore({ path: '/', params: {}, query: {}, meta: null })
-
-    const { meta } = useRoute()
-    expect(meta).toBeNull()
-  })
-})
-
-// ─── Client path ──────────────────────────────────────────────────────────────
-
-describe('useRoute() — client path (__cerRouter)', () => {
-  beforeEach(() => {
-    delete g['__CER_ROUTE_STORE__']
-  })
-
-  afterEach(() => {
-    delete g['__cerRouter']
-  })
-
-  it('reads from the global router on the client', () => {
-    g['__cerRouter'] = {
-      getCurrent: () => ({ path: '/about', query: { ref: 'nav' } }),
-      matchRoute: () => ({ route: { meta: { title: 'About' } }, params: {} }),
-    }
-
-    const route = useRoute()
-    expect(route.path).toBe('/about')
-    expect(route.query).toEqual({ ref: 'nav' })
-    expect(route.meta).toEqual({ title: 'About' })
-  })
-
-  it('defaults query to {} when getCurrent() omits the query property', () => {
-    g['__cerRouter'] = {
-      getCurrent: () => ({ path: '/home' }),
-      matchRoute: () => ({ route: { meta: null }, params: {} }),
-    }
-
-    const route = useRoute()
-    expect(route.query).toEqual({})
-  })
-
-  it('extracts params from matched route', () => {
-    g['__cerRouter'] = {
-      getCurrent: () => ({ path: '/posts/7', query: {} }),
-      matchRoute: () => ({ route: { meta: null }, params: { id: '7' } }),
-    }
-
-    const { params } = useRoute()
-    expect(params).toEqual({ id: '7' })
-  })
-
-  it('returns null meta when route has none', () => {
-    g['__cerRouter'] = {
-      getCurrent: () => ({ path: '/', query: {} }),
-      matchRoute: () => ({ route: { meta: null }, params: {} }),
-    }
-
-    expect(useRoute().meta).toBeNull()
-  })
-
-  it('handles unmatched route gracefully', () => {
-    g['__cerRouter'] = {
-      getCurrent: () => ({ path: '/unknown', query: {} }),
-      matchRoute: () => null,
-    }
-
-    const route = useRoute()
-    expect(route.params).toEqual({})
-    expect(route.meta).toBeNull()
-  })
-})
-
-// ─── Fallback ─────────────────────────────────────────────────────────────────
-
-describe('useRoute() — fallback (no store, no router)', () => {
-  beforeEach(() => {
-    delete g['__CER_ROUTE_STORE__']
-    delete g['__cerRouter']
-  })
-
-  it('returns a default route object', () => {
-    const route = useRoute()
-    expect(route.path).toBe('/')
-    expect(route.params).toEqual({})
-    expect(route.query).toEqual({})
-    expect(route.meta).toBeNull()
-  })
-})

package/src/__tests__/runtime/use-runtime-config.test.ts

@@ -1,182 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
-import { useRuntimeConfig, initRuntimeConfig, resolvePrivateConfig } from '../../runtime/composables/use-runtime-config.js'
-
-beforeEach(() => {
-  // Reset global state between tests
-  delete (globalThis as Record<string, unknown>).__cerRuntimeConfig
-  // Ensure window is not set (server context for most tests)
-  delete (globalThis as Record<string, unknown>).window
-})
-
-afterEach(() => {
-  delete (globalThis as Record<string, unknown>).window
-})
-
-describe('initRuntimeConfig', () => {
-  it('stores the config on globalThis', () => {
-    initRuntimeConfig({ public: { apiBase: '/api' } })
-    expect((globalThis as Record<string, unknown>).__cerRuntimeConfig).toEqual({ public: { apiBase: '/api' } })
-  })
-
-  it('overwrites a previous config', () => {
-    initRuntimeConfig({ public: { apiBase: '/v1' } })
-    initRuntimeConfig({ public: { apiBase: '/v2' } })
-    const stored = (globalThis as Record<string, unknown>).__cerRuntimeConfig as { public: Record<string, unknown> }
-    expect(stored.public.apiBase).toBe('/v2')
-  })
-})
-
-describe('useRuntimeConfig', () => {
-  it('returns empty public config when not initialized', () => {
-    const config = useRuntimeConfig()
-    expect(config.public).toEqual({})
-  })
-
-  it('returns the config set by initRuntimeConfig', () => {
-    initRuntimeConfig({ public: { apiBase: '/api' } })
-    const config = useRuntimeConfig()
-    expect(config.public.apiBase).toBe('/api')
-  })
-
-  it('returns the full public config object', () => {
-    initRuntimeConfig({ public: { apiBase: '/api', version: '1.0', debug: false } })
-    const config = useRuntimeConfig()
-    expect(config.public).toEqual({ apiBase: '/api', version: '1.0', debug: false })
-  })
-
-  it('returns a reference to the stored config (not a copy)', () => {
-    const stored = { public: { apiBase: '/api' } }
-    initRuntimeConfig(stored)
-    const config = useRuntimeConfig()
-    expect(config).toBe(stored)
-  })
-
-  it('reflects updates when initRuntimeConfig is called again', () => {
-    initRuntimeConfig({ public: { key: 'first' } })
-    initRuntimeConfig({ public: { key: 'second' } })
-    expect(useRuntimeConfig().public.key).toBe('second')
-  })
-
-  it('handles empty public config', () => {
-    initRuntimeConfig({ public: {} })
-    const config = useRuntimeConfig()
-    expect(config.public).toEqual({})
-  })
-
-  it('returns private config when initialized with it', () => {
-    initRuntimeConfig({ public: {}, private: { dbUrl: 'postgres://localhost', secretKey: 'abc' } })
-    const config = useRuntimeConfig()
-    expect(config.private).toEqual({ dbUrl: 'postgres://localhost', secretKey: 'abc' })
-  })
-
-  it('private is undefined when not supplied', () => {
-    initRuntimeConfig({ public: { apiBase: '/api' } })
-    const config = useRuntimeConfig()
-    expect(config.private).toBeUndefined()
-  })
-
-  it('returns empty private config when initialized with empty object', () => {
-    initRuntimeConfig({ public: {}, private: {} })
-    expect(useRuntimeConfig().private).toEqual({})
-  })
-})
-
-// ─── Browser Proxy (private config enforcement) ───────────────────────────────
-
-describe('useRuntimeConfig browser Proxy', () => {
-  it('throws a clear error when .private is accessed in a browser context', () => {
-    ;(globalThis as Record<string, unknown>).window = {}
-    initRuntimeConfig({ public: { apiBase: '/api' }, private: { secret: 'shh' } })
-    const config = useRuntimeConfig()
-    expect(() => config.private).toThrow('[cer-app] runtimeConfig.private is not available in the browser')
-  })
-
-  it('allows .public access in a browser context', () => {
-    ;(globalThis as Record<string, unknown>).window = {}
-    initRuntimeConfig({ public: { apiBase: '/api' }, private: { secret: 'shh' } })
-    const config = useRuntimeConfig()
-    expect(config.public).toEqual({ apiBase: '/api' })
-  })
-
-  it('does NOT throw when .private is accessed in a server (non-browser) context', () => {
-    // window is not set — server environment
-    initRuntimeConfig({ public: {}, private: { secret: 'shh' } })
-    const config = useRuntimeConfig()
-    expect(() => config.private).not.toThrow()
-    expect(config.private).toEqual({ secret: 'shh' })
-  })
-
-  it('error message instructs moving access to a loader or middleware', () => {
-    ;(globalThis as Record<string, unknown>).window = {}
-    initRuntimeConfig({ public: {} })
-    const config = useRuntimeConfig()
-    expect(() => config.private).toThrow('loader, middleware, or API handler')
-  })
-})
-
-// ─── resolvePrivateConfig ─────────────────────────────────────────────────────
-
-describe('resolvePrivateConfig', () => {
-  it('resolves a key from the exact-case env var', () => {
-    const result = resolvePrivateConfig({ dbUrl: '' }, { dbUrl: 'postgres://localhost' })
-    expect(result.dbUrl).toBe('postgres://localhost')
-  })
-
-  it('resolves a key from the ALL_CAPS env var when exact case is absent', () => {
-    const result = resolvePrivateConfig({ dbUrl: '' }, { DB_URL: 'postgres://prod' })
-    expect(result.dbUrl).toBe('postgres://prod')
-  })
-
-  it('falls back to the declared default when neither env var is set', () => {
-    const result = resolvePrivateConfig({ dbUrl: 'default-db' }, {})
-    expect(result.dbUrl).toBe('default-db')
-  })
-
-  it('exact-case env var takes precedence over ALL_CAPS', () => {
-    const result = resolvePrivateConfig({ dbUrl: '' }, { dbUrl: 'exact', DB_URL: 'caps' })
-    expect(result.dbUrl).toBe('exact')
-  })
-
-  it('handles multiple keys independently', () => {
-    const result = resolvePrivateConfig(
-      { dbUrl: '', secretKey: '', apiToken: 'default-token' },
-      { dbUrl: 'pg://host', SECRET_KEY: 's3cr3t' },
-    )
-    expect(result.dbUrl).toBe('pg://host')
-    expect(result.secretKey).toBe('s3cr3t')
-    expect(result.apiToken).toBe('default-token')
-  })
-
-  it('returns an empty object when defaults is empty', () => {
-    expect(resolvePrivateConfig({}, { ANY: 'value' })).toEqual({})
-  })
-
-  it('preserves key names exactly as declared in output (does not rename keys)', () => {
-    const result = resolvePrivateConfig({ camelCase: 'def' }, { CAMEL_CASE: 'val' })
-    expect(Object.keys(result)).toEqual(['camelCase'])
-    expect(result.camelCase).toBe('val')
-  })
-
-  it('emits a console.warn when a key has an empty-string default and no env var is set', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    resolvePrivateConfig({ dbUrl: '' }, {})
-    expect(warn).toHaveBeenCalledOnce()
-    expect(warn.mock.calls[0][0]).toContain('dbUrl')
-    expect(warn.mock.calls[0][0]).toContain('DB_URL')
-    warn.mockRestore()
-  })
-
-  it('does NOT warn when the env var supplies a value for an empty-default key', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    resolvePrivateConfig({ dbUrl: '' }, { DB_URL: 'postgres://prod' })
-    expect(warn).not.toHaveBeenCalled()
-    warn.mockRestore()
-  })
-
-  it('does NOT warn when the declared default is non-empty and no env var is set', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    resolvePrivateConfig({ apiToken: 'fallback-token' }, {})
-    expect(warn).not.toHaveBeenCalled()
-    warn.mockRestore()
-  })
-})