@vmz/vmz 0.1.29 → 0.1.31

package/dist/cli.js

@@ -4,30 +4,31 @@
 import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { HOST_PROTOCOL, createWorkspace, getProtocolVersions, materializeServeHostRuntime, resolveCoreRuntimeDist, resolveNativePath, } from './index.js';
+import { createCli } from '@vmz/commander';
+import { registerApplicationCommands } from './application-cmd.js';
+import { assembleDelivery, emitBuildProof } from './build-assemble.js';
+import { resolveCliLocalesRoot } from './cli-localize.js';
+import { normalizeDeliveryAuthoring, resolveProfileArtifactDir, selectBuildProfile } from './delivery-profile.js';
 import { createDevSession } from './dev-session.js';
-import { gateGlobalProjectCommand, getInvocationContext, isGlobalAllowedCommand } from './invocation.js';
-import { log } from './log.js';
-import { findAvailablePort } from './port.js';
-import { readPackageMeta, resolveWorkspaceDirs } from './resolve.js';
-import { registerTestCommand } from './test-cmd.js';
 import { registerDocumentCommands } from './document-cmd.js';
 import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
-import { registerLocaleCommands } from './locale-cmd.js';
+import { registerExplainCommand } from './explain-cmd.js';
+import { registerGithubActionsCommand } from './github-actions-cmd.js';
+import { createWorkspace, getProtocolVersions, HOST_PROTOCOL, materializeServeHostRuntime, resolveCoreRuntimeDist, resolveNativePath, } from './index.js';
+import { gateGlobalProjectCommand, getInvocationContext, isGlobalAllowedCommand } from './invocation.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
+import { registerLocaleCommands } from './locale-cmd.js';
 import { emitLocaleRouteRealization } from './locale-route-emit.js';
-import { registerApplicationCommands } from './application-cmd.js';
-import { registerArtifactCommands } from './release-cmd.js';
-import { registerRefactorCommands } from './refactor-cmd.js';
-import { registerExplainCommand } from './explain-cmd.js';
+import { log } from './log.js';
+import { packFromDeploymentIr } from './pack.js';
 import { registerPlanCommands } from './plan-cmd.js';
-import { registerGithubActionsCommand } from './github-actions-cmd.js';
 import { loadVmzConfig } from './plugin-host.js';
-import { normalizeDeliveryAuthoring, resolveProfileArtifactDir, selectBuildProfile } from './delivery-profile.js';
-import { packFromDeploymentIr } from './pack.js';
-import { assembleDelivery, emitBuildProof } from './build-assemble.js';
-import { createCli } from '@vmz/commander';
-import { resolveCliLocalesRoot } from './cli-localize.js';
+import { findAvailablePort } from './port.js';
+import { registerRefactorCommands } from './refactor-cmd.js';
+import { registerArtifactCommands } from './release-cmd.js';
+import { readPackageMeta, resolveWorkspaceDirs } from './resolve.js';
+import { emitRouteCatalog } from './route-catalog-emit.js';
+import { registerTestCommand } from './test-cmd.js';
 export function printGlobalHelp() {
     return buildProductCli({ mode: 'global' }).parse(['help']);
 }
@@ -224,6 +225,14 @@ async function cmdBuild(args) {
         if (localeRoutes.written.length) {
             log.info(`locale route realization (${localeRoutes.written.length} artifact(s))`);
         }
+        const routeCatalog = emitRouteCatalog(outDir);
+        if (!routeCatalog.ok) {
+            log.error(routeCatalog.error || 'route catalog emit failed');
+            return 1;
+        }
+        if (routeCatalog.written.length) {
+            log.info(`route catalog (${routeCatalog.written.length} artifact(s))`);
+        }
         if (projectHasDocuments(project)) {
             const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
             if (!docs.ok)
@@ -409,7 +418,7 @@ async function cmdDev(args) {
     }
     const outDir = resolveProfileArtifactDir(outDirRoot, selected.profile);
     const host = typeof args.host === 'string' ? args.host : '127.0.0.1';
-    const portLocked = Object.prototype.hasOwnProperty.call(args, 'port');
+    const portLocked = Object.hasOwn(args, 'port');
     let port;
     if (portLocked) {
         port = Number(args.port);

package/dist/index.d.ts

@@ -30,9 +30,9 @@ export declare function getProtocolVersions(): ProtocolVersions;
 export declare function handshake(host?: ProtocolVersions): void;
 /** Resolve `@vmz/core` package `dist/` for runtime JS copies into app outDir. */
 export declare function resolveCoreRuntimeDist(): string | null;
-/** Runtime companions required by dist/vmz-serve-host.mjs relative imports. */
+/** Runtime companions required by dist/_vmz/host/vmz-serve-host.mjs relative imports. */
 export declare const SERVE_HOST_RUNTIME_FILES: ReadonlyArray<readonly [string, string]>;
-/** Copy serve-host + registry bootstrap modules from `@vmz/core` into app outDir. */
+/** Copy serve-host + registry bootstrap modules from `@vmz/core` into `_vmz/host/`. */
 export declare function materializeServeHostRuntime(outDir: string, coreDist?: string | null): void;
 /** Create a long-lived compile workspace. */
 export declare function createWorkspace(options: WorkspaceOptions): VmzNativeAddon;

package/dist/index.js

@@ -3,7 +3,7 @@
  * Coarse-grained only — no transform hooks / per-AST callbacks.
  */
 import { createRequire } from 'node:module';
-import { copyFileSync, existsSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { materializeWechatPackaging } from './wechat-packaging.js';
@@ -119,17 +119,17 @@ export function resolveCoreRuntimeDist() {
         return nested;
     return null;
 }
-/** Runtime companions required by dist/vmz-serve-host.mjs relative imports. */
+/** Runtime companions required by dist/_vmz/host/vmz-serve-host.mjs relative imports. */
 export const SERVE_HOST_RUNTIME_FILES = [
-    ['serve-host.mjs', 'vmz-serve-host.mjs'],
-    ['native-addon.js', 'native-addon.js'],
-    ['list-client-components.js', 'list-client-components.js'],
-    ['deployment-registry.js', 'deployment-registry.js'],
-    ['render-host.js', 'render-host.js'],
-    ['route-layout-chain.js', 'route-layout-chain.js'],
-    ['localize-body-links.js', 'localize-body-links.js'],
+    ['serve-host.mjs', '_vmz/host/vmz-serve-host.mjs'],
+    ['native-addon.js', '_vmz/host/native-addon.js'],
+    ['list-client-components.js', '_vmz/host/list-client-components.js'],
+    ['deployment-registry.js', '_vmz/host/deployment-registry.js'],
+    ['render-host.js', '_vmz/host/render-host.js'],
+    ['route-layout-chain.js', '_vmz/host/route-layout-chain.js'],
+    ['localize-body-links.js', '_vmz/host/localize-body-links.js'],
 ];
-/** Copy serve-host + registry bootstrap modules from `@vmz/core` into app outDir. */
+/** Copy serve-host + registry bootstrap modules from `@vmz/core` into `_vmz/host/`. */
 export function materializeServeHostRuntime(outDir, coreDist = resolveCoreRuntimeDist()) {
     if (!coreDist) {
         throw new Error('materializeServeHostRuntime: @vmz/core dist not found');
@@ -140,8 +140,18 @@ export function materializeServeHostRuntime(outDir, coreDist = resolveCoreRuntim
         if (!existsSync(src)) {
             throw new Error(`materializeServeHostRuntime: missing ${src}`);
         }
-        copyFileSync(src, dst);
+        mkdirSync(path.dirname(dst), { recursive: true });
+        if (srcName === 'serve-host.mjs') {
+            // Nested under `_vmz/host/`: delivery-root `vmz-runtime.js` is two levels up.
+            const text = readFileSync(src, 'utf8').replace(/from\s+(['"])\.\/vmz-runtime\.js\1/g, 'from $1../../vmz-runtime.js$1');
+            writeFileSync(dst, text, 'utf8');
+        }
+        else {
+            copyFileSync(src, dst);
+        }
     }
+    const stub = path.join(outDir, 'vmz-serve-host.mjs');
+    writeFileSync(stub, "// Generated launcher — host companions live under `_vmz/host/` (0.1.31).\nimport './_vmz/host/vmz-serve-host.mjs';\n", 'utf8');
 }
 /** Create a long-lived compile workspace. */
 export function createWorkspace(options) {

package/dist/locale-route-emit.d.ts

@@ -2,7 +2,10 @@
  * Emit RouteId × LocaleId realization (+ PageMeta / hreflang seed) into dist/_vmz.
  * Consumed by serve-host + static-emit; LocaleId stays out of stable RouteId.
  */
+import { LOCALE_LINK_PLAN_SCHEMA } from '@vmz/core/localize-body-links';
 export declare const LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA = "vmz.locale.route_realization.v0";
+export declare const LOCALE_LINK_PLAN_REL = "_vmz/locale-link-plan.json";
+export { LOCALE_LINK_PLAN_SCHEMA };
 export interface EmitLocaleRouteRealizationOpts {
     origin?: string;
 }
@@ -46,6 +49,7 @@ export declare function emitLocaleRouteRealization(projectRoot: string, distDir:
             diagnostics: import("./locale-router.js").LocaleDiagnostic[];
             status: string;
         }[];
+        linkRouteAliases: import("@vmz/core/localize-body-links").LinkRouteAlias[];
     };
     diagnostics: any[];
 };

package/dist/locale-route-emit.js

@@ -4,11 +4,14 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { buildLocaleLinkPlan, LOCALE_LINK_PLAN_SCHEMA, linkRouteAliasesFromUnits } from '@vmz/core/localize-body-links';
 import { checkLocales, localeHasErrors } from './locale-check.js';
 import { buildLocalePageMeta, buildLocaleRouteRealizationTable } from './locale-router.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 import { listPublicPageUnits, unitBrowserPathPattern } from './route-path.js';
 export const LOCALE_ROUTE_REALIZATION_ARTIFACT_SCHEMA = 'vmz.locale.route_realization.v0';
+export const LOCALE_LINK_PLAN_REL = '_vmz/locale-link-plan.json';
+export { LOCALE_LINK_PLAN_SCHEMA };
 export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
     const report = checkLocales({ projectRoot, checkUnused: false });
     if (localeHasErrors(report)) {
@@ -81,6 +84,7 @@ export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
         routes,
         realizations: table.realizations,
         pageMetas,
+        linkRouteAliases: linkRouteAliasesFromUnits(pages),
     };
     const vmzDir = path.join(distDir, '_vmz');
     fs.mkdirSync(vmzDir, { recursive: true });
@@ -93,9 +97,14 @@ export function emitLocaleRouteRealization(projectRoot, distDir, opts = {}) {
         locales: artifact.locales,
         routing: artifact.routing,
     });
+    const linkPlan = buildLocaleLinkPlan(artifact);
+    writePrettyJsonFile(path.join(distDir, ...LOCALE_LINK_PLAN_REL.split('/')), {
+        schema: LOCALE_LINK_PLAN_SCHEMA,
+        rows: linkPlan.rows,
+    });
     return {
         ok: true,
-        written: ['_vmz/locale-route-realization.json', '_vmz/locale-manifest.json'],
+        written: ['_vmz/locale-route-realization.json', '_vmz/locale-manifest.json', LOCALE_LINK_PLAN_REL],
         artifact,
         diagnostics: [],
     };

package/dist/pack.js

@@ -20,7 +20,7 @@ export const PACK_MANIFEST_SCHEMA = 'vmz.pack.manifest.v0';
 export function ensureRuntimeCompanions(outDir, coreDist) {
     if (!coreDist)
         return [];
-    const names = ['dom-core.js', 'dom-ssr.js', 'dom.client.js', 'direct-host-box.js', 'unknown-component.js'];
+    const names = ['dom-core.js', 'dom-ssr.js', 'dom.client.js', 'dom.browser.js', 'direct-host-box.js', 'unknown-component.js'];
     const copied = [];
     for (const name of names) {
         const src = path.join(coreDist, name);

package/dist/project-build.js

@@ -11,6 +11,7 @@ import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
 import { emitLocaleRouteRealization } from './locale-route-emit.js';
 import { packFromDeploymentIr } from './pack.js';
 import { loadVmzConfig } from './plugin-host.js';
+import { emitRouteCatalog } from './route-catalog-emit.js';
 function dedupeDiagnostics(list) {
     const seen = new Set();
     const out = [];
@@ -129,6 +130,17 @@ export async function buildProjectToOutDirRoot(project, outDirRoot, opts = {}) {
                 error: 'locale route realization emit failed',
             };
         }
+        const routeCatalog = emitRouteCatalog(artifactDir);
+        if (!routeCatalog.ok) {
+            return {
+                ok: false,
+                outDirRoot: root,
+                artifactDir,
+                deliveryName,
+                diagnostics,
+                error: routeCatalog.error || 'route catalog emit failed',
+            };
+        }
         if (projectHasDocuments(project)) {
             const docs = await buildIntegratedDocuments({ projectRoot: project, outDir: artifactDir });
             if (!docs.ok) {

package/dist/route-catalog-emit.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compiled route catalog (`_vmz/route-catalog.json`) — 0.1.30 authority for page matching.
+ * Hosts load this artifact; they must not re-parse deployment pathPattern into a live catalog.
+ */
+import { type DeploymentPageUnit, type PathSeg } from './route-path.js';
+export declare const ROUTE_CATALOG_SCHEMA = "vmz.route.catalog.v0";
+export declare const ROUTE_CATALOG_REL = "_vmz/route-catalog.json";
+export type RouteCatalogPage = {
+    chunkId: string;
+    routeId: string;
+    pathPattern: string;
+    pageRel: string;
+    segs: PathSeg[];
+};
+export type RouteCatalog = {
+    schema: typeof ROUTE_CATALOG_SCHEMA;
+    pages: RouteCatalogPage[];
+};
+export declare function buildRouteCatalogFromDeployment(deployment: {
+    units?: DeploymentPageUnit[];
+} | null | undefined): RouteCatalog;
+export declare function emitRouteCatalog(distDir: string): {
+    ok: boolean;
+    written: string[];
+    catalog: RouteCatalog | null;
+    error?: string;
+};
+export declare function loadRouteCatalog(distDir: string): RouteCatalog | null;

package/dist/route-catalog-emit.js

@@ -0,0 +1,63 @@
+/**
+ * Compiled route catalog (`_vmz/route-catalog.json`) — 0.1.30 authority for page matching.
+ * Hosts load this artifact; they must not re-parse deployment pathPattern into a live catalog.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { writePrettyJsonFile } from './pretty-json.js';
+import { listPublicPageUnits, parsePathPattern, unitBrowserPathPattern } from './route-path.js';
+export const ROUTE_CATALOG_SCHEMA = 'vmz.route.catalog.v0';
+export const ROUTE_CATALOG_REL = '_vmz/route-catalog.json';
+export function buildRouteCatalogFromDeployment(deployment) {
+    const pages = [];
+    for (const unit of listPublicPageUnits(deployment)) {
+        const chunkId = String(unit.chunkId || '').replace(/\\/g, '/');
+        const pathPattern = unitBrowserPathPattern(unit);
+        const pageRel = String(unit.clientEntry || `${chunkId}.client.js`).replace(/\\/g, '/');
+        const routeId = typeof unit.routeId === 'string' && unit.routeId.trim() ? unit.routeId.trim() : chunkId;
+        pages.push({
+            chunkId,
+            routeId,
+            pathPattern,
+            pageRel,
+            segs: parsePathPattern(pathPattern),
+        });
+    }
+    pages.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
+    return { schema: ROUTE_CATALOG_SCHEMA, pages };
+}
+export function emitRouteCatalog(distDir) {
+    const deploymentPath = path.join(distDir, 'vmz-deployment.json');
+    if (!fs.existsSync(deploymentPath)) {
+        return { ok: false, written: [], catalog: null, error: `missing ${deploymentPath}` };
+    }
+    let deployment;
+    try {
+        deployment = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+    }
+    catch (err) {
+        return { ok: false, written: [], catalog: null, error: err instanceof Error ? err.message : String(err) };
+    }
+    const catalog = buildRouteCatalogFromDeployment(deployment);
+    if (!catalog.pages.length) {
+        return { ok: false, written: [], catalog: null, error: 'no page units with pathPattern' };
+    }
+    const vmzDir = path.join(distDir, '_vmz');
+    fs.mkdirSync(vmzDir, { recursive: true });
+    writePrettyJsonFile(path.join(distDir, ...ROUTE_CATALOG_REL.split('/')), catalog);
+    return { ok: true, written: [ROUTE_CATALOG_REL], catalog };
+}
+export function loadRouteCatalog(distDir) {
+    const p = path.join(distDir, ...ROUTE_CATALOG_REL.split('/'));
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+        if (raw?.schema !== ROUTE_CATALOG_SCHEMA || !Array.isArray(raw.pages))
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/static-emit.js

@@ -11,11 +11,12 @@ import { createRenderHost } from '@vmz/core/render-host';
 import { resolveRouteLayoutChain } from '@vmz/core/route-layout-chain';
 import { emitCdnPolicy } from './cdn-policy.js';
 import { emitContentAddressedAssets, hashedAssetHref } from './content-addressed-assets.js';
+import { LOCALE_LINK_PLAN_REL } from './locale-route-emit.js';
 import { absoluteUrl, applyLocaleLinkPlan, buildLocaleLinkPlan, buildLocalePageMeta, linkRouteAliasesFromUnits } from './locale-router.js';
 import { requireNativeAddon } from './native-addon.js';
 import { writePrettyJsonFile } from './pretty-json.js';
 import { emitPublicStaticAssets } from './public-static-assets.js';
-import { listPublicPageUnits, parsePathPattern, unitBrowserPathPattern } from './route-path.js';
+import { emitRouteCatalog, loadRouteCatalog, ROUTE_CATALOG_SCHEMA } from './route-catalog-emit.js';
 import { emitSiteFavicon, readSiteFaviconHeadHtml } from './site-favicon.js';
 export const STATIC_DELIVERY_MANIFEST_SCHEMA = 'vmz.static.delivery_manifest.v0';
 export const STATIC_EMIT_PLAN_SCHEMA = 'vmz.static.emit_plan.v0';
@@ -42,7 +43,7 @@ export async function emitWebStatic(distDir, opts = {}) {
     const cssEntry = hashedAssetHref(assets.rewrites, cssLogical) || hashedAssetHref(assets.rewrites, 'vmz.css');
     const moduleScriptSrc = hashedAssetHref(assets.rewrites, 'entry-client.js') || '/entry-client.js';
     const localeArt = loadLocaleArtifact(distDir);
-    const localeLinkPlan = buildLocaleLinkPlan(withLinkRouteAliases(localeArt, distDir, pageCatalog));
+    const localeLinkPlan = loadLocaleLinkPlan(distDir) || buildLocaleLinkPlan(withLinkRouteAliases(localeArt, distDir, pageCatalog));
     for (const page of pageCatalog) {
         const pattern = page.pathPattern || patternFromSegs(page.segs);
         const routeId = guessRouteId(distDir, page.chunkId);
@@ -284,26 +285,21 @@ function sortKeys(value) {
  * @param {string} distDir
  */
 function listPageClientFiles(distDir) {
-    const fromDep = listPagesFromDeployment(distDir);
-    if (!fromDep.length) {
-        throw new Error(`emitWebStatic: no page units with pathPattern in ${path.join(distDir, 'vmz-deployment.json')} (plan-only host)`);
-    }
-    return fromDep;
-}
-/**
- * @param {string} distDir
- */
-function listPagesFromDeployment(distDir) {
-    const deploymentPath = path.join(distDir, 'vmz-deployment.json');
-    if (!fs.existsSync(deploymentPath)) {
-        throw new Error(`emitWebStatic: missing ${deploymentPath} (plan-only host)`);
+    let catalog = loadRouteCatalog(distDir);
+    if (!catalog?.pages?.length) {
+        const emitted = emitRouteCatalog(distDir);
+        if (!emitted.ok || !emitted.catalog?.pages?.length) {
+            throw new Error(`emitWebStatic: missing compiled ${ROUTE_CATALOG_SCHEMA} at _vmz/route-catalog.json (${emitted.error || 'empty'})`);
+        }
+        catalog = emitted.catalog;
     }
-    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) };
-    });
+    return catalog.pages.map((p) => ({
+        chunkId: p.chunkId,
+        pathPattern: p.pathPattern,
+        pageRel: p.pageRel,
+        segs: p.segs,
+        routeId: p.routeId,
+    }));
 }
 /**
  * @param {ReturnType<typeof parsePathPattern>} segs
@@ -381,6 +377,20 @@ function loadLocaleArtifact(distDir) {
         return null;
     }
 }
+function loadLocaleLinkPlan(distDir) {
+    const p = path.join(distDir, ...LOCALE_LINK_PLAN_REL.split('/'));
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+        if (raw?.schema !== 'vmz.static.locale_link_plan.v0' || !Array.isArray(raw.rows))
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
 /** Bridge Link class RouteId ↔ realization chunk routeId for locale href rewrite. */
 function withLinkRouteAliases(localeArt, distDir, pageCatalog) {
     if (!localeArt)

package/package.json

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