@vmz/core 0.1.11 → 0.1.13

package/dist/deployment-registry.d.ts

@@ -1,6 +1,6 @@
 /**
  * Deployment graph → component registry bootstrap (shared by all SSR/DOM hosts).
- * Replaces ad-hoc registerComponents calls with an explicit preload contract.
+ * Parse/validate and graph queries delegate to Rust vmz-artifacts via N-API.
  */
 export declare const DEPLOYMENT_SCHEMA = "vmz.deployment.v0";
 /**
@@ -13,7 +13,7 @@ export declare function readDeploymentDocument(distDir: any, opts?: {}): any;
  * @param {any} deployment
  * @returns {Array<{ chunkId: string, name: string, entry: string, source: string }>}
  */
-export declare function componentEntriesFromDeployment(deployment: any): any[];
+export declare function componentEntriesFromDeployment(deployment: any): any;
 /**
  * @param {any} deployment
  * @param {string[]} rootChunkIds

package/dist/deployment-registry.js

@@ -1,13 +1,22 @@
 // @ts-nocheck
 /**
  * Deployment graph → component registry bootstrap (shared by all SSR/DOM hosts).
- * Replaces ad-hoc registerComponents calls with an explicit preload contract.
+ * Parse/validate and graph queries delegate to Rust vmz-artifacts via N-API.
  */
 import fs from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { requireNativeFn } from './native-addon.js';
 export const DEPLOYMENT_SCHEMA = 'vmz.deployment.v0';
+/**
+ * @param {string} jsonText
+ * @returns {any}
+ */
+function parseDeploymentJson(jsonText) {
+    requireNativeFn('deploymentValidate')(jsonText);
+    return JSON.parse(jsonText);
+}
 /**
  * @param {string} distDir
  * @param {{ strict?: boolean }} [opts]
@@ -31,45 +40,22 @@ export function readDeploymentDocument(distDir, opts = {}) {
             throw new Error(`vmz: cannot read vmz-deployment.json: ${e instanceof Error ? e.message : e}`);
         return null;
     }
-    let doc;
     try {
-        doc = JSON.parse(raw);
+        return parseDeploymentJson(raw);
     }
     catch (e) {
         if (strict)
             throw new Error(`vmz: invalid vmz-deployment.json: ${e instanceof Error ? e.message : e}`);
         return null;
     }
-    if (doc.schema !== DEPLOYMENT_SCHEMA) {
-        if (strict)
-            throw new Error(`vmz: unsupported deployment schema ${doc.schema}`);
-        return null;
-    }
-    return doc;
 }
 /**
  * @param {any} deployment
  * @returns {Array<{ chunkId: string, name: string, entry: string, source: string }>}
  */
 export function componentEntriesFromDeployment(deployment) {
-    /** @type {Array<{ chunkId: string, name: string, entry: string, source: string }>} */
-    const out = [];
-    for (const unit of deployment.units || []) {
-        if (unit?.kind !== 'component')
-            continue;
-        const chunkId = String(unit.chunkId || '').replace(/\\/g, '/');
-        const name = chunkId.split('/').pop();
-        if (!name)
-            continue;
-        const entry = String(unit.clientEntry || `${chunkId}.client.js`).replace(/\\/g, '/');
-        out.push({
-            chunkId,
-            name,
-            entry,
-            source: String(unit.source || ''),
-        });
-    }
-    return out.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
+    const json = JSON.stringify(deployment);
+    return requireNativeFn('deploymentComponentEntries')(json);
 }
 /**
  * @param {any} deployment
@@ -77,30 +63,9 @@ export function componentEntriesFromDeployment(deployment) {
  * @returns {Set<string>}
  */
 export function collectDependsOnClosure(deployment, rootChunkIds) {
-    /** @type {Map<string, any>} */
-    const byId = new Map();
-    for (const unit of deployment.units || []) {
-        byId.set(String(unit.chunkId || '').replace(/\\/g, '/'), unit);
-    }
-    /** @type {Set<string>} */
-    const out = new Set();
-    /** @type {string[]} */
-    const stack = rootChunkIds.map((id) => String(id).replace(/\\/g, '/')).filter(Boolean);
-    while (stack.length) {
-        const id = stack.pop();
-        if (!id || out.has(id))
-            continue;
-        out.add(id);
-        const unit = byId.get(id);
-        if (!unit)
-            continue;
-        for (const dep of unit.dependsOn || []) {
-            const d = String(dep).replace(/\\/g, '/');
-            if (!out.has(d))
-                stack.push(d);
-        }
-    }
-    return out;
+    const json = JSON.stringify(deployment);
+    const ids = requireNativeFn('deploymentDependsOnClosure')(json, rootChunkIds);
+    return new Set(ids);
 }
 /**
  * Resolve tag conflicts; strict mode throws, dev mode warns and keeps last chunkId.

package/dist/dom-core.js

@@ -498,6 +498,14 @@ export const directApi = {
             if (typeof propName !== 'string' || !propName || propName.startsWith('#'))
                 return;
             child[propName] = raw;
+            if (typeof child.__vmzOnParentProp === 'function') {
+                try {
+                    child.__vmzOnParentProp(propName, raw);
+                }
+                catch (err) {
+                    console.error('vmz:dom __vmzOnParentProp', err);
+                }
+            }
             scheduleRefresh(child, { type: 'replace', root: propName });
         });
     },

package/dist/list-client-components.js

@@ -24,7 +24,7 @@ export async function listClientComponents(dir, opts = {}) {
             name: e.name,
             entry: e.entry,
             source: e.source,
-        }))).map((e) => ({
+        })), { strict }).map((e) => ({
             name: e.name,
             entry: e.entry,
             chunkId: e.chunkId,
@@ -65,7 +65,7 @@ export function listClientComponentsSync(dir, opts = {}) {
             name: e.name,
             entry: e.entry,
             source: e.source,
-        }))).map((e) => ({
+        })), { strict }).map((e) => ({
             name: e.name,
             entry: e.entry,
             chunkId: e.chunkId,

package/dist/native-addon.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Discover and load the vmz N-API addon (same contract as `@vmz/vmz` loadNative).
+ */
+/**
+ * @returns {any}
+ */
+export declare function loadNativeAddon(): any;
+/**
+ * @param {string} fnName
+ * @returns {any}
+ */
+export declare function requireNativeFn(fnName: any): any;

package/dist/native-addon.js

@@ -0,0 +1,116 @@
+// @ts-nocheck
+/**
+ * Discover and load the vmz N-API addon (same contract as `@vmz/vmz` loadNative).
+ */
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const require = createRequire(import.meta.url);
+/** @type {any | null | undefined} */
+let _nativeAddon;
+/**
+ * @returns {string}
+ */
+function platformTriple() {
+    const { platform, arch } = process;
+    if (platform === 'win32' && arch === 'x64')
+        return 'win32-x64-msvc';
+    if (platform === 'win32' && arch === 'arm64')
+        return 'win32-arm64-msvc';
+    if (platform === 'darwin' && arch === 'arm64')
+        return 'darwin-arm64';
+    if (platform === 'darwin' && arch === 'x64')
+        return 'darwin-x64';
+    if (platform === 'linux' && arch === 'x64')
+        return 'linux-x64-gnu';
+    if (platform === 'linux' && arch === 'arm64')
+        return 'linux-arm64-gnu';
+    return `${platform}-${arch}`;
+}
+/**
+ * @param {string} triple
+ * @returns {string}
+ */
+function platformShort(triple) {
+    if (triple === 'win32-x64-msvc')
+        return 'win32-x64';
+    if (triple === 'win32-arm64-msvc')
+        return 'win32-arm64';
+    if (triple === 'linux-x64-gnu')
+        return 'linux-x64';
+    if (triple === 'linux-arm64-gnu')
+        return 'linux-arm64';
+    return triple;
+}
+/**
+ * @returns {string[]}
+ */
+function nativeCandidatePaths() {
+    const triple = platformTriple();
+    const short = platformShort(triple);
+    const name = `@vmz/vmz-${short}`;
+    /** @type {string[]} */
+    const candidates = [];
+    try {
+        const resolved = require.resolve(`${name}/package.json`);
+        const dir = path.dirname(resolved);
+        candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
+    }
+    catch {
+        /* optional dep not installed */
+    }
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 12; depth++) {
+        candidates.push(path.join(dir, 'node_modules', name, `vmz.${triple}.node`), path.join(dir, 'node_modules', name, 'vmz.node'));
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return candidates;
+}
+/**
+ * @returns {any}
+ */
+export function loadNativeAddon() {
+    if (_nativeAddon !== undefined) {
+        if (!_nativeAddon) {
+            throw new Error('vmz native addon missing — run `pnpm napi:build`');
+        }
+        return _nativeAddon;
+    }
+    try {
+        const envPath = (typeof process.env.VMZ_NATIVE_NODE === 'string' && process.env.VMZ_NATIVE_NODE.trim()) || '';
+        if (envPath) {
+            _nativeAddon = require(path.resolve(envPath));
+            return _nativeAddon;
+        }
+        for (const p of nativeCandidatePaths()) {
+            if (existsSync(p)) {
+                _nativeAddon = require(p);
+                return _nativeAddon;
+            }
+        }
+        _nativeAddon = null;
+    }
+    catch {
+        _nativeAddon = null;
+    }
+    if (!_nativeAddon) {
+        throw new Error('vmz native addon missing — run `pnpm napi:build`');
+    }
+    return _nativeAddon;
+}
+/**
+ * @param {string} fnName
+ * @returns {any}
+ */
+export function requireNativeFn(fnName) {
+    const native = loadNativeAddon();
+    const fn = native[fnName];
+    if (typeof fn !== 'function') {
+        throw new Error(`vmz native addon missing ${fnName} — run \`pnpm napi:build\``);
+    }
+    return fn;
+}

package/dist/route-layout-chain.d.ts

@@ -0,0 +1,18 @@
+/**
+ * File-route layout chain: Application shell (outermost) + nested page Layout components.
+ */
+/** Chunk id for `src/Application.vmz` emit (`Application.client.js`). */
+export declare const APPLICATION_SHELL_CHUNK = "Application";
+/**
+ * True when the compile output includes a root Application shell.
+ */
+export declare function hasApplicationShell(distDir: string): boolean;
+/**
+ * Nearest page Layout.client.js walking up from the page chunk (outer to inner).
+ * Does not include Application — use resolveRouteLayoutChain.
+ */
+export declare function resolveNestedLayoutChain(distDir: string, pageChunkId: string): string[];
+/**
+ * Full SSR / hydrate layout chain: optional Application shell, then nested page layouts.
+ */
+export declare function resolveRouteLayoutChain(distDir: string, pageChunkId: string): string[];

package/dist/route-layout-chain.js

@@ -0,0 +1,41 @@
+/**
+ * File-route layout chain: Application shell (outermost) + nested page Layout components.
+ */
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+/** Chunk id for `src/Application.vmz` emit (`Application.client.js`). */
+export const APPLICATION_SHELL_CHUNK = 'Application';
+/**
+ * True when the compile output includes a root Application shell.
+ */
+export function hasApplicationShell(distDir) {
+    return existsSync(path.join(distDir, `${APPLICATION_SHELL_CHUNK}.client.js`));
+}
+/**
+ * Nearest page Layout.client.js walking up from the page chunk (outer to inner).
+ * Does not include Application — use resolveRouteLayoutChain.
+ */
+export function resolveNestedLayoutChain(distDir, pageChunkId) {
+    const rel = pageChunkId.replace(/^pages\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    parts.pop();
+    const chain = [];
+    for (let i = parts.length; i >= 0; i--) {
+        const dirParts = parts.slice(0, i);
+        const layoutChunk = ['pages', ...dirParts, 'Layout'].join('/');
+        if (existsSync(path.join(distDir, `${layoutChunk}.client.js`))) {
+            chain.unshift(layoutChunk);
+        }
+    }
+    return chain;
+}
+/**
+ * Full SSR / hydrate layout chain: optional Application shell, then nested page layouts.
+ */
+export function resolveRouteLayoutChain(distDir, pageChunkId) {
+    const chain = resolveNestedLayoutChain(distDir, pageChunkId);
+    if (hasApplicationShell(distDir)) {
+        chain.unshift(APPLICATION_SHELL_CHUNK);
+    }
+    return chain;
+}

package/dist/serve-host.mjs

@@ -24,9 +24,70 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createRenderHost } from './render-host.js';
 import { listClientComponents } from './list-client-components.js';
+import { loadNativeAddon } from './native-addon.js';
+import { resolveRouteLayoutChain } from './route-layout-chain.js';
 import { handleNodeRequest, setRoutes, setServerModuleResolver } from './vmz-runtime.js';
 const require = createRequire(import.meta.url);
 const distDir = process.env.VMZ_DIST ? path.resolve(process.env.VMZ_DIST) : path.dirname(fileURLToPath(import.meta.url));
+/** App project root for bare import / JSON resolve (dev SSR ≡ build node_modules). */
+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();
+}
+/** @type {ReturnType<typeof createRequire> | null} */
+let appPackageRequire = null;
+function appPackageRequireResolve() {
+    if (!appPackageRequire) {
+        const root = projectRootForResolve();
+        const pkg = path.join(root, 'package.json');
+        appPackageRequire = existsSync(pkg) ? createRequire(pkg) : require;
+    }
+    return appPackageRequire;
+}
+/**
+ * Dev/prod serve-host: resolve workspace peers + JSON imports from the app package root.
+ * Dist-relative ESM cannot see app `node_modules` without this hook.
+ */
+function installAppModuleResolveHooks() {
+    registerHooks({
+        resolve(specifier, context, nextResolve) {
+            if (!specifier ||
+                specifier.startsWith('.') ||
+                specifier.startsWith('node:') ||
+                specifier.startsWith('file:') ||
+                specifier.startsWith('#')) {
+                return nextResolve(specifier, context);
+            }
+            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);
+            }
+        },
+    });
+}
+installAppModuleResolveHooks();
 const host = process.env.VMZ_HOST || '127.0.0.1';
 const port = Number(process.env.VMZ_PORT || process.env.PORT || 5173);
 const isDev = process.env.VMZ_DEV === '1' || process.env.VMZ_DEV === 'true';
@@ -86,6 +147,8 @@ let pageCatalog = [];
 const pageCtors = new Map();
 /** Stylesheet from deployment `cssEntry` (e.g. vmz.css). */
 let cssEntry = null;
+/** Fingerprint of style inputs — busts `@import` siblings when tokens change (VMZ-8). */
+let styleBundleHash = null;
 /** @type {{ defaultThemeId: string, themeIds: string[], activationAttr: string, contentHash: string|null } | null} */
 let styleTheme = null;
 /** Locale route realization artifact from `_vmz/locale-route-realization.json` (optional). */
@@ -99,12 +162,6 @@ let shuttingDown = false;
 let ready = false;
 /** @type {{ message: string, stack?: string, at: number } | null} */
 let lastDevError = null;
-/**
- * Native CodeGenerators handle — must be declared before top-level `await softReload()`
- * (TDZ: requireNativeGenerator may run during that await).
- * @type {any}
- */
-let _nativeGen;
 setServerModuleResolver((moduleId) => {
     const rel = moduleId.replace(/^#server\//, '') + '.js';
     return bustUrl(pathToFileURL(path.join(distDir, '#server', rel)).href);
@@ -279,7 +336,7 @@ async function renderPageStream(pathname, opts = {}) {
     const resumeEntries = await loadPageResumeEntries(distDir, match.chunkId);
     const strategies = resumeEntries.map((e) => e.strategy);
     const eventOnlyShell = isEventOnlyShell(strategies);
-    const layoutChain = resolveLayoutChain(match.chunkId);
+    const layoutChain = resolveRouteLayoutChain(distDir, match.chunkId);
     return {
         status,
         stream: emitPageHtml(Page, match.chunkId, eventOnlyShell, props, opts, layoutChain, localeCtx),
@@ -338,7 +395,7 @@ function normalizeActionResult(acted) {
  * @param {string} marker
  */
 async function* emitAccessShell(marker) {
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generateHtmlShell !== 'function') {
         throw new Error('vmz native addon missing generateHtmlShell — rebuild with `pnpm napi:build`');
     }
@@ -544,12 +601,12 @@ async function* emitPageHtml(Page, chunkId, eventOnlyShell, props = {}, opts = {
     }
     if (signal?.aborted)
         return;
-    const native = requireNativeGenerator();
+    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=${reloadToken}`;
-    const cssHref = cssEntry ? `${String(cssEntry).replace(/^\/+/, '')}?t=${reloadToken}` : undefined;
+    const cssHref = cssEntryWithBust(cssEntry);
     yield native.generatePageShell({
         bodyHtml,
         chunkId,
@@ -762,6 +819,7 @@ async function softReload(opts = {}) {
         const resumeEntries = await loadPageResumeEntries(distDir, indexChunk);
         const styleMeta = await loadDeploymentStyle(distDir);
         cssEntry = styleMeta.cssEntry;
+        styleBundleHash = styleMeta.styleBundleHash;
         styleTheme = styleMeta.styleTheme;
         const lazyEventNames = resumeEntries
             .filter((e) => isEventStrategy(e.strategy))
@@ -903,7 +961,7 @@ async function* emitDevErrorHtml(err) {
     };
   })();
   </script>`;
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generateHtmlShell !== 'function') {
         throw new Error('vmz native addon missing generateHtmlShell — rebuild with `pnpm napi:build`');
     }
@@ -1202,32 +1260,6 @@ function isRouteGroupDir(seg) {
 function isRouteBoundaryStem(stem) {
     return stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound';
 }
-/**
- * Nearest `Layout.client.js` walking up from the page chunk (outer→inner).
- * @param {string} pageChunkId
- * @returns {string[]}
- */
-function resolveLayoutChain(pageChunkId) {
-    const rel = pageChunkId.replace(/^pages\//, '');
-    const parts = rel.split('/').filter(Boolean);
-    parts.pop(); // page stem
-    /** @type {string[]} */
-    const chain = [];
-    for (let i = parts.length; i >= 0; i--) {
-        const dirParts = parts.slice(0, i);
-        const layoutChunk = ['pages', ...dirParts, 'Layout'].join('/');
-        const abs = path.join(distDir, `${layoutChunk}.client.js`);
-        try {
-            // sync existence — layouts are compile artifacts next to pages
-            if (existsSync(abs))
-                chain.unshift(layoutChunk);
-        }
-        catch {
-            /* ignore */
-        }
-    }
-    return chain;
-}
 /**
  * @param {string} pathname
  * @param {typeof pageCatalog} catalog
@@ -1345,7 +1377,7 @@ async function runRouteGate(pathname, chunkId) {
  */
 function emitEntryClient(eager, lazy, token) {
     const q = `?t=${token}`;
-    const native = requireNativeGenerator();
+    const native = loadNativeAddon();
     if (typeof native.generateServeEntryClient !== 'function') {
         throw new Error('vmz native addon missing generateServeEntryClient — rebuild with `pnpm napi:build`');
     }
@@ -1358,87 +1390,32 @@ function emitEntryClient(eager, lazy, token) {
  */
 function emitEntryEvent(token) {
     const q = `?t=${token}`;
-    const native = requireNativeGenerator();
+    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);
 }
-/**
- * Load vmz N-API CodeGenerators (same discovery as `@vmz/vmz` native-addon).
- * @returns {any}
- */
-function requireNativeGenerator() {
-    if (_nativeGen !== undefined) {
-        if (!_nativeGen) {
-            throw new Error('vmz native addon missing — run `pnpm napi:build` (serve entry printers live in vmz-generator via N-API)');
-        }
-        return _nativeGen;
-    }
-    try {
-        const envPath = (typeof process.env.VMZ_NATIVE_NODE === 'string' && process.env.VMZ_NATIVE_NODE.trim()) || '';
-        if (envPath) {
-            _nativeGen = require(path.resolve(envPath));
-            return _nativeGen;
-        }
-        const { platform, arch } = process;
-        let triple = `${platform}-${arch}`;
-        if (platform === 'win32' && arch === 'x64')
-            triple = 'win32-x64-msvc';
-        else if (platform === 'win32' && arch === 'arm64')
-            triple = 'win32-arm64-msvc';
-        else if (platform === 'darwin' && arch === 'arm64')
-            triple = 'darwin-arm64';
-        else if (platform === 'darwin' && arch === 'x64')
-            triple = 'darwin-x64';
-        else if (platform === 'linux' && arch === 'x64')
-            triple = 'linux-x64-gnu';
-        else if (platform === 'linux' && arch === 'arm64')
-            triple = 'linux-arm64-gnu';
-        const short = triple === 'win32-x64-msvc'
-            ? 'win32-x64'
-            : triple === 'win32-arm64-msvc'
-                ? 'win32-arm64'
-                : triple === 'linux-x64-gnu'
-                    ? 'linux-x64'
-                    : triple === 'linux-arm64-gnu'
-                        ? 'linux-arm64'
-                        : triple;
-        const name = `@vmz/vmz-${short}`;
-        /** @type {string[]} */
-        const candidates = [];
-        try {
-            const resolved = require.resolve(`${name}/package.json`);
-            const dir = path.dirname(resolved);
-            candidates.push(path.join(dir, `vmz.${triple}.node`), path.join(dir, 'vmz.node'));
-        }
-        catch {
-            /* optional */
-        }
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        candidates.push(path.join(here, 'node_modules', name, `vmz.${triple}.node`), path.join(here, 'node_modules', name, 'vmz.node'), path.join(here, '..', 'node_modules', name, `vmz.${triple}.node`), path.join(here, '..', 'node_modules', name, 'vmz.node'));
-        for (const p of candidates) {
-            if (existsSync(p)) {
-                _nativeGen = require(p);
-                return _nativeGen;
-            }
-        }
-        _nativeGen = null;
-    }
-    catch {
-        _nativeGen = null;
-    }
-    if (!_nativeGen) {
-        throw new Error('vmz native addon missing — run `pnpm napi:build` (serve entry printers live in vmz-generator via N-API)');
-    }
-    return _nativeGen;
-}
 /**
  * Style Theme cookie / localStorage key (host contract, not a second theme API).
  */
 const THEME_STORE_KEY = 'vmz-theme';
 /** Host preference key for `routing.strategy: 'none'` (cookie + localStorage). */
 const LOCALE_STORE_KEY = 'vmz.locale';
+/**
+ * Cache-bust stylesheet entry for dev reload (token + serve revision).
+ * @param {string | null | undefined} entry
+ */
+function cssEntryWithBust(entry) {
+    if (!entry)
+        return undefined;
+    const base = String(entry).replace(/^\/+/, '');
+    const params = new URLSearchParams();
+    params.set('t', String(reloadToken));
+    if (styleBundleHash)
+        params.set('h', styleBundleHash);
+    return `${base}?${params.toString()}`;
+}
 /**
  * @param {string} dir
  * @returns {Promise<{ cssEntry: string|null, styleTheme: typeof styleTheme, styleBundleHash: string|null }>}

package/dist/server.js

@@ -751,9 +751,15 @@ async function sendHtmlStream(res, status, source, signal) {
  * @param {string} type
  */
 function sendBytes(res, status, body, type) {
-    res.writeHead(status, {
+    /** @type {Record<string, string | number>} */
+    const headers = {
         'content-type': type,
         'content-length': body.byteLength,
-    });
+    };
+    // Dev: stylesheets are rebuilt in-place — never cache @import siblings (VMZ-8).
+    if (process.env.VMZ_DEV === '1' && typeof type === 'string' && type.startsWith('text/css')) {
+        headers['cache-control'] = 'no-store';
+    }
+    res.writeHead(status, headers);
     res.end(body);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/core",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "description": "VMZ production runtime core — DOM / SSR / HTTP / WriteBarrier (no compiler)",
   "exports": {
@@ -35,6 +35,10 @@
     "./render-host": {
       "types": "./dist/render-host.d.ts",
       "default": "./dist/render-host.js"
+    },
+    "./route-layout-chain": {
+      "types": "./dist/route-layout-chain.d.ts",
+      "default": "./dist/route-layout-chain.js"
     }
   },
   "files": [
@@ -53,6 +57,14 @@
   "dependencies": {
     "linkedom": "^0.18.13"
   },
+  "optionalDependencies": {
+    "@vmz/vmz-win32-x64": "0.1.13",
+    "@vmz/vmz-win32-arm64": "0.1.13",
+    "@vmz/vmz-darwin-x64": "0.1.13",
+    "@vmz/vmz-darwin-arm64": "0.1.13",
+    "@vmz/vmz-linux-x64": "0.1.13",
+    "@vmz/vmz-linux-arm64": "0.1.13"
+  },
   "publishConfig": {
     "access": "public"
   },