kmcom-nuxt-layers 2.3.2 → 2.5.1

package/layers/metadata/providers/google-books/server/utils/metadata-google-books/normalise.ts

@@ -0,0 +1,39 @@
+import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { GoogleBooksVolume } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseGoogleBooksVolume(volume: GoogleBooksVolume): MetadataRecord {
+  const { volumeInfo } = volume
+
+  const creators: MetadataCreator[] = (volumeInfo.authors ?? []).map((name) => ({
+    name,
+    role: 'author',
+  }))
+
+  const isbn10 = volumeInfo.industryIdentifiers?.find((i) => i.type === 'ISBN_10')?.identifier
+  const isbn13 = volumeInfo.industryIdentifiers?.find((i) => i.type === 'ISBN_13')?.identifier
+
+  const cover = volumeInfo.imageLinks?.thumbnail ?? volumeInfo.imageLinks?.smallThumbnail
+
+  return {
+    id: `google-books:volume:${volume.id}`,
+    provider: 'google-books',
+    providerId: volume.id,
+    mediaType: 'book',
+    title: volumeInfo.title,
+    subtitle: volumeInfo.subtitle,
+    description: volumeInfo.description,
+    creators: creators.length ? creators : undefined,
+    publisher: volumeInfo.publisher,
+    publishedAt: volumeInfo.publishedDate,
+    coverUrl: cover ? cover.replace('http://', 'https://') : undefined,
+    identifiers: {
+      isbn10,
+      isbn13,
+      googleBooksId: volume.id,
+    },
+    sourceUrl: volumeInfo.canonicalVolumeLink ?? volumeInfo.infoLink,
+    raw: volume,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

package/layers/metadata/providers/google-books/server/utils/metadata-google-books/provider.ts

@@ -0,0 +1,21 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const googleBooksProvider: MetadataProvider = {
+  id: 'google-books',
+  label: 'Google Books',
+  mediaTypes: ['book', 'graphic-novel', 'collected-edition'],
+
+  async search({ query, limit = 10 }) {
+    const res = await searchGoogleBooks(query, limit)
+    return (res.items ?? []).map(normaliseGoogleBooksVolume)
+  },
+
+  async lookup({ providerId }) {
+    const volume = await fetchGoogleBooksVolume(providerId)
+    return normaliseGoogleBooksVolume(volume)
+  },
+
+  async sync({ providerId }) {
+    return (await googleBooksProvider.lookup!({ provider: 'google-books', providerId }))!
+  },
+}

package/layers/metadata/providers/google-books/server/utils/metadata-google-books/types.ts

@@ -0,0 +1,25 @@
+export type GoogleBooksVolumeInfo = {
+  title: string
+  subtitle?: string
+  authors?: string[]
+  publisher?: string
+  publishedDate?: string
+  description?: string
+  industryIdentifiers?: Array<{ type: 'ISBN_10' | 'ISBN_13' | string; identifier: string }>
+  pageCount?: number
+  imageLinks?: { thumbnail?: string; smallThumbnail?: string }
+  previewLink?: string
+  infoLink?: string
+  canonicalVolumeLink?: string
+}
+
+export type GoogleBooksVolume = {
+  id: string
+  selfLink: string
+  volumeInfo: GoogleBooksVolumeInfo
+}
+
+export type GoogleBooksSearchResponse = {
+  totalItems: number
+  items?: GoogleBooksVolume[]
+}

package/layers/metadata/providers/google-books/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/layers/metadata/providers/openlibrary/nuxt.config.ts

@@ -0,0 +1,18 @@
+export default defineNuxtConfig({
+  $meta: {
+    name: 'metadata-openlibrary',
+  },
+
+  extends: ['../../'],
+
+  alias: {
+    '#layers/metadata-openlibrary': import.meta.dirname,
+  },
+
+  compatibilityDate: '2026-06-30',
+
+  typescript: {
+    typeCheck: false,
+    strict: true,
+  },
+})

package/layers/metadata/providers/openlibrary/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "kmcom-layer-metadata-openlibrary",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev",
+    "dev:playground": "PLAYGROUND_LAYERS=core,metadata,metadata-openlibrary pnpm -F playground dev",
+    "typecheck": "vue-tsc --noEmit -p ../../tsconfig.typecheck.json",
+    "lint": "eslint ."
+  }
+}

package/layers/metadata/providers/openlibrary/server/plugins/openlibrary-register.ts

@@ -0,0 +1,3 @@
+export default defineNitroPlugin(() => {
+  registerProvider(openLibraryProvider)
+})

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

@@ -0,0 +1,30 @@
+import type { OpenLibrarySearchResponse, OpenLibraryWork, OpenLibraryEdition } from './types'
+
+const BASE = 'https://openlibrary.org'
+
+export function openLibraryCoverUrl(coverId: number, size: 'S' | 'M' | 'L' = 'M'): string {
+  return `https://covers.openlibrary.org/b/id/${coverId}-${size}.jpg`
+}
+
+export async function searchOpenLibrary(query: string, limit = 10): Promise<OpenLibrarySearchResponse> {
+  return $fetch<OpenLibrarySearchResponse>(`${BASE}/search.json`, {
+    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> {
+  return $fetch<OpenLibraryWork>(`${BASE}/works/${workId}.json`)
+}
+
+export async function lookupOpenLibraryEdition(editionId: string): Promise<OpenLibraryEdition> {
+  return $fetch<OpenLibraryEdition>(`${BASE}/books/${editionId}.json`)
+}
+
+export async function lookupByIsbn(isbn: string): Promise<OpenLibraryEdition | null> {
+  try {
+    return await $fetch<OpenLibraryEdition>(`${BASE}/isbn/${isbn}.json`)
+  }
+  catch {
+    return null
+  }
+}

package/layers/metadata/providers/openlibrary/server/utils/metadata-openlibrary/normalise.ts

@@ -0,0 +1,81 @@
+import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
+import type { OpenLibrarySearchDoc, OpenLibraryWork, OpenLibraryEdition } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseOpenLibrarySearchDoc(doc: OpenLibrarySearchDoc): MetadataRecord {
+  const creators: MetadataCreator[] = (doc.author_name ?? []).map((name, i) => ({
+    name,
+    role: 'author',
+    providerId: doc.author_key?.[i]?.replace('/authors/', '') ?? undefined,
+  }))
+
+  const id = doc.key.replace('/works/', '')
+
+  return {
+    id: `openlibrary:work:${id}`,
+    provider: 'openlibrary',
+    providerId: id,
+    mediaType: 'book',
+    title: doc.title,
+    subtitle: doc.subtitle,
+    creators: creators.length ? creators : undefined,
+    publisher: doc.publisher?.[0] ?? undefined,
+    publishedAt: doc.first_publish_year ? String(doc.first_publish_year) : undefined,
+    coverUrl: doc.cover_i ? openLibraryCoverUrl(doc.cover_i) : undefined,
+    identifiers: {
+      isbn10: doc.isbn?.find((i) => i.length === 10),
+      isbn13: doc.isbn?.find((i) => i.length === 13),
+      openLibraryId: id,
+    },
+    sourceUrl: `https://openlibrary.org${doc.key}`,
+    raw: doc,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+// fallow-ignore-next-line complexity
+export function normaliseOpenLibraryWork(work: OpenLibraryWork): MetadataRecord {
+  const id = work.key.replace('/works/', '')
+  const desc = typeof work.description === 'string' ? work.description : work.description?.value
+
+  return {
+    id: `openlibrary:work:${id}`,
+    provider: 'openlibrary',
+    providerId: id,
+    mediaType: 'book',
+    title: work.title,
+    subtitle: work.subtitle,
+    description: desc,
+    coverUrl: work.covers?.[0] ? openLibraryCoverUrl(work.covers[0]) : undefined,
+    publishedAt: work.first_publish_date,
+    identifiers: { openLibraryId: id },
+    sourceUrl: `https://openlibrary.org${work.key}`,
+    raw: work,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+// fallow-ignore-next-line complexity
+export function normaliseOpenLibraryEdition(edition: OpenLibraryEdition): MetadataRecord {
+  const id = edition.key.replace('/books/', '')
+
+  return {
+    id: `openlibrary:edition:${id}`,
+    provider: 'openlibrary',
+    providerId: id,
+    mediaType: 'book',
+    title: edition.title,
+    subtitle: edition.subtitle,
+    publisher: edition.publishers?.[0] ?? undefined,
+    publishedAt: edition.publish_date,
+    coverUrl: edition.covers?.[0] ? openLibraryCoverUrl(edition.covers[0]) : undefined,
+    identifiers: {
+      isbn10: edition.isbn_10?.[0],
+      isbn13: edition.isbn_13?.[0],
+      openLibraryId: id,
+    },
+    sourceUrl: `https://openlibrary.org${edition.key}`,
+    raw: edition,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

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

@@ -0,0 +1,25 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const openLibraryProvider: MetadataProvider = {
+  id: 'openlibrary',
+  label: 'Open Library',
+  mediaTypes: ['book', 'graphic-novel', 'collected-edition'],
+
+  async search({ query, limit = 10 }) {
+    const res = await searchOpenLibrary(query, limit)
+    return res.docs.map(normaliseOpenLibrarySearchDoc)
+  },
+
+  async lookup({ providerId, resourceType = 'work' }) {
+    if (resourceType === 'edition') {
+      const edition = await lookupOpenLibraryEdition(providerId)
+      return normaliseOpenLibraryEdition(edition)
+    }
+    const work = await lookupOpenLibraryWork(providerId)
+    return normaliseOpenLibraryWork(work)
+  },
+
+  async sync({ providerId, resourceType = 'work' }) {
+    return (await openLibraryProvider.lookup!({ provider: 'openlibrary', providerId, resourceType }))!
+  },
+}

package/layers/metadata/providers/openlibrary/server/utils/metadata-openlibrary/types.ts

@@ -0,0 +1,48 @@
+export type OpenLibrarySearchDoc = {
+  key: string
+  title: string
+  subtitle?: string
+  author_name?: string[]
+  author_key?: string[]
+  publisher?: string[]
+  first_publish_year?: number
+  isbn?: string[]
+  cover_i?: number
+  number_of_pages_median?: number
+  language?: string[]
+}
+
+export type OpenLibrarySearchResponse = {
+  numFound: number
+  docs: OpenLibrarySearchDoc[]
+}
+
+export type OpenLibraryWork = {
+  key: string
+  title: string
+  subtitle?: string
+  description?: { value: string } | string
+  authors?: Array<{ author: { key: string }; type: { key: string } }>
+  first_publish_date?: string
+  covers?: number[]
+  subjects?: string[]
+}
+
+export type OpenLibraryEdition = {
+  key: string
+  title: string
+  subtitle?: string
+  publishers?: string[]
+  publish_date?: string
+  isbn_13?: string[]
+  isbn_10?: string[]
+  covers?: number[]
+  works?: Array<{ key: string }>
+  number_of_pages?: number
+}
+
+export type OpenLibraryAuthor = {
+  key: string
+  name: string
+  personal_name?: string
+}

package/layers/metadata/providers/openlibrary/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

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

@@ -0,0 +1,40 @@
+import type { MetadataProviderId } from '#layers/metadata/shared/types'
+
+// 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 })
+  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
+})

package/layers/metadata/server/api/metadata/providers.get.ts

@@ -0,0 +1,7 @@
+export default defineEventHandler(() => {
+  return getProviders().map((p) => ({
+    id: p.id,
+    label: p.label,
+    mediaTypes: p.mediaTypes,
+  }))
+})

package/layers/metadata/server/api/metadata/search.get.ts

@@ -0,0 +1,17 @@
+import type { MetadataMediaType, MetadataProviderId } from '#layers/metadata/shared/types'
+
+// fallow-ignore-next-line complexity
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event)
+
+  const q = String(query.q ?? '').trim()
+  if (!q) throw createError({ statusCode: 400, message: 'q is required' })
+
+  const mediaType = query.mediaType as MetadataMediaType | undefined
+  const providers = query.providers
+    ? String(query.providers).split(',').filter(Boolean) as MetadataProviderId[]
+    : undefined
+  const limit = query.limit ? Number(query.limit) : 10
+
+  return searchMetadata({ query: q, mediaType, providers, limit })
+})

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

@@ -0,0 +1,40 @@
+import type { MetadataSyncInput, MetadataProviderId } 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, 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 }
+})

package/layers/metadata/server/utils/metadata/cache.ts

@@ -0,0 +1,36 @@
+import type { MetadataCacheRecord } from '#layers/metadata/shared/types'
+
+// Cache keys: metadata:{provider}:{resourceType}:{providerId}
+//             metadata-search:{provider}:{mediaType}:{queryHash}
+
+export function makeCacheKey(...parts: string[]): string {
+  return parts.join(':')
+}
+
+export async function getCacheRecord(key: string): Promise<MetadataCacheRecord | null> {
+  const storage = useStorage('metadata')
+  return (await storage.getItem<MetadataCacheRecord>(key)) ?? null
+}
+
+export async function setCacheRecord(key: string, record: MetadataCacheRecord, ttl?: number): Promise<void> {
+  const storage = useStorage('metadata')
+  await storage.setItem(key, record, ttl ? { ttl } : undefined)
+}
+
+export async function getSearchCache<T>(key: string): Promise<T | null> {
+  const storage = useStorage('metadata')
+  return (await storage.getItem<T>(key)) ?? null
+}
+
+export async function setSearchCache<T>(key: string, value: T, ttl = 3600): Promise<void> {
+  const storage = useStorage('metadata')
+  await storage.setItem(key, value, { ttl })
+}
+
+export function hashQuery(query: string): string {
+  let h = 0
+  for (let i = 0; i < query.length; i++) {
+    h = (Math.imul(31, h) + query.charCodeAt(i)) | 0
+  }
+  return Math.abs(h).toString(36)
+}

package/layers/metadata/server/utils/metadata/errors.ts

@@ -0,0 +1,24 @@
+export class MetadataProviderError extends Error {
+  constructor(
+    public readonly provider: string,
+    message: string,
+    public readonly cause?: unknown,
+  ) {
+    super(`[metadata:${provider}] ${message}`)
+    this.name = 'MetadataProviderError'
+  }
+}
+
+export class MetadataNotFoundError extends Error {
+  constructor(provider: string, id: string) {
+    super(`[metadata:${provider}] Not found: ${id}`)
+    this.name = 'MetadataNotFoundError'
+  }
+}
+
+export class MetadataRateLimitError extends Error {
+  constructor(provider: string) {
+    super(`[metadata:${provider}] Rate limit exceeded`)
+    this.name = 'MetadataRateLimitError'
+  }
+}

package/layers/metadata/server/utils/metadata/provider-registry.ts

@@ -0,0 +1,15 @@
+import type { MetadataProvider, MetadataProviderId } from '#layers/metadata/shared/types'
+
+const _registry = new Map<MetadataProviderId, MetadataProvider>()
+
+export function registerProvider(provider: MetadataProvider) {
+  _registry.set(provider.id, provider)
+}
+
+export function getProvider(id: MetadataProviderId): MetadataProvider | null {
+  return _registry.get(id) ?? null
+}
+
+export function getProviders(): MetadataProvider[] {
+  return [..._registry.values()]
+}

package/layers/metadata/server/utils/metadata/search.ts

@@ -0,0 +1,42 @@
+import type { MetadataSearchInput, MetadataSearchResult } from '#layers/metadata/shared/types'
+
+// fallow-ignore-next-line complexity
+export async function searchMetadata(input: MetadataSearchInput): Promise<MetadataSearchResult[]> {
+  const all = getProviders()
+  const targets = input.providers?.length
+    ? all.filter((p) => input.providers!.includes(p.id))
+    : all.filter((p) => !input.mediaType || p.mediaTypes.includes(input.mediaType))
+
+  if (!targets.length) return []
+
+  const cacheKey = makeCacheKey(
+    'metadata-search',
+    targets.map((p) => p.id).join('+'),
+    input.mediaType ?? 'any',
+    hashQuery(`${input.query}:${input.limit ?? 10}`),
+  )
+
+  const cached = await getSearchCache<MetadataSearchResult[]>(cacheKey)
+  if (cached) return cached
+
+  const settled = await Promise.allSettled(targets.map((p) => p.search(input)))
+
+  const results: MetadataSearchResult[] = []
+  for (const outcome of settled) {
+    if (outcome.status === 'fulfilled') results.push(...outcome.value)
+  }
+
+  const deduped = deduplicateResults(results)
+  await setSearchCache(cacheKey, deduped)
+  return deduped
+}
+
+function deduplicateResults(results: MetadataSearchResult[]): MetadataSearchResult[] {
+  const seen = new Set<string>()
+  return results.filter((r) => {
+    const key = `${r.title.toLowerCase()}:${r.publishedAt?.slice(0, 4) ?? ''}`
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}

package/layers/metadata/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../apps/playground/tsconfig.json",
+  "compilerOptions": {
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kmcom-nuxt-layers",
   "private": false,
-  "version": "2.3.2",
+  "version": "2.5.1",
   "description": "Composable Nuxt 4 layers for building scalable Vue applications",
   "exports": {
     "./layers/core": "./layers/core/nuxt.config.ts",
@@ -21,11 +21,17 @@
     "./layers/shader": "./layers/shader/nuxt.config.ts",
     "./layers/mailer": "./layers/mailer/nuxt.config.ts",
     "./layers/forms": "./layers/forms/nuxt.config.ts",
+    "./layers/database": "./layers/database/nuxt.config.ts",
+    "./layers/auth": "./layers/auth/nuxt.config.ts",
     "./layers/theme": "./layers/theme/nuxt.config.ts",
     "./layers/content": "./layers/content/nuxt.config.ts",
     "./layers/feeds": "./layers/feeds/nuxt.config.ts",
     "./layers/routing": "./layers/routing/nuxt.config.ts",
-    "./layers/starter": "./layers/starter/nuxt.config.ts"
+    "./layers/starter": "./layers/starter/nuxt.config.ts",
+    "./layers/metadata": "./layers/metadata/nuxt.config.ts",
+    "./layers/metadata/providers/comicvine": "./layers/metadata/providers/comicvine/nuxt.config.ts",
+    "./layers/metadata/providers/openlibrary": "./layers/metadata/providers/openlibrary/nuxt.config.ts",
+    "./layers/metadata/providers/google-books": "./layers/metadata/providers/google-books/nuxt.config.ts"
   },
   "files": [
     "layers/*/nuxt.config.ts",
@@ -36,6 +42,10 @@
     "layers/*/app/**",
     "layers/*/public/**",
     "layers/*/server/**",
+    "layers/*/providers/*/nuxt.config.ts",
+    "layers/*/providers/*/package.json",
+    "layers/*/providers/*/tsconfig.json",
+    "layers/*/providers/*/server/**",
     "types/**",
     "docs/"
   ],
@@ -159,6 +169,7 @@
     "@webgpu/glslang": "^0.0.15",
     "@webgpu/types": "^0.1.70",
     "browserslist": "^4.28.2",
+    "browserslist-config-baseline": "^0.5.0",
     "changesets": "^1.0.2",
     "csstype": "^3.2.3",
     "cypress": "^15.16.0",
@@ -207,7 +218,7 @@
     "last 2 Firefox major versions",
     "last 2 Safari major versions",
     "last 2 Edge major versions",
-    "baseline widely available"
+    "extends browserslist-config-baseline"
   ],
   "dependencies": {
     "node-gyp": "^12.3.0",
@@ -228,6 +239,8 @@
     "dev:ui": "PLAYGROUND_LAYERS=core,ui pnpm -F playground dev",
     "dev:layout": "PLAYGROUND_LAYERS=core,ui,layout pnpm -F playground dev",
     "dev:motion": "PLAYGROUND_LAYERS=core,motion pnpm -F playground dev",
+    "dev:database": "PLAYGROUND_LAYERS=core,database pnpm -F playground dev",
+    "dev:auth": "PLAYGROUND_LAYERS=core,auth pnpm -F playground dev",
     "build": "turbo run build",
     "lint": "turbo run lint",
     "lint:fix": "turbo run lint -- --fix",

package/types/auth.ts

@@ -0,0 +1,7 @@
+// fallow-ignore-next-line unused-type
+export type SessionUser = {
+  provider: 'github'
+  providerId: string
+  username: string
+  avatarUrl?: string
+}

package/types/index.ts

@@ -17,3 +17,5 @@ export type {
 export type { ScrollLockEvent, LoadingStateEvent, LayerEvent } from './events'
 export type { MotionConfig, TransitionConfig } from './motion'
 export type { PublicRuntimeConfig } from './runtime'
+// fallow-ignore-next-line unused-type
+export type { SessionUser } from './auth'