@michaelthielemann/kestrel 4.1.2 → 5.0.0

package/layers/auth/server/plugins/01.register-auth-pipelines.ts

@@ -1,7 +0,0 @@
-import { registerPipeline } from '@michaelthielemann/kestrel-core'
-import { buildAuthPipelines } from '@michaelthielemann/kestrel-auth'
-
-// Registration only — nothing resolves a pipeline here; the registry is read on the first request.
-export default defineNitroPlugin(() => {
-  for (const def of buildAuthPipelines()) registerPipeline(def)
-})

package/layers/collections/nuxt.config.ts

@@ -1 +0,0 @@
-export default defineNuxtConfig({})

package/layers/collections/server/plugins/01.register.ts

@@ -1,29 +0,0 @@
-import collections from '#kestrel/collections'
-import blocks from '#kestrel/blocks'
-import { registerBlock, type BlockDef } from '@michaelthielemann/kestrel-fields'
-import { ensureBuilt, collectionEnabled, registerCollection  } from '@michaelthielemann/kestrel-core'
-import { resolveServerKestrel, serverRuntimeConfig } from '../../../core/server/utils/server-config'
-import type { BuiltCollection, CollectionDef } from '@michaelthielemann/kestrel-core'
-// Auto-discovered collection files default-export either a plain CollectionDef (the common consumer
-// form, `export default defineCollection(…)`) or an already-built collection (advanced). `ensureBuilt`
-// normalizes both so the registry only ever holds BuiltCollections.
-//
-// NOTE on ordering: this plugin's real execution position is declared data now
-// (layers/core/modules/plugin-order/plugin-order.ts), not an accident of filename/layer scan order — it
-// runs after every core plugin (00.migrate/02.schema-sync included), identically in both build contexts.
-// It is order-free regardless: nothing reads the registry at plugin init — migrate/schema-sync read the
-// `#kestrel/collections` virtual directly, and the ref/cleanup/publish plugins register deferred listeners.
-// Keep that invariant — do not add an init-time allCollections() read.
-export default defineNitroPlugin(() => {
-  for (const block of blocks as BlockDef[]) registerBlock(block)
-  // Built-in collections (`pages`, `media`) register by default but can be disabled per consumer via
-  // `kestrel: { collections: { <name>: false } }`. Prefer the value the kestrel module put on runtimeConfig
-  // (the consumer's `kestrel: {}`); fall back to Kestrel's own resolved config for non-Nitro / dev callers.
-  const toggles = (serverRuntimeConfig()?.kestrel?.collections ?? resolveServerKestrel().collections) as Record<string, boolean>
-  for (const collection of collections as (CollectionDef | BuiltCollection)[]) {
-    const built = ensureBuilt(collection)
-    // The shared predicate (schema/bootstrap) — the schema engine gates on exactly the same rule.
-    if (!collectionEnabled(built.def, toggles)) continue
-    registerCollection(built)
-  }
-})

package/layers/collections/server/plugins/02.register-relation-populate.ts

@@ -1,18 +0,0 @@
-import { getCollection, getOne, registerFieldPopulator, useDb } from '@michaelthielemann/kestrel-core'
-import { isPubliclyReadable, publicReadableResources } from '@michaelthielemann/kestrel-access'
-import { buildRelationFieldPopulator, skipMissing } from '@michaelthielemann/kestrel-collections'
-// Expand relation fields to the fully-populated related record(s) under `$<name>` at read time (depth ≥ 1).
-// The related read is published-only (a draft target is skipped, never leaked to a public read), tolerates a
-// stale/deleted id (getOne 404 → null via `skipMissing`, other errors propagate — fail-loud), and runs at
-// `depth - 1`, so `populateRow` bails at 0 and cycles terminate. Registered per-type; the shared field-tree
-// walker (fields layer) dispatches it.
-// The reachability predicate is the declared public set, NOT the guard's full decision — the guard also
-// folds in `registeredGrants()`, which this omits. So a collection opened to anonymous by a registered
-// grant is served on its own route but stays unexpanded here: fail-closed drift, never a widening.
-export default defineNitroPlugin(() => {
-  registerFieldPopulator('relation', buildRelationFieldPopulator((collection, id, depth, locale, publicOnly) => {
-    const built = getCollection(collection)
-    if (!built) return null
-    return skipMissing(() => getOne(useDb(), built, id, depth, locale, true, publicOnly) as Record<string, unknown>)
-  }, (collection) => isPubliclyReadable(collection, publicReadableResources())))
-})

package/layers/core/app/composables/layouts.ts

@@ -1,5 +0,0 @@
-import { kestrelLayouts } from '#build/kestrel-layouts.mjs'
-
-export function useOfferableLayouts(): string[] {
-  return kestrelLayouts
-}

package/layers/core/app/utils/field-factories.ts

@@ -1,129 +0,0 @@
-import type { FieldDef } from '@michaelthielemann/kestrel-core'
-
-/**
- * Field factories for single-file (SFC) block authoring, à la Pruvious. A block's schema is declared as its
- * component's `defineProps({ heading: textField({ required: true }), … })`; each factory returns a DUAL
- * object — a Vue prop descriptor (`type` = a JS-global constructor) that ALSO carries the Kestrel `FieldDef`
- * under `[KESTREL_FIELD]`. Vue reads `type` at runtime; the build-time SFC extractor reads `[KESTREL_FIELD]`.
- *
- * This file imports NO Vue/Nuxt runtime (only JS globals), so it is importable BOTH in the browser (the SFC's
- * props declaration) AND by the Node extractor that injects these factories to evaluate a block's schema.
- * `Symbol.for` (global registry) keeps the key identical even if the file is instantiated twice.
- */
-export const KESTREL_FIELD = Symbol.for('kestrel.field')
-
-export interface FieldFactoryResult<C = unknown> {
-  /** A Vue prop constructor (String / Number / Boolean / Object / Array) — the runtime prop shape. Typed as
-   *  the specific constructor so Vue's `defineProps` accepts the factory result AND infers the prop's value
-   *  type (`textField()` → `string`, `mediaField()` → `number`, …). */
-  type: C
-  /** The Kestrel field definition the extractor lifts into the block's schema. */
-  [KESTREL_FIELD]: FieldDef
-}
-
-// Keys that belong on the FieldDef itself (not inside `options`); everything else a factory receives is a
-// type-specific option. Mirrors `BaseFieldDef` in defineCollection.ts.
-const BASE_KEYS = new Set(['required', 'unique', 'label', 'default', 'condition', 'renamedFrom', 'populate'])
-
-function partition(opts: Record<string, unknown>): { base: Record<string, unknown>; options: Record<string, unknown> } {
-  const base: Record<string, unknown> = {}
-  const options: Record<string, unknown> = {}
-  for (const [k, v] of Object.entries(opts)) (BASE_KEYS.has(k) ? base : options)[k] = v
-  return { base, options }
-}
-
-function wrap<C>(def: Record<string, unknown>, vueType: C): FieldFactoryResult<C> {
-  // The factory assembles the FieldDef structurally (open discriminated union); cast through `unknown`.
-  return { type: vueType, [KESTREL_FIELD]: def as unknown as FieldDef }
-}
-
-/** A leaf field: base props at the top level, everything else under `options`. */
-function leaf<C>(type: string, vueType: C) {
-  return (opts: Record<string, unknown> = {}): FieldFactoryResult<C> => {
-    const { base, options } = partition(opts)
-    const def: Record<string, unknown> = { type, ...base }
-    if (Object.keys(options).length) def.options = options
-    return wrap(def, vueType)
-  }
-}
-
-/** Generic escape hatch for a CUSTOM field type (registered via `defineFieldType`) that has no dedicated
- *  factory — `field('secureGallery', { … })`. Base props split off the top level, the rest into `options`;
- *  the Vue prop is typed `Object` (unknown value shape). */
-export function field(type: string, opts: Record<string, unknown> = {}): FieldFactoryResult<ObjectConstructor> {
-  const { base, options } = partition(opts)
-  const def: Record<string, unknown> = { type, ...base }
-  if (Object.keys(options).length) def.options = options
-  return wrap(def, Object)
-}
-
-export const textField = leaf('text', String)
-export const slugField = leaf('slug', String)
-export const richtextField = leaf('richtext', String)
-export const numberField = leaf('number', Number)
-export const booleanField = leaf('boolean', Boolean)
-export const jsonField = leaf('json', Object)
-export const linkField = leaf('link', Object)
-
-/** Media: `multiple` (stored bare, an id array) → Array prop; single (a `<name>Id` FK) → Number prop. */
-export function mediaField(opts: Record<string, unknown> = {}): FieldFactoryResult<ArrayConstructor | NumberConstructor> {
-  const { base, options } = partition(opts)
-  const def: Record<string, unknown> = { type: 'media', ...base }
-  if (Object.keys(options).length) def.options = options
-  return wrap(def, options.multiple ? Array : Number)
-}
-
-/** Choice: `multiple` → the value is a `string[]` (Array prop), single → a `string` (String prop). */
-export function choiceField(opts: Record<string, unknown> = {}): FieldFactoryResult<ArrayConstructor | StringConstructor> {
-  const { base, options } = partition(opts)
-  const def: Record<string, unknown> = { type: 'choice', ...base }
-  if (Object.keys(options).length) def.options = options
-  return wrap(def, options.multiple ? Array : String)
-}
-
-/** Datetime: `range` → the value is a `{ start, end }` object (Object prop), else a `string` (String prop). */
-export function datetimeField(opts: Record<string, unknown> = {}): FieldFactoryResult<ObjectConstructor | StringConstructor> {
-  const { base, options } = partition(opts)
-  const def: Record<string, unknown> = { type: 'datetime', ...base }
-  if (Object.keys(options).length) def.options = options
-  return wrap(def, options.range ? Object : String)
-}
-
-/** Relation: `collection`/`many`/`labelField` map into `relation`; `many` → Array prop, single → Number. */
-export function relationField(opts: Record<string, unknown> = {}): FieldFactoryResult<ArrayConstructor | NumberConstructor> {
-  const { collection, many, labelField, ...rest } = opts as {
-    collection?: string
-    many?: boolean
-    labelField?: string
-  } & Record<string, unknown>
-  if (typeof collection !== 'string' || !collection) {
-    throw new Error('relationField requires a `collection` (the target collection name)')
-  }
-  const { base, options } = partition(rest)
-  const relation: Record<string, unknown> = { collection }
-  if (many) relation.many = many
-  if (labelField) relation.labelField = labelField
-  const def: Record<string, unknown> = { type: 'relation', ...base, relation }
-  if (Object.keys(options).length) def.options = options
-  return wrap(def, many ? Array : Number)
-}
-
-/** Repeater: sub-fields are authored as factory calls too — unwrap each to its FieldDef (recursively).
- *  `fieldLayout` (the sub-field editor layout) forwards into `options` instead of being dropped. */
-export function repeaterField(opts: Record<string, unknown> = {}): FieldFactoryResult<ArrayConstructor> {
-  const { fields, fieldLayout, ...rest } = opts as { fields?: Record<string, unknown>; fieldLayout?: unknown } & Record<string, unknown>
-  const { base } = partition(rest)
-  const options: Record<string, unknown> = { fields: unwrapFields(fields ?? {}) }
-  if (fieldLayout !== undefined) options.fieldLayout = fieldLayout
-  return wrap({ type: 'repeater', ...base, options }, Array)
-}
-
-/** Convert a `{ name: <factory-result | FieldDef> }` map into a `{ name: FieldDef }` map. A nested repeater's
- *  result already carries a fully-unwrapped def, so recursion is implicit. */
-function unwrapFields(fields: Record<string, unknown>): Record<string, FieldDef> {
-  const out: Record<string, FieldDef> = {}
-  for (const [k, v] of Object.entries(fields)) {
-    out[k] = v && typeof v === 'object' && KESTREL_FIELD in v ? (v as FieldFactoryResult)[KESTREL_FIELD] : (v as FieldDef)
-  }
-  return out
-}

package/layers/core/app/utils/layouts.ts

@@ -1,38 +0,0 @@
-/** The admin shell. Never offerable for a public record — a page rendered inside it would carry the
- *  admin chrome and its own `useHead`. */
-export const ADMIN_LAYOUT = 'admin'
-
-/** Nuxt's resolved `app.layouts` entry (`nuxt.options.app.layouts`, filled before the `app:resolve` hook). */
-export interface ResolvedLayout { name: string, file: string }
-
-/**
- * The layout names a page may be assigned, from Nuxt's own resolved layout map. Nuxt has already done the
- * layer-ordered, name-first dedup (a consumer's `default.vue` shadows the engine's), so this only filters
- * and sorts — no directory scan of our own.
- */
-export function offerableLayouts(layouts: Record<string, ResolvedLayout | undefined>): string[] {
-  return Object.values(layouts)
-    .filter((l): l is ResolvedLayout => !!l && typeof l.file === 'string' && l.file.endsWith('.vue'))
-    .map((l) => l.name)
-    .filter((name) => name !== ADMIN_LAYOUT)
-    .sort()
-}
-
-export function renderLayoutRegistry(names: string[]): string {
-  return `export const kestrelLayouts = ${JSON.stringify(names)}\n`
-}
-
-/**
- * Options for the page-layout select. The fallback is one entry with an EMPTY value — an unset column
- * already renders `default`, so offering `default` as its own value would give the editor two controls for
- * one outcome and pin the row to a name the consumer may later rename.
- */
-export function layoutSelectOptions(names: string[], fallbackLabel: string): { label: string, value: string }[] {
-  return [
-    { label: fallbackLabel, value: '' },
-    ...names.filter((n) => n !== DEFAULT_LAYOUT_NAME).map((n) => ({ label: n, value: n })),
-  ]
-}
-
-/** Mirrors `DEFAULT_LAYOUT` in the public layer; kept local so this util stays dependency-free. */
-const DEFAULT_LAYOUT_NAME = 'default'

package/layers/core/modules/auto-discovery/extract-block.ts

@@ -1,179 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { basename } from 'node:path'
-import { parse } from '@babel/parser'
-import type { FieldDef } from '@michaelthielemann/kestrel-core'
-import * as factoryModule from '../../app/utils/field-factories'
-import { KESTREL_FIELD } from '../../app/utils/field-factories'
-
-/** The extracted block definition (shape mirrors `BlockDef`, kept structural so this build-time module
- *  needs no `layers/fields` runtime import). */
-export interface ExtractedBlock {
-  name: string
-  fields: Record<string, FieldDef>
-  slots?: string[]
-  label?: unknown
-  icon?: string
-  image?: string
-}
-
-// Only the callable factories are injected into the schema-eval scope (exclude the KESTREL_FIELD symbol).
-const FACTORIES: Record<string, unknown> = Object.fromEntries(
-  Object.entries(factoryModule).filter(([, v]) => typeof v === 'function'),
-)
-// The factory functions themselves, to catch an uncalled factory (`heading: textField` vs `textField()`).
-const FACTORY_SET = new Set(Object.values(FACTORIES))
-
-/** `Hero.vue` → `hero`, `BoxedContainer.vue` → `boxedContainer` (camel-case; `BlockRenderer` pascal-cases it
- *  back to the `Blocks<Name>` component). */
-export function blockNameFromFile(fileBase: string): string {
-  const name = fileBase.replace(/\.vue$/, '')
-  return name.charAt(0).toLowerCase() + name.slice(1)
-}
-
-/** The raw `<script setup>` source. `setup` is matched in ANY attribute position (`<script setup lang="ts">`
- *  and `<script lang="ts" setup>` are both valid), so a plain `<script>` block (no `setup` word) is skipped.
- *  (A real Vite build could use `@vue/compiler-sfc parse` for full robustness — e.g. a `</script>` inside a
- *  string literal; a scoped match is adequate + dependency-light here.) */
-function scriptSetup(sfc: string, where: string): string {
-  const m = sfc.match(/<script\b[^>]*\bsetup\b[^>]*>([\s\S]*?)<\/script>/)
-  if (!m) throw new Error(`${where}: a Kestrel block SFC must have a <script setup> block`)
-  return m[1]
-}
-
-interface Node { type: string; start: number; end: number; [k: string]: unknown }
-
-/** Peel the wrappers a macro call is commonly written behind so the CallExpression underneath is reached:
- *  a TS as-cast / satisfies (`defineProps({…}) as T`), a non-null assertion (`defineProps({…})!`), and
- *  parentheses. */
-function unwrapExpr(node: unknown): Record<string, unknown> | undefined {
-  let n = node as Record<string, unknown> | undefined
-  while (n && (n.type === 'TSAsExpression' || n.type === 'TSSatisfiesExpression' || n.type === 'TSNonNullExpression' || n.type === 'ParenthesizedExpression')) {
-    n = n.expression as Record<string, unknown> | undefined
-  }
-  return n
-}
-
-/** If `call` resolves to `<macro>(…)`, its first arg node + whether it carried a type parameter
- *  (`defineProps<T>()`, unsupported — no runtime schema). Also looks INSIDE `withDefaults(defineProps(…), …)`
- *  — the most common props idiom — so that form is not silently extracted as an empty schema. */
-function macroInCall(call: unknown, macro: string): { arg?: Node; hasTypeParam: boolean } | undefined {
-  const n = unwrapExpr(call)
-  if (n?.type !== 'CallExpression') return undefined
-  const callee = n.callee as Record<string, unknown> | undefined
-  if (callee?.type === 'Identifier' && callee.name === macro) {
-    return { arg: (n.arguments as Node[])[0], hasTypeParam: !!(n.typeParameters || n.typeArguments) }
-  }
-  // withDefaults(defineProps(…), { … }) — recurse into its arguments to find the wrapped macro call.
-  if (callee?.type === 'Identifier' && callee.name === 'withDefaults') {
-    for (const a of (n.arguments as unknown[]) ?? []) {
-      const hit = macroInCall(a, macro)
-      if (hit) return hit
-    }
-  }
-  return undefined
-}
-
-/** The FIRST TOP-LEVEL `<macro>(…)` call — a bare `defineBlock({…})` (ExpressionStatement), a
- *  `const props = defineProps({…})` (VariableDeclaration init, incl. `export const` and wrapper forms).
- *  Vue's macros are top-level by contract, so scanning only `program.body` (not a deep DFS) means a call
- *  nested in a helper function can't shadow it. */
-function macroCall(ast: unknown, macro: string): { arg?: Node; hasTypeParam: boolean } | undefined {
-  const body = (ast as { program?: { body?: unknown[] } }).program?.body
-  if (!Array.isArray(body)) return undefined
-  for (const raw of body as Array<Record<string, unknown>>) {
-    // Unwrap `export const props = …` → the VariableDeclaration it wraps.
-    const stmt = raw.type === 'ExportNamedDeclaration' && raw.declaration ? (raw.declaration as Record<string, unknown>) : raw
-    if (stmt.type === 'ExpressionStatement') {
-      const hit = macroInCall(stmt.expression, macro)
-      if (hit) return hit
-    } else if (stmt.type === 'VariableDeclaration') {
-      for (const d of (stmt.declarations as Array<Record<string, unknown>>) ?? []) {
-        const hit = macroInCall(d.init, macro)
-        if (hit) return hit
-      }
-    }
-  }
-  return undefined
-}
-
-function evalObjectExpr(content: string, node: Node, scope: Record<string, unknown>, where: string): Record<string, unknown> {
-  const src = content.slice(node.start, node.end)
-  const names = Object.keys(scope)
-  try {
-    // `src` is a slice of the CONSUMER's own block-SFC source, evaluated once here at build/discovery time
-    // to recover the object literal's runtime shape — never attacker- or request-supplied, so this is not
-    // an eval-injection surface.
-    const fn = new Function(...names, `return (${src})`)
-    const out = fn(...names.map((k) => scope[k]))
-    if (!out || typeof out !== 'object') throw new Error('expected an object literal')
-    return out as Record<string, unknown>
-  } catch (e) {
-    throw new Error(
-      `${where}: could not evaluate the block declaration. Field/block args must be self-contained literals + ` +
-        `field-factory calls (no imported constants, computed values, or TS type-args). Cause: ${(e as Error).message}`,
-      { cause: e },
-    )
-  }
-}
-
-/**
- * Extract a `BlockDef` from a block SFC's source: `defineProps({ … field factories … })` → `fields`,
- * `defineBlock({ label, slots, icon })` → metadata, `name` ← filename. Static (no component execution): the
- * `defineProps`/`defineBlock` argument object-literals are sliced from source and evaluated with the field
- * factories in scope; each field's `[KESTREL_FIELD]` is lifted into the schema.
- */
-export function extractBlockDef(sfcSource: string, fileBase: string): ExtractedBlock {
-  const name = blockNameFromFile(fileBase)
-  const content = scriptSetup(sfcSource, fileBase)
-  let ast: ReturnType<typeof parse>
-  try {
-    ast = parse(content, { sourceType: 'module', plugins: ['typescript'] })
-  } catch (e) {
-    throw new Error(`${fileBase}: could not parse <script setup> — ${(e as Error).message}`, { cause: e })
-  }
-
-  const props = macroCall(ast, 'defineProps')
-  if (props?.hasTypeParam && !props.arg) {
-    throw new Error(`${fileBase}: use the runtime form defineProps({ … }) with field factories, not defineProps<T>() — the type-only form carries no schema`)
-  }
-  const propsObj = props?.arg ? evalObjectExpr(content, props.arg, FACTORIES, fileBase) : {}
-
-  const block = macroCall(ast, 'defineBlock')
-  const meta = block?.arg ? evalObjectExpr(content, block.arg, {}, fileBase) : {}
-
-  const fields: Record<string, FieldDef> = {}
-  for (const [key, value] of Object.entries(propsObj)) {
-    const carried = value && typeof value === 'object' ? (value as Record<symbol, unknown>)[KESTREL_FIELD] : undefined
-    if (carried === undefined) {
-      // An UNCALLED field factory (`heading: textField` instead of `textField()`) evaluates to the factory
-      // function itself — catch that common slip loudly rather than silently dropping the field.
-      if (typeof value === 'function' && FACTORY_SET.has(value)) {
-        throw new Error(`${fileBase}: prop "${key}" is a field factory that was not called — write ${(value as { name?: string }).name ?? 'xField'}({ … })`)
-      }
-      // Otherwise it's a plain (display-only) Vue prop (e.g. `media: Object`, the server-resolved $media bag
-      // BlockRenderer passes) — not part of the block schema. A misspelled factory throws at eval time above.
-      continue
-    }
-    const def = carried as FieldDef & { default?: unknown }
-    if (typeof def.default === 'function') {
-      // The registry is inlined as JSON (renderBlockRegistry) — a function default would be silently dropped.
-      throw new Error(`${fileBase}: prop "${key}" has a function \`default\` — block field defaults must be JSON-serializable literals`)
-    }
-    fields[key] = carried as FieldDef
-  }
-
-  const out: ExtractedBlock = { name, fields }
-  if (meta.label !== undefined) out.label = meta.label
-  if (Array.isArray(meta.slots) && meta.slots.length) out.slots = meta.slots as string[]
-  if (typeof meta.icon === 'string') out.icon = meta.icon
-  if (typeof meta.image === 'string') out.image = meta.image
-  return out
-}
-
-/** The `#kestrel/blocks` virtual body: extract each block SFC and inline the definitions as JSON data
- *  (the block registry is plain, JSON-safe data — no imports needed beyond the field-type side effect the
- *  caller prepends). */
-export function renderBlockRegistry(vuePaths: string[]): string {
-  const defs = vuePaths.map((p) => extractBlockDef(readFileSync(p, 'utf8'), basename(p)))
-  return `export default ${JSON.stringify(defs)}`
-}

package/layers/core/modules/auto-discovery/index.ts

@@ -1,112 +0,0 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { addComponentsDir, addTemplate, addTypeTemplate, createResolver, defineNuxtModule } from '@nuxt/kit'
-import { collectBlockSfcs, collectDefinitions, collectManifestFiles, renderPackageConcatRegistry, renderPackageMergedRegistry, renderRegistry, resolvePackageEntry } from './scan'
-import { renderBlockRegistry } from './extract-block'
-import { offerableLayouts, renderLayoutRegistry } from '../../app/utils/layouts'
-import { PACKAGE_COLLECTIONS, PACKAGE_MANIFESTS, PACKAGE_SCHEMA_TABLES } from './package-registry'
-
-export default defineNuxtModule({
-  meta: { name: 'kestrel-auto-discovery' },
-  setup(_options, nuxt) {
-    const roots = nuxt.options._layers.map((layer) => layer.cwd)
-    // The `#kestrel/*` registries are Nitro VIRTUAL modules (runtime only) — tsc can't see their shape, so
-    // server code importing them would be `Cannot find module`. Register the ambient declarations into BOTH
-    // the Nitro and Nuxt tsconfigs so the typecheck resolves them.
-    const { resolve } = createResolver(import.meta.url)
-    addTypeTemplate({ filename: 'types/kestrel-virtual.d.ts', src: resolve('./virtual.d.ts') }, { nitro: true, nuxt: true })
-
-    // Blocks are authored as single `.vue` files under each layer's `app/blocks/` — the SFC is BOTH the
-    // schema source (extracted at build into `#kestrel/blocks`) AND the display component. Register the dir
-    // so `app/blocks/Hero.vue` resolves as the global `BlocksHero` that the public BlockRenderer renders.
-    // No Kestrel package ships a block today, so this stays a pure consumer-dir scan (nothing to bridge).
-    for (const root of roots) {
-      const dir = join(root, 'app/blocks')
-      if (existsSync(dir)) addComponentsDir({ path: dir, prefix: 'Blocks', global: true, pathPrefix: false })
-    }
-
-    // Layouts need no scan of our own: Nuxt already resolves `app/layouts/*.vue` across the layers with the
-    // same name-first, consumer-wins dedup, and fills `app.layouts` just before `app:resolve` — which runs
-    // inside `generateApp`, ahead of the templates being written, so the closure below is filled in time.
-    let layoutNames: string[] = []
-    nuxt.hook('app:resolve', (app) => { layoutNames = offerableLayouts(app.layouts ?? {}) })
-    // `write` so the resolved list is inspectable in `.nuxt/` — a virtual-only template makes "which layouts
-    // did the build actually find" unanswerable without a debugger.
-    addTemplate({ filename: 'kestrel-layouts.mjs', write: true, getContents: () => renderLayoutRegistry(layoutNames) })
-
-    nuxt.hook('nitro:config', (nitro) => {
-      nitro.virtual ||= {}
-      // `@michaelthielemann/kestrel-fields`'s built-in descriptors (text/richtext/number/…) seed `core`'s field-type registry
-      // as a side effect of importing the package itself — core cannot import fields, so this is the one
-      // place that import happens. Resolved to a real file path (`resolvePackageEntry`), not left as the
-      // bare specifier: a Nitro virtual module has no real file of its own for a bundler to resolve a bare
-      // import FROM, so it falls back to the project root — where, under a real consumer's pnpm install,
-      // this package isn't visible (only the engine directly depends on it). Prepended so it always runs, even with zero consumer
-      // field types (an empty `collectDefinitions` result would otherwise generate `export default []`,
-      // importing nothing). Consumer field types register as a side effect on import too, and the schema
-      // engine builds a table the moment a collection/block module loads — so the collections/blocks/
-      // schema-tables/module-manifests virtuals ALL import the field-type seed FIRST (every one of them can
-      // now reach a package's `buildCollection()` call transitively via `kestrelDiscovery`, per ADR-0029 —
-      // an ESM barrel is an eager, whole-module-graph load — so all four need the same guard, not only the
-      // two that directly build collections themselves).
-      const importFieldTypesSeed = `import { fieldTypes as __kestrelSeed } from ${JSON.stringify(resolvePackageEntry('@michaelthielemann/kestrel-fields'))}\n`
-        + `if (!__kestrelSeed || typeof __kestrelSeed !== 'object') throw new Error('[kestrel] built-in field types failed to seed')\n`
-      // A real runtime check on the imported binding, not a bare `import "path"` or a discarded `void x`
-      // — Nitro's dev build tree-shakes an import whose binding has no provable effect, silently dropping
-      // the seed and breaking every collection. A `throw` Rollup can't prove unreachable survives.
-      // MUST be a static `import` (not `import()`): a dynamic import runs as an ordinary statement AFTER
-      // every static import of the same module has already evaluated (ESM linking order), which would run
-      // it too late — after a collection's own static import has already tried to build its table. A static
-      // import evaluates before any sibling static import declared after it, which is what orders this
-      // correctly. Every virtual below imports `@michaelthielemann/kestrel-fields` directly for this reason (on top of, not
-      // instead of, `#kestrel/field-types` for collections/blocks — chaining virtual-imports-virtual was
-      // unreliable in Nitro dev, so the real package import stays even where the virtual ALSO gets imported).
-      const importFieldTypesVirtual = `${importFieldTypesSeed}import { default as __kestrelFieldTypes } from '#kestrel/field-types'\n`
-        + `if (!__kestrelFieldTypes) throw new Error('[kestrel] #kestrel/field-types failed to load')\n`
-
-      nitro.virtual['#kestrel/field-types'] = () =>
-        `${importFieldTypesSeed}${renderRegistry(collectDefinitions(roots, 'server/field-types'))}`
-
-      nitro.virtual['#kestrel/collections'] = () =>
-        renderPackageMergedRegistry({
-          packages: PACKAGE_COLLECTIONS.map(resolvePackageEntry),
-          property: 'collections',
-          consumerFiles: collectDefinitions(roots, 'server/collections'),
-          nameOfExpr: '(x) => x.name',
-          preamble: importFieldTypesVirtual,
-        })
-
-      // Extract each `app/blocks/*.vue` into a plain BlockDef inlined as JSON (no per-file imports needed).
-      // No package ships a block today (see above), so this stays the plain consumer-dir scan, prefixed
-      // with the same seed a block's field-typed props may need.
-      nitro.virtual['#kestrel/blocks'] = () =>
-        `${importFieldTypesVirtual}${renderBlockRegistry(collectBlockSfcs(roots))}`
-
-      // Standalone (non-collection) tables: each package's `kestrelDiscovery.schemaTables`, merged with
-      // each layer's `server/schema-tables/*.ts` default export (media → folders, public → publish_deps/
-      // publish_status/…; consumers can add their own). The schema engine consumes this instead of core
-      // hardcoding upper-layer tables.
-      nitro.virtual['#kestrel/schema-tables'] = () =>
-        renderPackageMergedRegistry({
-          packages: PACKAGE_SCHEMA_TABLES.map(resolvePackageEntry),
-          property: 'schemaTables',
-          consumerFiles: collectDefinitions(roots, 'server/schema-tables'),
-          nameOfExpr: '(x) => __kestrelTableName(x)',
-          extraImports: `import { getTableName as __kestrelTableName } from 'drizzle-orm'`,
-          preamble: importFieldTypesVirtual,
-        })
-
-      // Per-module ownership manifests (ADR-0012): each package's `kestrelDiscovery.manifest` plus each
-      // layer's `server/db/manifest.ts` default export, for the `db:migrate-module` task to enumerate
-      // without core importing an upper layer (or a package) directly. No dedup — every contribution is a
-      // distinct module (see `collectManifestFiles`'s own TSDoc).
-      nitro.virtual['#kestrel/module-manifests'] = () =>
-        renderPackageConcatRegistry({
-          packages: PACKAGE_MANIFESTS.map(resolvePackageEntry),
-          property: 'manifest',
-          consumerFiles: collectManifestFiles(roots),
-          preamble: importFieldTypesVirtual,
-        })
-    })
-  },
-})

package/layers/core/modules/auto-discovery/package-registry.ts

@@ -1,19 +0,0 @@
-/**
- * Kestrel's own packages that ship discoverable content, by category — a package declares WHAT it
- * contributes via its own `kestrelDiscovery` named export (see `@michaelthielemann/kestrel-core`'s `KestrelPackageDiscovery`
- * TSDoc); this module still needs an explicit list of WHICH packages to check, since a Nitro virtual's
- * generated source is plain text written before anything runs — there is no filesystem/`node_modules` scan
- * to discover the list itself. Deliberately per-category, not one flat package list: a virtual only ever
- * imports a package here if that package actually contributes to ITS category, so (for example) building
- * the schema-tables virtual never eagerly touches `@michaelthielemann/kestrel-collections`, which has none.
- *
- * A package with content in a new category is added to the matching list below when that lands — an
- * explicit, reviewable registration, not a guess. `test/architecture/kestrel-discovery.test.ts`'s
- * "bidirectional consistency" suite computes, against every real workspace package's actual
- * `kestrelDiscovery` export, that these three lists are exactly right (nothing missing, nothing stale) —
- * so a package that starts or stops contributing a category and forgets to update the matching list here
- * fails a fast unit test, not a runtime 404 discovered later.
- */
-export const PACKAGE_COLLECTIONS = ['@michaelthielemann/kestrel-media', '@michaelthielemann/kestrel-collections', '@michaelthielemann/kestrel-publishing']
-export const PACKAGE_SCHEMA_TABLES = ['@michaelthielemann/kestrel-media', '@michaelthielemann/kestrel-publishing']
-export const PACKAGE_MANIFESTS = ['@michaelthielemann/kestrel-media', '@michaelthielemann/kestrel-publishing']