@vmz/vmz 0.3.12 → 0.3.13

package/dist/workspace/static-emit.d.ts

@@ -9,6 +9,12 @@ export type EmitWebStaticOpts = {
     applicationId?: string;
     staticParams?: Record<string, Array<Record<string, string>>>;
     projectRoot?: string;
+    /** Assembly recorded in the manifest (`local-static` overrides the static default). */
+    deliveryProfile?: string;
+    /** Build cancellation signal, forwarded into the SSR `onMount` budget race. */
+    signal?: AbortSignal;
+    /** Per-instance SSR `onMount` budget in ms (runtime default applies when unset). */
+    onMountBudgetMs?: number;
 };
 type StaticDeliveryManifest = {
     schema: string;
@@ -134,4 +140,28 @@ export declare function emitWebStatic(distDir: string, opts?: EmitWebStaticOpts)
         };
     };
 }>;
+/**
+ * Write the browser bootstrap modules ahead of the pack stage: `pack` needs the
+ * literal dynamic-import tables in `entry-client.js` / `entry-event.js` as graph
+ * entries and must run before HTML emit (HTML resolves `_vmz/pack/` URLs). The
+ * static emit stage re-runs the same function, so both passes produce identical
+ * bytes.
+ * @param {string} distDir
+ * @returns {string[]} written bootstrap file names
+ */
+export declare function emitStaticBootstrapEntries(distDir: any): string[];
+/**
+ * Prune the web-static delivery to its final browser set after HTML emit:
+ * remove the Node-only serve-host material (`_vmz/host/`, `vmz-serve-host.mjs`)
+ * and every unpacked module JS/map that `_vmz/pack/` chunks supersede
+ * (bootstrap entries, page/component/layout units, server faces, `#server/`,
+ * `ssr/`). The `/dom.browser.js` face closure stays — the packed navigation
+ * keeps that root-URL load by contract. JSON metadata and assets are untouched.
+ * Only `vmz serve` re-materializes the host (`materializeServeHostRuntime`);
+ * static hosting never needs it.
+ */
+export declare function pruneWebStaticDelivery(outDir: string): {
+    removed: number;
+    keptFaces: string[];
+};
 export {};

package/dist/workspace/static-emit.js

@@ -6,7 +6,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { listClientComponentsSync } from '@vmz/core/component-registry';
+import { collectDependsOnClosure, listClientComponentsSync, readDeploymentDocument } from '@vmz/core/component-registry';
 import { createRenderHost } from '@vmz/core/render-host';
 import { resolveRouteLayoutChain } from '@vmz/core/route-layout-chain';
 import { emitCdnPolicy } from './cdn-policy.js';
@@ -14,6 +14,7 @@ import { emitContentAddressedAssets, hashedAssetHref } from './content-addressed
 import { LOCALE_LINK_PLAN_REL } from '../locale/locale-route-emit.js';
 import { absoluteUrl, applyLocaleLinkPlan, buildLocaleLinkPlan, buildLocalePageMeta, linkRouteAliasesFromUnits, } from '../locale/locale-router.js';
 import { requireNativeAddon } from './native-addon.js';
+import { PACK_NODE_MANIFEST_REL, PACK_NODE_OUTPUT_DIR_REL, packEntryHref, packNodeEntryFile } from './pack.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 import { emitPublicStaticAssets } from './public-static-assets.js';
 import { emitRouteCatalog, loadRouteCatalog, ROUTE_CATALOG_SCHEMA } from './route-catalog-emit.js';
@@ -23,6 +24,7 @@ export const STATIC_EMIT_PLAN_SCHEMA = 'vmz.static.emit_plan.v0';
 export async function emitWebStatic(distDir, opts = {}) {
     const origin = String(opts.origin || process.env.VMZ_SITE_ORIGIN || 'https://example.test').replace(/\/$/, '');
     const applicationId = opts.applicationId || path.basename(path.dirname(distDir));
+    const deliveryProfile = String(opts.deliveryProfile || 'static');
     const domPath = path.join(distDir, 'vmz-dom.js');
     if (!fs.existsSync(domPath)) {
         throw new Error(`emitWebStatic: missing ${domPath} — run vmz build first`);
@@ -32,6 +34,9 @@ export async function emitWebStatic(distDir, opts = {}) {
     const publicAssets = emitPublicStaticAssets(distDir, { projectRoot: opts.projectRoot });
     const host = await createRenderHost(distDir, { strictDeployment: true, preload: 'none' });
     const { renderToString, renderToStream } = host;
+    // One budget/signal pair for every SSR render of this build: a hung or
+    // aborted `onMount` fails the page build instead of stalling it.
+    const renderOpts = { signal: opts.signal ?? undefined, onMountBudgetMs: opts.onMountBudgetMs };
     const pageCatalog = listPageClientFiles(distDir);
     const generations = [];
     const skipped = [];
@@ -41,7 +46,9 @@ export async function emitWebStatic(distDir, opts = {}) {
     const assets = emitContentAddressedAssets(distDir);
     const cssLogical = readCssEntry(distDir);
     const cssEntry = hashedAssetHref(assets.rewrites, cssLogical) || hashedAssetHref(assets.rewrites, 'vmz.css');
-    const moduleScriptSrc = hashedAssetHref(assets.rewrites, 'entry-client.js') || '/entry-client.js';
+    // Packed browser JS is final-named under `_vmz/pack/` — resolve via the pack
+    // manifest entryFiles mapping; unpacked root bytes are never a fallback.
+    const moduleScriptSrc = packEntryHref(distDir, 'entry-client.js');
     const localeArt = loadLocaleArtifact(distDir);
     const localeLinkPlan = loadLocaleLinkPlan(distDir) || buildLocaleLinkPlan(withLinkRouteAliases(localeArt, distDir, pageCatalog));
     for (const page of pageCatalog) {
@@ -99,14 +106,23 @@ export async function emitWebStatic(distDir, opts = {}) {
         const layoutChain = resolveRouteLayoutChain(distDir, page.chunkId);
         await host.ensureComponents([page.chunkId, ...layoutChain]);
         let bodyHtml = '';
-        for await (const chunk of renderToStream(Page, props, {})) {
-            bodyHtml += chunk;
+        try {
+            for await (const chunk of renderToStream(Page, props, renderOpts)) {
+                bodyHtml += chunk;
+            }
+            for (let i = layoutChain.length - 1; i >= 0; i--) {
+                const Layout = await loadCtor(distDir, layoutChain[i]);
+                if (!Layout)
+                    continue;
+                bodyHtml = await renderToString(Layout, {}, { ...renderOpts, slotHtml: bodyHtml });
+            }
         }
-        for (let i = layoutChain.length - 1; i >= 0; i--) {
-            const Layout = await loadCtor(distDir, layoutChain[i]);
-            if (!Layout)
-                continue;
-            bodyHtml = await renderToString(Layout, {}, { slotHtml: bodyHtml });
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            throw new Error(`emitWebStatic: SSR render failed for route ${pattern} (${page.chunkId}): ${detail}`, { cause: err });
+        }
+        if (opts.signal?.aborted) {
+            throw new Error(`emitWebStatic: build aborted during SSR render for route ${pattern} (${page.chunkId})`);
         }
         const localeWrites = expandLocaleStaticGenerations({
             localeArt,
@@ -188,7 +204,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     const manifest = {
         schema: STATIC_DELIVERY_MANIFEST_SCHEMA,
         applicationId,
-        deliveryProfile: 'static',
+        deliveryProfile,
         origin,
         generatedAt: new Date().toISOString(),
         spaFallback: false,
@@ -232,7 +248,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     writePrettyJsonFile(path.join(vmzDir, 'static-emit-plan.json'), {
         schema: STATIC_EMIT_PLAN_SCHEMA,
         applicationId,
-        deliveryProfile: 'static',
+        deliveryProfile,
         origin,
         localeLinks: localeLinkPlan,
         assetPlanPath: '_vmz/asset-plan.json',
@@ -331,8 +347,11 @@ function htmlPathForRoute(pathname) {
  * @param {string} chunkId
  */
 async function loadCtor(distDir, chunkId) {
-    const href = pathToFileURL(path.join(distDir, `${chunkId}.client.js`)).href;
-    const mod = await import(`${href}?t=${Date.now()}`);
+    // Node chunk identity comes from `_vmz/pack-node-manifest.json`; the
+    // unpacked root `${chunkId}.client.js` is not a fallback. No `?t=` cache
+    // bust: packed chunks are shared instance URLs.
+    const href = pathToFileURL(packNodeEntryFile(distDir, chunkId)).href;
+    const mod = await import(href);
     return mod.default;
 }
 /**
@@ -559,9 +578,14 @@ function buildSitemap(_origin, generations) {
     return native.generateSitemapXml(urls);
 }
 /**
- * Static CDN must ship entry-client/event like serve-host (content-addressed + HTML rewrite).
+ * Static CDN must ship entry-client/event like serve-host. The bootstrap tables
+ * are literal dynamic-import maps: page/layout units are keyed by chunkId
+ * (`data-vmz-page` / `data-vmz-layout` lookups) and islands are enumerated
+ * explicitly — unknown names throw at runtime by design, never via fallback
+ * specifier concatenation.
  * @param {string} distDir
  * @param {Array<{ chunkId: string }>} pageCatalog
+ * @returns {string[]} written bootstrap file names
  */
 function emitStaticClientEntries(distDir, pageCatalog) {
     const componentEntries = listClientComponentsSync(distDir, { strict: true });
@@ -571,16 +595,74 @@ function emitStaticClientEntries(distDir, pageCatalog) {
         .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));
+    // Pages/layouts resolve `<chunkId>.client.js` at the dist root (SSR loadCtor
+    // uses the same path); they must be in the table or hydration throws.
+    const pageEntries = pageCatalog.map((p) => ({ name: p.chunkId, entry: `${p.chunkId}.client.js` }));
+    const layoutNames = new Set();
+    for (const page of pageCatalog) {
+        for (const id of resolveRouteLayoutChain(distDir, page.chunkId))
+            layoutNames.add(String(id));
+    }
+    const layoutEntries = [...layoutNames].sort().map((id) => ({ name: id, entry: `${id}.client.js` }));
+    // 引导表只登记从页面/布局可达的组件：部署 IR 的 `dependsOn` 闭包之外的
+    // 组件没有任何模板引用，进入表只会变成 pack 死字节；不登记后 pack 图
+    // 不可达，prune 同时清掉未打包的散落模块。
+    const deployment = readDeploymentDocument(distDir, { strict: true });
+    const closure = collectDependsOnClosure(deployment, [...pageCatalog.map((p) => p.chunkId), ...layoutNames]);
+    const reachableComponents = componentEntries.filter((e) => closure.has(e.chunkId));
+    const eagerComponents = reachableComponents.filter((e) => !lazySet.has(e.name));
+    const lazyComponents = reachableComponents.filter((e) => lazySet.has(e.name));
+    const eager = [...eagerComponents, ...pageEntries, ...layoutEntries];
     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');
+    const written = ['entry-client.js'];
+    fs.writeFileSync(path.join(distDir, 'entry-client.js'), native.generateServeEntryClient(eager, lazyComponents, ''), 'utf8');
     if (typeof native.generateServeEntryEvent === 'function') {
-        fs.writeFileSync(path.join(distDir, 'entry-event.js'), native.generateServeEntryEvent(''), 'utf8');
+        // Event shell islands: event-strategy components + document islands whose
+        // compiled module exists in the component set (explicit enumeration).
+        const islandNames = readDocumentIslandNames(distDir);
+        const islands = [...lazyComponents];
+        for (const entry of eagerComponents) {
+            if (islandNames.has(entry.name))
+                islands.push(entry);
+        }
+        fs.writeFileSync(path.join(distDir, 'entry-event.js'), native.generateServeEntryEvent([], islands, ''), 'utf8');
+        written.push('entry-event.js');
     }
+    return written;
+}
+/**
+ * Write the browser bootstrap modules ahead of the pack stage: `pack` needs the
+ * literal dynamic-import tables in `entry-client.js` / `entry-event.js` as graph
+ * entries and must run before HTML emit (HTML resolves `_vmz/pack/` URLs). The
+ * static emit stage re-runs the same function, so both passes produce identical
+ * bytes.
+ * @param {string} distDir
+ * @returns {string[]} written bootstrap file names
+ */
+export function emitStaticBootstrapEntries(distDir) {
+    return emitStaticClientEntries(distDir, listPageClientFiles(distDir));
+}
+/**
+ * Island names from an integrated document surface (`document.islands.json`,
+ * written by the document build into the same dist). Absent file → no islands.
+ * @param {string} distDir
+ */
+function readDocumentIslandNames(distDir) {
+    const names = new Set();
+    try {
+        const plan = JSON.parse(fs.readFileSync(path.join(distDir, 'document.islands.json'), 'utf8'));
+        for (const island of plan?.islands || []) {
+            if (typeof island?.name === 'string' && island.name)
+                names.add(island.name);
+        }
+    }
+    catch {
+        /* no document surface */
+    }
+    return names;
 }
 /**
  * @param {string} distDir
@@ -605,3 +687,114 @@ function loadPageResumeEntriesSync(distDir, chunkId) {
 function isEventResumeStrategy(strategy) {
     return strategy === 'event' || strategy === 'click' || String(strategy).startsWith('event:');
 }
+/** Runtime face barrel loaded by URL (`import('/dom.browser.js')`) in the packed client navigation. */
+const FACE_ENTRY_REL = 'dom.browser.js';
+/**
+ * Transitive closure of the URL-loaded browser face: start at `dom.browser.js`
+ * and follow relative import specifiers that resolve to files in the dist tree.
+ * Everything else that is executable JS is either packed into `_vmz/pack/` or
+ * Node-side, so it must not ship in a web-static delivery.
+ */
+function collectFaceClosure(abs) {
+    const closure = new Set();
+    if (!fs.existsSync(path.join(abs, FACE_ENTRY_REL)))
+        return closure;
+    const queue = [FACE_ENTRY_REL];
+    while (queue.length) {
+        const rel = queue.shift();
+        if (closure.has(rel))
+            continue;
+        closure.add(rel);
+        let text;
+        try {
+            text = fs.readFileSync(path.join(abs, ...rel.split('/')), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const specs = [
+            ...text.matchAll(/from\s+['"](\.[^'"]+)['"]/g),
+            ...text.matchAll(/import\(\s*['"](\.[^'"]+)['"]/g),
+        ];
+        for (const m of specs) {
+            const next = path.posix.normalize(`${path.posix.dirname(rel)}/${m[1]}`);
+            if (next.startsWith('..'))
+                continue;
+            if (!fs.existsSync(path.join(abs, ...next.split('/'))))
+                continue;
+            if (!closure.has(next))
+                queue.push(next);
+        }
+    }
+    return closure;
+}
+function listFilesRecursive(abs, rel = '') {
+    const out = [];
+    for (const entry of fs.readdirSync(path.join(abs, ...rel.split('/')), { withFileTypes: true })) {
+        const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
+        if (entry.isDirectory())
+            out.push(...listFilesRecursive(abs, nextRel));
+        else if (entry.isFile())
+            out.push(nextRel);
+    }
+    return out;
+}
+function removeEmptyDirsBottomUp(abs, rel = '') {
+    for (const entry of fs.readdirSync(path.join(abs, ...rel.split('/')), { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const nextRel = rel ? `${rel}/${entry.name}` : entry.name;
+        if (nextRel === '_vmz/pack' || nextRel.startsWith('_vmz/pack/'))
+            continue;
+        removeEmptyDirsBottomUp(abs, nextRel);
+        if (nextRel === '_vmz')
+            continue;
+        if (fs.readdirSync(path.join(abs, ...nextRel.split('/'))).length === 0) {
+            fs.rmdirSync(path.join(abs, ...nextRel.split('/')));
+        }
+    }
+}
+/**
+ * Prune the web-static delivery to its final browser set after HTML emit:
+ * remove the Node-only serve-host material (`_vmz/host/`, `vmz-serve-host.mjs`)
+ * and every unpacked module JS/map that `_vmz/pack/` chunks supersede
+ * (bootstrap entries, page/component/layout units, server faces, `#server/`,
+ * `ssr/`). The `/dom.browser.js` face closure stays — the packed navigation
+ * keeps that root-URL load by contract. JSON metadata and assets are untouched.
+ * Only `vmz serve` re-materializes the host (`materializeServeHostRuntime`);
+ * static hosting never needs it.
+ */
+export function pruneWebStaticDelivery(outDir) {
+    const abs = path.resolve(outDir);
+    if (!fs.existsSync(abs))
+        throw new Error(`pruneWebStaticDelivery: missing dist ${abs}`);
+    const faceClosure = collectFaceClosure(abs);
+    let removed = 0;
+    for (const rel of listFilesRecursive(abs)) {
+        if (rel.startsWith('_vmz/pack/') || rel.startsWith('assets/'))
+            continue;
+        const isHost = rel.startsWith('_vmz/host/');
+        const isJs = rel.endsWith('.js') || rel.endsWith('.mjs') || rel.endsWith('.map');
+        if (!isHost && (!isJs || faceClosure.has(rel)))
+            continue;
+        fs.rmSync(path.join(abs, ...rel.split('/')), { force: true });
+        removed++;
+    }
+    // Node pack 是构建期产物：静态托管不会执行它，浏览器集已由 `_vmz/pack/`
+    // 定型。这里显式清掉 Node chunk 目录与 manifest，避免把服务端字节一起交付。
+    const nodePackDir = path.join(abs, ...PACK_NODE_OUTPUT_DIR_REL.split('/'));
+    if (fs.existsSync(nodePackDir)) {
+        for (const entry of fs.readdirSync(nodePackDir, { recursive: true, withFileTypes: true })) {
+            if (entry.isFile())
+                removed++;
+        }
+        fs.rmSync(nodePackDir, { recursive: true, force: true });
+    }
+    const nodeManifestPath = path.join(abs, ...PACK_NODE_MANIFEST_REL.split('/'));
+    if (fs.existsSync(nodeManifestPath)) {
+        fs.rmSync(nodeManifestPath, { force: true });
+        removed++;
+    }
+    removeEmptyDirsBottomUp(abs);
+    return { removed, keptFaces: [...faceClosure].sort() };
+}

package/dist/workspace/user-config.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Application authoring config surface — `defineConfig` + `VmzUserConfig`.
+ *
+ * Ownership: the application config entry belongs to the `vmz` package (CLI /
+ * workspace host). `@vmz/plugin` keeps the plugin author surface (`definePlugin`,
+ * protocol types). Plugin-facing types (`VmzPlugin`, `VmzEngines`) stay in
+ * `@vmz/plugin` and are referenced here by type import only.
+ */
+import type { VmzEngines, VmzPlugin } from '@vmz/plugin';
+/**
+ * Format options (`vmz format` reads `vmz.config` `format`).
+ *
+ * Scope is always the explicit CLI path; config can only narrow it. There is
+ * no `includes` / language toggle here — `vmz format <path>` formats the
+ * given file or directory and nothing else.
+ */
+export interface VmzFormatConfig {
+    /** Skip paths under these globs inside an explicit directory target. */
+    excludes?: string[];
+    /** Biome-style formatter config (default: `biome.json` at project root). */
+    style?: string;
+}
+export interface VmzUserConfig {
+    plugins?: Array<string | VmzPlugin | Promise<VmzPlugin>>;
+    engines?: VmzEngines;
+    /** Format excludes / style (`vmz format` scope is the explicit CLI path). */
+    format?: VmzFormatConfig;
+    /** Application identity (optional authoring). */
+    application?: {
+        id?: string;
+        [key: string]: unknown;
+    };
+    /**
+     * Delivery: named profiles (`default` + `profiles`) or legacy site sugar.
+     * Pure data only; never a parallel `vmz.site.ts` entry.
+     */
+    delivery?: DeliveryAuthoring;
+}
+/** Site resource sources (embedded | filesystem | remote) — orthogonal to assembly. */
+export interface SiteDeliveryAuthoring {
+    artifact: string;
+    siteId?: string;
+    sources: Array<{
+        id: string;
+        kind: 'embedded' | 'filesystem' | 'remote';
+        directory?: string;
+        baseUrl?: string;
+        artifact?: string;
+        trust?: string;
+        timeoutMs?: number;
+        priority?: number;
+        integrity?: unknown;
+        signaturePolicy?: string;
+    }>;
+    resolution?: {
+        mode?: 'release';
+        fallback?: string[];
+    };
+    activation?: 'atomic';
+    expectedCompatibility?: unknown;
+    failure?: unknown;
+    failurePolicy?: unknown;
+    update?: unknown;
+    updatePolicy?: unknown;
+    rollback?: unknown;
+    rollbackPolicy?: unknown;
+    security?: unknown;
+    securityPolicy?: unknown;
+}
+export type DeliveryAssembly = 'local-static' | 'web-static' | 'server-host' | 'cdn+server' | 'rust-embedded';
+export type DeliveryServerRuntime = 'node' | 'worker' | 'deno' | 'bun' | 'rust-host';
+export interface DeliveryProfileAuthoring {
+    host?: 'browser';
+    assembly: DeliveryAssembly;
+    /**
+     * Artifact directory under CLI `--out-dir` (default = profile id).
+     * Example: profile `static` + `name: 'cdn'` → `dist/cdn`.
+     */
+    name?: string;
+    serverRuntime?: DeliveryServerRuntime;
+    /** Inline site sources or `defineSite({...})`. */
+    sources?: SiteDeliveryAuthoring | SiteDeliveryAuthoring['sources'];
+    artifact?: string;
+    resolution?: SiteDeliveryAuthoring['resolution'];
+    activation?: SiteDeliveryAuthoring['activation'];
+}
+/** WeChat DevTools project identity. Pure data; not WeChat JSON / wx.* APIs. */
+export interface WechatPackagingAuthoring {
+    /** Registered AppID. Omit for WeChat tourist mode (`touristappid`). */
+    appId?: string;
+    projectName?: string;
+    /** `app.json` `window.navigationBarTitleText`. */
+    title?: string;
+}
+/** Vendor packaging identity under `defineConfig({ delivery })`. */
+export interface DeliveryPackagingAuthoring {
+    wechat?: WechatPackagingAuthoring;
+}
+/** Named profiles (preferred) or legacy site-only sugar. */
+export type DeliveryAuthoring = {
+    default?: string;
+    profiles: Record<string, DeliveryProfileAuthoring>;
+    packaging?: DeliveryPackagingAuthoring;
+} | (SiteDeliveryAuthoring & {
+    default?: string;
+    assembly?: DeliveryAssembly;
+    host?: 'browser';
+    serverRuntime?: DeliveryServerRuntime;
+    packaging?: DeliveryPackagingAuthoring;
+});
+/** Identity helper for `vmz.config.ts` inference. */
+export declare function defineConfig(config: VmzUserConfig): VmzUserConfig;

package/dist/workspace/user-config.js

@@ -0,0 +1,12 @@
+/**
+ * Application authoring config surface — `defineConfig` + `VmzUserConfig`.
+ *
+ * Ownership: the application config entry belongs to the `vmz` package (CLI /
+ * workspace host). `@vmz/plugin` keeps the plugin author surface (`definePlugin`,
+ * protocol types). Plugin-facing types (`VmzPlugin`, `VmzEngines`) stay in
+ * `@vmz/plugin` and are referenced here by type import only.
+ */
+/** Identity helper for `vmz.config.ts` inference. */
+export function defineConfig(config) {
+    return config ?? {};
+}

package/host-runtime-files.json

@@ -14,6 +14,7 @@
         { "src": "host/serve/hmr-dev.js", "out": "_vmz/host/serve/hmr-dev.js", "rewriteVmzRuntimeImport": true },
         { "src": "host/serve/page-render.js", "out": "_vmz/host/serve/page-render.js", "rewriteVmzRuntimeImport": true },
         { "src": "host/serve/page-catalog.js", "out": "_vmz/host/serve/page-catalog.js" },
+        { "src": "host/serve/pack-entry.js", "out": "_vmz/host/serve/pack-entry.js" },
         { "src": "host/serve/locale-theme.js", "out": "_vmz/host/serve/locale-theme.js" },
         { "src": "host/serve/constants.js", "out": "_vmz/host/serve/constants.js" },
         { "src": "host/serve/route-catalog.js", "out": "_vmz/host/serve/route-catalog.js" },

package/locales/en-US/cli.json

@@ -5,10 +5,11 @@
     "cli.cmd.build": "Build project via Workspace",
     "cli.cmd.serve": "Serve dist (optional --build)",
     "cli.cmd.dev": "Rebuild session",
-    "cli.cmd.format": "Format workspace surfaces and .vmz via vmz.config format",
-    "cli.opt.format-no-javascript": "Skip JS/TS workspace format",
-    "cli.opt.format-no-rust": "Skip cargo fmt",
-    "cli.opt.format-no-vmz": "Skip .vmz author format",
+    "cli.cmd.format": "Format an explicit file/directory path (JS/TS, .vmz, .rs with --rust)",
+    "cli.opt.format-rust": "Also format .rs files under a directory target via rustfmt",
+    "cli.opt.format-no-javascript": "Reject JS/TS targets",
+    "cli.opt.format-no-rust": "Reject .rs targets",
+    "cli.opt.format-no-vmz": "Skip .vmz targets",
     "cli.cmd.lint": "Lint (= check) via N-API",
     "cli.cmd.test": "Native test discover / report",
     "cli.cmd.document": "Project /documents domain",

package/package.json

@@ -3,23 +3,23 @@
     "vmz": "./bin/vmz.js"
   },
   "dependencies": {
-    "@vmz/commander": "0.3.12",
-    "@vmz/core": "0.3.12",
-    "@vmz/diagnostic": "0.3.12",
-    "@vmz/plugin": "0.3.12",
-    "@vmz/protocol": "0.3.12"
+    "@vmz/commander": "0.3.13",
+    "@vmz/core": "0.3.13",
+    "@vmz/diagnostic": "0.3.13",
+    "@vmz/plugin": "0.3.13",
+    "@vmz/protocol": "0.3.13"
   },
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "devDependencies": {
     "@types/node": "^22.15.0",
-    "@vmz/plugin": "0.3.12",
-    "@vmz/plugin-katex": "0.3.12",
-    "@vmz/plugin-markdown-it": "0.3.12",
-    "@vmz/plugin-shiki": "0.3.12",
-    "@vmz/test": "0.3.12",
+    "@vmz/plugin": "0.3.13",
+    "@vmz/plugin-katex": "0.3.13",
+    "@vmz/plugin-markdown-it": "0.3.13",
+    "@vmz/plugin-shiki": "0.3.13",
+    "@vmz/test": "0.3.13",
     "linkedom": "^0.18.13",
     "typescript": "^5.8.3",
-    "vmz-plugin-conformance": "0.3.12"
+    "vmz-plugin-conformance": "0.3.13"
   },
   "engines": {
     "node": ">=24.12.0"
@@ -80,16 +80,16 @@
   "main": "./dist/index.js",
   "name": "@vmz/vmz",
   "optionalDependencies": {
-    "@vmz/vmz-darwin-arm64": "0.3.12",
-    "@vmz/vmz-darwin-x64": "0.3.12",
-    "@vmz/vmz-linux-arm64": "0.3.12",
-    "@vmz/vmz-linux-x64": "0.3.12",
-    "@vmz/vmz-win32-arm64": "0.3.12",
-    "@vmz/vmz-win32-x64": "0.3.12"
+    "@vmz/vmz-darwin-arm64": "0.3.13",
+    "@vmz/vmz-darwin-x64": "0.3.13",
+    "@vmz/vmz-linux-arm64": "0.3.13",
+    "@vmz/vmz-linux-x64": "0.3.13",
+    "@vmz/vmz-win32-arm64": "0.3.13",
+    "@vmz/vmz-win32-x64": "0.3.13"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.3.12",
-    "@vmz/test": "0.3.12",
+    "@vmz/plugin-markdown-it": "0.3.13",
+    "@vmz/test": "0.3.13",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -122,5 +122,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "0.3.12"
+  "version": "0.3.13"
 }

package/dist/workspace/pack-client-packages.d.ts

@@ -1,34 +0,0 @@
-/**
- * Browser-safe client package lowering (Pack stage thin slice).
- *
- * Bare npm/workspace imports are legal on the author surface (01/04).
- * Browser ESM cannot resolve them. Pack materializes reachable package
- * modules under `dist/vendor/<pkg>/…` and rewrites importers to relative paths
- * via a bounded rewrite of generated module syntax. Pack must not re-enter the
- * parser pipeline for every emitted JavaScript file.
- *
- * This stage is only that thin slice. Linking, dead-code elimination, chunk
- * splitting, and minification are NOT implemented here — the pack manifest
- * reports their absence rather than a placeholder backend.
- */
-/**
- * @param {string} outDir
- * @param {{ projectRoot?: string | null }} [opts]
- * @returns {{ rewrittenFiles: number, vendoredModules: string[], bareSpecs: string[] }}
- */
-interface PackClientBareImportsOpts {
-    projectRoot?: string | null;
-}
-export declare function packClientBareImports(outDir: string, opts?: PackClientBareImportsOpts): {
-    rewrittenFiles: number;
-    vendoredModules: string[];
-    bareSpecs: any[];
-    unresolvedBareSpecs: any[];
-    skippedVmzExports: any[];
-    remainingBareSpecs: any[];
-};
-/** @param {string} js */
-export declare function collectBareSpecs(js: any): unknown[];
-/** Native (N-API) module specifier rewrite (`.ts`→`.js` + optional exact map). */
-export declare function rewriteRelativeTsSpecs(js: any, exactMap?: any): any;
-export {};