@vmz/vmz 0.1.9 → 0.1.10

package/dist/cli.js

@@ -3,9 +3,9 @@
  * Node CLI command implementations .
  */
 import { spawn } from 'node:child_process';
-import { copyFileSync, existsSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { HOST_PROTOCOL, createWorkspace, getProtocolVersions, resolveCoreRuntimeDist, resolveNativePath } from './index.js';
+import { HOST_PROTOCOL, createWorkspace, getProtocolVersions, materializeServeHostRuntime, resolveCoreRuntimeDist, resolveNativePath, } from './index.js';
 import { createDevSession } from './dev-session.js';
 import { gateGlobalProjectCommand, getInvocationContext, isGlobalAllowedCommand } from './invocation.js';
 import { log } from './log.js';
@@ -501,14 +501,12 @@ async function cmdServe(args) {
     });
     const hostJs = path.join(outDir, 'vmz-serve-host.mjs');
     if (!existsSync(hostJs)) {
-        const coreDist = resolveCoreRuntimeDist();
-        const src = coreDist ? path.join(coreDist, 'serve-host.mjs') : null;
-        if (src && existsSync(src)) {
-            copyFileSync(src, hostJs);
+        try {
+            materializeServeHostRuntime(outDir);
             log.info(`materialized ${hostJs} from @vmz/core (release builds omit it)`);
         }
-        else {
-            log.error(`missing ${hostJs} — run \`vmz build\` (without --release) or ensure @vmz/core is installed`);
+        catch (err) {
+            log.error(`missing ${hostJs} — run \`vmz build\` (without --release) or ensure @vmz/core is installed (${err instanceof Error ? err.message : err})`);
             return 1;
         }
     }

package/dist/content-addressed-assets.d.ts

@@ -1,9 +1,15 @@
 /**
  * A3: content-addressed assets/<hash> layout for immutable CDN objects.
  * Logical paths stay available for serve/dev; static HTML rewrites to hashed URLs.
- * Identical bytes → identical asset path (cross-release / cross-source reuse by digest).
+ * CSS aggregators (vmz.css) rewrite `@import` to hashed sibling paths under assets/.
  */
 export declare const CONTENT_ADDRESSED_ASSETS_SCHEMA = "vmz.content_addressed_assets.v0";
+/**
+ * Rewrite relative `@import "./foo.css"` to hashed paths under assets/.
+ * @param {string} cssText
+ * @param {Record<string, string>} rewrites logical (no leading slash) or `/logical` → `assets/hash.ext`
+ */
+export declare function rewriteCssImports(cssText: any, rewrites: any): any;
 /**
  * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
  * @param {string} distDir

package/dist/content-addressed-assets.js

@@ -1,7 +1,7 @@
 /**
  * A3: content-addressed assets/<hash> layout for immutable CDN objects.
  * Logical paths stay available for serve/dev; static HTML rewrites to hashed URLs.
- * Identical bytes → identical asset path (cross-release / cross-source reuse by digest).
+ * CSS aggregators (vmz.css) rewrite `@import` to hashed sibling paths under assets/.
  */
 // @ts-nocheck
 import crypto from 'node:crypto';
@@ -16,11 +16,33 @@ const DEFAULT_CANDIDATES = [
     'entry-event.js',
     'vmz.css',
     'vmz-designs.css',
+    'vmz-style.css',
     'vmz-dom.js',
     'vmz-runtime.js',
     'vmz-http.js',
     'vmz-client-nav.js',
 ];
+/** CSS files that may @import other logical CSS; processed after leaf CSS is hashed. */
+const CSS_AGGREGATORS = new Set(['vmz.css']);
+const CSS_IMPORT_RE = /@import\s*(?:url\()?['"]?(\.\/)?([^'")\s;]+)['"]?\)?/gi;
+/**
+ * Rewrite relative `@import "./foo.css"` to hashed paths under assets/.
+ * @param {string} cssText
+ * @param {Record<string, string>} rewrites logical (no leading slash) or `/logical` → `assets/hash.ext`
+ */
+export function rewriteCssImports(cssText, rewrites) {
+    return cssText.replace(CSS_IMPORT_RE, (match, _dot, target) => {
+        const logical = String(target || '').replace(/^\.\//, '');
+        if (!logical)
+            return match;
+        const hashed = rewrites[logical] || rewrites[`/${logical}`] || rewrites[`assets/${logical}`];
+        if (!hashed)
+            return match;
+        const rel = hashed.startsWith('/') ? hashed.slice(1) : hashed;
+        const sibling = rel.startsWith('assets/') ? `./${path.basename(rel)}` : `./${rel}`;
+        return `@import"${sibling}"`;
+    });
+}
 /**
  * Emit `assets/<sha256>.<ext>` copies and rewrite HTML href/src to hashed URLs.
  * @param {string} distDir
@@ -38,36 +60,24 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
     const objects = [];
     /** @type {Record<string, string>} */
     const rewrites = {};
-    for (const rel of candidates) {
-        const logical = String(rel).replace(/\\/g, '/').replace(/^\//, '');
-        const src = path.join(abs, ...logical.split('/'));
-        if (!fs.existsSync(src) || !fs.statSync(src).isFile())
+    const ordered = orderCandidates(candidates);
+    for (const rel of ordered) {
+        ingestCandidate(abs, rel, rewrites, objects, { transform: null });
+    }
+    // Aggregator CSS (vmz.css) must import hashed leaf files — rewrite then hash.
+    for (const rel of ordered) {
+        if (!CSS_AGGREGATORS.has(rel))
             continue;
-        const buf = fs.readFileSync(src);
-        const digest = sha256Hex(buf);
-        const ext = path.extname(logical) || '';
-        const assetRel = `assets/${digest}${ext}`;
-        const dest = path.join(abs, ...assetRel.split('/'));
-        if (!fs.existsSync(dest)) {
-            fs.mkdirSync(path.dirname(dest), { recursive: true });
-            fs.writeFileSync(dest, buf);
-        }
-        else {
-            // Cross-release reuse: identical digest must not be rewritten.
-            const existing = sha256Hex(fs.readFileSync(dest));
-            if (existing !== digest) {
-                throw new Error(`content-address collision at ${assetRel}`);
-            }
-        }
-        objects.push({
-            logicalPath: logical,
-            assetPath: assetRel,
-            digest,
-            bytes: buf.length,
-            immutable: true,
+        const src = path.join(abs, rel);
+        if (!fs.existsSync(src))
+            continue;
+        const rewritten = rewriteCssImports(fs.readFileSync(src, 'utf8'), rewrites);
+        removeLogicalObject(objects, rel);
+        delete rewrites[`/${rel}`];
+        delete rewrites[rel];
+        ingestCandidate(abs, rel, rewrites, objects, {
+            transform: () => Buffer.from(rewritten, 'utf8'),
         });
-        rewrites[`/${logical}`] = `/${assetRel}`;
-        rewrites[logical] = assetRel;
     }
     objects.sort((a, b) => (a.logicalPath < b.logicalPath ? -1 : a.logicalPath > b.logicalPath ? 1 : 0));
     let rewrittenHtml = 0;
@@ -89,6 +99,74 @@ export function emitContentAddressedAssets(distDir, opts = {}) {
     writePrettyJsonFile(outPath, manifest);
     return { manifest, assetsDir, rewrites, manifestPath: outPath };
 }
+/**
+ * @param {string[]} candidates
+ */
+function orderCandidates(candidates) {
+    const set = new Set(candidates.map((c) => String(c).replace(/\\/g, '/').replace(/^\//, '')));
+    /** @type {string[]} */
+    const out = [];
+    for (const name of DEFAULT_CANDIDATES) {
+        if (set.has(name) && !CSS_AGGREGATORS.has(name))
+            out.push(name);
+    }
+    for (const name of [...set].sort()) {
+        if (!CSS_AGGREGATORS.has(name) && !out.includes(name))
+            out.push(name);
+    }
+    if (set.has('vmz.css'))
+        out.push('vmz.css');
+    return out;
+}
+/**
+ * @param {Array<Record<string, any>>} objects
+ * @param {string} logical
+ */
+function removeLogicalObject(objects, logical) {
+    const idx = objects.findIndex((o) => o.logicalPath === logical);
+    if (idx >= 0)
+        objects.splice(idx, 1);
+}
+/**
+ * @param {string} absDist
+ * @param {string} rel
+ * @param {Record<string, string>} rewrites
+ * @param {Array<Record<string, any>>} objects
+ * @param {{ transform?: ((buf: Buffer) => Buffer) | null }} opts
+ */
+function ingestCandidate(absDist, rel, rewrites, objects, opts) {
+    const logical = String(rel).replace(/\\/g, '/').replace(/^\//, '');
+    const src = path.join(absDist, ...logical.split('/'));
+    if (!fs.existsSync(src) || !fs.statSync(src).isFile())
+        return;
+    let buf = fs.readFileSync(src);
+    if (typeof opts.transform === 'function') {
+        buf = opts.transform(buf);
+    }
+    const digest = sha256Hex(buf);
+    const ext = path.extname(logical) || '';
+    const assetRel = `assets/${digest}${ext}`;
+    const dest = path.join(absDist, ...assetRel.split('/'));
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.writeFileSync(dest, buf);
+    }
+    else {
+        const existing = sha256Hex(fs.readFileSync(dest));
+        if (existing !== digest) {
+            throw new Error(`content-address collision at ${assetRel}`);
+        }
+    }
+    objects.push({
+        logicalPath: logical,
+        assetPath: assetRel,
+        digest,
+        bytes: buf.length,
+        immutable: true,
+    });
+    rewrites[`/${logical}`] = `/${assetRel}`;
+    rewrites[logical] = assetRel;
+}
 /**
  * Resolve an immutable object by digest under dist/assets (cross-source reuse).
  * @param {string} distDir
@@ -124,7 +202,6 @@ export function assertSharedAssetPath(distDir, a, b, ext = '.js') {
     const rel = `assets/${da}${ext}`;
     const dest = path.join(distDir, ...rel.split('/'));
     fs.writeFileSync(dest, typeof a === 'string' ? Buffer.from(a) : a);
-    // Second write of identical bytes must be reuse, not fork.
     fs.writeFileSync(dest, typeof b === 'string' ? Buffer.from(b) : b);
     const again = resolveAssetByDigest(distDir, da, ext);
     if (!again || again.assetPath !== rel) {
@@ -139,7 +216,6 @@ function collectCandidates(distDir) {
         if (fs.existsSync(path.join(distDir, name)))
             out.push(name);
     }
-    // Include top-level *.client.js and pages/**/*.client.js referenced by resume.
     walk(distDir, distDir, (rel) => {
         if (/\.client\.js$/i.test(rel))
             out.push(rel);
@@ -173,7 +249,6 @@ function rewriteHtmlReferences(distDir, rewrites) {
         let text = fs.readFileSync(file, 'utf8');
         let next = text;
         for (const [from, to] of pairs) {
-            // href="/x" src="/x" and unquoted variants in attributes
             next = next.split(from).join(to);
         }
         if (next !== text) {

package/dist/index.d.ts

@@ -53,6 +53,14 @@ export declare function handshake(host?: {
  * @returns {string | null}
  */
 export declare function resolveCoreRuntimeDist(): string;
+/** Runtime companions required by dist/vmz-serve-host.mjs relative imports. */
+export declare const SERVE_HOST_RUNTIME_FILES: string[][];
+/**
+ * Copy serve-host + registry bootstrap modules from `@vmz/core` into app outDir.
+ * @param {string} outDir
+ * @param {string} [coreDist]
+ */
+export declare function materializeServeHostRuntime(outDir: any, coreDist?: string): void;
 /**
  * @typedef {object} WorkspaceOptions
  * @property {string} root
@@ -234,6 +242,8 @@ declare const _default: {
     expectedProtocol: typeof expectedProtocol;
     resolveNativePath: typeof resolveNativePath;
     resolveCoreRuntimeDist: typeof resolveCoreRuntimeDist;
+    materializeServeHostRuntime: typeof materializeServeHostRuntime;
+    SERVE_HOST_RUNTIME_FILES: string[][];
     loadNative: typeof loadNative;
     getProtocolVersions: typeof getProtocolVersions;
     handshake: typeof handshake;

package/dist/index.js

@@ -4,7 +4,7 @@
  * Coarse-grained only — no transform hooks / per-AST callbacks.
  */
 import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
+import { copyFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { materializeWechatPackaging } from './wechat-packaging.js';
@@ -144,6 +144,31 @@ export function resolveCoreRuntimeDist() {
         return nested;
     return null;
 }
+/** Runtime companions required by dist/vmz-serve-host.mjs relative imports. */
+export const SERVE_HOST_RUNTIME_FILES = [
+    ['serve-host.mjs', 'vmz-serve-host.mjs'],
+    ['list-client-components.js', 'list-client-components.js'],
+    ['deployment-registry.js', 'deployment-registry.js'],
+    ['render-host.js', 'render-host.js'],
+];
+/**
+ * Copy serve-host + registry bootstrap modules from `@vmz/core` into app outDir.
+ * @param {string} outDir
+ * @param {string} [coreDist]
+ */
+export function materializeServeHostRuntime(outDir, coreDist = resolveCoreRuntimeDist()) {
+    if (!coreDist) {
+        throw new Error('materializeServeHostRuntime: @vmz/core dist not found');
+    }
+    for (const [srcName, outName] of SERVE_HOST_RUNTIME_FILES) {
+        const src = path.join(coreDist, srcName);
+        const dst = path.join(outDir, outName);
+        if (!existsSync(src)) {
+            throw new Error(`materializeServeHostRuntime: missing ${src}`);
+        }
+        copyFileSync(src, dst);
+    }
+}
 /**
  * @typedef {object} WorkspaceOptions
  * @property {string} root
@@ -458,6 +483,8 @@ export default {
     expectedProtocol,
     resolveNativePath,
     resolveCoreRuntimeDist,
+    materializeServeHostRuntime,
+    SERVE_HOST_RUNTIME_FILES,
     loadNative,
     getProtocolVersions,
     handshake,

package/dist/static-emit.js

@@ -7,7 +7,8 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { preloadComponentRegistry } from '@vmz/core/component-registry';
+import { createRenderHost } from '@vmz/core/render-host';
+import { listClientComponentsSync } from '@vmz/core/component-registry';
 import { emitCdnPolicy } from './cdn-policy.js';
 import { emitContentAddressedAssets } from './content-addressed-assets.js';
 import { absoluteUrl, buildLocalePageMeta, localizeBodyLinks } from './locale-router.js';
@@ -30,8 +31,8 @@ export async function emitWebStatic(distDir, opts = {}) {
     if (!fs.existsSync(domPath)) {
         throw new Error(`emitWebStatic: missing ${domPath} — run vmz build first`);
     }
-    const { renderToString, renderToStream, registerComponents } = await import(pathToFileURL(domPath).href);
-    await preloadComponentRegistry(distDir, registerComponents);
+    const host = await createRenderHost(distDir, { strictDeployment: true, preload: 'none' });
+    const { renderToString, renderToStream } = host;
     const pageCatalog = listPageClientFiles(distDir);
     /** @type {Array<{
      *   routeId: string,
@@ -100,6 +101,7 @@ export async function emitWebStatic(distDir, opts = {}) {
         }
         const meta = await resolvePageMeta(Page, { params, props, pathname: pattern, origin });
         const layoutChain = resolveLayoutChain(distDir, page.chunkId);
+        await host.ensureComponents([page.chunkId, ...layoutChain]);
         let bodyHtml = '';
         for await (const chunk of renderToStream(Page, props, {})) {
             bodyHtml += chunk;
@@ -217,6 +219,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     const digest = sha256Hex(canonicalJson(manifest));
     manifest.manifestDigest = digest;
     writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
+    emitStaticClientEntries(distDir, pageCatalog);
     const assets = emitContentAddressedAssets(distDir);
     manifest.contentAddressedAssets = {
         schema: assets.manifest.schema,
@@ -558,3 +561,50 @@ function buildSitemap(_origin, generations) {
     }
     return native.generateSitemapXml(urls);
 }
+/**
+ * Static CDN must ship entry-client/event like serve-host (content-addressed + HTML rewrite).
+ * @param {string} distDir
+ * @param {Array<{ chunkId: string }>} pageCatalog
+ */
+function emitStaticClientEntries(distDir, pageCatalog) {
+    const componentEntries = listClientComponentsSync(distDir, { strict: true });
+    const indexChunk = pageCatalog.find((p) => p.chunkId === 'pages/index')?.chunkId || pageCatalog[0]?.chunkId || 'pages/index';
+    const resumeEntries = loadPageResumeEntriesSync(distDir, indexChunk);
+    const lazySet = new Set(resumeEntries
+        .filter((e) => isEventResumeStrategy(e.strategy))
+        .map((e) => e.component)
+        .filter(Boolean));
+    const eager = componentEntries.filter((e) => !lazySet.has(e.name));
+    const lazy = componentEntries.filter((e) => lazySet.has(e.name));
+    const native = requireNativeAddon();
+    if (typeof native.generateServeEntryClient !== 'function') {
+        throw new Error('vmz native addon missing generateServeEntryClient — rebuild with `pnpm napi:build`');
+    }
+    fs.writeFileSync(path.join(distDir, 'entry-client.js'), native.generateServeEntryClient(eager, lazy, ''), 'utf8');
+    if (typeof native.generateServeEntryEvent === 'function') {
+        fs.writeFileSync(path.join(distDir, 'entry-event.js'), native.generateServeEntryEvent(''), 'utf8');
+    }
+}
+/**
+ * @param {string} distDir
+ * @param {string} chunkId
+ */
+function loadPageResumeEntriesSync(distDir, chunkId) {
+    try {
+        const dep = JSON.parse(fs.readFileSync(path.join(distDir, 'vmz-deployment.json'), 'utf8'));
+        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 [];
+    }
+}
+/** @param {string} strategy */
+function isEventResumeStrategy(strategy) {
+    return strategy === 'event' || strategy === 'click' || String(strategy).startsWith('event:');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "type": "module",
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "license": "MIT",
@@ -48,15 +48,15 @@
     }
   },
   "dependencies": {
-    "@vmz/core": "0.1.9",
-    "@vmz/plugin": "0.1.9",
-    "@vmz/protocol": "0.1.9",
+    "@vmz/core": "0.1.10",
+    "@vmz/plugin": "0.1.10",
+    "@vmz/protocol": "0.1.10",
     "jiti": "^2.6.1",
     "json5": "^2.2.3"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.1.9",
-    "@vmz/test": "0.1.9",
+    "@vmz/plugin-markdown-it": "0.1.10",
+    "@vmz/test": "0.1.10",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -90,12 +90,12 @@
     "cli"
   ],
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.1.9",
-    "@vmz/vmz-win32-arm64": "0.1.9",
-    "@vmz/vmz-darwin-x64": "0.1.9",
-    "@vmz/vmz-darwin-arm64": "0.1.9",
-    "@vmz/vmz-linux-x64": "0.1.9",
-    "@vmz/vmz-linux-arm64": "0.1.9"
+    "@vmz/vmz-win32-x64": "0.1.10",
+    "@vmz/vmz-win32-arm64": "0.1.10",
+    "@vmz/vmz-darwin-x64": "0.1.10",
+    "@vmz/vmz-darwin-arm64": "0.1.10",
+    "@vmz/vmz-linux-x64": "0.1.10",
+    "@vmz/vmz-linux-arm64": "0.1.10"
   },
   "publishConfig": {
     "access": "public"