@vmz/core 0.2.5 → 0.2.6

package/dist/host/serve/hmr-dev.js

@@ -0,0 +1,294 @@
+import { readFileSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { registerHooks } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { listClientComponents } from '../list-client-components.js';
+import { LOCALE_LINK_PLAN_SCHEMA, linkRouteAliasesFromUnits } from '../localize-body-links.js';
+import { loadNativeAddon } from '../native-addon.js';
+import { createRenderHost } from '../render/render-host.js';
+import { setRoutes } from '../../faces/vmz-runtime.js';
+import { LOCALE_LINK_PLAN_REL } from './constants.js';
+import { loadDeploymentStyle } from './locale-theme.js';
+import { bustUrl, isEventOnlyShell, isEventStrategy, listPageClientFiles, loadPageResumeEntries, pageNeedsReload } from './page-catalog.js';
+import { serveState } from './state.js';
+export function installDevImportTokenHooks() {
+    if (!serveState.isDev)
+        return;
+    const distUrlPrefix = pathToFileURL(serveState.distDir.endsWith(path.sep) ? serveState.distDir : `${serveState.distDir}${path.sep}`).href;
+    registerHooks({
+        resolve(specifier, context, nextResolve) {
+            const result = nextResolve(specifier, context);
+            if (!specifier.startsWith('.') || !context.parentURL || !result?.url)
+                return result;
+            let token = '';
+            try {
+                token = new URL(context.parentURL).searchParams.get('t') || '';
+            }
+            catch {
+                return result;
+            }
+            if (!token)
+                return result;
+            if (!result.url.startsWith('file:'))
+                return result;
+            if (!result.url.startsWith(distUrlPrefix)) {
+                try {
+                    if (!fileURLToPath(result.url).startsWith(serveState.distDir))
+                        return result;
+                }
+                catch {
+                    return result;
+                }
+            }
+            const u = new URL(result.url);
+            if (u.searchParams.get('t') === token)
+                return result;
+            u.searchParams.set('t', token);
+            return { ...result, url: u.href, shortCircuit: true };
+        },
+    });
+}
+function attachLinkRouteAliases(artifact, dir) {
+    if (!artifact || typeof artifact !== 'object')
+        return artifact;
+    try {
+        const dep = JSON.parse(readFileSync(path.join(dir, 'vmz-deployment.json'), 'utf8'));
+        const aliases = linkRouteAliasesFromUnits(Array.isArray(dep.units) ? dep.units : []);
+        if (!aliases.length)
+            return artifact;
+        return { ...artifact, linkRouteAliases: aliases };
+    }
+    catch {
+        return artifact;
+    }
+}
+export function notifySse(event) {
+    for (const client of [...serveState.sseClients]) {
+        try {
+            client.write(`data: ${event}\n\n`);
+        }
+        catch {
+            serveState.sseClients.delete(client);
+        }
+    }
+}
+export function normalizeDevError(err) {
+    if (err && typeof err === 'object') {
+        const e = err;
+        return {
+            message: e.message ? String(e.message) : String(err),
+            stack: e.stack ? String(e.stack) : undefined,
+            at: Date.now(),
+        };
+    }
+    return { message: String(err), at: Date.now() };
+}
+export async function* emitDevErrorHtml(err) {
+    const msg = escapeHtml(err.message || 'Unknown error');
+    const stack = err.stack ? escapeHtml(err.stack) : '';
+    const style = `<style>
+    body{margin:0;background:#0f1115;color:#f4f4f5;font:14px/1.5 ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+    main{max-width:56rem;margin:0 auto;padding:2rem 1.25rem}
+    h1{margin:0 0 .75rem;color:#f87171;font-size:1.1rem}
+    pre{white-space:pre-wrap;margin:0 0 1rem}
+    .hint{opacity:.65;font-size:12px}
+  </style>`;
+    const body = `${style}
+  <main data-vmz-error="500">
+    <h1>Dev Error</h1>
+    <pre>${msg}</pre>
+    ${stack ? `<pre style="opacity:.7;font-size:12px">${stack}</pre>` : ''}
+    <p class="hint">Dev host stayed up. Fix the source and save — soft reload will recover.</p>
+  </main>
+  <script>
+  (() => {
+    const es = new EventSource("/__vmz/events");
+    es.onmessage = (ev) => {
+      let msg = null;
+      try { msg = JSON.parse(ev.data); } catch {}
+      if (msg && msg.type === "hmr") location.reload();
+    };
+  })();
+  </script>`;
+    try {
+        const native = loadNativeAddon();
+        if (typeof native.generateHtmlShell === 'function') {
+            yield native.generateHtmlShell({
+                title: 'Dev Error',
+                lang: 'en',
+                cssHrefs: [],
+                bodyHtml: body,
+                bodyAttrs: [],
+            });
+            return;
+        }
+    }
+    catch {
+        /* fall through */
+    }
+    yield `<!DOCTYPE html><html lang="en"><head><meta charset="utf-8" /><title>Dev Error</title></head><body>${body}</body></html>`;
+}
+function escapeHtml(s) {
+    return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+function emitEntryClient(eager, lazy, token) {
+    const q = `?t=${token}`;
+    const native = loadNativeAddon();
+    if (typeof native.generateServeEntryClient !== 'function') {
+        throw new Error('vmz native addon missing generateServeEntryClient — rebuild with `pnpm napi:build`');
+    }
+    return native.generateServeEntryClient(eager, lazy, q);
+}
+function emitEntryEvent(token) {
+    const q = `?t=${token}`;
+    const native = loadNativeAddon();
+    if (typeof native.generateServeEntryEvent !== 'function') {
+        throw new Error('vmz native addon missing generateServeEntryEvent — rebuild with `pnpm napi:build`');
+    }
+    return native.generateServeEntryEvent(q);
+}
+export async function softReload(opts = {}) {
+    const prevToken = serveState.reloadToken;
+    const prevCatalog = serveState.pageCatalog;
+    const prevCtors = new Map(serveState.pageCtors);
+    const nextToken = Date.now();
+    serveState.reloadToken = nextToken;
+    const affected = opts.payload?.affectedChunks ?? [];
+    const seeds = opts.payload?.seedChunks ?? [];
+    const full = opts.payload?.full;
+    const islandHmr = Boolean(opts.payload?.islandHmr);
+    const rerunLoaders = opts.payload?.rerunLoaders ?? [];
+    const skipEntryRewrite = Boolean(opts.payload?.skipEntryRewrite);
+    const buildId = opts.payload?.buildId != null ? String(opts.payload.buildId) : null;
+    const sourceRevision = opts.payload?.sourceRevision != null ? String(opts.payload.sourceRevision) : null;
+    const bundleRevision = opts.payload?.bundleRevision != null ? String(opts.payload.bundleRevision) : null;
+    if (buildId)
+        serveState.lastDevBuildId = buildId;
+    const reloadAllPages = Boolean(full) || (!islandHmr && rerunLoaders.length === 0 && affected.length === 0);
+    try {
+        try {
+            const routes = JSON.parse(await readFile(path.join(serveState.distDir, 'vmz-routes.json'), 'utf8'));
+            setRoutes(routes);
+        }
+        catch {
+            setRoutes([]);
+        }
+        try {
+            serveState.localeArtifact = JSON.parse(await readFile(path.join(serveState.distDir, '_vmz', 'locale-route-realization.json'), 'utf8'));
+            serveState.localeArtifact = attachLinkRouteAliases(serveState.localeArtifact, serveState.distDir);
+        }
+        catch {
+            serveState.localeArtifact = null;
+        }
+        try {
+            const rawPlan = JSON.parse(await readFile(path.join(serveState.distDir, ...LOCALE_LINK_PLAN_REL.split('/')), 'utf8'));
+            serveState.localeLinkPlan = rawPlan?.schema === LOCALE_LINK_PLAN_SCHEMA && Array.isArray(rawPlan.rows) ? rawPlan : null;
+        }
+        catch {
+            serveState.localeLinkPlan = null;
+        }
+        const componentEntries = await listClientComponents(serveState.distDir, { strict: !serveState.isDev });
+        serveState.ssrRenderHost = await createRenderHost(serveState.distDir, {
+            strictDeployment: !serveState.isDev,
+            preload: 'none',
+            cacheBust: nextToken,
+        });
+        const nextCatalog = await listPageClientFiles(serveState.distDir);
+        const nextCtors = new Map();
+        if (!islandHmr) {
+            const reloadSet = rerunLoaders.length > 0
+                ? rerunLoaders
+                : reloadAllPages
+                    ? nextCatalog.map((p) => p.chunkId)
+                    : nextCatalog.filter((p) => pageNeedsReload(p.chunkId, affected)).map((p) => p.chunkId);
+            const pagesToLoad = nextCatalog.filter((p) => reloadSet.includes(p.chunkId));
+            for (const p of pagesToLoad) {
+                const pageRel = `${p.chunkId}.client.js`;
+                const href = bustUrl(pathToFileURL(path.join(serveState.distDir, pageRel)).href);
+                const mod = await import(href);
+                nextCtors.set(p.chunkId, mod.default);
+            }
+        }
+        serveState.pageCatalog = nextCatalog;
+        if (!islandHmr) {
+            if (reloadAllPages) {
+                serveState.pageCtors.clear();
+                for (const [k, v] of nextCtors)
+                    serveState.pageCtors.set(k, v);
+            }
+            else {
+                for (const [k, v] of nextCtors)
+                    serveState.pageCtors.set(k, v);
+                for (const id of [...serveState.pageCtors.keys()]) {
+                    if (!nextCatalog.some((p) => p.chunkId === id))
+                        serveState.pageCtors.delete(id);
+                }
+            }
+        }
+        const indexChunk = serveState.pageCatalog.find((p) => p.chunkId === 'pages/index')?.chunkId || serveState.pageCatalog[0].chunkId;
+        const resumeEntries = await loadPageResumeEntries(serveState.distDir, indexChunk);
+        const styleMeta = await loadDeploymentStyle(serveState.distDir);
+        serveState.cssEntry = styleMeta.cssEntry;
+        serveState.styleBundleHash = styleMeta.styleBundleHash;
+        serveState.styleTheme = styleMeta.styleTheme;
+        const lazyEventNames = resumeEntries
+            .filter((e) => isEventStrategy(e.strategy))
+            .map((e) => e.component)
+            .filter(Boolean);
+        const lazySet = new Set(lazyEventNames);
+        await writeFile(path.join(serveState.distDir, 'entry-client.js'), emitEntryClient(componentEntries.filter((e) => !lazySet.has(e.name)), componentEntries.filter((e) => lazySet.has(e.name)), skipEntryRewrite ? serveState.reloadToken : nextToken), 'utf8');
+        const strategies = resumeEntries.map((e) => e.strategy);
+        const eventOnlyShell = isEventOnlyShell(strategies);
+        await writeFile(path.join(serveState.distDir, 'entry-event.js'), emitEntryEvent(skipEntryRewrite ? serveState.reloadToken : nextToken), 'utf8');
+        serveState.lastDevError = null;
+        const mode = islandHmr ? 'island' : eventOnlyShell ? 'event-shell' : 'full';
+        notifySse(JSON.stringify({
+            type: 'hmr',
+            mode,
+            affectedChunks: affected,
+            seedChunks: seeds,
+            token: serveState.reloadToken,
+            buildId: buildId || serveState.lastDevBuildId,
+            sourceRevision,
+            bundleRevision,
+            serveRevision: String(serveState.reloadToken),
+            full: Boolean(full),
+            eventOnlyShell,
+        }));
+        if (!opts.quiet) {
+            const aff = affected.length > 0 ? ` affected=[${affected.join(', ')}]` : full === false ? ' affected=[]' : '';
+            const scope = islandHmr ? 'island' : reloadAllPages ? 'all-pages' : `pages=${nextCtors.size}`;
+            const bid = buildId || serveState.lastDevBuildId;
+            const rev = bid || sourceRevision || bundleRevision
+                ? ` buildId=${bid || '-'} source=${sourceRevision || '-'} bundle=${bundleRevision || '-'} serve=${serveState.reloadToken}`
+                : ` t=${serveState.reloadToken}`;
+            console.log(`vmz serve: soft reload ok (mode=${mode}; ${scope}; catalog=${serveState.pageCatalog.length};${rev}${aff})`);
+        }
+        return {
+            affectedChunks: affected,
+            seedChunks: seeds,
+            full: Boolean(full),
+            islandHmr,
+            mode,
+            eventOnlyShell,
+            pageCount: serveState.pageCatalog.length,
+            reloadedPages: islandHmr ? 0 : nextCtors.size,
+            reloadAllPages,
+            buildId: buildId || serveState.lastDevBuildId,
+            sourceRevision,
+            bundleRevision,
+            serveRevision: String(serveState.reloadToken),
+            token: serveState.reloadToken,
+        };
+    }
+    catch (err) {
+        serveState.reloadToken = prevToken;
+        serveState.pageCatalog = prevCatalog;
+        serveState.pageCtors.clear();
+        for (const [k, v] of prevCtors)
+            serveState.pageCtors.set(k, v);
+        serveState.lastDevError = normalizeDevError(err);
+        throw err;
+    }
+}

package/dist/host/serve/http.d.ts

@@ -0,0 +1 @@
+export declare function startServeHttp(): void;

package/dist/host/serve/http.js

@@ -0,0 +1,124 @@
+import http from 'node:http';
+import { handleNodeRequest } from '../../faces/vmz-runtime.js';
+import { SHUTDOWN_TIMEOUT_MS } from './constants.js';
+import { normalizeDevError, notifySse, softReload } from './hmr-dev.js';
+import { renderPage, renderPageStream } from './page-render.js';
+import { serveState } from './state.js';
+function readRequestBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+async function gracefulShutdown(signal) {
+    if (serveState.shuttingDown)
+        return;
+    serveState.shuttingDown = true;
+    serveState.ready = false;
+    console.log(`vmz serve: ${signal} — draining in-flight=${serveState.inFlight} timeout=${SHUTDOWN_TIMEOUT_MS}ms`);
+    serveState.server?.close();
+    const start = Date.now();
+    while (serveState.inFlight > 0 && Date.now() - start < SHUTDOWN_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, 25));
+    }
+    for (const client of serveState.sseClients) {
+        try {
+            client.end();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    serveState.sseClients.clear();
+    process.exit(serveState.inFlight > 0 ? 1 : 0);
+}
+export function startServeHttp() {
+    serveState.server = http.createServer((req, res) => {
+        const url = new URL(req.url || '/', `http://${serveState.host}:${serveState.port}`);
+        if (url.pathname === '/__vmz/health' && req.method === 'GET') {
+            res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            res.end(JSON.stringify({ status: 'ok', shuttingDown: serveState.shuttingDown, inFlight: serveState.inFlight }));
+            return;
+        }
+        if (url.pathname === '/__vmz/ready' && req.method === 'GET') {
+            if (!serveState.ready || serveState.shuttingDown) {
+                res.writeHead(503, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+                res.end(JSON.stringify({ status: 'not-ready', ready: serveState.ready, shuttingDown: serveState.shuttingDown }));
+                return;
+            }
+            res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            res.end(JSON.stringify({ status: 'ready', ready: true, inFlight: serveState.inFlight }));
+            return;
+        }
+        if (serveState.shuttingDown) {
+            res.writeHead(503, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            res.end(JSON.stringify({ status: 'shutting-down' }));
+            return;
+        }
+        serveState.inFlight += 1;
+        let settled = false;
+        const done = () => {
+            if (settled)
+                return;
+            settled = true;
+            serveState.inFlight = Math.max(0, serveState.inFlight - 1);
+        };
+        res.on('finish', done);
+        res.on('close', done);
+        if (url.pathname === '/__vmz/reload' && req.method === 'POST') {
+            readRequestBody(req)
+                .then((raw) => {
+                let payload = {};
+                try {
+                    payload = raw ? JSON.parse(String(raw)) : {};
+                }
+                catch {
+                    payload = {};
+                }
+                return softReload({ payload });
+            })
+                .then((info) => {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, token: serveState.reloadToken, ...info }));
+            })
+                .catch((err) => {
+                console.error('vmz serve: soft reload failed', err);
+                serveState.lastDevError = normalizeDevError(err);
+                notifySse(JSON.stringify({
+                    type: 'error',
+                    message: serveState.lastDevError.message,
+                    stack: serveState.lastDevError.stack,
+                    at: serveState.lastDevError.at,
+                }));
+                res.writeHead(500, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: serveState.lastDevError.message }));
+            });
+            return;
+        }
+        if (url.pathname === '/__vmz/events' && req.method === 'GET') {
+            res.writeHead(200, {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache',
+                connection: 'keep-alive',
+            });
+            res.write(': connected\n\n');
+            serveState.sseClients.add(res);
+            req.on('close', () => {
+                serveState.sseClients.delete(res);
+            });
+            return;
+        }
+        handleNodeRequest(req, res, { distDir: serveState.distDir, renderPage, renderPageStream });
+    });
+    serveState.server.listen(serveState.port, serveState.host, () => {
+        console.log(`vmz serve http://${serveState.host}:${serveState.port} (dist=${serveState.distDir}${serveState.isDev ? ', dev' : ''})`);
+    });
+    process.on('SIGTERM', () => {
+        void gracefulShutdown('SIGTERM');
+    });
+    process.on('SIGINT', () => {
+        void gracefulShutdown('SIGINT');
+    });
+}

package/dist/host/serve/locale-theme.d.ts

@@ -0,0 +1,19 @@
+export declare function resolveLocalePath(pathname: string, cookieHeader: string | undefined): {
+    localeId: any;
+    dir: any;
+    restPath: string;
+    redirectTo: string;
+};
+export declare function pageMetaAlternates(chunkId: string, localeId: string): any;
+export declare function cssEntryWithBust(entry: string | null): string;
+export declare function loadDeploymentStyle(dir: string): Promise<{
+    cssEntry: string;
+    styleTheme: any;
+    styleBundleHash: any;
+}>;
+export declare function resolveThemeId(searchParams: URLSearchParams | undefined, cookieHeader: string | undefined): string;
+export declare function htmlThemeAttrPair(themeId: string | null): any[];
+export declare function themeBootstrapScript(): string;
+export declare function localeBootstrapScript(): string;
+export declare function siteFaviconHeadHtml(): any;
+export declare function readCookie(header: string | undefined, name: string): string;

package/dist/host/serve/locale-theme.js

@@ -0,0 +1,169 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { LOCALE_STORE_KEY, THEME_STORE_KEY } from './constants.js';
+import { serveState } from './state.js';
+export function resolveLocalePath(pathname, cookieHeader) {
+    const raw = String(pathname || '/');
+    const normalized = raw.length > 1 && raw.endsWith('/') ? raw.slice(0, -1) : raw || '/';
+    if (!serveState.localeArtifact) {
+        return { localeId: 'en', dir: 'ltr', restPath: normalized, redirectTo: null };
+    }
+    const supported = (serveState.localeArtifact.locales || []).map((l) => l.id);
+    const defaultLocale = serveState.localeArtifact.defaultLocale || supported[0] || 'en';
+    const directions = Object.fromEntries((serveState.localeArtifact.locales || []).map((l) => [l.id, l.direction || 'ltr']));
+    const routing = serveState.localeArtifact.routing || {};
+    const strategy = routing.strategy || 'prefix';
+    if (strategy === 'none') {
+        const preferred = readCookie(cookieHeader, LOCALE_STORE_KEY);
+        const localeId = preferred && supported.includes(preferred) ? preferred : defaultLocale;
+        return {
+            localeId,
+            dir: directions[localeId] || 'ltr',
+            restPath: normalized,
+            redirectTo: null,
+        };
+    }
+    const parts = normalized.split('/').filter(Boolean);
+    let localeId = null;
+    let restPath = normalized;
+    if (parts.length && supported.includes(parts[0])) {
+        localeId = parts[0];
+        const rest = parts.slice(1);
+        restPath = rest.length ? `/${rest.join('/')}` : '/';
+    }
+    if (routing.defaultPrefix === 'omit' && localeId === defaultLocale) {
+        return {
+            localeId: defaultLocale,
+            dir: directions[defaultLocale] || 'ltr',
+            restPath,
+            redirectTo: restPath,
+        };
+    }
+    const contentLocale = localeId || defaultLocale;
+    return {
+        localeId: contentLocale,
+        dir: directions[contentLocale] || 'ltr',
+        restPath,
+        redirectTo: null,
+    };
+}
+export function pageMetaAlternates(chunkId, localeId) {
+    if (!serveState.localeArtifact?.pageMetas)
+        return [];
+    const meta = serveState.localeArtifact.pageMetas.find((m) => m.routeId === chunkId && m.locale === localeId) ||
+        serveState.localeArtifact.pageMetas.find((m) => m.routeId === chunkId && m.locale === serveState.localeArtifact.defaultLocale);
+    return Array.isArray(meta?.alternates) ? meta.alternates : [];
+}
+export function cssEntryWithBust(entry) {
+    if (!entry)
+        return undefined;
+    const base = String(entry).replace(/^\/+/, '');
+    const params = new URLSearchParams();
+    params.set('t', String(serveState.reloadToken));
+    if (serveState.styleBundleHash)
+        params.set('h', serveState.styleBundleHash);
+    return `${base}?${params.toString()}`;
+}
+export async function loadDeploymentStyle(dir) {
+    try {
+        const raw = await readFile(path.join(dir, 'vmz-deployment.json'), 'utf8');
+        const dep = JSON.parse(raw);
+        const entry = dep.cssEntry;
+        const css = typeof entry === 'string' && entry.trim() ? entry.trim().replace(/^\/+/, '') : null;
+        const st = dep.styleTheme;
+        let theme = null;
+        if (st && typeof st === 'object') {
+            theme = {
+                defaultThemeId: String(st.defaultThemeId || 'default'),
+                themeIds: Array.isArray(st.themeIds) ? st.themeIds.map(String) : [],
+                activationAttr: String(st.activationAttr || 'data-theme'),
+                prefersColorScheme: st.prefersColorScheme && typeof st.prefersColorScheme === 'object'
+                    ? Object.fromEntries(Object.entries(st.prefersColorScheme).map(([k, v]) => [String(k), String(v)]))
+                    : {},
+                contentHash: st.contentHash ? String(st.contentHash) : null,
+            };
+        }
+        const bundleHash = typeof dep.styleBundleHash === 'string' && dep.styleBundleHash.trim() ? dep.styleBundleHash.trim() : null;
+        return { cssEntry: css, styleTheme: theme, styleBundleHash: bundleHash };
+    }
+    catch {
+        return { cssEntry: null, styleTheme: null, styleBundleHash: null };
+    }
+}
+export function resolveThemeId(searchParams, cookieHeader) {
+    if (!serveState.styleTheme)
+        return null;
+    const ids = serveState.styleTheme.themeIds || [];
+    const q = searchParams && typeof searchParams.get === 'function' ? searchParams.get('theme') : null;
+    if (q && ids.includes(q))
+        return q;
+    const fromCookie = readCookie(cookieHeader, THEME_STORE_KEY);
+    if (fromCookie && ids.includes(fromCookie))
+        return fromCookie;
+    return null;
+}
+export function htmlThemeAttrPair(themeId) {
+    if (!serveState.styleTheme || !themeId)
+        return [];
+    const attr = serveState.styleTheme.activationAttr || 'data-theme';
+    if (!(serveState.styleTheme.themeIds || []).includes(themeId))
+        return [];
+    return [attr, themeId];
+}
+export function themeBootstrapScript() {
+    if (!serveState.styleTheme)
+        return '';
+    const attr = JSON.stringify(serveState.styleTheme.activationAttr || 'data-theme');
+    const ids = JSON.stringify(serveState.styleTheme.themeIds || []);
+    const key = JSON.stringify(THEME_STORE_KEY);
+    return `  <script>(function(){try{var k=${key},attr=${attr},ids=${ids};var id=localStorage.getItem(k);if(!id||ids.indexOf(id)<0)return;document.documentElement.setAttribute(attr,id);}catch(e){}})();</script>\n`;
+}
+export function localeBootstrapScript() {
+    if (!serveState.localeArtifact)
+        return '';
+    const routing = serveState.localeArtifact.routing || {};
+    if ((routing.strategy || 'prefix') !== 'none')
+        return '';
+    const ids = (serveState.localeArtifact.locales || []).map((l) => l.id).filter(Boolean);
+    if (!ids.length)
+        return '';
+    const key = JSON.stringify(LOCALE_STORE_KEY);
+    const idList = JSON.stringify(ids);
+    return `  <script>(function(){try{var k=${key},ids=${idList};var id=localStorage.getItem(k);if(!id||ids.indexOf(id)<0)return;document.documentElement.setAttribute("data-locale",id);document.documentElement.setAttribute("lang",id);window.__vmzLocaleIdHint=id;document.cookie=k+"="+encodeURIComponent(id)+"; path=/; max-age=31536000; SameSite=Lax";}catch(e){}})();</script>\n`;
+}
+export function siteFaviconHeadHtml() {
+    try {
+        const p = path.join(serveState.distDir, '_vmz', 'site-favicon.json');
+        if (!existsSync(p))
+            return '';
+        const raw = readFileSync(p, 'utf8');
+        const j = JSON.parse(raw);
+        if (j?.status !== 'ready' || typeof j.headHtml !== 'string')
+            return '';
+        return j.headHtml;
+    }
+    catch {
+        return '';
+    }
+}
+export function readCookie(header, name) {
+    if (!header)
+        return null;
+    const parts = String(header).split(';');
+    for (const part of parts) {
+        const idx = part.indexOf('=');
+        if (idx < 0)
+            continue;
+        const k = part.slice(0, idx).trim();
+        if (k !== name)
+            continue;
+        try {
+            return decodeURIComponent(part.slice(idx + 1).trim());
+        }
+        catch {
+            return part.slice(idx + 1).trim();
+        }
+    }
+    return null;
+}

package/dist/host/serve/page-catalog.d.ts

@@ -0,0 +1,14 @@
+export declare function bustUrl(href: string): string;
+export declare function loadPageCtor(chunkId: string): Promise<any>;
+export declare function listPageClientFiles(dir: string): Promise<{
+    chunkId: string;
+    pageRel: string;
+    routeId: string;
+    pathPattern?: string;
+    segs: string[];
+}[]>;
+export declare function runRouteGate(pathname: string, chunkId: string | undefined): Promise<any>;
+export declare function pageNeedsReload(chunkId: string, affected: string[]): boolean;
+export declare function loadPageResumeEntries(dir: string, chunkId: string): Promise<any>;
+export declare function isEventStrategy(strategy: string): boolean;
+export declare function isEventOnlyShell(strategies: string[]): boolean;