@vmz/core 0.2.5 → 0.2.7

package/dist/host/serve/page-catalog.js

@@ -0,0 +1,105 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ROUTE_CATALOG_REL, ROUTE_CATALOG_SCHEMA } from './constants.js';
+import { isRouteBoundaryStem, parsePathPattern } from './route-catalog.js';
+import { serveState } from './state.js';
+export function bustUrl(href) {
+    const u = new URL(href);
+    u.searchParams.set('t', String(serveState.reloadToken));
+    return u.href;
+}
+export async function loadPageCtor(chunkId) {
+    const pageRel = `${chunkId}.client.js`;
+    const href = bustUrl(pathToFileURL(path.join(serveState.distDir, pageRel)).href);
+    const mod = await import(href);
+    serveState.pageCtors.set(chunkId, mod.default);
+    return mod.default;
+}
+export async function listPageClientFiles(dir) {
+    const fromCatalog = await listPagesFromRouteCatalog(dir);
+    if (!fromCatalog.length) {
+        if (serveState.isDev) {
+            console.warn(`vmz dev: missing compiled ${ROUTE_CATALOG_SCHEMA} at ${path.join(dir, ...ROUTE_CATALOG_REL.split('/'))}`);
+            return [];
+        }
+        throw new Error(`vmz serve: missing compiled ${ROUTE_CATALOG_SCHEMA} at ${path.join(dir, ...ROUTE_CATALOG_REL.split('/'))}`);
+    }
+    return fromCatalog;
+}
+async function listPagesFromRouteCatalog(dir) {
+    const out = [];
+    try {
+        const raw = await readFile(path.join(dir, ...ROUTE_CATALOG_REL.split('/')), 'utf8');
+        const catalog = JSON.parse(raw);
+        if (catalog?.schema !== ROUTE_CATALOG_SCHEMA || !Array.isArray(catalog.pages))
+            return [];
+        for (const page of catalog.pages) {
+            const chunkId = String(page?.chunkId || '').replace(/\\/g, '/');
+            if (!chunkId.startsWith('pages/'))
+                continue;
+            const stem = chunkId.split('/').pop() || '';
+            if (isRouteBoundaryStem(stem))
+                continue;
+            const segs = Array.isArray(page?.segs) && page.segs.length ? page.segs : parsePathPattern(String(page?.pathPattern || ''));
+            const pageRel = String(page?.pageRel || `${chunkId}.client.js`).replace(/\\/g, '/');
+            out.push({
+                chunkId,
+                pageRel,
+                routeId: typeof page?.routeId === 'string' ? page.routeId : chunkId,
+                pathPattern: typeof page?.pathPattern === 'string' ? page.pathPattern : undefined,
+                segs,
+            });
+        }
+    }
+    catch {
+        return [];
+    }
+    return out;
+}
+export async function runRouteGate(pathname, chunkId) {
+    try {
+        const href = bustUrl(pathToFileURL(path.join(serveState.distDir, 'vmz-route-gate.mjs')).href);
+        const mod = await import(href);
+        if (typeof mod.check !== 'function')
+            return null;
+        return await mod.check(pathname, chunkId ?? null);
+    }
+    catch {
+        return null;
+    }
+}
+export function pageNeedsReload(chunkId, affected) {
+    if (chunkId === 'pages/Layout' || chunkId.endsWith('/Layout'))
+        return true;
+    return affected.some((a) => {
+        const id = String(a);
+        return id === chunkId || chunkId.startsWith(`${id}/`) || id.startsWith(`${chunkId}/`);
+    });
+}
+export async function loadPageResumeEntries(dir, chunkId) {
+    try {
+        const raw = await readFile(path.join(dir, 'vmz-deployment.json'), 'utf8');
+        const dep = JSON.parse(raw);
+        const units = Array.isArray(dep.units) ? dep.units : [];
+        const page = units.find((u) => u.chunkId === chunkId) ||
+            units.find((u) => u.chunkId === 'pages/index') ||
+            units.find((u) => u.kind === 'page');
+        const entries = Array.isArray(page?.resumeEntries) ? page.resumeEntries : [];
+        return entries.map((e) => ({
+            component: String(e.component || ''),
+            strategy: String(e.strategy || ''),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export function isEventStrategy(strategy) {
+    return strategy === 'event' || strategy === 'click' || strategy.startsWith('event:');
+}
+export function isEventOnlyShell(strategies) {
+    if (!strategies.length)
+        return false;
+    return strategies.every((s) => isEventStrategy(s));
+}

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

@@ -0,0 +1,17 @@
+import type { HostRequestOpts } from '../../shared/host.types.js';
+export declare function renderPage(pathname: string, opts?: HostRequestOpts): Promise<string>;
+export declare function renderPageStream(pathname: string, opts?: HostRequestOpts & {
+    body?: unknown;
+}): Promise<{
+    status: number;
+    stream: AsyncGenerator<any, void, unknown>;
+    redirect?: undefined;
+    headers?: undefined;
+} | {
+    status: number;
+    redirect: string;
+    headers: {
+        Location: string;
+    };
+    stream?: undefined;
+}>;

package/dist/host/serve/page-render.js

@@ -0,0 +1,419 @@
+import { localeHrefTableFromPlan, localizeBodyLinks } from '../localize-body-links.js';
+import { loadNativeAddon } from '../native-addon.js';
+import { createRenderHost } from '../render/render-host.js';
+import { resolveRouteLayoutChain } from '../render/route-layout-chain.js';
+import { extractRouteParams, findRootCatchAll, isRootCatchAll, matchFileRoute } from './route-catalog.js';
+import { emitDevErrorHtml, normalizeDevError } from './hmr-dev.js';
+import { cssEntryWithBust, htmlThemeAttrPair, localeBootstrapScript, pageMetaAlternates, resolveLocalePath, resolveThemeId, siteFaviconHeadHtml, themeBootstrapScript, } from './locale-theme.js';
+import { isEventOnlyShell, loadPageCtor, loadPageResumeEntries, runRouteGate } from './page-catalog.js';
+import { serveState } from './state.js';
+export async function renderPage(pathname, opts = {}) {
+    const rendered = await renderPageStream(pathname, opts);
+    if (!rendered)
+        return null;
+    const raw = rendered.stream ?? rendered;
+    if (!raw || typeof raw !== 'object' || typeof raw[Symbol.asyncIterator] !== 'function') {
+        return null;
+    }
+    let html = '';
+    for await (const chunk of raw) {
+        html += chunk;
+    }
+    return html;
+}
+export async function renderPageStream(pathname, opts = {}) {
+    try {
+        return await renderPageStreamInner(pathname, opts);
+    }
+    catch (err) {
+        const normalized = normalizeDevError(err);
+        serveState.lastDevError = normalized;
+        console.error('vmz serve: renderPageStream failed', normalized.message);
+        return { status: 500, stream: emitDevErrorHtml(normalized) };
+    }
+}
+async function renderPageStreamInner(pathname, opts = {}) {
+    if (serveState.isDev && serveState.lastDevError && serveState.pageCtors.size === 0) {
+        return { status: 500, stream: emitDevErrorHtml(serveState.lastDevError) };
+    }
+    const localePlan = resolveLocalePath(pathname, opts.cookieHeader);
+    if (localePlan.redirectTo) {
+        return { status: 302, redirect: localePlan.redirectTo, headers: { Location: localePlan.redirectTo } };
+    }
+    const routePath = localePlan.restPath || pathname;
+    let match = matchFileRoute(routePath, serveState.pageCatalog);
+    let status = 200;
+    const gated = await runRouteGate(routePath, match?.chunkId);
+    if (gated === 'not_found') {
+        match = findRootCatchAll(serveState.pageCatalog);
+        status = 404;
+    }
+    else if (!match) {
+        match = findRootCatchAll(serveState.pageCatalog);
+        status = 404;
+    }
+    else if (isRootCatchAll(match)) {
+        status = 404;
+    }
+    if (!match) {
+        if (serveState.isDev && serveState.lastDevError) {
+            return { status: 500, stream: emitDevErrorHtml(serveState.lastDevError) };
+        }
+        return null;
+    }
+    const Page = await loadPageCtor(match.chunkId);
+    if (!Page) {
+        if (serveState.isDev && serveState.lastDevError) {
+            return { status: 500, stream: emitDevErrorHtml(serveState.lastDevError) };
+        }
+        return null;
+    }
+    const params = extractRouteParams(match.segs, routePath);
+    const method = String(opts.method || 'GET').toUpperCase();
+    const localeCtx = {
+        localeId: localePlan.localeId,
+        dir: localePlan.dir,
+        pathname,
+        routePath,
+        alternates: pageMetaAlternates(match.chunkId, localePlan.localeId),
+    };
+    const pageCtor = Page;
+    if (typeof pageCtor.access === 'function') {
+        const access = await pageCtor.access({
+            params,
+            pathname: routePath,
+            chunkId: match.chunkId,
+            signal: opts.signal,
+            searchParams: opts.searchParams,
+            method,
+            localeId: localeCtx.localeId,
+        });
+        const closed = normalizeAccessResult(access);
+        if (closed.kind === 'redirect') {
+            return { status: 302, redirect: closed.location, headers: { Location: closed.location } };
+        }
+        if (closed.kind === 'deny') {
+            return { status: 403, stream: emitAccessShell('route-access-deny') };
+        }
+        if (closed.kind === 'not-found') {
+            const catchAll = findRootCatchAll(serveState.pageCatalog);
+            if (catchAll) {
+                const NotFound = await loadPageCtor(catchAll.chunkId);
+                if (NotFound) {
+                    const resumeEntries = await loadPageResumeEntries(serveState.distDir, catchAll.chunkId);
+                    const eventOnlyShell = isEventOnlyShell(resumeEntries.map((e) => e.strategy));
+                    return {
+                        status: 404,
+                        stream: emitPageHtml(NotFound, catchAll.chunkId, eventOnlyShell, { ...params }, opts, [], localeCtx),
+                    };
+                }
+            }
+            return { status: 404, stream: emitAccessShell('route-access-not-found') };
+        }
+    }
+    let props = { ...params };
+    if (method === 'POST' && typeof pageCtor.action === 'function') {
+        const acted = await pageCtor.action({
+            params,
+            pathname: routePath,
+            chunkId: match.chunkId,
+            signal: opts.signal,
+            searchParams: opts.searchParams,
+            body: opts.body,
+            method,
+            localeId: localeCtx.localeId,
+        });
+        const actionClosed = normalizeActionResult(acted);
+        if (actionClosed.kind === 'redirect') {
+            return { status: 302, redirect: actionClosed.location, headers: { Location: actionClosed.location } };
+        }
+        if (actionClosed.kind === 'deny') {
+            return { status: 403, stream: emitAccessShell('route-action-deny') };
+        }
+        if (actionClosed.kind === 'not-found') {
+            return { status: 404, stream: emitAccessShell('route-action-not-found') };
+        }
+        if (actionClosed.props) {
+            props = { ...props, ...actionClosed.props };
+        }
+    }
+    if (typeof pageCtor.load === 'function') {
+        const loaded = await pageCtor.load({
+            params,
+            pathname: routePath,
+            chunkId: match.chunkId,
+            signal: opts.signal,
+            searchParams: opts.searchParams,
+            localeId: localeCtx.localeId,
+        });
+        if (opts.signal?.aborted) {
+            return { status: 499, stream: emitAccessShell('route-nav-cancelled') };
+        }
+        if (loaded && typeof loaded === 'object' && !Array.isArray(loaded)) {
+            props = { ...props, ...loaded };
+        }
+    }
+    if (opts.signal?.aborted) {
+        return { status: 499, stream: emitAccessShell('route-nav-cancelled') };
+    }
+    const resumeEntries = await loadPageResumeEntries(serveState.distDir, match.chunkId);
+    const strategies = resumeEntries.map((e) => e.strategy);
+    const eventOnlyShell = isEventOnlyShell(strategies);
+    const layoutChain = resolveRouteLayoutChain(serveState.distDir, match.chunkId);
+    return {
+        status,
+        stream: emitPageHtml(Page, match.chunkId, eventOnlyShell, props, opts, layoutChain, localeCtx),
+    };
+}
+function normalizeAccessResult(access) {
+    if (access == null || access === true)
+        return { kind: 'allow' };
+    if (typeof access === 'string') {
+        const k = access.toLowerCase();
+        if (k === 'allow')
+            return { kind: 'allow' };
+        if (k === 'deny')
+            return { kind: 'deny' };
+        if (k === 'not-found' || k === 'notfound')
+            return { kind: 'not-found' };
+    }
+    if (typeof access === 'object' && access) {
+        const row = access;
+        const kind = String(row.kind || row.type || 'allow').toLowerCase();
+        if (kind === 'redirect') {
+            const location = String(row.location || row.to || row.href || '');
+            if (!location)
+                return { kind: 'deny' };
+            return { kind: 'redirect', location };
+        }
+        if (kind === 'deny')
+            return { kind: 'deny' };
+        if (kind === 'not-found' || kind === 'notfound')
+            return { kind: 'not-found' };
+        return { kind: 'allow' };
+    }
+    return { kind: 'allow' };
+}
+function normalizeActionResult(acted) {
+    const base = normalizeAccessResult(acted);
+    if (base.kind !== 'allow')
+        return base;
+    if (acted && typeof acted === 'object' && !Array.isArray(acted)) {
+        const row = acted;
+        if (row.props && typeof row.props === 'object') {
+            return { kind: 'allow', props: row.props };
+        }
+        if (!('kind' in row) && !('type' in row)) {
+            return { kind: 'allow', props: row };
+        }
+    }
+    return { kind: 'allow' };
+}
+async function* emitAccessShell(marker) {
+    const native = loadNativeAddon();
+    if (typeof native.generateHtmlShell !== 'function') {
+        throw new Error('vmz native addon missing generateHtmlShell — rebuild with `pnpm napi:build`');
+    }
+    yield native.generateHtmlShell({
+        title: 'App',
+        lang: 'en',
+        cssHrefs: [],
+        bodyHtml: `<p>${marker}</p>`,
+        bodyAttrs: [],
+    });
+}
+function resolvePageDocumentMeta(Page) {
+    try {
+        let raw = {};
+        if (typeof Page?.meta === 'function')
+            raw = Page.meta() || {};
+        else if (Page?.meta && typeof Page.meta === 'object')
+            raw = Page.meta;
+        const title = String(raw.title || '').trim();
+        const description = String(raw.description || '').trim();
+        return { title: title || 'App', description };
+    }
+    catch {
+        return { title: 'App', description: '' };
+    }
+}
+async function* emitPageHtml(Page, chunkId, eventOnlyShell, props = {}, opts = {}, layoutChain = [], localeCtx = {}) {
+    const signal = opts.signal;
+    const live = serveState.isDev
+        ? `\n  <script>
+  (() => {
+    const es = new EventSource("/__vmz/events");
+    let sawDisconnect = false;
+    es.onerror = () => { sawDisconnect = true; };
+    es.onopen = () => {
+      if (sawDisconnect) location.reload();
+    };
+    function showOverlay(err) {
+      let el = document.getElementById("vmz-dev-overlay");
+      if (!el) {
+        el = document.createElement("div");
+        el.id = "vmz-dev-overlay";
+        el.setAttribute("role", "alert");
+        Object.assign(el.style, {
+          position: "fixed", inset: "0", zIndex: "2147483646",
+          background: "rgba(15,17,21,0.92)", color: "#f4f4f5",
+          fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+          padding: "2rem", overflow: "auto",
+        });
+        document.documentElement.appendChild(el);
+      }
+      const msg = (err && err.message) || String(err || "Unknown error");
+      const stack = (err && err.stack) || "";
+      const esc = (s) => String(s).replace(/[&<>]/g, (c) => ({"&":"&amp;","<":"&lt;",">":"&gt;"}[c]));
+      el.innerHTML = "<div style=\\"max-width:56rem;margin:0 auto\\">"
+        + "<p style=\\"margin:0 0 .5rem;color:#f87171;font-weight:700\\">Dev Error</p>"
+        + "<pre style=\\"white-space:pre-wrap;margin:0 0 1rem;font-size:13px;line-height:1.45\\">" + esc(msg) + "</pre>"
+        + (stack ? "<pre style=\\"white-space:pre-wrap;opacity:.7;font-size:12px\\">" + esc(stack) + "</pre>" : "")
+        + "<p style=\\"opacity:.65;font-size:12px\\">Fix the file and save — soft reload will clear this overlay.</p>"
+        + "</div>";
+    }
+    function hideOverlay() {
+      const el = document.getElementById("vmz-dev-overlay");
+      if (el) el.remove();
+    }
+    es.onmessage = async (ev) => {
+      let msg = null;
+      try { msg = JSON.parse(ev.data); } catch { /* plain string */ }
+      if (msg && msg.type === "error") {
+        showOverlay(msg);
+        return;
+      }
+      if (!msg || msg.type !== "hmr") {
+        if (ev.data === "reload") location.reload();
+        return;
+      }
+      hideOverlay();
+      if (msg.mode === "island") {
+        try {
+          const { hydrate } = await import("/dom.browser.js?t=" + msg.token);
+          const root = document.getElementById("app");
+          const pageChunk = root && root.getAttribute("data-vmz-page");
+          if (root && pageChunk) {
+            const pageMod = await import("/" + pageChunk + ".client.js?t=" + msg.token);
+            let hmrProps = {};
+            try {
+              const raw = root.getAttribute("data-vmz-props");
+              if (raw) hmrProps = JSON.parse(raw);
+            } catch { /* ignore */ }
+            await hydrate(pageMod.default, root, hmrProps, { preserveState: true, skipOnMount: true });
+          } else {
+            location.reload();
+          }
+        } catch (err) {
+          console.error("vmz island HMR failed", err);
+          showOverlay({ message: String(err && err.message || err), stack: err && err.stack });
+        }
+        return;
+      }
+      location.reload();
+    };
+  })();
+  </script>`
+        : '';
+    const bootOverlay = serveState.isDev && serveState.lastDevError
+        ? `\n  <script>window.__VMZ_DEV_ERROR__=${JSON.stringify(serveState.lastDevError)};` +
+            `(function(){var e=window.__VMZ_DEV_ERROR__;if(!e)return;` +
+            `var ev=new Event("message");ev.data=JSON.stringify({type:"error",message:e.message,stack:e.stack});` +
+            `var d=document.createElement("div");d.id="vmz-dev-overlay";d.setAttribute("role","alert");` +
+            `Object.assign(d.style,{position:"fixed",inset:"0",zIndex:"2147483646",background:"rgba(15,17,21,0.92)",color:"#f4f4f5",fontFamily:"ui-monospace,monospace",padding:"2rem",overflow:"auto"});` +
+            `d.innerHTML="<div style='max-width:56rem;margin:0 auto'><p style='color:#f87171;font-weight:700'>Dev Error</p><pre style='white-space:pre-wrap'>"+String(e.message||e).replace(/[<>&]/g,function(c){return {"<":"&lt;",">":"&gt;","&":"&amp;"}[c]})+"</pre></div>";` +
+            `document.documentElement.appendChild(d);})();</script>`
+        : '';
+    const buildIdBoot = serveState.isDev && serveState.lastDevBuildId
+        ? `\n  <script>window.__VMZ_DEV_BUILD_ID__=${JSON.stringify(serveState.lastDevBuildId)};</script>`
+        : '';
+    if (signal?.aborted)
+        return;
+    const themeId = resolveThemeId(opts.searchParams, opts.cookieHeader);
+    const themeBoot = themeBootstrapScript();
+    const localeBoot = localeBootstrapScript();
+    const faviconHead = siteFaviconHeadHtml();
+    const propsJson = JSON.stringify(props ?? {});
+    const localeId = localeCtx.localeId || serveState.localeArtifact?.defaultLocale || 'en';
+    const dir = localeCtx.dir || 'ltr';
+    const htmlExtraAttrs = [...htmlThemeAttrPair(themeId)];
+    if (serveState.localeArtifact?.routing) {
+        htmlExtraAttrs.push('data-vmz-locale-routing', JSON.stringify({
+            strategy: serveState.localeArtifact.routing.strategy || 'prefix',
+            defaultPrefix: serveState.localeArtifact.routing.defaultPrefix || 'include',
+            defaultLocale: serveState.localeArtifact.defaultLocale,
+            locales: (serveState.localeArtifact.locales || []).map((l) => l.id),
+        }));
+        const hrefTable = localeHrefTableFromPlan(serveState.localeLinkPlan);
+        if (hrefTable && Object.keys(hrefTable).length) {
+            htmlExtraAttrs.push('data-vmz-locale-hrefs', JSON.stringify(hrefTable));
+        }
+    }
+    const pageDocMeta = resolvePageDocumentMeta(Page);
+    const prevLocaleHint = globalThis.__vmzLocaleIdHint;
+    globalThis.__vmzLocaleIdHint = localeId;
+    if (!serveState.ssrRenderHost) {
+        serveState.ssrRenderHost = await createRenderHost(serveState.distDir, {
+            strictDeployment: !serveState.isDev,
+            preload: 'none',
+            cacheBust: serveState.reloadToken,
+        });
+    }
+    await serveState.ssrRenderHost.ensureComponents([chunkId, ...layoutChain]);
+    let bodyHtml = '';
+    try {
+        for await (const chunk of serveState.ssrRenderHost.renderToStream(Page, props, { signal })) {
+            if (signal?.aborted)
+                return;
+            bodyHtml += chunk;
+        }
+        if (signal?.aborted)
+            return;
+        for (let i = layoutChain.length - 1; i >= 0; i--) {
+            const Layout = await loadPageCtor(layoutChain[i]);
+            if (!Layout)
+                continue;
+            bodyHtml = await serveState.ssrRenderHost.renderToString(Layout, {}, { signal, slotHtml: bodyHtml });
+            if (signal?.aborted)
+                return;
+        }
+        if (serveState.localeArtifact && localeId) {
+            bodyHtml = localizeBodyLinks(bodyHtml, localeId, serveState.localeArtifact, undefined, serveState.localeLinkPlan);
+        }
+    }
+    finally {
+        if (prevLocaleHint === undefined)
+            delete globalThis.__vmzLocaleIdHint;
+        else
+            globalThis.__vmzLocaleIdHint = prevLocaleHint;
+    }
+    if (signal?.aborted)
+        return;
+    const native = loadNativeAddon();
+    if (typeof native.generatePageShell !== 'function') {
+        throw new Error('vmz native addon missing generatePageShell — rebuild with `pnpm napi:build`');
+    }
+    const entrySrc = `/${eventOnlyShell ? 'entry-event.js' : 'entry-client.js'}?t=${serveState.reloadToken}`;
+    const cssHref = cssEntryWithBust(serveState.cssEntry);
+    yield native.generatePageShell({
+        bodyHtml,
+        chunkId,
+        layoutChain,
+        propsJson,
+        meta: {
+            title: pageDocMeta.title,
+            description: pageDocMeta.description,
+            canonical: '',
+            robots: '',
+            lang: localeId,
+            dir,
+            alternates: localeCtx.alternates || [],
+        },
+        ...(cssHref ? { cssEntry: cssHref } : {}),
+        isErrorDocument: false,
+        htmlExtraAttrs,
+        headExtraHtml: `${themeBoot}${localeBoot}${faviconHead}`,
+        moduleScriptSrc: entrySrc,
+        bodyTailHtml: `${live}${bootOverlay}${buildIdBoot}`,
+    });
+}

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

@@ -0,0 +1,3 @@
+export declare function projectRootForResolve(): string;
+export declare function appPackageRequireResolve(): NodeJS.Require;
+export declare function installAppModuleResolveHooks(): void;

package/dist/host/serve/paths.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire, registerHooks } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { serveState } from './state.js';
+const require = createRequire(import.meta.url);
+export function projectRootForResolve() {
+    const fromEnv = typeof process.env.VMZ_PROJECT_ROOT === 'string' ? process.env.VMZ_PROJECT_ROOT.trim() : '';
+    if (fromEnv)
+        return path.resolve(fromEnv);
+    return process.cwd();
+}
+export function appPackageRequireResolve() {
+    if (!serveState.appPackageRequire) {
+        const root = projectRootForResolve();
+        const pkg = path.join(root, 'package.json');
+        serveState.appPackageRequire = existsSync(pkg) ? createRequire(pkg) : require;
+    }
+    return serveState.appPackageRequire;
+}
+export function installAppModuleResolveHooks() {
+    registerHooks({
+        resolve(specifier, context, nextResolve) {
+            if (!specifier ||
+                specifier.startsWith('.') ||
+                specifier.startsWith('node:') ||
+                specifier.startsWith('file:') ||
+                specifier.startsWith('#')) {
+                return nextResolve(specifier, context);
+            }
+            if (context.parentURL?.startsWith('file:')) {
+                try {
+                    const parentPath = fileURLToPath(context.parentURL);
+                    if (!parentPath.startsWith(serveState.distDir + path.sep))
+                        return nextResolve(specifier, context);
+                }
+                catch {
+                    return nextResolve(specifier, context);
+                }
+            }
+            try {
+                const appParent = pathToFileURL(path.join(projectRootForResolve(), 'package.json')).href;
+                return nextResolve(specifier, { ...context, parentURL: appParent });
+            }
+            catch {
+                // Some legacy packages expose only a CommonJS entry.
+            }
+            try {
+                const resolved = appPackageRequireResolve().resolve(specifier);
+                return { url: pathToFileURL(resolved).href, shortCircuit: true };
+            }
+            catch {
+                return nextResolve(specifier, context);
+            }
+        },
+        load(url, context, nextLoad) {
+            const pathOnly = url.split('?')[0].split('#')[0];
+            if (!pathOnly.endsWith('.json'))
+                return nextLoad(url, context);
+            try {
+                const filePath = fileURLToPath(pathOnly);
+                const raw = readFileSync(filePath, 'utf8');
+                return {
+                    format: 'module',
+                    shortCircuit: true,
+                    source: `export default ${raw}`,
+                };
+            }
+            catch {
+                return nextLoad(url, context);
+            }
+        },
+    });
+}

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

@@ -0,0 +1,6 @@
+export declare function parsePathPattern(pattern: any): any[];
+export declare function isRouteBoundaryStem(stem: any): boolean;
+export declare function matchFileRoute(pathname: any, catalog: any): any;
+export declare function extractRouteParams(segs: any, pathname: any): {};
+export declare function isRootCatchAll(page: any): boolean;
+export declare function findRootCatchAll(catalog: any): any;