@vmz/vmz 0.0.1 → 0.0.3

package/dist/dev-session.js

@@ -0,0 +1,290 @@
+// @ts-nocheck
+/**
+ * Long-lived Node dev session (/session).
+ *
+ * Rebuilds go through the N-API `Workspace` — never spawn `cargo` / `vmz-tools`.
+ * session: only dirty leaves are marked; Workspace emits affected deployment units.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
+import { createWorkspace } from './index.js';
+import { log } from './log.js';
+import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
+/**
+ * @typedef {object} DevSessionOptions
+ * @property {string} project
+ * @property {string} outDir
+ * @property {string} [host]
+ * @property {number} [port]
+ * @property {number} [pollMs]
+ * @property {AbortSignal} [signal]
+ * @property {typeof createWorkspace} [createWorkspaceFn]
+ * @property {(opts: { project: string, outDir: string, host: string, port: number }) => import('node:child_process').ChildProcess} [spawnHostFn]
+ * @property {(host: string, port: number, payload?: object) => Promise<void>} [softReloadFn]
+ */
+/**
+ * @param {DevSessionOptions} options
+ */
+export function createDevSession(options) {
+    const project = options.project;
+    const outDir = options.outDir;
+    const host = options.host ?? '127.0.0.1';
+    const port = options.port ?? 5173;
+    const pollMs = Math.max(50, options.pollMs ?? 300);
+    const createWs = options.createWorkspaceFn ?? createWorkspace;
+    const spawnHost = options.spawnHostFn ?? defaultSpawnHost;
+    const softReload = options.softReloadFn ?? defaultSoftReload;
+    const ws = createWs({ root: project, outDir });
+    /** @type {import('node:child_process').ChildProcess | null} */
+    let child = null;
+    let stopped = false;
+    /**
+     * @param {Array<{ path: string, kind: 'update' | 'delete' }>} [changes]
+     */
+    function rebuild(changes) {
+        if (changes?.length)
+            ws.updateFiles(changes);
+        return ws.build();
+    }
+    function printReport(report, label) {
+        const errors = log.diagnostics(report.diagnostics ?? []);
+        if (errors) {
+            log.error(`${label} failed (${errors} error(s))`);
+            return false;
+        }
+        const mode = report.full ? 'full' : 'affected';
+        const chunks = (report.affectedChunks || []).join(', ') || '(none)';
+        log.info(`${label} ok (${mode}; chunks=[${chunks}]; ${(report.emitted ?? []).length} emitted)`);
+        return true;
+    }
+    async function start() {
+        const src = path.join(project, 'src');
+        if (!existsSync(src)) {
+            throw new Error(`vmz dev: missing src/ under ${project}`);
+        }
+        log.info('initial build (N-API workspace, full)…');
+        // Empty dirty → full project build (session).
+        const initial = rebuild();
+        if (!printReport(initial, 'build')) {
+            throw new Error('vmz dev: initial build failed');
+        }
+        if (projectHasDocuments(project)) {
+            const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+            if (!docs.ok) {
+                throw new Error('vmz dev: integrated document build failed');
+            }
+        }
+        const hostJs = path.join(outDir, 'vmz-serve-host.mjs');
+        if (!existsSync(hostJs)) {
+            throw new Error(`vmz dev: missing ${hostJs}`);
+        }
+        child = spawnHost({ project, outDir, host, port });
+        const docsRoot = path.join(project, 'documents');
+        const watchRoots = [src].concat(existsSync(docsRoot) ? [docsRoot] : []);
+        log.info(`dev → http://${host}:${port} (watching ${watchRoots.join(', ')})`);
+        /** @type {Map<string, Map<string, string>>} */
+        let fingerprints = new Map();
+        for (const root of watchRoots) {
+            fingerprints.set(root, fileFingerprintMap(root));
+        }
+        const signal = options.signal;
+        const onAbort = () => {
+            void stop();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            while (!stopped && !signal?.aborted) {
+                await sleep(pollMs);
+                if (stopped || signal?.aborted)
+                    break;
+                if (child && child.exitCode != null) {
+                    throw new Error(`vmz serve-host exited: ${child.exitCode}`);
+                }
+                /** @type {{ srcChanged: string[], srcDeleted: string[], docsDirty: boolean }} */
+                let batch = { srcChanged: [], srcDeleted: [], docsDirty: false };
+                try {
+                    // Probe only — keep prior fingerprints until debounce resample
+                    // (same contract as pre-docs watcher: empty second pass would miss soft reload).
+                    for (const root of watchRoots) {
+                        const prev = fingerprints.get(root) || new Map();
+                        const next = fileFingerprintMap(root);
+                        const diff = diffFingerprints(prev, next);
+                        if (root === src) {
+                            batch.srcChanged = diff.changed;
+                            batch.srcDeleted = diff.deleted;
+                        }
+                        else if (diff.changed.length || diff.deleted.length) {
+                            batch.docsDirty = true;
+                        }
+                    }
+                }
+                catch (err) {
+                    log.warn('watch error:', err);
+                    continue;
+                }
+                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty)
+                    continue;
+                await sleep(200);
+                // Resample against the same prior fingerprints, then commit.
+                batch = { srcChanged: [], srcDeleted: [], docsDirty: false };
+                for (const root of watchRoots) {
+                    const prev = fingerprints.get(root) || new Map();
+                    const next = fileFingerprintMap(root);
+                    const diff = diffFingerprints(prev, next);
+                    fingerprints.set(root, next);
+                    if (root === src) {
+                        batch.srcChanged = diff.changed;
+                        batch.srcDeleted = diff.deleted;
+                    }
+                    else if (diff.changed.length || diff.deleted.length) {
+                        batch.docsDirty = true;
+                    }
+                }
+                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty)
+                    continue;
+                let needFullReload = batch.docsDirty;
+                if (batch.srcChanged.length || batch.srcDeleted.length) {
+                    log.info(`change detected (${batch.srcChanged.length} update, ${batch.srcDeleted.length} delete) — affected rebuild…`);
+                    const changes = [
+                        ...batch.srcChanged.map((p) => ({ path: p, kind: /** @type {'update'} */ ('update') })),
+                        ...batch.srcDeleted.map((p) => ({ path: p, kind: /** @type {'delete'} */ ('delete') })),
+                    ];
+                    const report = rebuild(changes);
+                    if (!printReport(report, 'rebuild')) {
+                        log.warn('rebuild failed — keeping previous server');
+                        continue;
+                    }
+                    if (batch.docsDirty || projectHasDocuments(project)) {
+                        // App rebuild may refresh designs CSS consumed by documents.
+                        const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+                        if (!docs.ok) {
+                            log.warn('document mount rebuild failed — keeping previous docs');
+                        }
+                        else {
+                            needFullReload = true;
+                        }
+                    }
+                    try {
+                        await softReload(host, port, {
+                            affectedChunks: report.affectedChunks ?? [],
+                            seedChunks: report.seedChunks ?? [],
+                            full: Boolean(report.full) || needFullReload,
+                            islandHmr: Boolean(report.islandHmr) && !needFullReload,
+                        });
+                        log.info(needFullReload
+                            ? 'soft reload ok (full page; docs)'
+                            : report.islandHmr
+                                ? 'soft reload ok (island HMR)'
+                                : 'soft reload ok (full page)');
+                    }
+                    catch (err) {
+                        log.warn(`soft reload failed (${err}) — restarting serve-host…`);
+                        killChild(child);
+                        child = spawnHost({ project, outDir, host, port });
+                    }
+                    continue;
+                }
+                if (batch.docsDirty) {
+                    log.info('documents change detected — rebuilding document mount…');
+                    const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+                    if (!docs.ok) {
+                        log.warn('document mount rebuild failed — keeping previous docs');
+                        continue;
+                    }
+                    try {
+                        await softReload(host, port, { full: true, islandHmr: false });
+                        log.info('soft reload ok (full page; docs)');
+                    }
+                    catch (err) {
+                        log.warn(`soft reload failed (${err}) — restarting serve-host…`);
+                        killChild(child);
+                        child = spawnHost({ project, outDir, host, port });
+                    }
+                }
+            }
+        }
+        finally {
+            signal?.removeEventListener('abort', onAbort);
+            await stop();
+        }
+    }
+    async function stop() {
+        if (stopped)
+            return;
+        stopped = true;
+        killChild(child);
+        child = null;
+        try {
+            ws.dispose();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return { ws, rebuild, start, stop, project, outDir, host, port };
+}
+/** @deprecated use fileFingerprintMap */
+export function srcFingerprint(srcDir) {
+    const map = fileFingerprintMap(srcDir);
+    let h = 0xcbf29ce484222325n;
+    const keys = [...map.keys()].sort();
+    for (const k of keys) {
+        for (const b of Buffer.from(`${k}|${map.get(k)}`)) {
+            h = (h * 0x100000001b3n + BigInt(b)) & 0xffffffffffffffffn;
+        }
+    }
+    return Number(h & 0xffffffffffffffffn);
+}
+/** @deprecated */
+export function listWatchedFiles(srcDir) {
+    return [...fileFingerprintMap(srcDir).keys()];
+}
+function defaultSpawnHost(opts) {
+    const hostJs = path.join(opts.outDir, 'vmz-serve-host.mjs');
+    const node = process.env.VMZ_NODE || process.execPath;
+    return spawn(node, [hostJs], {
+        cwd: opts.project,
+        env: {
+            ...process.env,
+            VMZ_DIST: opts.outDir,
+            VMZ_PORT: String(opts.port),
+            VMZ_HOST: opts.host,
+            VMZ_DEV: '1',
+        },
+        stdio: ['ignore', 'inherit', 'inherit'],
+    });
+}
+/**
+ * @param {string} host
+ * @param {number} port
+ * @param {object} [payload]
+ */
+async function defaultSoftReload(host, port, payload = {}) {
+    const url = `http://${host}:${port}/__vmz/reload`;
+    const body = JSON.stringify(payload);
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body,
+    });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+    const json = await res.json().catch(() => ({}));
+    if (!json?.ok)
+        throw new Error(JSON.stringify(json));
+}
+function killChild(child) {
+    if (!child || child.killed)
+        return;
+    try {
+        child.kill();
+    }
+    catch {
+        /* ignore */
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/dist/document-build.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @param {{ projectRoot: string, outDir?: string, strict?: boolean, engines?: { markdown?: string } }} opts
+ */
+export declare function buildDocuments(opts: any): Promise<{
+    ok: boolean;
+    manifest: {
+        schema: string;
+        root: string;
+        defaultLocale: any;
+        locales: any[];
+        localeLabels: {};
+        collections: any[];
+        mounts: any[];
+        pages: {
+            identity: any;
+            sourcePath: any;
+            route: any;
+            anchors: any[];
+        }[];
+        diagnostics: any[];
+    };
+    outDir: string;
+    pages: any[];
+    search?: undefined;
+    islands?: undefined;
+} | {
+    ok: boolean;
+    manifest: {
+        schema: string;
+        evidence: {
+            schema: string;
+            fences: any[];
+            apiRefs: any[];
+            testSelections: any[];
+            status: string;
+        };
+        search: {
+            schema: string;
+            status: string;
+            version: any;
+            records: any[];
+        };
+        islands: {
+            schema: string;
+            hydrate: string;
+            fullPageHydrate: boolean;
+            islands: {
+                name: string;
+                kind: string;
+                resume: string;
+                index: any;
+            }[];
+            status: string;
+        };
+        build: {
+            engine: any;
+            outDir: string;
+            designs: string;
+            designsCss: any;
+            pages: any[];
+            evidence: string;
+            search: string;
+            islands: string;
+        };
+        root: string;
+        defaultLocale: any;
+        locales: any[];
+        localeLabels: {};
+        collections: any[];
+        mounts: any[];
+        pages: {
+            identity: any;
+            sourcePath: any;
+            route: any;
+            anchors: any[];
+        }[];
+        diagnostics: any[];
+    };
+    outDir: string;
+    pages: any[];
+    search: {
+        schema: string;
+        status: string;
+        version: any;
+        records: any[];
+    };
+    islands: {
+        schema: string;
+        hydrate: string;
+        fullPageHydrate: boolean;
+        islands: {
+            name: string;
+            kind: string;
+            resume: string;
+            index: any;
+        }[];
+        status: string;
+    };
+}>;

package/dist/document-build.js

@@ -0,0 +1,273 @@
+// @ts-nocheck
+/**
+ * Document Static + Interactive artifacts.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { checkDocuments, manifestHasErrors } from './document-check.js';
+import { resolveDocumentDesignsCss } from './document-designs.js';
+import { enrichDocumentContent, pageHtmlRel } from './document-enrich.js';
+import { enrichDocumentEvidence } from './document-evidence.js';
+import { artifactHrefFromHtml, buildDocumentIslands, buildDocumentSearch, collectFenceBodies, renderIslandShellsHtml, } from './document-interactive.js';
+import { resolveMarkdownEngine } from './document-markdown.js';
+import { DOCUMENT_VIEW_SCHEMA } from './document-schema.js';
+import { createWorkspace } from './index.js';
+/**
+ * @param {{ projectRoot: string, outDir?: string, strict?: boolean, engines?: { markdown?: string } }} opts
+ */
+export async function buildDocuments(opts) {
+    const projectRoot = path.resolve(opts.projectRoot);
+    const outDir = path.resolve(opts.outDir || path.join(projectRoot, 'dist', 'documents'));
+    const strict = Boolean(opts.strict);
+    const manifest = checkDocuments({ projectRoot, strict });
+    const engine = await resolveMarkdownEngine({ engines: opts.engines, projectRoot });
+    const enriched = enrichDocumentContent(manifest, {
+        analyzeMarkdown: engine.analyzeMarkdown,
+        projectRoot,
+    });
+    manifest.diagnostics = enriched.diagnostics;
+    const evidence = await enrichDocumentEvidence(manifest, {
+        analyzeMarkdown: engine.analyzeMarkdown,
+        projectRoot,
+        createWorkspace,
+    });
+    manifest.diagnostics = evidence.diagnostics;
+    manifest.evidence = evidence.evidence;
+    if (manifestHasErrors(manifest)) {
+        return { ok: false, manifest, outDir, pages: [] };
+    }
+    /** @type {Map<string, any>} */
+    const analyzedByPageId = new Map();
+    for (const page of manifest.pages) {
+        const abs = path.isAbsolute(page.sourcePath) ? page.sourcePath : path.join(manifest.root, page.sourcePath);
+        const source = fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : '';
+        const id = `${page.identity.locale}:${page.identity.pageKey}`;
+        analyzedByPageId.set(id, engine.analyzeMarkdown(source));
+    }
+    const fenceBodies = collectFenceBodies(analyzedByPageId, manifest.pages);
+    const search = buildDocumentSearch({
+        manifest,
+        enriched,
+        evidence: evidence.evidence,
+        version: null,
+    });
+    const islands = buildDocumentIslands({
+        evidence: evidence.evidence,
+        searchHref: 'document.search.json',
+        fenceBodies,
+    });
+    manifest.search = search;
+    manifest.islands = islands;
+    const hostChrome = resolveHostSiteChrome(projectRoot);
+    const useHostShell = Boolean(hostChrome) && (manifest.mounts || []).some((m) => m.mode === 'integrated');
+    fs.mkdirSync(outDir, { recursive: true });
+    const designs = resolveDocumentDesignsCss(projectRoot);
+    /** @type {string | null} */
+    let designsHref = null;
+    if (designs.css && designs.href) {
+        const cssPath = path.join(outDir, designs.href);
+        fs.mkdirSync(path.dirname(cssPath), { recursive: true });
+        fs.writeFileSync(cssPath, designs.css, 'utf8');
+        designsHref = designs.href;
+    }
+    const viewsDir = path.join(outDir, 'views');
+    fs.mkdirSync(viewsDir, { recursive: true });
+    /** @type {Array<{ route: string, htmlPath: string, viewPath: string }>} */
+    const written = [];
+    for (const page of manifest.pages) {
+        const id = `${page.identity.locale}:${page.identity.pageKey}`;
+        const info = enriched.byId.get(id);
+        if (!info)
+            continue;
+        const nav = enriched.navByLocale[page.identity.locale] || [];
+        const htmlRel = pageHtmlRel(enriched.routeBase, page.identity.locale, page.identity.pageKey);
+        const htmlAbs = path.join(outDir, htmlRel);
+        fs.mkdirSync(path.dirname(htmlAbs), { recursive: true });
+        const searchIndexHref = artifactHrefFromHtml(htmlRel, 'document.search.json');
+        const shells = renderIslandShellsHtml({
+            islands,
+            searchIndexHref,
+            pageKey: page.identity.pageKey,
+            locale: page.identity.locale,
+        });
+        const view = {
+            schema: DOCUMENT_VIEW_SCHEMA,
+            pageKey: page.identity.pageKey,
+            locale: page.identity.locale,
+            route: info.route,
+            title: info.title,
+            headings: info.headings,
+            nav,
+            bodyKind: 'html',
+            html: info.html,
+            designsCss: designsHref,
+            noJsReadable: true,
+            hydrate: 'island-only',
+            hostShell: useHostShell,
+            islands: ['DocumentSearch'].concat((islands.islands || [])
+                .filter((isl) => isl.kind === 'playground' &&
+                isl.fence?.locale === page.identity.locale &&
+                isl.fence?.pageKey === page.identity.pageKey)
+                .map((isl) => isl.name)),
+        };
+        const viewRel = path.posix.join('views', page.identity.locale, `${page.identity.pageKey === 'index' ? 'index' : page.identity.pageKey}.view.json`);
+        const viewAbs = path.join(outDir, viewRel);
+        fs.mkdirSync(path.dirname(viewAbs), { recursive: true });
+        fs.writeFileSync(viewAbs, JSON.stringify(view, null, 2) + '\n', 'utf8');
+        const html = renderStaticHtml({
+            title: info.title,
+            locale: page.identity.locale,
+            route: info.route,
+            nav,
+            bodyHtml: info.html,
+            headings: info.headings,
+            designsHref,
+            htmlRel,
+            searchShellHtml: shells.searchHtml,
+            playgroundShellHtml: shells.playgroundHtml,
+            hostChrome: useHostShell ? hostChrome : null,
+        });
+        fs.writeFileSync(htmlAbs, html, 'utf8');
+        written.push({ route: info.route, htmlPath: htmlRel, viewPath: viewRel });
+    }
+    const manifestOut = {
+        ...manifest,
+        schema: manifest.schema,
+        evidence: evidence.evidence,
+        search,
+        islands,
+        build: {
+            engine: engine.engine,
+            outDir: path.relative(projectRoot, outDir).replace(/\\/g, '/') || '.',
+            designs: designs.source,
+            designsCss: designsHref,
+            pages: written,
+            evidence: 'document.evidence.json',
+            search: 'document.search.json',
+            islands: 'document.islands.json',
+        },
+    };
+    fs.writeFileSync(path.join(outDir, 'document.manifest.json'), JSON.stringify(manifestOut, null, 2) + '\n', 'utf8');
+    fs.writeFileSync(path.join(outDir, 'document.evidence.json'), JSON.stringify(evidence.evidence, null, 2) + '\n', 'utf8');
+    fs.writeFileSync(path.join(outDir, 'document.search.json'), JSON.stringify(search, null, 2) + '\n', 'utf8');
+    fs.writeFileSync(path.join(outDir, 'document.islands.json'), JSON.stringify(islands, null, 2) + '\n', 'utf8');
+    return { ok: true, manifest: manifestOut, outDir, pages: written, search, islands };
+}
+/**
+ * No-JS readable static HTML: nav + main landmarks, Island shells without scripts.
+ * Integrated mounts reuse host SiteHeader/SiteFooter templates when present.
+ */
+function renderStaticHtml({ title, locale, route, nav, bodyHtml, headings, designsHref, htmlRel, searchShellHtml = '', playgroundShellHtml = '', hostChrome = null, }) {
+    const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    const depth = htmlRel.split('/').length - 1;
+    const prefix = depth > 0 ? '../'.repeat(depth) : './';
+    /** @type {string[]} */
+    const cssHrefs = [];
+    if (hostChrome) {
+        // Same application stylesheet as landing pages (header/footer chrome).
+        cssHrefs.push(`${prefix}vmz.css`);
+    }
+    if (designsHref)
+        cssHrefs.push(prefix + designsHref);
+    const cssLink = cssHrefs.map((href) => `  <link rel="stylesheet" href="${esc(href)}" />`).join('\n') + (cssHrefs.length ? '\n' : '');
+    const navItems = nav
+        .map((n) => {
+        const href = relativeHref(htmlRel, n.href, route);
+        const current = n.href === route ? ' aria-current="page"' : '';
+        return `      <li><a href="${esc(href)}"${current}>${esc(n.title)}</a></li>`;
+    })
+        .join('\n');
+    const toc = headings.length > 1
+        ? `<nav aria-label="On this page" class="toc">\n    <ol>\n${headings
+            .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>
+  </nav>`;
+    if (hostChrome) {
+        const header = hostChrome.header.replace(/(<a\s+href="\/d\/?")([^>]*>文档<\/a>)/, '$1 aria-current="page"$2');
+        return `<!DOCTYPE html>
+<html lang="${esc(locale)}">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${esc(title)}</title>
+${cssLink}</head>
+<body data-vmz-hydrate="island-only">
+  <div class="site site--docs">
+  <a class="skip-link" href="#main">Skip to content</a>
+${header}
+${docsNav}
+${searchShellHtml}
+  <div class="doc-body">
+  ${toc}<main id="main">
+${bodyHtml}
+${playgroundShellHtml}
+  </main>
+  </div>
+${hostChrome.footer}
+  </div>
+</body>
+</html>
+`;
+    }
+    return `<!DOCTYPE html>
+<html lang="${esc(locale)}">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${esc(title)}</title>
+${cssLink}</head>
+<body data-vmz-hydrate="island-only">
+  <a class="skip-link" href="#main">Skip to content</a>
+${docsNav}
+${searchShellHtml}
+  ${toc}<main id="main">
+${bodyHtml}
+${playgroundShellHtml}
+  </main>
+</body>
+</html>
+`;
+}
+/**
+ * Integrated DocumentMount: reuse host SiteHeader / SiteFooter .vmz templates.
+ * @param {string} projectRoot
+ * @returns {{ header: string, footer: string } | null}
+ */
+function resolveHostSiteChrome(projectRoot) {
+    const headerPath = path.join(projectRoot, 'src', 'components', 'SiteHeader.vmz');
+    const footerPath = path.join(projectRoot, 'src', 'components', 'SiteFooter.vmz');
+    if (!fs.existsSync(headerPath) || !fs.existsSync(footerPath))
+        return null;
+    const header = extractVmzTemplateHtml(headerPath);
+    const footer = extractVmzTemplateHtml(footerPath);
+    if (!header || !footer)
+        return null;
+    return { header, footer };
+}
+/** @param {string} filePath */
+function extractVmzTemplateHtml(filePath) {
+    const src = fs.readFileSync(filePath, 'utf8');
+    const m = src.match(/<template>([\s\S]*?)<\/template>/);
+    return m ? m[1].trim() : '';
+}
+function relativeHref(fromHtmlRel, toRoute, _fromRoute) {
+    const toParts = String(toRoute).replace(/^\//, '').split('/').filter(Boolean);
+    let toRel;
+    if (toParts.length <= 2) {
+        toRel = [...toParts, 'index.html'].join('/');
+    }
+    else {
+        const file = toParts.slice(2).join('/') + '.html';
+        toRel = [...toParts.slice(0, 2), file].join('/');
+    }
+    const fromDir = path.posix.dirname(fromHtmlRel.replace(/\\/g, '/'));
+    let rel = path.posix.relative(fromDir, toRel);
+    if (!rel.startsWith('.') && !rel.startsWith('/'))
+        rel = './' + rel;
+    return rel || './index.html';
+}