mikser-io 8.3.9 → 9.0.0

package/CLAUDE.md

@@ -81,7 +81,10 @@ brevity.
   (`minThreads: 0` + `idleTimeout: 30_000`) so INLINE-only workloads
   pay no worker overhead. `workerSafeOptions(runtime.options)`
   strips plugin-surface functions before TASKS.WORKER dispatch so
-  Piscina's structured clone doesn't choke.
+  Piscina's structured clone doesn't choke. Renderer / postprocessor
+  descriptors in `runtime.options.plugins` are projected to their
+  `render-${name}` / `post-${name}` identifier so workers can
+  resolve them via dynamic import.
 - `database/` — `createSqliteDatabase()`, `registerSchema()`,
   `useDatabase()` (the `mikser_meta` table stamps schema_version).
   `sift-to-sql.js` translates sift filters to SQL WHERE clauses
@@ -111,10 +114,27 @@ brevity.
   the engine's logger. Each worker opens its own read-only sqlite
   handle on first task (`ensureWorkerDb` in render.js) so template
   helpers like `runtime.lookupHref` stay sync. Never touch the journal
-  directly.
-- `config.js` — loads `mikser.config.js` at `onLoad`.
-- `plugins.js` — loads user plugins at `onLoad`. Plugin factories
-  receive the full `core` exports as their first argument.
+  directly. Plugin loading: main-thread INLINE dispatch reads
+  `runtime.renderers` / `runtime.postprocessors` first (populated by
+  plugins.js from descriptor returns); workers see empty registries
+  in their separate-process runtime and fall through to dynamic-import
+  by `mikser-io-${name}` package name. Per-plugin options flow through
+  `descriptor.options` and arrive as the `config` arg to
+  `load`/`render`/`setup`/`postprocess`/`teardown`.
+- `config.js` — loads `mikser.config.js` at `onLoad` into
+  `runtime.config`. v9 holds only engine-level keys (`server`,
+  `logging`, `catalog` if tuned) plus the `plugins` array — all
+  plugin options moved to the factory call site (ADR-0010).
+- `plugins.js` — dispatches v9 plugin entries at `onLoad`. Each
+  entry in `plugins: []` is a factory call return; the dispatcher
+  duck-types on shape:
+  - function → lifecycle plugin; called with `core` so it can
+    register hooks.
+  - `{ name, options, load?, render? }` → renderer descriptor;
+    stored in `runtime.renderers`.
+  - `{ name, options, postprocess, output?, setup?, teardown? }` →
+    postprocessor descriptor; stored in `runtime.postprocessors`.
+  Strings produce a v9 migration error pointing at the new shape.
 - `manager.js` — file watching (chokidar) and cron scheduling.
 - `source.js` — `useSource` codifies the folder-of-files pattern.
 - `constants.js` — `OPERATION` (CREATE/UPDATE/DELETE/RENDER/
@@ -149,7 +169,10 @@ brevity.
   `import { queryEntities, subscribe, useRenderer, useCollection,
   readEntityContent, isTextEntity } from 'mikser-io'`.
 - **Plugin packages**: `mikser-io-<name>` (mikser-io-mcp, mikser-io-vector,
-  mikser-io-schemas, etc.).
+  mikser-io-schemas, etc.). Each exports a v9 named factory in
+  camelCase: `import { vector } from 'mikser-io-vector'`,
+  `import { renderHbs } from 'mikser-io'`. Consumer uses
+  `plugins: [vector({...})]` — never the bare string.
 - **MCP tools**: `mikser_<verb>` or `mikser_<subsystem>_<verb>`:
   `mikser_query_entities`, `mikser_read_entity`, `mikser_update_entity`,
   `mikser_delete_entity`, `mikser_render`, `mikser_refs_inbound`,
@@ -206,25 +229,39 @@ brevity.
   persistence pattern. Journal-on-sqlite (Phase 7) enables `--resume`;
   auto-persist (Phase 9) means plugins mutate the yielded entity and
   the journal writes back without an explicit `updateEntry` call.
+- **0010** — Plugin bundles + factory-call form + inline options.
+  Plugins are imported by name and called as factories;
+  `plugins: []` carries factory returns, never strings.
+  Lifecycle plugins are `(options) => (core) => void`; renderers
+  return `{name, options, load?, render?}`; postprocessors return
+  `{name, options, output?, setup?, postprocess, teardown?}`. Per-
+  plugin config moved entirely off `runtime.config.<plugin>`; it
+  arrives as factory args, gets stashed on the descriptor, and is
+  passed as `config` to `load`/`render`/`setup`/`postprocess`.
 
 ## MCP
 
-Lives in `mikser-io-mcp` plugin (separate repo). Activate by listing
-`'mcp'` **first** in your `mikser.config.js` plugins array:
+Lives in `mikser-io-mcp` plugin (separate repo). Activate by calling
+`mcp()` **first** in your `mikser.config.js` plugins array:
 
 ```js
+import { mcp } from 'mikser-io-mcp'
+
 export default {
-    plugins: ['mcp', /* ...other plugins */],
-    mcp: {
-        path: '/mcp',          // optional; default '/mcp'
-        // endpoints: { ... }  // optional; per-endpoint token + scope
-    },
+    plugins: [
+        mcp({
+            // path: '/mcp',          // default '/mcp'
+            // endpoints: { ... },    // per-endpoint token + scope
+        }),
+        /* ...other plugins */
+    ],
 }
 ```
 
 Must be first because its factory creates `runtime.options.mcp`
-synchronously, and other plugins gate their MCP tool registration on
-`if (runtime.options.mcp)` in their own `onLoaded`.
+synchronously when its closure runs, and other plugins gate their
+MCP tool registration on `if (runtime.options.mcp)` in their own
+`onLoaded`.
 
 There is **no `--mcp` CLI flag**. Activation is plugin-presence only.
 
@@ -276,9 +313,13 @@ There is **no `--mcp` CLI flag**. Activation is plugin-presence only.
 
 - **New engine capability?** Run through ADR-0006's five tests. Bar
   is high. Express is the only earned addition.
-- **New plugin?** Own repo, named `mikser-io-<name>`. Composes
-  against `runtime.options.app` / `runtime.options.mcp` / lifecycle
-  hooks. Never imports another plugin's source.
+- **New plugin?** Own repo, named `mikser-io-<name>`. Exports a
+  named v9 factory (e.g. `export function vector(options = {}) {
+  return (core) => { ... } }`). Composes against
+  `runtime.options.app` / `runtime.options.mcp` / lifecycle hooks.
+  Never imports another plugin's source — and the engine never
+  reads `runtime.config.<plugin>` for plugin options; everything
+  flows through the factory arg (ADR-0010).
 - **New MCP tool?** Add to `mikser-io-mcp/index.js` via
   `mcp.simpleTool(name, description, zodSchema, handler)`. Tool name
   follows `mikser_*` convention.

package/README.md

@@ -92,9 +92,11 @@ Plugins extend the tool surface the same way they mount HTTP routes; install the
 
 ```js
 // mikser.config.js
+import { mcp } from 'mikser-io-mcp'
+
 export default {
-    plugins: ['mcp', /* … */],
-    // optional: mcp: { path: '/mcp', endpoints: { … } }
+    plugins: [mcp(), /* … */],
+    // mcp({ path: '/mcp', endpoints: { … } }) when options are needed
 }
 ```
 

package/index.js

@@ -15,4 +15,35 @@ export * from './src/manager.js'
 export * from './src/logger.js'
 export * from './src/engine.js'
 export * from './src/render.js'
-export * from './src/source.js'
+export * from './src/source.js'
+
+// Built-in plugin factories. Each takes options and returns the
+// (core) => void closure the engine calls at onLoad time. See ADR-0010
+// for the v9 plugin shape.
+export { api }           from './src/plugins/api.js'
+export { assets }        from './src/plugins/assets.js'
+export { commands }      from './src/plugins/commands.js'
+export { data }          from './src/plugins/data.js'
+export { documents }     from './src/plugins/documents.js'
+export { files }         from './src/plugins/files.js'
+export { frontMatter }   from './src/plugins/front-matter.js'
+export { json }          from './src/plugins/json.js'
+export { layouts }       from './src/plugins/layouts.js'
+export { mapper }        from './src/plugins/mapper.js'
+export { observer }      from './src/plugins/observer.js'
+export { preview }       from './src/plugins/preview.js'
+export { resources }     from './src/plugins/resources.js'
+export { shares }        from './src/plugins/shares.js'
+export { validator }     from './src/plugins/validator.js'
+export { yaml }          from './src/plugins/yaml.js'
+
+// Built-in renderers. v9 factory shape returns the descriptor that the
+// loader stores in `runtime.renderers`; the same module also still
+// exports `load`/`render` at the top level so Piscina worker dispatch
+// can resolve via dynamic import. ADR-0010.
+export { renderAsset }    from './src/plugins/render/asset.js'
+export { renderFile }     from './src/plugins/render/file.js'
+export { renderHbs }      from './src/plugins/render/hbs.js'
+export { renderHref }     from './src/plugins/render/href.js'
+export { renderPreset }   from './src/plugins/render/preset.js'
+export { renderResource } from './src/plugins/render/resource.js'

package/package.json

@@ -1,8 +1,13 @@
 {
 	"name": "mikser-io",
-	"version": "8.3.9",
+	"version": "9.0.0",
 	"description": "<p align=\"center\">   <img src=\"mikser-lockup-stacked.svg\" alt=\"mikser\" width=\"198\" /> </p>",
 	"main": "index.js",
+	"exports": {
+		".":            "./index.js",
+		"./package.json": "./package.json",
+		"./*":          "./*"
+	},
 	"scripts": {
 		"debug": "node --no-warnings app.js --server --watch --working-folder test/fixture",
 		"test:unit": "node --test --test-reporter=spec 'test/unit/**/*.test.js'",

package/src/config.js

@@ -4,34 +4,25 @@ import { onLoad } from './lifecycle.js'
 import path from 'node:path'
 
 onLoad(async () => {
-	const logger = useLogger()
-	const configFile = path.resolve(runtime.options.config)
-	logger.info('Config: %s', configFile)
-	try {
-		const config = await import(configFile)
-		if (typeof config.default == 'function') {
-			runtime.config = await config.default(runtime)
-		} else if (typeof config.default == 'object') {
-			runtime.config = config.default
-		}
-	} catch (err) {
-		if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
-	}
+    const logger = useLogger()
+    const configFile = path.resolve(runtime.options.config)
+    logger.info('Config: %s', configFile)
+    try {
+        const config = await import(configFile)
+        if (typeof config.default == 'function') {
+            runtime.config = await config.default(runtime)
+        } else if (typeof config.default == 'object') {
+            runtime.config = config.default
+        }
+    } catch (err) {
+        if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
+    }
 
-	const plugins = runtime.options.plugins.concat(runtime.config.plugins).filter((plugin) => plugin)
-	for (const plugin of plugins) {
-		if (!runtime.config[plugin]) {
-			try {
-				const pluginConfig = path.join(runtime.options.workingFolder, 'config', `${plugin}.config.js`)
-				const config = await import(pluginConfig)
-				if (typeof config.default == 'function') {
-					runtime.config[plugin] = await config.default(runtime)
-				} else if (typeof config.default == 'object') {
-					runtime.config[plugin] = config.default
-				}
-			} catch (err) {
-				if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
-			}
-		}
-	}
+    // v8 used to walk `runtime.config.plugins` looking for matching
+    // `config/<plugin>.config.js` files to merge into `runtime.config`,
+    // because plugin entries were strings (names). v9 entries are factory
+    // call results (closures or descriptors), and plugin options arrive
+    // as factory args — see ADR-0010 — so per-plugin auxiliary config
+    // files have nothing to bind to. The loader was removed when the
+    // plugins list stopped carrying names.
 })

package/src/engine.js

@@ -38,6 +38,24 @@ import { queryContext } from './database/query-context.js'
 function workerSafeOptions(opts) {
     const result = {}
     for (const [k, v] of Object.entries(opts)) {
+        // `plugins` is a mixed array of factory-return values — functions
+        // (lifecycle plugins; workers don't need them) and descriptor
+        // objects (renderers / postprocessors) carrying closures that
+        // can't survive structuredClone. Project descriptors to their
+        // `render-${name}` / `post-${name}` identifiers so the worker
+        // can resolve them via dynamic import.
+        if (k === 'plugins' && Array.isArray(v)) {
+            result[k] = v
+                .map(p => {
+                    if (p && typeof p === 'object' && typeof p.name === 'string'
+                        && (typeof p.load === 'function' || typeof p.render === 'function'))   return `render-${p.name}`
+                    if (p && typeof p === 'object' && typeof p.name === 'string'
+                        && typeof p.postprocess === 'function')                                return `post-${p.name}`
+                    return null
+                })
+                .filter(Boolean)
+            continue
+        }
         try {
             structuredClone(v)
             result[k] = v
@@ -89,7 +107,6 @@ export async function setup(options) {
     onInitialize(async () => {
         runtime.engine.commander?.version(packageInfo.version)
             .option('-i --working-folder <folder>', 'set mikser working folder', './')
-            .option('-p --plugins [plugins...]', 'list of mikser plugins to load', [])
             .option('-c --config <file>', 'set mikser mikser.config.js location', './mikser.config.js')
             .option('-m --mode <mode>', 'set mikser runtime mode', 'development')
             .option('-r --clear', 'clear current state before execution', false)
@@ -203,16 +220,6 @@ export async function setup(options) {
     onRender(async (signal) => {
         const logger = useLogger()
         const renderJobs = new Set()
-        // Computed once per cycle — runtime.config doesn't mutate
-        // mid-cycle, so every render gets the same filtered slice.
-        // Native key iteration + String#startsWith; was a per-render
-        // `_.pickBy(runtime.config, (v,k) => _.startsWith(k,'render-'))`
-        // which charged ~20 predicate calls + 1 object allocation per
-        // entry. Symmetric with onPostprocess's `config` below.
-        const renderConfig = {}
-        for (const key in runtime.config) {
-            if (key.startsWith('render-')) renderConfig[key] = runtime.config[key]
-        }
 
         // Collect this cycle's mutated entity ids/hrefs/entities so the
         // manifest skip check can re-render anything whose dependencies
@@ -326,7 +333,11 @@ export async function setup(options) {
                         ...runtime.options,
                         ...options,
                     },
-                    config: renderConfig,
+                    // Per-renderer options live on each renderer
+                    // descriptor (.options) and are picked up inside
+                    // render.js at dispatch time — no top-level config
+                    // channel anymore (ADR-0010).
+                    config: {},
                     context,
                     state: runtime.state,
                     track,
@@ -470,25 +481,13 @@ export async function setup(options) {
         for await (const { entity, options, context, output } of useJournal('Queuing postprocess', [OPERATION.RENDER], signal)) {
             if (output?.success && options.postprocessor) {
                 const ext = await resolveOutputExt(options.postprocessor)
-                let destination = changeExtension(entity.destination, ext)
-
-                // cleanUrls renders a non-index page `foo` to
-                // `foo/index.html` so the served URL is `/foo/`. A
-                // postprocessor that emits a *different* file type (e.g.
-                // PDF) shouldn't inherit that clean-URL folder — a
-                // downloadable artifact wants to be `foo.pdf`, not
-                // `foo/index.pdf`. Collapse the `/index` segment when the
-                // produced extension differs from the rendered page's.
-                // Genuine index documents (name ends in `index`) keep
-                // their path.
-                const originExt = path.extname(entity.destination).slice(1)
-                const isCleanUrlPage =
-                    runtime.config.layouts?.cleanUrls &&
-                    !_.endsWith(entity.name, 'index') &&
-                    path.basename(entity.destination, path.extname(entity.destination)) === 'index'
-                if (ext !== originExt && isCleanUrlPage) {
-                    destination = `${path.dirname(entity.destination)}.${ext}`
-                }
+                // Engine swaps the extension on whatever destination the
+                // entity carries. Routing semantics (cleanUrls folder
+                // structure, alternate placements, etc.) are whoever-set-
+                // entity.destination's responsibility — typically the
+                // layouts plugin during layout-match. The postprocess
+                // subsystem has no opinion about routing.
+                const destination = changeExtension(entity.destination, ext)
 
                 tasks.push({
                     entity: {
@@ -521,14 +520,23 @@ export async function setup(options) {
 
     onPostprocess(async (signal) => {
         const logger = useLogger()
-        const config = _.pickBy(runtime.config, (value, key) => _.startsWith(key, 'post-'))
 
+        // Collect every postprocessor descriptor in the plugins list
+        // and project to the `post-${name}` identifier the loader uses.
+        // Per-postprocessor options now live on each descriptor (.options)
+        // — no top-level `config['post-*']` channel anymore (ADR-0010).
+        const postPluginNames = []
+        for (const entry of runtime.options.plugins) {
+            if (entry && typeof entry === 'object' && typeof entry.postprocess === 'function' && typeof entry.name === 'string') {
+                postPluginNames.push(`post-${entry.name}`)
+            }
+        }
         const postPlugins = {}
-        for (const pluginName of runtime.options.plugins.filter(p => p.startsWith('post-'))) {
+        for (const pluginName of postPluginNames) {
             const plugin = await loadPostPlugin(pluginName, runtime.options.workingFolder)
             if (plugin) {
                 postPlugins[pluginName] = plugin
-                if (plugin.setup) await plugin.setup({ options: runtime.options, config: config[pluginName], state: runtime.state, logger })
+                if (plugin.setup) await plugin.setup({ options: runtime.options, config: plugin.options, state: runtime.state, logger })
             }
         }
 
@@ -546,7 +554,11 @@ export async function setup(options) {
                             ...runtime.options,
                             ...options,
                         },
-                        config,
+                        // Per-postprocessor options live on the descriptor
+                        // and are read inside postprocess.js at dispatch
+                        // time; the empty object here keeps the worker
+                        // arg shape stable.
+                        config: {},
                         context,
                         state: runtime.state
                     }
@@ -632,7 +644,7 @@ export async function setup(options) {
             postprocessJobs.size && logger.info('Postprocessed: %d', postprocessJobs.size)
         } finally {
             for (const [pluginName, plugin] of Object.entries(postPlugins)) {
-                if (plugin.teardown) await plugin.teardown({ options: runtime.options, config: config[pluginName], state: runtime.state, logger })
+                if (plugin.teardown) await plugin.teardown({ options: runtime.options, config: plugin.options, state: runtime.state, logger })
             }
         }
     })

package/src/plugins/api.js

@@ -312,18 +312,19 @@ function sseSend(res, eventName, payload) {
     } catch { /* connection dropped — cleanup runs via 'close' */ }
 }
 
-export default ({
-    runtime,
-    onLoaded,
-    onFinalize,
-    useLogger,
-    useJournal,
-    constants: { OPERATION },
-}) => {
+export function api(options = {}) {
+    return ({
+        runtime,
+        onLoaded,
+        onFinalize,
+        useLogger,
+        useJournal,
+        constants: { OPERATION },
+    }) => {
     // Shared between onLoaded (populates) and onFinalize (consumes).
     // Hoisted so the lifecycle hooks see the same registry; the body
     // inside onLoaded is what actually fills it in based on
-    // runtime.config.api.endpoints.
+    // `options.endpoints`.
     let apiBase = '/api'
     const cachedEndpoints = []
 
@@ -343,9 +344,9 @@ export default ({
             )
         }
 
-        const endpoints = runtime.config.api?.endpoints
+        const endpoints = options.endpoints
         if (!endpoints || !Object.keys(endpoints).length) {
-            logger.warn('Api plugin loaded but no endpoints configured (api.endpoints) — nothing to mount')
+            logger.warn('Api plugin loaded but no endpoints configured (pass { endpoints: {...} } to api()) — nothing to mount')
             return
         }
 
@@ -353,10 +354,10 @@ export default ({
             throw new Error('Express is required for the api plugin — run: npm install express')
         })
 
-        apiBase = runtime.config.api?.base ?? '/api'
+        apiBase = options.base ?? '/api'
         const base = apiBase   // alias so existing local references still work
-        const globalPageSize = runtime.config.api?.pageSize ?? 10
-        const globalRenderTimeout = runtime.config.api?.renderTimeout ?? 30_000
+        const globalPageSize = options.pageSize ?? 10
+        const globalRenderTimeout = options.renderTimeout ?? 30_000
 
         // Preview workflow (render → cache → URL) lives in its own
         // plugin (src/plugins/preview.js) as of v7.3.0. The api plugin
@@ -916,4 +917,5 @@ export default ({
             }
         }
     })
+    }
 }

package/src/plugins/assets.js

@@ -6,7 +6,7 @@ import { globby } from 'globby'
 import _ from 'lodash'
 import map from 'p-map'
 
-// Normalize a `runtime.config.assets.presets[name]` value to a consistent
+// Normalize a `options.presets[name]` value to a consistent
 // { matches, options } shape so callers don't have to inspect which form
 // the config used.
 //
@@ -48,35 +48,36 @@ export function normalizePresetConfig(value) {
     return { matches: [value], options: {} }
 }
 
-export default ({
-    runtime,
-    onLoaded,
-    useLogger,
-    onImport,
-    watch,
-    onProcessed,
-    onBeforeRender,
-    useJournal,
-    createEntity,
-    updateEntity,
-    deleteEntity,
-    renderEntities,
-    onComplete,
-    onSync,
-    onFinalize,
-    findEntity,
-    matchEntity,
-    changeExtension,
-    constants: { ACTION, OPERATION },
-}) => {
+export function assets(options = {}) {
+    return ({
+        runtime,
+        onLoaded,
+        useLogger,
+        onImport,
+        watch,
+        onProcessed,
+        onBeforeRender,
+        useJournal,
+        createEntity,
+        updateEntity,
+        deleteEntity,
+        renderEntities,
+        onComplete,
+        onSync,
+        onFinalize,
+        findEntity,
+        matchEntity,
+        changeExtension,
+        constants: { ACTION, OPERATION },
+    }) => {
     const collection = 'presets'
     const type = 'preset'
     const checksumMap = new Set()
 
     async function getEntityPresets(entity) {
         const entityPresets = []
-        for (let preset in (runtime.config.assets?.presets || {})) {
-            const { matches } = normalizePresetConfig(runtime.config.assets.presets[preset])
+        for (let preset in (options.presets || {})) {
+            const { matches } = normalizePresetConfig(options.presets[preset])
             for (let match of matches) {
                 if (matchEntity(entity, match)) {
                     entityPresets.push(preset)
@@ -178,7 +179,7 @@ export default ({
                 // picked up on the next cycle without rebuilding the
                 // preset entity from its module.
                 const { options: configOptions } = normalizePresetConfig(
-                    runtime.config.assets?.presets?.[entityPreset]
+                    options.presets?.[entityPreset]
                 )
                 let destination = entity.name
                 if (entity.preset.format) {
@@ -204,27 +205,27 @@ export default ({
     onLoaded(async () => {
         const logger = useLogger()
 
-        const assetsName = runtime.config.assets?.assetsFolder || 'assets'
+        const assetsName = options.assetsFolder || 'assets'
         runtime.state.assets = {
             presets: {},
             assetsMap: {},
-            assetsFolder: runtime.config.assets?.outputFolder
-                ? path.join(runtime.config.assets.outputFolder, assetsName)
+            assetsFolder: options.outputFolder
+                ? path.join(options.outputFolder, assetsName)
                 : assetsName,
         }
 
-        runtime.options.presets = runtime.config.presets?.presetsFolder || collection
+        runtime.options.presets = options.presetsFolder || collection
         runtime.options.presetsFolder = path.join(runtime.options.workingFolder, runtime.options.presets)
         logger.debug('Presets folder: %s', runtime.options.presetsFolder)
         await mkdir(runtime.options.presetsFolder, { recursive: true })
 
-        runtime.options.assets = runtime.config.assets?.assetsFolder || 'assets'
+        runtime.options.assets = options.assetsFolder || 'assets'
         runtime.options.assetsFolder = path.join(runtime.options.workingFolder, runtime.options.assets)
         logger.debug('Assets folder: %s', runtime.options.assetsFolder)
         await mkdir(runtime.options.assetsFolder, { recursive: true })
 
         let link = path.join(runtime.options.outputFolder, runtime.options.assets)
-        if (runtime.config.assets?.outputFolder) link = path.join(runtime.options.outputFolder, runtime.config.assets?.outputFolder, runtime.options.assets)
+        if (options.outputFolder) link = path.join(runtime.options.outputFolder, options.outputFolder, runtime.options.assets)
         try {
             await mkdir(path.dirname(link), { recursive: true })
             await symlink(path.resolve(runtime.options.assetsFolder), link, 'dir')
@@ -317,7 +318,7 @@ export default ({
         // `mikser-io-preset-<name>`. Config is the source of truth for
         // which presets a project uses; this fills the names a folder
         // scan can't (the code lives in node_modules, not presets/).
-        for (const name of Object.keys(runtime.config.assets?.presets || {})) {
+        for (const name of Object.keys(options.presets || {})) {
             if (presets[name]) continue   // a local file already loaded it
             const resolved = resolvePreset(name)
             if (!resolved) {
@@ -430,8 +431,9 @@ export default ({
         }
     })
 
-    return {
-        collection,
-        type
+        return {
+            collection,
+            type,
+        }
     }
 }