@jasonshimmy/vite-plugin-cer-app 0.4.6 → 0.5.0

package/src/__tests__/cli/preview-isr.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import {
+  matchRoutePattern,
+  findRevalidate,
+  renderForIsr,
+  serveFromIsrCache,
+  type IsrCacheEntry,
+} from '../../cli/commands/preview-isr.js'
+
+// ─── matchRoutePattern ────────────────────────────────────────────────────────
+
+describe('matchRoutePattern', () => {
+  it('matches identical paths', () => {
+    expect(matchRoutePattern('/about', '/about')).toBe(true)
+  })
+
+  it('matches root path', () => {
+    expect(matchRoutePattern('/', '/')).toBe(true)
+  })
+
+  it('does not match different static paths', () => {
+    expect(matchRoutePattern('/about', '/contact')).toBe(false)
+  })
+
+  it('matches :param segments', () => {
+    expect(matchRoutePattern('/blog/:slug', '/blog/hello-world')).toBe(true)
+  })
+
+  it('does not match when param segment is missing', () => {
+    expect(matchRoutePattern('/blog/:slug', '/blog')).toBe(false)
+  })
+
+  it('matches :param* catch-all against single segment', () => {
+    expect(matchRoutePattern('/:all*', '/about')).toBe(true)
+  })
+
+  it('matches :param* catch-all against multi-segment path', () => {
+    expect(matchRoutePattern('/:all*', '/deeply/nested/path')).toBe(true)
+  })
+
+  it('matches :param* catch-all against root', () => {
+    expect(matchRoutePattern('/:all*', '/')).toBe(true)
+  })
+
+  it('does not match longer path against shorter static pattern', () => {
+    expect(matchRoutePattern('/blog', '/blog/extra')).toBe(false)
+  })
+
+  it('handles trailing slashes gracefully', () => {
+    expect(matchRoutePattern('/about/', '/about')).toBe(true)
+    expect(matchRoutePattern('/about', '/about/')).toBe(true)
+  })
+
+  it('matches multiple :param segments', () => {
+    expect(matchRoutePattern('/users/:id/posts/:postId', '/users/42/posts/99')).toBe(true)
+  })
+
+  it('does not match paths that differ only by a regex wildcard character (dot-safety)', () => {
+    // Without escaping, '/api.v1' regex would be '^/apixv1$' which matches '/apixv1'.
+    // With escaping, the dot is literal and '/apixv1' must not match '/api.v1'.
+    expect(matchRoutePattern('/api.v1/users', '/apixv1/users')).toBe(false)
+  })
+
+  it('matches route with literal dot in static segment', () => {
+    expect(matchRoutePattern('/api.v1/users', '/api.v1/users')).toBe(true)
+  })
+})
+
+// ─── findRevalidate ───────────────────────────────────────────────────────────
+
+describe('findRevalidate', () => {
+  it('returns null for an empty routes array', () => {
+    expect(findRevalidate([], '/about')).toBeNull()
+  })
+
+  it('returns null when no route matches', () => {
+    const routes = [{ path: '/contact', meta: { ssg: { revalidate: 60 } } }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+
+  it('returns null when matched route has no meta', () => {
+    const routes = [{ path: '/about' }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+
+  it('returns null when matched route has no ssg.revalidate', () => {
+    const routes = [{ path: '/about', meta: { layout: 'default' } }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+
+  it('returns revalidate value for a matching static route', () => {
+    const routes = [{ path: '/about', meta: { ssg: { revalidate: 60 } } }]
+    expect(findRevalidate(routes, '/about')).toBe(60)
+  })
+
+  it('returns revalidate value for a matching dynamic route', () => {
+    const routes = [{ path: '/blog/:slug', meta: { ssg: { revalidate: 300 } } }]
+    expect(findRevalidate(routes, '/blog/hello')).toBe(300)
+  })
+
+  it('returns revalidate value for a catch-all route', () => {
+    const routes = [{ path: '/:all*', meta: { ssg: { revalidate: 120 } } }]
+    expect(findRevalidate(routes, '/some/unmatched/path')).toBe(120)
+  })
+
+  it('picks the first matching route when multiple match', () => {
+    const routes = [
+      { path: '/blog/:slug', meta: { ssg: { revalidate: 300 } } },
+      { path: '/:all*', meta: { ssg: { revalidate: 60 } } },
+    ]
+    // /blog/:slug matches first
+    expect(findRevalidate(routes, '/blog/post')).toBe(300)
+  })
+
+  it('ignores non-numeric revalidate values', () => {
+    const routes = [{ path: '/about', meta: { ssg: { revalidate: 'invalid' } } }]
+    expect(findRevalidate(routes, '/about')).toBeNull()
+  })
+})
+
+// ─── renderForIsr ─────────────────────────────────────────────────────────────
+
+describe('renderForIsr', () => {
+  it('captures HTML from the handler', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Content-Type', 'text/html')
+      res.end('<html>hello</html>')
+    }
+    const entry = await renderForIsr('/about', handler, 60)
+    expect(entry).not.toBeNull()
+    expect(entry!.html).toBe('<html>hello</html>')
+  })
+
+  it('captures status code from the handler', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => {
+      res.statusCode = 404
+      res.end('Not Found')
+    }
+    const entry = await renderForIsr('/missing', handler, 30)
+    expect(entry!.statusCode).toBe(404)
+  })
+
+  it('captures response headers from the handler', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Content-Type', 'text/html; charset=utf-8')
+      res.end('<html/>')
+    }
+    const entry = await renderForIsr('/about', handler, 60)
+    expect(entry!.headers['content-type']).toBe('text/html; charset=utf-8')
+  })
+
+  it('sets revalidate to the provided TTL', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => { res.end('ok') }
+    const entry = await renderForIsr('/about', handler, 300)
+    expect(entry!.revalidate).toBe(300)
+  })
+
+  it('sets revalidating to false on the returned entry', async () => {
+    const handler = (_req: IncomingMessage, res: ServerResponse) => { res.end('ok') }
+    const entry = await renderForIsr('/about', handler, 60)
+    expect(entry!.revalidating).toBe(false)
+  })
+
+  it('returns null when the handler throws', async () => {
+    const handler = () => { throw new Error('boom') }
+    const entry = await renderForIsr('/about', handler as SsrHandlerFn, 60)
+    expect(entry).toBeNull()
+  })
+
+  it('passes the correct URL to the synthetic request', async () => {
+    let capturedUrl = ''
+    const handler = (req: IncomingMessage, res: ServerResponse) => {
+      capturedUrl = req.url ?? ''
+      res.end('ok')
+    }
+    await renderForIsr('/blog/hello', handler, 60)
+    expect(capturedUrl).toBe('/blog/hello')
+  })
+})
+
+type SsrHandlerFn = (req: IncomingMessage, res: ServerResponse) => void | Promise<void>
+
+// ─── serveFromIsrCache ────────────────────────────────────────────────────────
+
+describe('serveFromIsrCache', () => {
+  function makeFakeRes() {
+    const headers: Record<string, string> = {}
+    let statusCode = 200
+    let body = ''
+    const res = {
+      get statusCode() { return statusCode },
+      set statusCode(v: number) { statusCode = v },
+      setHeader: vi.fn((name: string, value: string) => { headers[name] = value }),
+      end: vi.fn((chunk: string) => { body = chunk }),
+      _headers: headers,
+      _body: () => body,
+      _status: () => statusCode,
+    }
+    return res
+  }
+
+  function makeEntry(overrides: Partial<IsrCacheEntry> = {}): IsrCacheEntry {
+    return {
+      html: '<html>cached</html>',
+      headers: { 'content-type': 'text/html' },
+      statusCode: 200,
+      builtAt: Date.now(),
+      revalidate: 60,
+      revalidating: false,
+      ...overrides,
+    }
+  }
+
+  it('writes the cached HTML to the response', () => {
+    const res = makeFakeRes()
+    serveFromIsrCache(makeEntry(), res as unknown as ServerResponse, 'HIT')
+    expect(res.end).toHaveBeenCalledWith('<html>cached</html>')
+  })
+
+  it('sets X-Cache: HIT header', () => {
+    const res = makeFakeRes()
+    serveFromIsrCache(makeEntry(), res as unknown as ServerResponse, 'HIT')
+    expect(res.setHeader).toHaveBeenCalledWith('X-Cache', 'HIT')
+  })
+
+  it('sets X-Cache: STALE header', () => {
+    const res = makeFakeRes()
+    serveFromIsrCache(makeEntry(), res as unknown as ServerResponse, 'STALE')
+    expect(res.setHeader).toHaveBeenCalledWith('X-Cache', 'STALE')
+  })
+
+  it('forwards cached headers to the response', () => {
+    const entry = makeEntry({ headers: { 'content-type': 'text/html; charset=utf-8' } })
+    const res = makeFakeRes()
+    serveFromIsrCache(entry, res as unknown as ServerResponse, 'HIT')
+    expect(res.setHeader).toHaveBeenCalledWith('content-type', 'text/html; charset=utf-8')
+  })
+
+  it('sets the status code from the cache entry', () => {
+    const entry = makeEntry({ statusCode: 404 })
+    const res = makeFakeRes()
+    serveFromIsrCache(entry, res as unknown as ServerResponse, 'HIT')
+    expect(res._status()).toBe(404)
+  })
+})

package/src/__tests__/plugin/dts-generator.test.ts

@@ -168,6 +168,11 @@ describe('generateAutoImportDts', () => {
     expect(dts).toContain("const useInject: typeof import('@jasonshimmy/vite-plugin-cer-app/composables')['useInject']")
   })
 
+  it('declares useRuntimeConfig as a framework global', async () => {
+    const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("const useRuntimeConfig: typeof import('@jasonshimmy/vite-plugin-cer-app/composables')['useRuntimeConfig']")
+  })
+
   it('declares when directive as a global', async () => {
     const dts = await generateAutoImportDts(ROOT, COMPOSABLES_DIR)
     expect(dts).toContain("const when: typeof import('@jasonshimmy/custom-elements-runtime/directives')['when']")
@@ -233,6 +238,21 @@ describe('generateVirtualModuleDts', () => {
     expect(dts).toContain('errorTag')
   })
 
+  it('declares virtual:cer-app-config module', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain("declare module 'virtual:cer-app-config'")
+  })
+
+  it('declares runtimeConfig export in virtual:cer-app-config', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('runtimeConfig')
+  })
+
+  it('declares RuntimePublicConfig in virtual:cer-app-config', async () => {
+    const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR)
+    expect(dts).toContain('RuntimePublicConfig')
+  })
+
   it('includes user composable re-exports in virtual:cer-composables', async () => {
     const exports = new Map([['useMyThing', `${ROOT}/app/composables/my-thing.ts`]])
     const dts = await generateVirtualModuleDts(ROOT, COMPOSABLES_DIR, exports)

package/src/__tests__/plugin/resolve-config.test.ts

@@ -140,4 +140,19 @@ describe('resolveConfig', () => {
     const cfg = resolveConfig({}, ROOT)
     expect(cfg.root).toBe(ROOT)
   })
+
+  it('defaults runtimeConfig.public to an empty object', () => {
+    const cfg = resolveConfig({}, ROOT)
+    expect(cfg.runtimeConfig.public).toEqual({})
+  })
+
+  it('passes runtimeConfig.public values through', () => {
+    const cfg = resolveConfig({ runtimeConfig: { public: { apiBase: '/api', version: '1' } } }, ROOT)
+    expect(cfg.runtimeConfig.public).toEqual({ apiBase: '/api', version: '1' })
+  })
+
+  it('preserves runtimeConfig.public when other runtimeConfig fields are omitted', () => {
+    const cfg = resolveConfig({ runtimeConfig: { public: { foo: 42 } } }, ROOT)
+    expect(cfg.runtimeConfig.public.foo).toBe(42)
+  })
 })

package/src/__tests__/plugin/transforms/auto-import.test.ts

@@ -233,6 +233,22 @@ describe('autoImportTransform — framework composable injection', () => {
     const result = autoImportTransform(code, '/project/app/loading.ts', opts)!
     expect(result).toContain('usePageData')
   })
+
+  it('injects useRuntimeConfig import when useRuntimeConfig is used', () => {
+    const code = "component('page-dashboard', () => { const cfg = useRuntimeConfig(); return html`<div></div>` })"
+    const result = autoImportTransform(code, '/project/app/pages/dashboard.ts', opts)!
+    expect(result).toContain(`from ${FRAMEWORK_PKG}`)
+    expect(result).toContain('useRuntimeConfig')
+  })
+
+  it('injects useRuntimeConfig alongside other framework composables', () => {
+    const code = "component('page-x', () => { useHead({ title: 'x' }); const cfg = useRuntimeConfig(); return html`<div></div>` })"
+    const result = autoImportTransform(code, '/project/app/pages/x.ts', opts)!
+    expect(result).toContain('useHead')
+    expect(result).toContain('useRuntimeConfig')
+    const count = result.split(`from ${FRAMEWORK_PKG}`).length - 1
+    expect(count).toBe(1)
+  })
 })
 
 // ─── Composable import injection ─────────────────────────────────────────────

package/src/__tests__/plugin/virtual/routes.test.ts

@@ -200,3 +200,198 @@ describe('generateRoutesCode — 404.ts convention', () => {
     expect(idIdx).toBeLessThan(allIdx)
   })
 })
+
+// ─── _layout.ts filtering ─────────────────────────────────────────────────────
+
+describe('generateRoutesCode — _layout.ts filtering', () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([])
+    vi.mocked(readFile).mockResolvedValue('' as never)
+  })
+
+  it('excludes _layout.ts files from the generated routes', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([
+      `${PAGES}/admin/index.ts`,
+      `${PAGES}/admin/_layout.ts`,
+    ])
+    const code = await generateRoutesCode(PAGES)
+    expect(code).not.toContain('_layout')
+    expect(code).toContain('/admin')
+  })
+
+  it('generates a route for non-underscore files in the same directory', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([
+      `${PAGES}/admin/users.ts`,
+      `${PAGES}/admin/_layout.ts`,
+    ])
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('/admin/users')
+    expect(code).not.toContain('_layout')
+  })
+})
+
+// ─── meta.revalidate ─────────────────────────────────────────────────────────
+
+describe('generateRoutesCode — meta.ssg.revalidate', () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([])
+    vi.mocked(readFile).mockResolvedValue('' as never)
+  })
+
+  it('emits meta.ssg.revalidate when declared in page source', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/blog.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { ssg: { revalidate: 60 } }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('ssg: { revalidate: 60 }')
+  })
+
+  it('emits larger revalidate values correctly', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/products.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { ssg: { revalidate: 3600 } }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('ssg: { revalidate: 3600 }')
+  })
+
+  it('omits ssg meta when no revalidate is declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `component('page-about', () => html\`<h1>About</h1>\`)` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).not.toContain('revalidate')
+  })
+
+  it('can combine revalidate with layout in meta', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/blog.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { layout: 'minimal', ssg: { revalidate: 120 } }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('layout: "minimal"')
+    expect(code).toContain('ssg: { revalidate: 120 }')
+  })
+})
+
+// ─── meta.transition ─────────────────────────────────────────────────────────
+
+describe('generateRoutesCode — meta.transition', () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([])
+    vi.mocked(readFile).mockResolvedValue('' as never)
+  })
+
+  it('emits meta.transition string when declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { transition: 'fade' }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('transition: "fade"')
+  })
+
+  it('emits meta.transition true (boolean) when declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { transition: true }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('transition: true')
+  })
+
+  it('omits transition meta when not declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `component('page-about', () => html\`<h1>About</h1>\`)` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).not.toContain('transition')
+  })
+
+  it('emits meta.transition false (boolean) when declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { transition: false }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('transition: false')
+  })
+
+  it('can combine transition with middleware', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/dashboard.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { transition: 'slide', middleware: ['auth'] }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('transition: "slide"')
+    expect(code).toContain('beforeEnter')
+    expect(code).toContain('"auth"')
+  })
+})
+
+// ─── nested layouts (layoutChain) ────────────────────────────────────────────
+
+describe('generateRoutesCode — layoutChain (nested layouts)', () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([])
+    vi.mocked(readFile).mockResolvedValue('' as never)
+  })
+
+  it('emits meta.layoutChain when a _layout.ts exists in ancestor directory', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/admin/users.ts`])
+    vi.mocked(readFile).mockImplementation(async (path: unknown) => {
+      if (String(path).endsWith('_layout.ts')) return 'export default \'minimal\''
+      return ''
+    })
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('layoutChain:')
+    expect(code).toContain('"default"')
+    expect(code).toContain('"minimal"')
+  })
+
+  it('uses outerLayout from page meta when layoutChain is emitted', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/admin/users.ts`])
+    vi.mocked(readFile).mockImplementation(async (path: unknown) => {
+      const p = String(path)
+      if (p.endsWith('_layout.ts')) return 'export default \'sidebar\''
+      // page source has its own layout
+      return `export const meta = { layout: 'clean' }`
+    })
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('layoutChain:')
+    expect(code).toContain('"clean"')
+    expect(code).toContain('"sidebar"')
+    // Should not emit a plain meta.layout — the chain replaces it
+    expect(code).not.toContain('layout: "clean"')
+  })
+
+  it('omits layoutChain for top-level pages with no _layout.ts', async () => {
+    vi.mocked(existsSync).mockImplementation((p: unknown) => {
+      // Return false for any _layout.ts path so no chain is resolved
+      if (String(p).endsWith('_layout.ts')) return false
+      return true
+    })
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { layout: 'default' }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).not.toContain('layoutChain')
+    expect(code).toContain('layout: "default"')
+  })
+
+  it('omits layoutChain for top-level pages even when existsSync returns true', async () => {
+    // top-level page has no subdirectory segments, so resolveLayoutChain returns null immediately
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/index.ts`])
+    vi.mocked(readFile).mockResolvedValue('' as never)
+    const code = await generateRoutesCode(PAGES)
+    expect(code).not.toContain('layoutChain')
+  })
+})

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

@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { useRuntimeConfig, initRuntimeConfig } from '../../runtime/composables/use-runtime-config.js'
+
+beforeEach(() => {
+  // Reset global state between tests
+  delete (globalThis as Record<string, unknown>).__cerRuntimeConfig
+})
+
+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({})
+  })
+})