@vmz/vmz 0.1.0 → 0.1.1

package/dist/route-path.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Browser HTTP path projection from Route Graph / `vmz-deployment.json`.
+ * Mini pack ignores this and lowers RouteId → chunk id → page stem.
+ */
+export declare function isRouteBoundaryStem(stem: string): boolean;
+export declare function isRouteGroupDir(seg: string): boolean;
+/**
+ * File-route fallback (`pages/home` → `/home`, `pages/index` → `/`).
+ * Used only when a deployment unit has no `pathPattern`.
+ */
+export declare function filePathPatternFromChunk(chunkId: string): string;
+export type DeploymentPageUnit = {
+    kind?: string;
+    chunkId?: string;
+    clientEntry?: string;
+    programIr?: string;
+    pathPattern?: string;
+    routeId?: string;
+};
+/** Canonical Browser HTTP pattern for a page unit. Mini must not read this. */
+export declare function unitBrowserPathPattern(unit: DeploymentPageUnit | null | undefined): string;
+export type PathSeg = {
+    kind: 'static';
+    value: string;
+} | {
+    kind: 'param';
+    name: string;
+} | {
+    kind: 'catch';
+    name: string;
+};
+export declare function parsePathPattern(pattern: string): PathSeg[];
+export declare function listPublicPageUnits(deployment: {
+    units?: DeploymentPageUnit[];
+} | null | undefined): DeploymentPageUnit[];

package/dist/route-path.js

@@ -0,0 +1,77 @@
+/**
+ * Browser HTTP path projection from Route Graph / `vmz-deployment.json`.
+ * Mini pack ignores this and lowers RouteId → chunk id → page stem.
+ */
+export function isRouteBoundaryStem(stem) {
+    return stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound';
+}
+export function isRouteGroupDir(seg) {
+    return typeof seg === 'string' && seg.startsWith('(') && seg.endsWith(')') && seg.length > 2;
+}
+/**
+ * File-route fallback (`pages/home` → `/home`, `pages/index` → `/`).
+ * Used only when a deployment unit has no `pathPattern`.
+ */
+export function filePathPatternFromChunk(chunkId) {
+    const rel = String(chunkId || '').replace(/^pages\//, '');
+    const parts = rel.split('/').filter(Boolean);
+    const segs = [];
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (isRouteGroupDir(p))
+            continue;
+        if (p === 'index' && i === parts.length - 1)
+            continue;
+        if (isRouteBoundaryStem(p))
+            continue;
+        segs.push(p);
+    }
+    return segs.length ? `/${segs.join('/')}` : '/';
+}
+/** Canonical Browser HTTP pattern for a page unit. Mini must not read this. */
+export function unitBrowserPathPattern(unit) {
+    const explicit = String(unit?.pathPattern || '').trim();
+    if (explicit)
+        return explicit.startsWith('/') ? explicit : `/${explicit}`;
+    return filePathPatternFromChunk(String(unit?.chunkId || ''));
+}
+export function parsePathPattern(pattern) {
+    const raw = String(pattern || '').trim();
+    if (!raw || raw === '/')
+        return [];
+    const parts = raw.replace(/^\/+/, '').replace(/\/+$/, '').split('/').filter(Boolean);
+    const segs = [];
+    for (const p of parts) {
+        if (isRouteGroupDir(p))
+            continue;
+        segs.push(parsePathSegment(p));
+    }
+    return segs;
+}
+function parsePathSegment(p) {
+    const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(p);
+    const star = /^\*([A-Za-z_][\w]*)$/.exec(p);
+    const param = /^\[([^\]]+)\]$/.exec(p);
+    const colon = /^:([A-Za-z_][\w]*)$/.exec(p);
+    if (catchAll)
+        return { kind: 'catch', name: catchAll[1] };
+    if (star)
+        return { kind: 'catch', name: star[1] };
+    if (param)
+        return { kind: 'param', name: param[1] };
+    if (colon)
+        return { kind: 'param', name: colon[1] };
+    return { kind: 'static', value: p.toLowerCase() };
+}
+export function listPublicPageUnits(deployment) {
+    const units = Array.isArray(deployment?.units) ? deployment.units : [];
+    return units.filter((u) => {
+        if (u?.kind !== 'page')
+            return false;
+        const chunkId = String(u.chunkId || '').replace(/\\/g, '/');
+        if (!chunkId.startsWith('pages/'))
+            return false;
+        const stem = chunkId.split('/').pop() || '';
+        return !isRouteBoundaryStem(stem);
+    });
+}

package/dist/server-artifact.js

@@ -4,9 +4,10 @@
  */
 // @ts-nocheck
 import crypto from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { SERVER_RUNTIMES } from './delivery-profile.js';
+import { writePrettyJsonFile } from './pretty-json.js';
 export const SERVER_ARTIFACT_SCHEMA = 'vmz.server.artifact.v0';
 export const HTTP_CONTRACT_SCHEMA = 'vmz.http.contract.v0';
 export const SERVER_RUNTIME_ADAPTER_SCHEMA = 'vmz.server.runtime_adapter.v0';
@@ -116,14 +117,14 @@ export function emitServerArtifact(outDir, opts = {}) {
     const vmzDir = path.join(outDir, '_vmz');
     mkdirSync(vmzDir, { recursive: true });
     const file = path.join(vmzDir, 'server-artifact.json');
-    writeFileSync(file, `${JSON.stringify(artifact, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(file, artifact);
     const adapterDir = path.join(vmzDir, 'adapters');
     mkdirSync(adapterDir, { recursive: true });
     for (const adapterId of ['worker', 'rust-host']) {
         const projection = projectServerRuntimeAdapter(artifact, adapterId);
         const dir = path.join(adapterDir, adapterId);
         mkdirSync(dir, { recursive: true });
-        writeFileSync(path.join(dir, 'adapter.json'), `${JSON.stringify(projection, null, 2)}\n`, 'utf8');
+        writePrettyJsonFile(path.join(dir, 'adapter.json'), projection);
     }
     return { artifact, path: file, httpContractDigest };
 }
@@ -144,9 +145,7 @@ export function projectServerRuntimeAdapter(artifact, adapterId) {
         spaFallback: false,
         entry: artifact.entry,
         publicRouteCount: Array.isArray(artifact.publicRoutes) ? artifact.publicRoutes.length : 0,
-        internalCapabilityCount: Array.isArray(artifact.internalCapabilities)
-            ? artifact.internalCapabilities.length
-            : 0,
+        internalCapabilityCount: Array.isArray(artifact.internalCapabilities) ? artifact.internalCapabilities.length : 0,
     };
     if (id === 'node') {
         return { ...base, host: 'node:http', invoke: 'handleNodeRequest', status: 'runtime' };

package/dist/site-delivery.js

@@ -6,6 +6,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { writePrettyJsonFile } from './pretty-json.js';
 export const SITE_DELIVERY_CONTRACT_SCHEMA = 'vmz.site.delivery_contract.v0';
 export const SITE_DELIVERY_RESOLUTION_SCHEMA = 'vmz.site.delivery_resolution.v0';
 /**
@@ -318,11 +319,11 @@ export function emitSiteDelivery(outDir, deliveryRaw, opts = {}) {
     }
     const vmzDir = path.join(outDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
-    fs.writeFileSync(path.join(vmzDir, 'site-delivery-contract.json'), `${JSON.stringify(norm.contract, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(vmzDir, 'site-delivery-contract.json'), norm.contract);
     let resolution = null;
     if (opts.probes) {
         resolution = resolveSiteRelease(norm.contract, opts.probes);
-        fs.writeFileSync(path.join(vmzDir, 'site-delivery-resolution.json'), `${JSON.stringify(resolution, null, 2)}\n`, 'utf8');
+        writePrettyJsonFile(path.join(vmzDir, 'site-delivery-resolution.json'), resolution);
     }
     return { contract: norm.contract, resolution };
 }

package/dist/static-emit.js

@@ -10,6 +10,9 @@ import { pathToFileURL } from 'node:url';
 import { emitCdnPolicy } from './cdn-policy.js';
 import { emitContentAddressedAssets } from './content-addressed-assets.js';
 import { absoluteUrl, buildLocalePageMeta, localizeBodyLinks } from './locale-router.js';
+import { requireNativeAddon } from './native-addon.js';
+import { writePrettyJsonFile } from './pretty-json.js';
+import { filePathPatternFromChunk, isRouteBoundaryStem, listPublicPageUnits, parsePathPattern, unitBrowserPathPattern, } from './route-path.js';
 export const STATIC_DELIVERY_MANIFEST_SCHEMA = 'vmz.static.delivery_manifest.v0';
 /**
  * @param {string} distDir
@@ -43,7 +46,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     /** @type {Array<{ routeId: string, path: string, chunkId: string, classification: string, reason: string }>} */
     const skipped = [];
     for (const page of pageCatalog) {
-        const pattern = patternFromSegs(page.segs);
+        const pattern = page.pathPattern || patternFromSegs(page.segs);
         const routeId = guessRouteId(distDir, page.chunkId);
         if (page.segs.some((s) => s.kind === 'param' || s.kind === 'catch')) {
             skipped.push({
@@ -119,9 +122,7 @@ export async function emitWebStatic(distDir, opts = {}) {
             const absHtml = path.join(distDir, gen.htmlPath);
             fs.mkdirSync(path.dirname(absHtml), { recursive: true });
             // Each LocaleId HTML must retain locale on same-app Links (realization authority).
-            const localizedBody = gen.localeId && localeArt
-                ? localizeBodyLinks(bodyHtml, gen.localeId, localeArt)
-                : bodyHtml;
+            const localizedBody = gen.localeId && localeArt ? localizeBodyLinks(bodyHtml, gen.localeId, localeArt) : bodyHtml;
             const html = wrapDocument({
                 bodyHtml: localizedBody,
                 chunkId: page.chunkId,
@@ -164,7 +165,11 @@ export async function emitWebStatic(distDir, opts = {}) {
     fs.writeFileSync(path.join(distDir, '404.html'), notFoundHtml, 'utf8');
     const sitemap = buildSitemap(origin, generations);
     fs.writeFileSync(path.join(distDir, 'sitemap.xml'), sitemap, 'utf8');
-    const robots = `User-agent: *\nAllow: /\nDisallow: /404\nSitemap: ${origin}/sitemap.xml\n`;
+    const nativeRobots = requireNativeAddon();
+    if (typeof nativeRobots.generateRobotsTxt !== 'function') {
+        throw new Error('vmz native addon missing generateRobotsTxt — rebuild with `pnpm napi:build`');
+    }
+    const robots = nativeRobots.generateRobotsTxt(`${origin}/sitemap.xml`);
     fs.writeFileSync(path.join(distDir, 'robots.txt'), robots, 'utf8');
     // Hard rule: no SPA fallback shim in artifact.
     for (const bad of ['_redirects', 'vercel.json', 'netlify.toml']) {
@@ -209,7 +214,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     };
     const digest = sha256Hex(canonicalJson(manifest));
     manifest.manifestDigest = digest;
-    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
     const assets = emitContentAddressedAssets(distDir);
     manifest.contentAddressedAssets = {
         schema: assets.manifest.schema,
@@ -220,7 +225,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     // Re-stamp static manifest after linking asset digest (HTML already rewritten on disk).
     delete manifest.manifestDigest;
     manifest.manifestDigest = sha256Hex(canonicalJson(manifest));
-    fs.writeFileSync(path.join(vmzDir, 'static-delivery-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    writePrettyJsonFile(path.join(vmzDir, 'static-delivery-manifest.json'), manifest);
     const cdn = emitCdnPolicy(distDir, manifest);
     return {
         manifest,
@@ -260,8 +265,11 @@ function sortKeys(value) {
  * @param {string} distDir
  */
 function listPageClientFiles(distDir) {
+    const fromDep = listPagesFromDeployment(distDir);
+    if (fromDep.length)
+        return fromDep;
     const root = path.join(distDir, 'pages');
-    /** @type {Array<{ chunkId: string, segs: ReturnType<typeof parseChunkSegments> }>} */
+    /** @type {Array<{ chunkId: string, segs: ReturnType<typeof parsePathPattern>, pathPattern: string }>} */
     const out = [];
     function walk(abs, relParts) {
         let ents;
@@ -276,10 +284,11 @@ function listPageClientFiles(distDir) {
                 walk(path.join(abs, e.name), [...relParts, e.name]);
             else if (e.isFile() && e.name.endsWith('.client.js')) {
                 const stem = e.name.replace(/\.client\.js$/, '');
-                if (stem === 'Layout' || stem === 'Loading' || stem === 'Error' || stem === 'NotFound')
+                if (isRouteBoundaryStem(stem))
                     continue;
                 const chunkId = ['pages', ...relParts, stem].join('/');
-                out.push({ chunkId, segs: parseChunkSegments(chunkId) });
+                const pathPattern = filePathPatternFromChunk(chunkId);
+                out.push({ chunkId, pathPattern, segs: parsePathPattern(pathPattern) });
             }
         }
     }
@@ -287,32 +296,26 @@ function listPageClientFiles(distDir) {
     return out;
 }
 /**
- * @param {string} chunkId
+ * @param {string} distDir
  */
-function parseChunkSegments(chunkId) {
-    const rel = chunkId.replace(/^pages\//, '');
-    const parts = rel.split('/').filter(Boolean);
-    /** @type {Array<{ kind: 'static' | 'param' | 'catch', value?: string, name?: string }>} */
-    const segs = [];
-    for (let i = 0; i < parts.length; i++) {
-        const p = parts[i];
-        if (p.startsWith('(') && p.endsWith(')') && p.length > 2)
-            continue;
-        if (p === 'index' && i === parts.length - 1)
-            continue;
-        const catchAll = /^\[\.\.\.([^\]]+)\]$/.exec(p);
-        const param = /^\[([^\]]+)\]$/.exec(p);
-        if (catchAll)
-            segs.push({ kind: 'catch', name: catchAll[1] });
-        else if (param)
-            segs.push({ kind: 'param', name: param[1] });
-        else
-            segs.push({ kind: 'static', value: p.toLowerCase() });
+function listPagesFromDeployment(distDir) {
+    const deploymentPath = path.join(distDir, 'vmz-deployment.json');
+    if (!fs.existsSync(deploymentPath))
+        return [];
+    try {
+        const deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+        return listPublicPageUnits(deployment).map((u) => {
+            const chunkId = String(u.chunkId || '').replace(/\\/g, '/');
+            const pathPattern = unitBrowserPathPattern(u);
+            return { chunkId, pathPattern, segs: parsePathPattern(pathPattern) };
+        });
+    }
+    catch {
+        return [];
     }
-    return segs;
 }
 /**
- * @param {ReturnType<typeof parseChunkSegments>} segs
+ * @param {ReturnType<typeof parsePathPattern>} segs
  */
 function patternFromSegs(segs) {
     if (!segs.length)
@@ -391,8 +394,8 @@ async function resolvePageMeta(Page, ctx) {
     else if (Page.meta && typeof Page.meta === 'object') {
         raw = Page.meta;
     }
-    const title = String(raw.title || `${guessTitle(ctx.pathname)} · VMZ`);
-    const description = String(raw.description || `VMZ page ${ctx.pathname}`);
+    const title = String(raw.title || guessTitle(ctx.pathname) || 'App');
+    const description = String(raw.description || '');
     const canonical = String(raw.canonical || `${ctx.origin}${ctx.pathname === '/' ? '/' : ctx.pathname}`);
     const robots = String(raw.robots || 'index,follow');
     const lang = String(raw.lang || 'en');
@@ -438,10 +441,7 @@ function expandLocaleStaticGenerations(input) {
     const locales = (localeArt.locales || []).map((l) => l.id);
     const directions = Object.fromEntries((localeArt.locales || []).map((l) => [l.id, l.direction || 'ltr']));
     const defaultLocale = localeArt.defaultLocale || locales[0];
-    const forRoute = (localeArt.realizations || []).filter((r) => r.routeId === routeId ||
-        r.routeId === input.chunkId ||
-        r.pathPattern === pattern ||
-        (r.path === pattern && !r.prefixed));
+    const forRoute = (localeArt.realizations || []).filter((r) => r.routeId === routeId || r.routeId === input.chunkId || r.pathPattern === pattern || (r.path === pattern && !r.prefixed));
     /** @type {any[]} */
     const out = [];
     for (const loc of locales) {
@@ -519,59 +519,40 @@ function readCssEntry(distDir) {
  */
 function wrapDocument(input) {
     const propsJson = JSON.stringify(input.props ?? {});
-    const layoutAttr = input.layoutChain.length ? ` data-vmz-layout="${escapeAttr(input.layoutChain.join(','))}"` : '';
-    const pageAttr = input.chunkId ? ` data-vmz-page="${escapeAttr(input.chunkId)}"` : '';
     const localeId = input.meta.lang || 'en';
     const dir = input.meta.dir || 'ltr';
-    const localeAttr = ` data-vmz-locale="${escapeAttr(localeId)}" data-vmz-dir="${escapeAttr(dir)}"`;
-    const cssLink = input.cssEntry ? `  <link rel="stylesheet" href="/${String(input.cssEntry).replace(/^\/+/, '')}" />\n` : '';
-    const entry = input.isErrorDocument ? '' : `  <script type="module" src="/entry-client.js"></script>\n`;
-    const hreflang = (input.meta.alternates || [])
-        .map((a) => `  <link rel="alternate" hreflang="${escapeAttr(a.hreflang)}" href="${escapeAttr(a.href)}" />`)
-        .join('\n');
-    const hreflangBlock = hreflang ? `${hreflang}\n` : '';
-    return `<!DOCTYPE html>
-<html lang="${escapeAttr(localeId)}" data-locale="${escapeAttr(localeId)}" dir="${escapeAttr(dir)}">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>${escapeHtml(input.meta.title)}</title>
-  <meta name="description" content="${escapeAttr(input.meta.description)}" />
-  <meta name="robots" content="${escapeAttr(input.meta.robots)}" />
-  <link rel="canonical" href="${escapeAttr(input.meta.canonical)}" />
-${hreflangBlock}  <meta property="og:title" content="${escapeAttr(input.meta.title)}" />
-  <meta property="og:description" content="${escapeAttr(input.meta.description)}" />
-  <meta property="og:url" content="${escapeAttr(input.meta.canonical)}" />
-${cssLink}</head>
-<body>
-  <div id="app"${pageAttr}${layoutAttr}${localeAttr} data-vmz-props="${escapeAttr(propsJson)}">${input.bodyHtml}</div>
-${entry}</body>
-</html>
-`;
+    const native = requireNativeAddon();
+    if (typeof native.generatePageShell !== 'function') {
+        throw new Error('vmz native addon missing generatePageShell — rebuild with `pnpm napi:build`');
+    }
+    return native.generatePageShell({
+        bodyHtml: input.bodyHtml,
+        chunkId: input.chunkId || '',
+        layoutChain: input.layoutChain || [],
+        propsJson,
+        meta: {
+            title: input.meta.title,
+            description: input.meta.description,
+            canonical: input.meta.canonical,
+            robots: input.meta.robots,
+            lang: localeId,
+            dir,
+            alternates: input.meta.alternates || [],
+        },
+        // napi Option<String>: omit/undefined = None; null is rejected as String
+        ...(input.cssEntry ? { cssEntry: String(input.cssEntry) } : {}),
+        isErrorDocument: !!input.isErrorDocument,
+    });
 }
 /**
  * @param {string} origin
  * @param {Array<{ canonical: string, robots: string }>} generations
  */
-function buildSitemap(origin, generations) {
-    const urls = generations
-        .filter((g) => !String(g.robots).includes('noindex'))
-        .map((g) => `  <url>
-    <loc>${escapeXml(g.canonical)}</loc>
-  </url>`)
-        .join('\n');
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls}
-</urlset>
-`;
-}
-function escapeHtml(s) {
-    return String(s).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
-}
-function escapeAttr(s) {
-    return escapeHtml(s).replaceAll('"', '&quot;');
-}
-function escapeXml(s) {
-    return escapeAttr(s).replaceAll("'", '&apos;');
+function buildSitemap(_origin, generations) {
+    const urls = generations.filter((g) => !String(g.robots).includes('noindex')).map((g) => ({ loc: g.canonical }));
+    const native = requireNativeAddon();
+    if (typeof native.generateSitemapXml !== 'function') {
+        throw new Error('vmz native addon missing generateSitemapXml — rebuild with `pnpm napi:build`');
+    }
+    return native.generateSitemapXml(urls);
 }

package/dist/test-cmd.js

@@ -6,6 +6,7 @@
 import path from 'node:path';
 import { createWorkspace } from './index.js';
 import { log } from './log.js';
+import { generatePrettyJson } from './pretty-json.js';
 /**
  * @returns {Promise<typeof import('@vmz/test')>}
  */
@@ -317,7 +318,7 @@ export async function cmdTest(args) {
         return errors.length ? 2 : 0;
     }
     if (wantJson) {
-        const text = `${JSON.stringify(report, null, 2)}\n`;
+        const text = `${generatePrettyJson(report)}\n`;
         if (typeof args.json === 'string' && args.json !== 'true') {
             const { writeFileSync } = await import('node:fs');
             writeFileSync(path.resolve(String(args.json)), text);

package/dist/wechat-packaging.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Materialize `defineConfig({ delivery: { packaging: { wechat } } })` for wechat_pack.
+ * Pure data only. Writes `dist/_vmz/wechat-packaging.json` (not a second config entry).
+ */
+export declare const WECHAT_PACKAGING_SCHEMA = "vmz.target.wechat_packaging.v0";
+export declare const WECHAT_PACKAGING_REL = "dist/_vmz/wechat-packaging.json";
+/**
+ * @param {unknown} delivery
+ * @returns {{ schema: string, appId: string, projectName?: string, title?: string }}
+ */
+export declare function wechatPackagingFromDelivery(delivery: any): {
+    schema: string;
+    appId: any;
+};
+/**
+ * Load `vmz.config.*` and write the WeChat packaging contract for the Rust packer.
+ * @param {string} project
+ */
+export declare function materializeWechatPackaging(project: any): {
+    schema: string;
+    appId: any;
+};

package/dist/wechat-packaging.js

@@ -0,0 +1,59 @@
+/**
+ * Materialize `defineConfig({ delivery: { packaging: { wechat } } })` for wechat_pack.
+ * Pure data only. Writes `dist/_vmz/wechat-packaging.json` (not a second config entry).
+ */
+// @ts-nocheck
+import { existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { createJiti } from 'jiti';
+import { pickDeliveryPackaging } from './delivery-profile.js';
+import { writePrettyJsonFile } from './pretty-json.js';
+export const WECHAT_PACKAGING_SCHEMA = 'vmz.target.wechat_packaging.v0';
+export const WECHAT_PACKAGING_REL = 'dist/_vmz/wechat-packaging.json';
+const CONFIG_NAMES = ['vmz.config.ts', 'vmz.config.mts', 'vmz.config.mjs', 'vmz.config.js'];
+function loadConfigSync(project) {
+    for (const name of CONFIG_NAMES) {
+        const full = path.join(project, name);
+        if (!existsSync(full))
+            continue;
+        const jiti = createJiti(import.meta.url, {
+            interopDefault: true,
+            moduleCache: false,
+        });
+        return jiti(full);
+    }
+    return null;
+}
+/**
+ * @param {unknown} delivery
+ * @returns {{ schema: string, appId: string, projectName?: string, title?: string }}
+ */
+export function wechatPackagingFromDelivery(delivery) {
+    const diagnostics = [];
+    const packaging = pickDeliveryPackaging(delivery && typeof delivery === 'object' ? delivery : {}, diagnostics);
+    const wechat = packaging && packaging.wechat ? packaging.wechat : {};
+    /** @type {{ schema: string, appId: string, projectName?: string, title?: string }} */
+    const out = {
+        schema: WECHAT_PACKAGING_SCHEMA,
+        appId: typeof wechat.appId === 'string' && wechat.appId.trim() ? wechat.appId.trim() : 'touristappid',
+    };
+    if (typeof wechat.projectName === 'string' && wechat.projectName.trim()) {
+        out.projectName = wechat.projectName.trim();
+    }
+    if (typeof wechat.title === 'string' && wechat.title.trim()) {
+        out.title = wechat.title.trim();
+    }
+    return out;
+}
+/**
+ * Load `vmz.config.*` and write the WeChat packaging contract for the Rust packer.
+ * @param {string} project
+ */
+export function materializeWechatPackaging(project) {
+    const cfg = loadConfigSync(project);
+    const spec = wechatPackagingFromDelivery(cfg?.delivery);
+    const abs = path.join(project, WECHAT_PACKAGING_REL);
+    mkdirSync(path.dirname(abs), { recursive: true });
+    writePrettyJsonFile(abs, spec);
+    return spec;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vmz/vmz",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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.0",
-    "@vmz/plugin": "0.1.0",
-    "@vmz/protocol": "0.1.0",
+    "@vmz/core": "0.1.1",
+    "@vmz/plugin": "0.1.1",
+    "@vmz/protocol": "0.1.1",
     "jiti": "^2.6.1",
     "json5": "^2.2.3"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.1.0",
-    "@vmz/test": "0.1.0",
+    "@vmz/plugin-markdown-it": "0.1.1",
+    "@vmz/test": "0.1.1",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -90,12 +90,12 @@
     "cli"
   ],
   "optionalDependencies": {
-    "@vmz/vmz-win32-x64": "0.1.0",
-    "@vmz/vmz-win32-arm64": "0.1.0",
-    "@vmz/vmz-darwin-x64": "0.1.0",
-    "@vmz/vmz-darwin-arm64": "0.1.0",
-    "@vmz/vmz-linux-x64": "0.1.0",
-    "@vmz/vmz-linux-arm64": "0.1.0"
+    "@vmz/vmz-win32-x64": "0.1.1",
+    "@vmz/vmz-win32-arm64": "0.1.1",
+    "@vmz/vmz-darwin-x64": "0.1.1",
+    "@vmz/vmz-darwin-arm64": "0.1.1",
+    "@vmz/vmz-linux-x64": "0.1.1",
+    "@vmz/vmz-linux-arm64": "0.1.1"
   },
   "publishConfig": {
     "access": "public"