@vmz/vmz 0.3.6 → 0.3.8

package/dist/dev/dev-session.js

@@ -14,13 +14,20 @@ import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { buildIntegratedDocuments, projectHasDocuments } from '../document/document-integrate.js';
 import { createWorkspace, resolveNativePath } from '../workspace/public-api.js';
+import { materializeWechatPackaging } from '../workspace/wechat-packaging.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from '../locale/locale-check.js';
 import { log } from '../workspace/log.js';
-import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets, collectDevConfigPaths, configFingerprintMap, } from './dev-watch-roots.js';
+import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets, collectConfigDependencies, configCandidatePaths, configFingerprintMap, } from './dev-watch-roots.js';
+import { createConfigCycle } from './config-cycle.js';
 import { buildReloadPayload, filterGenerationIgnore, parseHmrPlan, registerWrittenOutputsIgnore, shouldSoftReload, staticRevisionFromArtifact, } from './dev-incremental.js';
 import { diffFingerprints, fileFingerprintMap } from '../workspace/watch-diff.js';
 /** Track serve-host so a failed/killed launcher cannot leave an orphan port. */
 const DEV_HOST_PID = '.vmz-dev-host.pid';
+function cycleFailure(report) {
+    const detail = report.error?.args?.detail ?? 'config build process failed';
+    const error = new Error(detail);
+    return report.error ? Object.assign(error, { diagnostic: report.error }) : error;
+}
 export function createDevSession(options) {
     const project = options.project;
     const outDir = options.outDir;
@@ -28,9 +35,13 @@ export function createDevSession(options) {
     const port = options.port ?? 5173;
     const pollMs = Math.max(50, options.pollMs ?? 300);
     const wechatPreview = options.target === 'mini-program-wechat';
+    let delivery = options.delivery ?? null;
     const createWs = options.createWorkspaceFn ?? createWorkspace;
     const spawnHost = options.spawnHostFn ?? defaultSpawnHost;
     const softReload = options.softReloadFn ?? defaultSoftReload;
+    const makeConfigCycle = options.configCycleFn ?? createConfigCycle;
+    const configCandidates = configCandidatePaths(project);
+    let configCycle = null;
     const ws = createWs({ root: project, outDir });
     let child = null;
     let stopped = false;
@@ -119,6 +130,8 @@ export function createDevSession(options) {
         }
         let report;
         try {
+            // Same prepared snapshot for this build cycle; native pack never reads config.
+            materializeWechatPackaging(project, delivery);
             const raw = ws.lowerMiniprogramWechatPackaging();
             report = typeof raw === 'string' ? JSON.parse(raw) : raw;
         }
@@ -191,15 +204,15 @@ export function createDevSession(options) {
         if (!existsSync(src)) {
             throw new Error(`vmz dev: missing src/ under ${project}`);
         }
-        // Same as `vmz build`: materialize plugin sources (e.g. `<Shiki>`) before compile.
-        // Soft rebuilds reuse the workspace; config/plugin changes still need a process restart
-        // until `vmz.config.*` is watched.
-        {
-            const { loadVmzConfig, applyPlugins } = await import('../workspace/plugin-host.js');
-            const { plugins, engines } = await loadVmzConfig(project);
-            if (plugins.length) {
-                await applyPlugins(ws, plugins, { project, outDir, engines });
-            }
+        // Config evaluation + plugin contributions run in a detached build process.
+        // Functions/plugin objects never cross the boundary; only the data report does.
+        if (configCandidates.some((p) => existsSync(p))) {
+            configCycle = makeConfigCycle({ project, outDir, ...(options.configCycleWorkerPath ? { workerPath: options.configCycleWorkerPath } : {}) });
+            const report = await configCycle.start();
+            if (!report.ok)
+                throw cycleFailure(report);
+            delivery = report.delivery ?? delivery;
+            log.info(`config build process ready${report.plugins.length ? ` (${report.plugins.map((p) => p.name).join(', ')})` : ''}`);
         }
         log.info('initial build (N-API workspace, full)…');
         const initialPair = planAndRebuild();
@@ -238,7 +251,14 @@ export function createDevSession(options) {
         const designsRoot = path.join(project, 'designs');
         const watched = collectDevWatchRoots({ project, outDir });
         const publicRoot = watched.publicRoot;
-        const configPaths = watched.configPaths.length ? watched.configPaths : collectDevConfigPaths(project);
+        /** Candidate config files plus their local reachable deps; refreshed after each cycle. */
+        const refreshConfigPaths = () => {
+            const deps = configCandidates
+                .filter((p) => existsSync(p))
+                .flatMap((p) => collectConfigDependencies(p, project));
+            return [...new Set([...configCandidates, ...deps])];
+        };
+        let configPaths = refreshConfigPaths();
         /** @type {string[]} */
         const watchRoots = [...watched.roots];
         /** @type {string[]} */
@@ -359,14 +379,66 @@ export function createDevSession(options) {
                     continue;
                 }
                 if (batch.configDirty) {
-                    log.info('vmz.config change detected — respawn required (devControl)');
-                    configFingerprints = configFingerprintMap(configPaths);
-                    commitFingerprints();
-                    await respawnHost('config-changed');
+                    log.info('vmz.config change detected — restarting the config build process…');
+                    let cycleReport = null;
+                    if (configCandidates.some((p) => existsSync(p))) {
+                        let failure = null;
+                        try {
+                            if (!configCycle) {
+                                configCycle = makeConfigCycle({
+                                    project,
+                                    outDir,
+                                    ...(options.configCycleWorkerPath ? { workerPath: options.configCycleWorkerPath } : {}),
+                                });
+                                cycleReport = await configCycle.start();
+                            }
+                            else {
+                                // Old process is cancelled and awaited before the new one writes artifacts.
+                                cycleReport = await configCycle.restart();
+                            }
+                        }
+                        catch (err) {
+                            failure = err instanceof Error ? err : new Error(String(err));
+                        }
+                        configPaths = refreshConfigPaths();
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        if (failure) {
+                            log.warn(`config build process restart failed: ${failure.message}`);
+                            continue;
+                        }
+                        if (cycleReport && !cycleReport.ok) {
+                            if (cycleReport.error)
+                                log.diagnostic(cycleReport.error);
+                            else
+                                log.error('config build process failed');
+                            continue;
+                        }
+                        if (cycleReport)
+                            delivery = cycleReport.delivery ?? delivery;
+                    }
+                    else if (configCycle) {
+                        await configCycle.cancel();
+                        configCycle = null;
+                        configPaths = refreshConfigPaths();
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        log.warn('vmz.config removed — config build process stopped, last artifacts kept');
+                        continue;
+                    }
+                    else {
+                        configFingerprints = configFingerprintMap(configPaths);
+                        commitFingerprints();
+                        continue;
+                    }
                     const report = rebuild();
                     if (printReport(report, 'rebuild')) {
                         lastOutputRevision = report.outputRevision ?? report.output_revision ?? null;
                         await emitPublicAndTrack();
+                        if (wechatPreview)
+                            packWechatPreview();
+                        else
+                            await respawnHost('config-changed');
                     }
                     continue;
                 }
@@ -605,6 +677,8 @@ export function createDevSession(options) {
         stopped = true;
         killChild(child);
         child = null;
+        await configCycle?.cancel().catch(() => { });
+        configCycle = null;
         clearDevHostPid(outDir, null);
         try {
             ws.dispose();

package/dist/dev/dev-watch-roots.d.ts

@@ -7,8 +7,15 @@
  */
 /** Author-facing vs generated dev input bucket. */
 export type DevInputKind = 'author' | 'dependency' | 'public' | 'devControl' | 'locales' | 'docs' | 'designs' | 'other';
+/** All supported `vmz.config.*` candidate paths, existing or not (so creation is detected). */
+export declare function configCandidatePaths(project: string): string[];
 /** `vmz.config.*` at project root (devControl). */
 export declare function collectDevConfigPaths(project: string): string[];
+/**
+ * Reachable local ESM dependencies of a config file (bounded, project-root only).
+ * These changes restart the dev config build process.
+ */
+export declare function collectConfigDependencies(configPath: string, project: string): string[];
 /** Fingerprint map for explicit config files (not directory walks). */
 export declare function configFingerprintMap(configPaths: string[]): Map<string, string>;
 export interface DirtySet {

package/dist/dev/dev-watch-roots.js

@@ -8,11 +8,74 @@
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { diffFingerprints, fileFingerprintMap } from '../workspace/watch-diff.js';
-const CONFIG_BASENAMES = ['vmz.config.ts', 'vmz.config.js', 'vmz.config.mjs', 'vmz.config.cjs'];
+const CONFIG_BASENAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.js', 'vmz.config.mjs', 'vmz.config.cjs'];
+const LOCAL_MODULE_EXTENSIONS = ['.ts', '.mts', '.js', '.mjs', '.cts', '.cjs'];
+/** All supported `vmz.config.*` candidate paths, existing or not (so creation is detected). */
+export function configCandidatePaths(project) {
+    const root = path.resolve(project);
+    return CONFIG_BASENAMES.map((name) => path.join(root, name));
+}
 /** `vmz.config.*` at project root (devControl). */
 export function collectDevConfigPaths(project) {
+    return configCandidatePaths(project).filter((p) => existsSync(p));
+}
+/**
+ * Reachable local ESM dependencies of a config file (bounded, project-root only).
+ * These changes restart the dev config build process.
+ */
+export function collectConfigDependencies(configPath, project) {
     const root = path.resolve(project);
-    return CONFIG_BASENAMES.map((name) => path.join(root, name)).filter((p) => existsSync(p));
+    const underRoot = (file) => file === root || file.startsWith(root + path.sep);
+    const seen = new Set();
+    const out = [];
+    const visit = (file, depth) => {
+        if (depth > 24 || seen.size > 200 || !existsSync(file) || !underRoot(file))
+            return;
+        if (seen.has(file))
+            return;
+        seen.add(file);
+        let text;
+        try {
+            text = readFileSync(file, 'utf8');
+        }
+        catch {
+            return;
+        }
+        const specs = new Set();
+        for (const match of text.matchAll(/\b(?:import|export)\s+(?:[^'";]*?\s+from\s+)?['"]([^'"]+)['"]/g)) {
+            if (match[1])
+                specs.add(match[1]);
+        }
+        for (const match of text.matchAll(/\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g)) {
+            if (match[1])
+                specs.add(match[1]);
+        }
+        for (const spec of specs) {
+            if (!spec.startsWith('.'))
+                continue;
+            const base = path.resolve(path.dirname(file), spec);
+            const candidates = [
+                base,
+                ...LOCAL_MODULE_EXTENSIONS.map((ext) => base + ext),
+                ...LOCAL_MODULE_EXTENSIONS.map((ext) => path.join(base, `index${ext}`)),
+            ];
+            for (const candidate of candidates) {
+                try {
+                    if (existsSync(candidate) && statSync(candidate).isFile()) {
+                        if (!seen.has(candidate))
+                            out.push(candidate);
+                        visit(candidate, depth + 1);
+                        break;
+                    }
+                }
+                catch {
+                    /* keep looking */
+                }
+            }
+        }
+    };
+    visit(path.resolve(configPath), 0);
+    return out;
 }
 /** Fingerprint map for explicit config files (not directory walks). */
 export function configFingerprintMap(configPaths) {

package/dist/document/document-build.js

@@ -66,7 +66,7 @@ export async function buildDocuments(opts) {
         assertIntegratedDistReady(appDistDir);
     }
     fs.mkdirSync(outDir, { recursive: true });
-    const designs = resolveDocumentDesignsCss(projectRoot);
+    const designs = resolveDocumentDesignsCss(projectRoot, appDistDir);
     let designsHref = null;
     if (designs.css && designs.href) {
         const cssPath = path.join(outDir, designs.href);
@@ -195,20 +195,20 @@ function buildDocumentSlotHtml({ nav, bodyHtml, headings, htmlRel, route, routin
             .map((h) => `      <li class="h${h.level}"><a href="#${esc(h.id)}">${esc(h.text)}</a></li>`)
             .join('\n')}\n    </ol>\n  </nav>\n`
         : '';
-    const docsNav = `  <nav aria-label="Documents" class="doc-subnav">
-    <ul>
-${navItems}
-    </ul>
+    const docsNav = `  <nav aria-label="Documents" class="doc-subnav">
+    <ul>
+${navItems}
+    </ul>
   </nav>`;
-    return `    <aside class="doc-sidebar">
-${docsNav}
-${searchShellHtml}
-    </aside>
-    <div class="doc-content">
-  ${toc}<main id="main">
-${bodyHtml}
-${playgroundShellHtml}
-  </main>
+    return `    <aside class="doc-sidebar">
+${docsNav}
+${searchShellHtml}
+    </aside>
+    <div class="doc-content">
+  ${toc}<main id="main">
+${bodyHtml}
+${playgroundShellHtml}
+  </main>
     </div>`;
 }
 /**
@@ -242,17 +242,17 @@ function renderStaticHtml({ title, locale, route, nav, bodyHtml, headings, desig
                 .map((h) => `      <li class="h${h.level}"><a href="#${esc(h.id)}">${esc(h.text)}</a></li>`)
                 .join('\n')}\n    </ol>\n  </nav>\n`
             : '';
-        bodyInner = `  <a class="skip-link" href="#main">Skip to content</a>
-  <nav aria-label="Documents" class="doc-subnav">
-    <ul>
-${navItems}
-    </ul>
-  </nav>
-${searchShellHtml}
-  ${toc}<main id="main">
-${bodyHtml}
-${playgroundShellHtml}
-  </main>
+        bodyInner = `  <a class="skip-link" href="#main">Skip to content</a>
+  <nav aria-label="Documents" class="doc-subnav">
+    <ul>
+${navItems}
+    </ul>
+  </nav>
+${searchShellHtml}
+  ${toc}<main id="main">
+${bodyHtml}
+${playgroundShellHtml}
+  </main>
 `;
     }
     const native = requireNativeAddon();

package/dist/document/document-designs.d.ts

@@ -3,4 +3,4 @@ export interface DocumentDesignsCssResult {
     source: string | null;
     href: string | null;
 }
-export declare function resolveDocumentDesignsCss(projectRoot: string): DocumentDesignsCssResult;
+export declare function resolveDocumentDesignsCss(projectRoot: string, appDistDir?: string | null): DocumentDesignsCssResult;

package/dist/document/document-designs.js

@@ -1,18 +1,25 @@
 /**
- * Document — wire project `/designs` into static document assets.
- * Prefer compiled `vmz-designs.css` / `vmz.css`; else emit a minimal token CSS.
+ * Document — wire project `/designs` and the compiled app stylesheet into
+ * static document assets.
+ *
+ * Layout chrome comes from `designs/document/chrome.css`. Theme tokens are not
+ * re-derived here: they come from the app build output (`vmz-designs.css` /
+ * `vmz.css` under `appDistDir`), which is the single compiled artifact.
  */
 import fs from 'node:fs';
 import path from 'node:path';
-export function resolveDocumentDesignsCss(projectRoot) {
+export function resolveDocumentDesignsCss(projectRoot, appDistDir) {
     const designsDir = path.join(projectRoot, 'designs');
     if (!fs.existsSync(designsDir) || !fs.statSync(designsDir).isDirectory()) {
         return { css: '', source: null, href: null };
     }
     const parts = [];
     const sources = [];
-    // Layout first so @import (fonts) stays at stylesheet top; theme tokens follow.
-    const layoutCandidates = [path.join(designsDir, 'document', 'chrome.css'), path.join(designsDir, 'styles', 'document.css')];
+    // Layout first so @import stays at stylesheet top; compiled tokens follow.
+    const layoutCandidates = [
+        path.join(designsDir, 'document', 'chrome.css'),
+        path.join(designsDir, 'styles', 'document.css'),
+    ];
     for (const p of layoutCandidates) {
         if (!fs.existsSync(p))
             continue;
@@ -20,122 +27,27 @@ export function resolveDocumentDesignsCss(projectRoot) {
         sources.push(path.relative(projectRoot, p).replace(/\\/g, '/'));
         break;
     }
-    const distCandidates = [path.join(projectRoot, 'dist', 'vmz-designs.css'), path.join(projectRoot, 'dist', 'vmz.css')];
-    for (const p of distCandidates) {
-        if (fs.existsSync(p)) {
-            parts.push(fs.readFileSync(p, 'utf8'));
-            sources.push(path.relative(projectRoot, p).replace(/\\/g, '/'));
-            break;
+    if (appDistDir) {
+        const compiled = [path.join(appDistDir, 'vmz-designs.css'), path.join(appDistDir, 'vmz.css')].find((p) => fs.existsSync(p));
+        if (!compiled) {
+            throw new Error(`vmz.document: app dist ${appDistDir} is missing vmz-designs.css / vmz.css; build the app before the documents`);
         }
-    }
-    if (parts.length) {
-        return {
-            css: parts.join('\n\n'),
-            source: sources.join('+'),
-            href: 'assets/vmz-designs.css',
-        };
-    }
-    const styleCandidates = [path.join(designsDir, 'styles', 'index.css')];
-    for (const p of styleCandidates) {
-        if (fs.existsSync(p)) {
-            return {
-                css: fs.readFileSync(p, 'utf8'),
-                source: path.relative(projectRoot, p).replace(/\\/g, '/'),
-                href: 'assets/vmz-designs.css',
-            };
+        parts.push(fs.readFileSync(compiled, 'utf8'));
+        sources.push(path.relative(projectRoot, compiled).replace(/\\/g, '/'));
+    }
+    else {
+        const entry = path.join(designsDir, 'styles', 'index.css');
+        if (fs.existsSync(entry)) {
+            parts.push(fs.readFileSync(entry, 'utf8'));
+            sources.push(path.relative(projectRoot, entry).replace(/\\/g, '/'));
         }
     }
-    const emitted = emitMinimalDesignsCss(designsDir);
-    if (emitted) {
-        return { css: emitted, source: 'designs/', href: 'assets/vmz-designs.css' };
-    }
-    return { css: '', source: 'designs/', href: null };
-}
-function emitMinimalDesignsCss(designsDir) {
-    const vars = {};
-    const tokenDir = path.join(designsDir, 'tokens');
-    if (fs.existsSync(tokenDir)) {
-        walkJson(tokenDir, (obj, prefix) => {
-            collectStyleThemeEntries(obj, vars);
-            flattenTokens(obj, prefix, vars);
-        });
-    }
-    const themeJson = path.join(designsDir, 'theme.json');
-    if (fs.existsSync(themeJson)) {
-        try {
-            const theme = JSON.parse(fs.readFileSync(themeJson, 'utf8'));
-            collectStyleThemeEntries(theme, vars);
-            flattenTokens(theme, '', vars);
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    const keys = Object.keys(vars).sort();
-    if (!keys.length) {
-        // Presence of /designs still warrants a readable baseline sheet.
-        return `/* vmz.document designs baseline */\n:root { color-scheme: light; }\nbody { font-family: system-ui, sans-serif; line-height: 1.5; margin: 0; }\nmain { max-width: 48rem; margin: 0 auto; padding: 1.5rem; }\nnav { padding: 1rem 1.5rem; border-bottom: 1px solid #ddd; }\n`;
-    }
-    const lines = keys.map((k) => `  ${cssVar(k)}: ${vars[k]};`);
-    return `/* vmz.document designs from /designs */\n:root {\n${lines.join('\n')}\n}\nbody { font-family: var(--font-sans, system-ui, sans-serif); line-height: 1.5; margin: 0; color: var(--color-fg, #111); background: var(--color-bg, #fff); }\nmain { max-width: 48rem; margin: 0 auto; padding: 1.5rem; }\nnav { padding: 1rem 1.5rem; border-bottom: 1px solid var(--color-border, #ddd); }\n`;
-}
-function cssVar(key) {
-    const name = String(key)
-        .replace(/[^a-zA-Z0-9_-]+/g, '-')
-        .replace(/^-|-$/g, '');
-    return `--${name}`;
-}
-/** Style Theme entries (`key.path` + `value`) → `vmz-*` CSS vars (same naming as application compile). */
-function collectStyleThemeEntries(obj, out) {
-    if (obj == null || typeof obj !== 'object' || Array.isArray(obj))
-        return;
-    const entries = obj.entries;
-    if (!Array.isArray(entries))
-        return;
-    for (const e of entries) {
-        const pathParts = e?.key?.path;
-        if (!Array.isArray(pathParts) || pathParts.length === 0)
-            continue;
-        if (typeof e.value !== 'string' && typeof e.value !== 'number')
-            continue;
-        const dotted = pathParts.map(String).join('-');
-        out[`vmz-${dotted}`] = String(e.value);
-    }
-}
-function flattenTokens(obj, prefix, out) {
-    if (obj == null || typeof obj !== 'object' || Array.isArray(obj))
-        return;
-    for (const [k, v] of Object.entries(obj)) {
-        if (k === 'entries')
-            continue;
-        const key = prefix ? `${prefix}-${k}` : k;
-        if (v != null && typeof v === 'object' && !Array.isArray(v)) {
-            if ('value' in v && (typeof v.value === 'string' || typeof v.value === 'number')) {
-                out[key] = String(v.value);
-            }
-            else {
-                flattenTokens(v, key, out);
-            }
-        }
-        else if (typeof v === 'string' || typeof v === 'number') {
-            out[key] = String(v);
-        }
-    }
-}
-function walkJson(dir, fn) {
-    if (!fs.existsSync(dir))
-        return;
-    for (const ent of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, ent.name);
-        if (ent.isDirectory())
-            walkJson(full, fn);
-        else if (ent.isFile() && ent.name.endsWith('.json')) {
-            try {
-                fn(JSON.parse(fs.readFileSync(full, 'utf8')), '');
-            }
-            catch {
-                /* ignore */
-            }
-        }
+    if (!parts.length) {
+        return { css: '', source: 'designs/', href: null };
     }
+    return {
+        css: parts.join('\n\n'),
+        source: sources.join('+'),
+        href: 'assets/vmz-designs.css',
+    };
 }

package/dist/document/document-markdown.d.ts

@@ -1,5 +1,5 @@
 /**
- * Document — resolve engines.markdown via the official plugin runtime.
+ * Document — resolve engines.markdown via the official plugin runtime export.
  */
 export interface ResolveMarkdownEngineOpts {
     engines?: {

package/dist/document/document-markdown.js

@@ -1,36 +1,22 @@
 /**
- * Document — resolve engines.markdown via the official plugin runtime.
+ * Document — resolve engines.markdown via the official plugin runtime export.
  */
-import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { importMaybeTs } from '../workspace/plugin-host.js';
-const require = createRequire(import.meta.url);
 export async function resolveMarkdownEngine(opts = {}) {
     const id = opts.engines?.markdown || 'markdown-it';
     if (id !== 'markdown-it') {
         throw new Error(`unsupported engines.markdown ${JSON.stringify(id)} (markdown-it only)`);
     }
-    let runtimeFile = null;
+    let mod;
     try {
-        const pkg = require.resolve('@vmz/plugin-markdown-it/package.json');
-        runtimeFile = path.join(path.dirname(pkg), 'runtime.ts');
+        // Public JS runtime export of the plugin package; never read the package directory.
+        mod = await import('@vmz/plugin-markdown-it/runtime');
     }
-    catch {
-        // Developer mode: monorepo source checkout.
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        const fallback = path.resolve(here, '../../../plugins/vmz-plugin-markdown-it/runtime.ts');
-        if (existsSync(fallback))
-            runtimeFile = fallback;
-    }
-    if (!runtimeFile || !existsSync(runtimeFile)) {
+    catch (err) {
         throw new Error('markdown engine needs `@vmz/plugin-markdown-it` (optional peer of `@vmz/vmz`).\n' +
-            '  Install:  pnpm add -D @vmz/plugin-markdown-it');
+            '  Install:  pnpm add -D @vmz/plugin-markdown-it', { cause: err });
     }
-    const mod = await importMaybeTs(runtimeFile);
     if (typeof mod.analyzeMarkdown !== 'function') {
-        throw new Error(`cannot load markdown engine markdown-it from ${runtimeFile}`);
+        throw new Error('cannot load markdown engine markdown-it: runtime export is missing analyzeMarkdown');
     }
     return {
         engine: id,

package/dist/workspace/plugin-host.d.ts

@@ -4,11 +4,9 @@
 import { contentHash, defineConfig, definePlugin } from '@vmz/plugin';
 export { contentHash, defineConfig, definePlugin };
 export declare const PLUGIN_PROTOCOL = "0.1.0";
-/**
- * @param {string} full
- * @returns {Promise<any>}
- */
-export declare function importMaybeTs(full: any): Promise<any>;
+export declare const CONFIG_NAMES: string[];
+export declare const CONFIG_LOAD_FAILED = "vmz::config::load_failed";
+export declare const PLUGIN_ENTRY_INVALID = "vmz::plugin::invalid_entry";
 /**
  * Load `vmz.config.*` from project root (+ optional root `vmz.plugin.*`).
  * @param {string} project