kmcom-nuxt-layers 5.0.8 → 6.0.0

package/layers/data/metadata/providers/openlibrary/server/utils/metadata-openlibrary/client.ts

@@ -1,3 +1,4 @@
+import { providerFetch } from '#layers/metadata/server/utils/metadata/provider-fetch'
 import type { OpenLibraryEdition, OpenLibrarySearchResponse, OpenLibraryWork } from './types'
 
 const BASE = 'https://openlibrary.org'
@@ -10,35 +11,23 @@ export async function searchOpenLibrary(
   query: string,
   limit = 10
 ): Promise<OpenLibrarySearchResponse> {
-  try {
-    return await $fetch<OpenLibrarySearchResponse>(`${BASE}/search.json`, {
-      timeout: 10000,
-      query: {
-        q: query,
-        limit,
-        fields:
-          'key,title,subtitle,author_name,author_key,publisher,first_publish_year,isbn,cover_i,number_of_pages_median',
-      },
-    })
-  } catch (err) {
-    throw new MetadataProviderError('openlibrary', `API error: ${String(err)}`)
-  }
+  return providerFetch<OpenLibrarySearchResponse>('openlibrary', `${BASE}/search.json`, {
+    timeout: 10000,
+    query: {
+      q: query,
+      limit,
+      fields:
+        'key,title,subtitle,author_name,author_key,publisher,first_publish_year,isbn,cover_i,number_of_pages_median',
+    },
+  })
 }
 
 export async function lookupOpenLibraryWork(workId: string): Promise<OpenLibraryWork> {
-  try {
-    return await $fetch<OpenLibraryWork>(`${BASE}/works/${workId}.json`)
-  } catch (err) {
-    throw new MetadataProviderError('openlibrary', `API error: ${String(err)}`)
-  }
+  return providerFetch<OpenLibraryWork>('openlibrary', `${BASE}/works/${workId}.json`)
 }
 
 export async function lookupOpenLibraryEdition(editionId: string): Promise<OpenLibraryEdition> {
-  try {
-    return await $fetch<OpenLibraryEdition>(`${BASE}/books/${editionId}.json`)
-  } catch (err) {
-    throw new MetadataProviderError('openlibrary', `API error: ${String(err)}`)
-  }
+  return providerFetch<OpenLibraryEdition>('openlibrary', `${BASE}/books/${editionId}.json`)
 }
 
 export async function lookupByIsbn(isbn: string): Promise<OpenLibraryEdition | null> {

package/layers/data/metadata/providers/openlibrary/server/utils/metadata-openlibrary/provider.ts

@@ -24,14 +24,4 @@ export const openLibraryProvider: MetadataProvider = {
     const work = await lookupOpenLibraryWork(providerId)
     return normaliseOpenLibraryWork(work)
   },
-
-  async sync({ providerId, resourceType = 'work' }) {
-    const record = await openLibraryProvider.lookup({
-      provider: 'openlibrary',
-      providerId,
-      resourceType,
-    })
-    if (!record) throw new MetadataProviderError('openlibrary', `No record found for ${providerId}`)
-    return record
-  },
 }

package/layers/data/metadata/providers/themoviedb/server/utils/metadata-tmdb/client.ts

@@ -1,3 +1,4 @@
+import { providerFetch } from '#layers/metadata/server/utils/metadata/provider-fetch'
 import { useRuntimeConfig } from 'nitropack/runtime'
 import type { TMDBFindResponse, TMDBMovie, TMDBSearchResponse, TMDBTVShow } from './types'
 
@@ -22,13 +23,9 @@ async function tmdbFetch<T>(path: string, params: Record<string, string> = {}):
   if (!isJwt) url.searchParams.set('api_key', apiKey)
   for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
 
-  try {
-    return await $fetch<T>(url.toString(), {
-      ...(isJwt && { headers: { Authorization: `Bearer ${apiKey}` } }),
-    })
-  } catch (err) {
-    throw new MetadataProviderError('tmdb', `API error: ${String(err)}`)
-  }
+  return providerFetch<T>('tmdb', url.toString(), {
+    ...(isJwt && { headers: { Authorization: `Bearer ${apiKey}` } }),
+  })
 }
 
 export async function searchTmdb(query: string, limit = 10): Promise<TMDBSearchResponse> {

package/layers/data/metadata/providers/themoviedb/server/utils/metadata-tmdb/provider.ts

@@ -32,10 +32,4 @@ export const tmdbProvider: MetadataProvider = {
     if (resourceType === 'tv-show') return normaliseTmdbTV(await fetchTmdbTV(providerId))
     return normaliseTmdbMovie(await fetchTmdbMovie(providerId))
   },
-
-  async sync(input) {
-    const record = await tmdbProvider.lookup(input)
-    if (!record) throw new MetadataProviderError('tmdb', `No record found for ${input.providerId}`)
-    return record
-  },
 }

package/layers/data/metadata/server/api/metadata/lookup.get.ts

@@ -1,48 +1,13 @@
-import { getCacheRecord, makeCacheKey, setCacheRecord } from '../../utils/metadata/cache'
-import { getProvider } from '../../utils/metadata/provider-registry'
-import { createError, defineEventHandler, getQuery } from 'h3'
-import type { MetadataProviderId } from '#layers/metadata/shared/types'
+import { resolveRecord } from '../../utils/metadata/resolve-record'
+import { defineEventHandler, getQuery } from 'h3'
 
-// fallow-ignore-next-line complexity
 export default defineEventHandler(async (event) => {
   const query = getQuery(event)
 
-  const providerId = String(query.providerId ?? '').trim()
-  const providerName = String(query.provider ?? '').trim() as MetadataProviderId
-  const resourceType = query.resourceType ? String(query.resourceType) : undefined
-
-  if (!providerName || !providerId) {
-    throw createError({ statusCode: 400, message: 'provider and providerId are required' })
-  }
-
-  const provider = getProvider(providerName)
-  if (!provider)
-    throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
-
-  const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
-  const cached = await getCacheRecord(cacheKey)
-  if (cached) return cached.normalised
-
-  const result = await provider.lookup({
-    provider: providerName,
-    providerId,
-    ...(resourceType && { resourceType }),
+  const { record } = await resolveRecord({
+    provider: String(query.provider ?? '').trim(),
+    providerId: String(query.providerId ?? '').trim(),
+    ...(query.resourceType && { resourceType: String(query.resourceType) }),
   })
-  if (!result) throw createError({ statusCode: 404, message: 'Not found' })
-
-  const now = new Date().toISOString()
-  await setCacheRecord(cacheKey, {
-    id: result.id,
-    provider: providerName,
-    providerId,
-    resourceType: resourceType ?? 'item',
-    mediaType: result.mediaType,
-    normalised: result,
-    raw: result.raw ?? null,
-    createdAt: now,
-    updatedAt: now,
-    lastSyncedAt: now,
-  })
-
-  return result
+  return record
 })

package/layers/data/metadata/server/api/metadata/sync.post.ts

@@ -1,53 +1,8 @@
-import { getCacheRecord, makeCacheKey, setCacheRecord } from '../../utils/metadata/cache'
-import { getProvider } from '../../utils/metadata/provider-registry'
-import { createError, defineEventHandler, readBody } from 'h3'
-import type { MetadataProviderId, MetadataSyncInput } from '#layers/metadata/shared/types'
+import { resolveRecord } from '../../utils/metadata/resolve-record'
+import { defineEventHandler, readBody } from 'h3'
+import type { MetadataSyncInput } from '#layers/metadata/shared/types'
 
-// fallow-ignore-next-line complexity
 export default defineEventHandler(async (event) => {
   const body = await readBody<MetadataSyncInput>(event)
-
-  const { provider: providerName, providerId, resourceType, force } = body ?? {}
-  if (!providerName || !providerId) {
-    throw createError({ statusCode: 400, message: 'provider and providerId are required' })
-  }
-
-  const provider = getProvider(providerName as MetadataProviderId)
-  if (!provider)
-    throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
-  if (!provider.sync)
-    throw createError({
-      statusCode: 400,
-      message: `Provider '${providerName}' does not support sync`,
-    })
-
-  const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
-
-  if (!force) {
-    const cached = await getCacheRecord(cacheKey)
-    if (cached) return { synced: false, record: cached.normalised }
-  }
-
-  const result = await provider.sync({
-    provider: providerName as MetadataProviderId,
-    providerId,
-    ...(resourceType && { resourceType }),
-    ...(force !== undefined && { force }),
-  })
-  const now = new Date().toISOString()
-
-  await setCacheRecord(cacheKey, {
-    id: result.id,
-    provider: providerName as MetadataProviderId,
-    providerId,
-    resourceType: resourceType ?? 'item',
-    mediaType: result.mediaType,
-    normalised: result,
-    raw: result.raw ?? null,
-    createdAt: now,
-    updatedAt: now,
-    lastSyncedAt: now,
-  })
-
-  return { synced: true, record: result }
+  return resolveRecord({ ...body })
 })

package/layers/data/metadata/server/utils/metadata/provider-fetch.test.ts

@@ -0,0 +1,27 @@
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
+
+import { MetadataProviderError } from './errors'
+import { providerFetch } from './provider-fetch'
+
+afterEach(() => vi.unstubAllGlobals())
+
+describe('providerFetch', () => {
+  it('returns the fetched body', async () => {
+    vi.stubGlobal(
+      '$fetch',
+      vi.fn(async () => ({ ok: true }))
+    )
+    await expect(providerFetch('tmdb', 'https://x.test')).resolves.toEqual({ ok: true })
+  })
+
+  it('wraps failures in a MetadataProviderError for the provider', async () => {
+    vi.stubGlobal(
+      '$fetch',
+      vi.fn(async () => Promise.reject(new Error('boom')))
+    )
+    const err = await providerFetch('tmdb', 'https://x.test').catch((e) => e)
+    expect(err).toBeInstanceOf(MetadataProviderError)
+    expect(err.provider).toBe('tmdb')
+    expect(err.message).toContain('API error')
+  })
+})

package/layers/data/metadata/server/utils/metadata/provider-fetch.ts

@@ -0,0 +1,14 @@
+import { MetadataProviderError } from './errors'
+
+/** `$fetch` that reports any failure as a MetadataProviderError for `provider`. */
+export async function providerFetch<T>(
+  provider: string,
+  url: string,
+  opts?: { query?: Record<string, unknown>; headers?: Record<string, string>; timeout?: number }
+): Promise<T> {
+  try {
+    return (await $fetch(url, opts)) as T
+  } catch (err) {
+    throw new MetadataProviderError(provider, `API error: ${String(err)}`, err)
+  }
+}

package/layers/data/metadata/server/utils/metadata/resolve-record.test.ts

@@ -0,0 +1,87 @@
+import type { MetadataProvider, MetadataRecord } from '#layers/metadata/shared/types'
+import type * as CacheModule from './cache'
+import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
+
+const { providerState, getCacheRecordMock, setCacheRecordMock } = vi.hoisted(() => ({
+  providerState: { provider: null as MetadataProvider | null },
+  getCacheRecordMock: vi.fn(async () => null as { normalised: MetadataRecord } | null),
+  setCacheRecordMock: vi.fn(async () => undefined),
+}))
+
+vi.mock('./provider-registry', () => ({ getProvider: () => providerState.provider }))
+vi.mock('./cache', async (importOriginal) => ({
+  ...(await importOriginal<typeof CacheModule>()),
+  getCacheRecord: getCacheRecordMock,
+  setCacheRecord: setCacheRecordMock,
+}))
+
+import { resolveRecord } from './resolve-record'
+
+const record = {
+  id: 'r1',
+  provider: 'comicvine',
+  providerId: '42',
+  mediaType: 'comic',
+  title: 'Watchmen',
+} as MetadataRecord
+
+const lookup = vi.fn(async () => record as MetadataRecord | null)
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  getCacheRecordMock.mockResolvedValue(null)
+  lookup.mockResolvedValue(record)
+  providerState.provider = {
+    id: 'comicvine',
+    label: 'Comic Vine',
+    mediaTypes: ['comic'],
+    search: async () => [],
+    lookup,
+  }
+})
+
+describe('resolveRecord', () => {
+  it('400s without provider or providerId', async () => {
+    await expect(resolveRecord({ provider: 'comicvine' })).rejects.toMatchObject({
+      statusCode: 400,
+    })
+  })
+
+  it('404s for an unregistered provider', async () => {
+    providerState.provider = null
+    await expect(resolveRecord({ provider: 'nope', providerId: '1' })).rejects.toMatchObject({
+      statusCode: 404,
+    })
+  })
+
+  it('fetches, caches and reports synced on a miss', async () => {
+    const out = await resolveRecord({ provider: 'comicvine', providerId: '42' })
+    expect(out).toEqual({ record, synced: true })
+    expect(setCacheRecordMock).toHaveBeenCalledWith(
+      'metadata:comicvine:item:42',
+      expect.objectContaining({ id: 'r1', providerId: '42', resourceType: 'item' })
+    )
+  })
+
+  it('returns the cached record without calling the provider', async () => {
+    getCacheRecordMock.mockResolvedValue({ normalised: record })
+    const out = await resolveRecord({ provider: 'comicvine', providerId: '42' })
+    expect(out).toEqual({ record, synced: false })
+    expect(lookup).not.toHaveBeenCalled()
+  })
+
+  it('force skips the cache read', async () => {
+    getCacheRecordMock.mockResolvedValue({ normalised: record })
+    const out = await resolveRecord({ provider: 'comicvine', providerId: '42', force: true })
+    expect(out.synced).toBe(true)
+    expect(lookup).toHaveBeenCalledOnce()
+  })
+
+  it('404s when the provider finds nothing and does not cache', async () => {
+    lookup.mockResolvedValue(null)
+    await expect(resolveRecord({ provider: 'comicvine', providerId: '42' })).rejects.toMatchObject({
+      statusCode: 404,
+    })
+    expect(setCacheRecordMock).not.toHaveBeenCalled()
+  })
+})

package/layers/data/metadata/server/utils/metadata/resolve-record.ts

@@ -0,0 +1,60 @@
+import { createError } from 'h3'
+import { getCacheRecord, makeCacheKey, setCacheRecord } from './cache'
+import { getProvider } from './provider-registry'
+import type { MetadataRecord } from '#layers/metadata/shared/types'
+
+export type ResolveRecordInput = {
+  provider?: string
+  providerId?: string
+  resourceType?: string
+  /** Skip the cache read and refetch from the provider. */
+  force?: boolean
+}
+
+/**
+ * Cache-through lookup of one record. `synced` is true when the provider was called,
+ * false when the cached record was returned. Throws h3 errors (400/404) for bad input.
+ */
+export async function resolveRecord(
+  input: ResolveRecordInput
+): Promise<{ record: MetadataRecord; synced: boolean }> {
+  const { provider: providerName, providerId, resourceType, force } = input
+  if (!providerName || !providerId) {
+    throw createError({ statusCode: 400, message: 'provider and providerId are required' })
+  }
+
+  const provider = getProvider(providerName)
+  if (!provider) {
+    throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
+  }
+
+  const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
+
+  if (!force) {
+    const cached = await getCacheRecord(cacheKey)
+    if (cached) return { record: cached.normalised, synced: false }
+  }
+
+  const record = await provider.lookup({
+    provider: providerName,
+    providerId,
+    ...(resourceType && { resourceType }),
+  })
+  if (!record) throw createError({ statusCode: 404, message: 'Not found' })
+
+  const now = new Date().toISOString()
+  await setCacheRecord(cacheKey, {
+    id: record.id,
+    provider: providerName,
+    providerId,
+    resourceType: resourceType ?? 'item',
+    mediaType: record.mediaType,
+    normalised: record,
+    raw: record.raw ?? null,
+    createdAt: now,
+    updatedAt: now,
+    lastSyncedAt: now,
+  })
+
+  return { record, synced: true }
+}

package/layers/data/metadata/shared/types/providers.ts

@@ -1,6 +1,8 @@
 import type { MetadataMediaType, MetadataRecord } from './metadata'
 
-export type MetadataProviderId = 'comicvine' | 'openlibrary' | 'google-books' | 'tmdb' | 'local'
+// Open: a provider layer registers whatever id it likes (built-ins: comicvine, openlibrary,
+// google-books, tmdb). Unknown ids are rejected at runtime by the provider registry.
+export type MetadataProviderId = string
 
 export type MetadataSearchInput = {
   query: string
@@ -32,5 +34,4 @@ export type MetadataProvider = {
   mediaTypes: MetadataMediaType[]
   search: (input: MetadataSearchInput) => Promise<MetadataSearchResult[]>
   lookup: (input: MetadataLookupInput) => Promise<MetadataRecord | null>
-  sync?: (input: MetadataSyncInput) => Promise<MetadataRecord>
 }

package/layers/design-system/theming/nuxt.config.ts

@@ -12,7 +12,7 @@ export default defineNuxtConfig({
     name: 'theming',
   },
 
-  extends: ['../../core'],
+  extends: ['../../core', '../typography'],
 
   runtimeConfig: {
     public: {

package/layers/design-system/typography/app/components/Typography/CodeBlock.vue

@@ -54,7 +54,7 @@
     ...(size !== undefined && { size }),
     ...(fluidSize !== undefined && { fluidSize }),
   }))
-  const colorClass = useColor(color, 'text')
+  const colorClass = useColor(() => color, 'text')
 </script>
 
 <template>

package/layers/design-system/typography/app/components/Typography/Headline.vue

@@ -71,7 +71,7 @@
     ...(size !== undefined && { size }),
     ...(appliedFluidSize.value !== undefined && { fluidSize: appliedFluidSize.value }),
   }))
-  const colorClass = useColor(color, 'text')
+  const colorClass = useColor(() => color, 'text')
 </script>
 
 <template>

package/layers/design-system/typography/app/components/Typography/QuoteBlock.vue

@@ -52,7 +52,7 @@
     ...(size !== undefined && { size }),
     ...(fluidSize !== undefined && { fluidSize }),
   }))
-  const colorClass = useColor(color, 'text')
+  const colorClass = useColor(() => color, 'text')
 </script>
 
 <template>

package/layers/design-system/typography/app/components/Typography/index.vue

@@ -55,7 +55,7 @@
     ...(font !== undefined && { font }),
     ...(fluidSize !== undefined && { fluidSize }),
   }))
-  const colorClass = useColor(color, 'text')
+  const colorClass = useColor(() => color, 'text')
 </script>
 
 <template>

package/layers/design-system/typography/app/composables/color.test.ts

@@ -0,0 +1,30 @@
+import { ref } from 'vue'
+import { describe, expect, it } from 'vite-plus/test'
+
+import { useColor } from './color'
+
+describe('useColor', () => {
+  it('builds a class from a plain value', () => {
+    expect(useColor('primary', 'text').value).toBe('text-primary')
+  })
+
+  it('falls back to default when color is undefined', () => {
+    expect(useColor(undefined, 'bg').value).toBe('bg-default')
+  })
+
+  it('tracks a ref', () => {
+    const color = ref<'primary' | 'error'>('primary')
+    const cls = useColor(color)
+    color.value = 'error'
+    expect(cls.value).toBe('text-error')
+  })
+
+  it('tracks a getter', () => {
+    let color: 'primary' | 'error' = 'primary'
+    const state = ref(0)
+    const cls = useColor(() => (state.value, color))
+    color = 'error'
+    state.value++
+    expect(cls.value).toBe('text-error')
+  })
+})

package/layers/design-system/typography/app/composables/color.ts

@@ -1,5 +1,12 @@
+import { computed, toValue, type MaybeRefOrGetter } from 'vue'
+
 import type { ColorUsage, UiColors } from '../types/colors'
 
-export function useColor(color?: UiColors, type: ColorUsage = 'text') {
-  return computed(() => `${type}-${color ?? 'default'}`)
+// Takes a getter (`() => color`) when `color` is a destructured prop — passing the bare
+// value reads it once at setup and the class never updates.
+export function useColor(
+  color?: MaybeRefOrGetter<UiColors | undefined>,
+  type: ColorUsage = 'text'
+) {
+  return computed(() => `${type}-${toValue(color) ?? 'default'}`)
 }

package/layers/design-system/visual/app/composables/tint.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vite-plus/test'
+
+import { useTint } from './tint'
+
+describe('useTint', () => {
+  it('resolves a slot to its ui color token with the level opacity', () => {
+    expect(useTint({ color: 'primary', level: 'light' }).style.value).toEqual({
+      backgroundColor: 'var(--ui-color-primary-500)',
+      opacity: 0.1,
+    })
+  })
+
+  it('honours shade and the white/black literals', () => {
+    expect(
+      useTint({ color: 'error', shade: 200, level: 'subtle' }).style.value.backgroundColor
+    ).toBe('var(--ui-color-error-200)')
+    expect(useTint({ color: 'white', level: 'heavy' }).style.value).toEqual({
+      backgroundColor: '#ffffff',
+      opacity: 0.5,
+    })
+  })
+})

package/layers/design-system/visual/app/composables/tint.ts

@@ -1,18 +1,17 @@
-import { toValue, type ComputedRef, type CSSProperties, type MaybeRefOrGetter } from 'vue'
+import { computed, toValue, type ComputedRef, type CSSProperties, type MaybeRefOrGetter } from 'vue'
 
 import { TINT_LEVEL_OPACITY, type TintConfig } from '../types/tint'
+import { resolveUiColorToken } from '../utils/colorTokens'
 
 export function useTint(config: MaybeRefOrGetter<TintConfig>): {
   style: ComputedRef<CSSProperties>
 } {
   const style = computed((): CSSProperties => {
     const { color, shade = 500, level } = toValue(config)
-    let backgroundColor = `var(--ui-color-${color}-${shade})`
-    if (color === 'white') backgroundColor = '#ffffff'
-    if (color === 'black') backgroundColor = '#000000'
-
-    const opacity = TINT_LEVEL_OPACITY[level] / 100
-    return { backgroundColor, opacity }
+    return {
+      backgroundColor: resolveUiColorToken({ color, shade }),
+      opacity: TINT_LEVEL_OPACITY[level] / 100,
+    }
   })
 
   return { style }

package/layers/render/shader/nuxt.config.ts

@@ -5,7 +5,7 @@ export default defineNuxtConfig({
 
   compatibilityDate: '2025-07-15',
 
-  extends: ['../canvas'],
+  extends: ['../canvas', '../../design-system/theming'],
 
   typescript: {
     typeCheck: false,

package/layers/structure/navigation/app/components/Links/Named.vue

@@ -17,7 +17,7 @@
     variant?: string
     color?: UiColors
   }>()
-  const colorClass = useColor(color, 'text')
+  const colorClass = useColor(() => color, 'text')
   // `name` is a plain string here, not one of the app's typed route names
   const to = computed(
     () => ({ name, params: params ?? {}, query: query ?? {} }) as unknown as LinkProps['to']

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kmcom-nuxt-layers",
   "private": false,
-  "version": "5.0.8",
+  "version": "6.0.0",
   "description": "Composable Nuxt 4 layers for building scalable Vue applications",
   "exports": {
     "./layers/core": "./layers/core/nuxt.config.ts",
@@ -11,6 +11,7 @@
     "./layers/navigation": "./layers/structure/navigation/nuxt.config.ts",
     "./layers/visual": "./layers/design-system/visual/nuxt.config.ts",
     "./layers/layout": "./layers/structure/layout/nuxt.config.ts",
+    "./layers/grid": "./layers/structure/grid/nuxt.config.ts",
     "./layers/scroll": "./layers/motion/scroll/nuxt.config.ts",
     "./layers/animations": "./layers/motion/animations/nuxt.config.ts",
     "./layers/transitions": "./layers/motion/transitions/nuxt.config.ts",
@@ -167,7 +168,7 @@
     "better-sqlite3": "^12.10.0",
     "@perplex-digital/stylelint-config": "^17.4.0",
     "@pinia/nuxt": "^0.11.3",
-    "@playwright/test": "1.61.0",
+    "@playwright/test": "1.64.1",
     "@types/node": "^25.9.1",
     "@types/three": "^0.184.1",
     "@typescript-eslint/eslint-plugin": "^8.60.1",
@@ -207,8 +208,8 @@
     "vite-plugin-checker": "^0.14.5",
     "vitest": "5.0.5",
     "vue": "3.5.35",
-    "vue-tsc": "3.3.11",
-    "zod": "^4.4.3",
+    "vue-tsc": "3.3.13",
+    "zod": "^4.3.6",
     "zod-to-json-schema": "^3.25.2",
     "vite-plus": "1.3.0"
   },