@vmz/vmz 0.1.13 → 0.1.15

package/dist/static-emit.js

@@ -7,9 +7,17 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { createRenderHost } from '@vmz/core/render-host';
+import { resolveRouteLayoutChain } from '@vmz/core/route-layout-chain';
+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';
+import { requireNativeAddon } from './native-addon.js';
+import { writePrettyJsonFile } from './pretty-json.js';
+import { emitPublicStaticAssets } from './public-static-assets.js';
+import { filePathPatternFromChunk, isRouteBoundaryStem, listPublicPageUnits, parsePathPattern, unitBrowserPathPattern } from './route-path.js';
+import { emitSiteFavicon, readSiteFaviconHeadHtml } from './site-favicon.js';
 export const STATIC_DELIVERY_MANIFEST_SCHEMA = 'vmz.static.delivery_manifest.v0';
 /**
  * @param {string} distDir
@@ -26,7 +34,11 @@ export async function emitWebStatic(distDir, opts = {}) {
     if (!fs.existsSync(domPath)) {
         throw new Error(`emitWebStatic: missing ${domPath} — run vmz build first`);
     }
-    const { renderToString, renderToStream } = await import(pathToFileURL(domPath).href);
+    emitSiteFavicon(distDir, { projectRoot: opts.projectRoot });
+    const faviconHead = readSiteFaviconHeadHtml(distDir);
+    const publicAssets = emitPublicStaticAssets(distDir, { projectRoot: opts.projectRoot });
+    const host = await createRenderHost(distDir, { strictDeployment: true, preload: 'none' });
+    const { renderToString, renderToStream } = host;
     const pageCatalog = listPageClientFiles(distDir);
     /** @type {Array<{
      *   routeId: string,
@@ -43,7 +55,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({
@@ -94,7 +106,8 @@ export async function emitWebStatic(distDir, opts = {}) {
             }
         }
         const meta = await resolvePageMeta(Page, { params, props, pathname: pattern, origin });
-        const layoutChain = resolveLayoutChain(distDir, page.chunkId);
+        const layoutChain = resolveRouteLayoutChain(distDir, page.chunkId);
+        await host.ensureComponents([page.chunkId, ...layoutChain]);
         let bodyHtml = '';
         for await (const chunk of renderToStream(Page, props, {})) {
             bodyHtml += chunk;
@@ -127,6 +140,7 @@ export async function emitWebStatic(distDir, opts = {}) {
                 props,
                 meta: gen.meta,
                 cssEntry: readCssEntry(distDir),
+                headExtraHtml: faviconHead,
             });
             fs.writeFileSync(absHtml, html, 'utf8');
             generations.push({
@@ -158,11 +172,16 @@ export async function emitWebStatic(distDir, opts = {}) {
         },
         cssEntry: readCssEntry(distDir),
         isErrorDocument: true,
+        headExtraHtml: faviconHead,
     });
     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']) {
@@ -179,7 +198,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     const manifest = {
         schema: STATIC_DELIVERY_MANIFEST_SCHEMA,
         applicationId,
-        deliveryProfile: 'web-static',
+        deliveryProfile: 'static',
         origin,
         generatedAt: new Date().toISOString(),
         spaFallback: false,
@@ -204,10 +223,17 @@ export async function emitWebStatic(distDir, opts = {}) {
             sitemap: 'sitemap.xml',
             robots: 'robots.txt',
         },
+        publicAssets: {
+            schema: publicAssets.schema,
+            status: publicAssets.status,
+            fileCount: publicAssets.fileCount ?? 0,
+            source: publicAssets.source || null,
+        },
     };
     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);
+    emitStaticClientEntries(distDir, pageCatalog);
     const assets = emitContentAddressedAssets(distDir);
     manifest.contentAddressedAssets = {
         schema: assets.manifest.schema,
@@ -218,7 +244,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,
@@ -226,6 +252,7 @@ export async function emitWebStatic(distDir, opts = {}) {
         skipped,
         digest: manifest.manifestDigest,
         assets: assets.manifest,
+        publicAssets,
         cdnPolicy: cdn.policy,
         cdnAdapters: cdn.adapters,
     };
@@ -258,8 +285,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;
@@ -274,10 +304,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) });
             }
         }
     }
@@ -285,32 +316,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)
@@ -343,24 +368,6 @@ async function loadCtor(distDir, chunkId) {
     const mod = await import(`${href}?t=${Date.now()}`);
     return mod.default;
 }
-/**
- * @param {string} distDir
- * @param {string} pageChunkId
- */
-function resolveLayoutChain(distDir, pageChunkId) {
-    const rel = pageChunkId.replace(/^pages\//, '');
-    const parts = rel.split('/').filter(Boolean);
-    parts.pop();
-    /** @type {string[]} */
-    const chain = [];
-    for (let i = parts.length; i >= 0; i--) {
-        const dirParts = parts.slice(0, i);
-        const layoutChunk = ['pages', ...dirParts, 'Layout'].join('/');
-        if (fs.existsSync(path.join(distDir, `${layoutChunk}.client.js`)))
-            chain.unshift(layoutChunk);
-    }
-    return chain;
-}
 /**
  * @param {string} distDir
  * @param {string} chunkId
@@ -389,8 +396,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');
@@ -510,63 +517,93 @@ function readCssEntry(distDir) {
  *   meta: { title: string, description: string, canonical: string, robots: string, lang: string, dir?: string, alternates?: Array<{ hreflang: string, href: string }> },
  *   cssEntry: string | null,
  *   isErrorDocument?: boolean,
+ *   headExtraHtml?: string,
  * }} input
  */
 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,
+        ...(input.headExtraHtml ? { headExtraHtml: String(input.headExtraHtml) } : {}),
+    });
 }
 /**
  * @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 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);
 }
-function escapeHtml(s) {
-    return String(s).replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+/**
+ * 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');
+    }
 }
-function escapeAttr(s) {
-    return escapeHtml(s).replaceAll('"', '&quot;');
+/**
+ * @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 [];
+    }
 }
-function escapeXml(s) {
-    return escapeAttr(s).replaceAll("'", '&apos;');
+/** @param {string} strategy */
+function isEventResumeStrategy(strategy) {
+    return strategy === 'event' || strategy === 'click' || String(strategy).startsWith('event:');
 }

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.13",
+  "version": "0.1.15",
   "type": "module",
   "description": "VMZ Node toolchain — N-API workspace session + CLI (publish name @vmz/vmz)",
   "license": "MIT",
@@ -48,15 +48,14 @@
     }
   },
   "dependencies": {
-    "@vmz/core": "0.1.13",
-    "@vmz/plugin": "0.1.13",
-    "@vmz/protocol": "0.1.13",
-    "jiti": "^2.6.1",
-    "json5": "^2.2.3"
+    "@vmz/core": "0.1.15",
+    "@vmz/plugin": "0.1.15",
+    "@vmz/protocol": "0.1.15",
+    "jiti": "^2.6.1"
   },
   "peerDependencies": {
-    "@vmz/plugin-markdown-it": "0.1.13",
-    "@vmz/test": "0.1.13",
+    "@vmz/plugin-markdown-it": "0.1.15",
+    "@vmz/test": "0.1.15",
     "typescript": "^5.8.3"
   },
   "peerDependenciesMeta": {
@@ -90,12 +89,12 @@
     "cli"
   ],
   "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"
+    "@vmz/vmz-win32-x64": "0.1.15",
+    "@vmz/vmz-win32-arm64": "0.1.15",
+    "@vmz/vmz-darwin-x64": "0.1.15",
+    "@vmz/vmz-darwin-arm64": "0.1.15",
+    "@vmz/vmz-linux-x64": "0.1.15",
+    "@vmz/vmz-linux-arm64": "0.1.15"
   },
   "publishConfig": {
     "access": "public"