@vmz/vmz 0.1.4 → 0.1.6

package/dist/dev-session.js

@@ -17,6 +17,7 @@ import { buildIntegratedDocuments, projectHasDocuments } from './document-integr
 import { createWorkspace, resolveNativePath } from './index.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
 import { log } from './log.js';
+import { coalesceRootBurst, collectDevWatchRoots, isDependencyPath, mergeDirtySets, } from './dev-watch-roots.js';
 import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
 /**
  * @typedef {object} DevSessionOptions
@@ -189,13 +190,20 @@ export function createDevSession(options) {
         }
         const docsRoot = path.join(project, 'documents');
         const localesRoot = path.join(project, 'locales');
-        const watchRoots = [src].concat(existsSync(docsRoot) ? [docsRoot] : []).concat(existsSync(localesRoot) ? [localesRoot] : []);
+        const watched = collectDevWatchRoots({ project, outDir });
+        /** @type {string[]} */
+        const watchRoots = [...watched.roots];
+        /** @type {string[]} */
+        let dependencyRoots = [...watched.dependencyRoots];
         if (wechatPreview) {
             log.info(`dev → WeChat DevTools (watching ${watchRoots.join(', ')}; keep dist/wechat open)`);
         }
         else {
             log.info(`dev → http://${host}:${port} (watching ${watchRoots.join(', ')})`);
         }
+        if (dependencyRoots.length) {
+            log.info(`dev dependency watch roots (${dependencyRoots.length}): ${dependencyRoots.join(', ')}`);
+        }
         /** @type {Map<string, Map<string, string>>} */
         const fingerprints = new Map();
         for (const root of watchRoots) {
@@ -207,18 +215,48 @@ export function createDevSession(options) {
         };
         signal?.addEventListener('abort', onAbort, { once: true });
         /**
-         * Wait until src/ stops changing (multi-file agent edits).
+         * Scan all watch roots into a batch. Does not update fingerprints.
          */
-        async function coalesceSrcBurst() {
-            let guard = 0;
-            while (guard++ < 20) {
-                await sleep(220);
-                const prev = fingerprints.get(src) || new Map();
-                const next = fileFingerprintMap(src);
+        function scanBatch() {
+            /** @type {{ srcChanged: string[], srcDeleted: string[], depChanged: string[], depDeleted: string[], docsDirty: boolean, localesDirty: boolean }} */
+            const batch = {
+                srcChanged: [],
+                srcDeleted: [],
+                depChanged: [],
+                depDeleted: [],
+                docsDirty: false,
+                localesDirty: false,
+            };
+            for (const root of watchRoots) {
+                const prev = fingerprints.get(root) || new Map();
+                const next = fileFingerprintMap(root);
                 const diff = diffFingerprints(prev, next);
                 if (!diff.changed.length && !diff.deleted.length)
-                    break;
-                fingerprints.set(src, next);
+                    continue;
+                if (root === src) {
+                    batch.srcChanged.push(...diff.changed);
+                    batch.srcDeleted.push(...diff.deleted);
+                }
+                else if (root === localesRoot) {
+                    batch.localesDirty = true;
+                }
+                else if (root === docsRoot) {
+                    batch.docsDirty = true;
+                }
+                else if (dependencyRoots.includes(root)) {
+                    batch.depChanged.push(...diff.changed);
+                    batch.depDeleted.push(...diff.deleted);
+                }
+                else {
+                    // designs or other application roots → treat like docs (full reload)
+                    batch.docsDirty = true;
+                }
+            }
+            return batch;
+        }
+        function commitFingerprints() {
+            for (const root of watchRoots) {
+                fingerprints.set(root, fileFingerprintMap(root));
             }
         }
         try {
@@ -232,58 +270,112 @@ export function createDevSession(options) {
                     await waitHostReady().catch(() => { });
                     continue;
                 }
-                /** @type {{ srcChanged: string[], srcDeleted: string[], docsDirty: boolean, localesDirty: boolean }} */
-                let batch = { srcChanged: [], srcDeleted: [], docsDirty: false, localesDirty: false };
+                let batch;
                 try {
-                    for (const root of watchRoots) {
-                        const prev = fingerprints.get(root) || new Map();
-                        const next = fileFingerprintMap(root);
-                        const diff = diffFingerprints(prev, next);
-                        if (root === src) {
-                            batch.srcChanged = diff.changed;
-                            batch.srcDeleted = diff.deleted;
-                        }
-                        else if (root === localesRoot) {
-                            if (diff.changed.length || diff.deleted.length)
-                                batch.localesDirty = true;
-                        }
-                        else if (diff.changed.length || diff.deleted.length) {
-                            batch.docsDirty = true;
-                        }
-                    }
+                    batch = scanBatch();
                 }
                 catch (err) {
                     log.warn('watch error:', err);
                     continue;
                 }
-                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty && !batch.localesDirty)
+                const srcDirty = batch.srcChanged.length + batch.srcDeleted.length;
+                const depDirty = batch.depChanged.length + batch.depDeleted.length;
+                if (!srcDirty && !depDirty && !batch.docsDirty && !batch.localesDirty)
                     continue;
-                if (batch.srcChanged.length + batch.srcDeleted.length > 1) {
-                    await coalesceSrcBurst();
+                // Coalesce multi-file bursts without dropping the initial dirty set.
+                if (srcDirty > 1) {
+                    const coalesced = await coalesceRootBurst(src, fingerprints, {
+                        changed: batch.srcChanged,
+                        deleted: batch.srcDeleted,
+                    });
+                    batch.srcChanged = coalesced.changed;
+                    batch.srcDeleted = coalesced.deleted;
                 }
-                else {
+                if (depDirty > 1) {
+                    // Coalesce each dirty dependency root independently, then merge.
+                    /** @type {{ changed: string[], deleted: string[] }} */
+                    let acc = { changed: [...batch.depChanged], deleted: [...batch.depDeleted] };
+                    for (const root of dependencyRoots) {
+                        const prev = fingerprints.get(root) || new Map();
+                        const next = fileFingerprintMap(root);
+                        const peek = diffFingerprints(prev, next);
+                        if (peek.changed.length + peek.deleted.length <= 1 && !acc.changed.some((f) => isDependencyPath(f, [root]))) {
+                            continue;
+                        }
+                        const coalesced = await coalesceRootBurst(root, fingerprints, {
+                            changed: acc.changed.filter((f) => isDependencyPath(f, [root])),
+                            deleted: acc.deleted.filter((f) => isDependencyPath(f, [root])),
+                        });
+                        const others = {
+                            changed: acc.changed.filter((f) => !isDependencyPath(f, [root])),
+                            deleted: acc.deleted.filter((f) => !isDependencyPath(f, [root])),
+                        };
+                        acc = mergeDirtySets(others, coalesced);
+                    }
+                    batch.depChanged = acc.changed;
+                    batch.depDeleted = acc.deleted;
+                }
+                else if (srcDirty === 1 || depDirty === 1) {
                     await sleep(200);
                 }
-                batch = { srcChanged: [], srcDeleted: [], docsDirty: false, localesDirty: false };
-                for (const root of watchRoots) {
-                    const prev = fingerprints.get(root) || new Map();
-                    const next = fileFingerprintMap(root);
-                    const diff = diffFingerprints(prev, next);
-                    fingerprints.set(root, next);
-                    if (root === src) {
-                        batch.srcChanged = diff.changed;
-                        batch.srcDeleted = diff.deleted;
+                // Refresh residual dirty after settle (without discarding coalesced sets).
+                const residual = scanBatch();
+                {
+                    const srcMerged = mergeDirtySets({ changed: batch.srcChanged, deleted: batch.srcDeleted }, { changed: residual.srcChanged, deleted: residual.srcDeleted });
+                    batch.srcChanged = srcMerged.changed;
+                    batch.srcDeleted = srcMerged.deleted;
+                    const depMerged = mergeDirtySets({ changed: batch.depChanged, deleted: batch.depDeleted }, { changed: residual.depChanged, deleted: residual.depDeleted });
+                    batch.depChanged = depMerged.changed;
+                    batch.depDeleted = depMerged.deleted;
+                    batch.docsDirty = batch.docsDirty || residual.docsDirty;
+                    batch.localesDirty = batch.localesDirty || residual.localesDirty;
+                }
+                commitFingerprints();
+                if (!batch.srcChanged.length &&
+                    !batch.srcDeleted.length &&
+                    !batch.depChanged.length &&
+                    !batch.depDeleted.length &&
+                    !batch.docsDirty &&
+                    !batch.localesDirty) {
+                    continue;
+                }
+                // Dependency changes: conservative full rebuild + full reload (v0.1.5).
+                if (batch.depChanged.length || batch.depDeleted.length) {
+                    log.info(`dependency change detected (${batch.depChanged.length} update, ${batch.depDeleted.length} delete) — full rebuild…`);
+                    const report = rebuild();
+                    if (!printReport(report, 'rebuild')) {
+                        log.warn('rebuild failed — keeping previous server');
+                        continue;
                     }
-                    else if (root === localesRoot) {
-                        if (diff.changed.length || diff.deleted.length)
-                            batch.localesDirty = true;
+                    // Refresh watch roots in case the graph gained new packages.
+                    const refreshed = collectDevWatchRoots({ project, outDir });
+                    for (const r of refreshed.roots) {
+                        if (!watchRoots.includes(r)) {
+                            watchRoots.push(r);
+                            fingerprints.set(r, fileFingerprintMap(r));
+                        }
                     }
-                    else if (diff.changed.length || diff.deleted.length) {
-                        batch.docsDirty = true;
+                    dependencyRoots = [...refreshed.dependencyRoots];
+                    if (batch.docsDirty || projectHasDocuments(project)) {
+                        const docs = await buildIntegratedDocuments({ projectRoot: project, outDir });
+                        if (!docs.ok)
+                            log.warn('document mount rebuild failed — keeping previous docs');
                     }
-                }
-                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty && !batch.localesDirty)
+                    if (wechatPreview) {
+                        if (!packWechatPreview())
+                            log.warn('wechat pack failed — keeping previous dist/wechat');
+                        continue;
+                    }
+                    const kind = await reloadAfterBuild({
+                        affectedChunks: report.affectedChunks ?? [],
+                        seedChunks: report.seedChunks ?? [],
+                        emitted: report.emitted ?? [],
+                        full: true,
+                        islandHmr: false,
+                    });
+                    log.info(kind === 'respawn' ? 'reload ok (respawned; deps)' : 'soft reload ok (full page; deps)');
                     continue;
+                }
                 let needFullReload = batch.docsDirty;
                 if (batch.srcChanged.length || batch.srcDeleted.length) {
                     log.info(`change detected (${batch.srcChanged.length} update, ${batch.srcDeleted.length} delete) — affected rebuild…`);

package/dist/dev-watch-roots.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Dev watch helpers: coalesce multi-file bursts without dropping dirty set,
+ * and derive extra watch roots from the compile graph (deployment unit sources).
+ */
+/**
+ * @typedef {{ changed: string[], deleted: string[] }} DirtySet
+ */
+/**
+ * Merge dirty sets: later change cancels delete and vice versa.
+ * @param {DirtySet} a
+ * @param {DirtySet} b
+ * @returns {DirtySet}
+ */
+export declare function mergeDirtySets(a: any, b: any): {
+    changed: unknown[];
+    deleted: unknown[];
+};
+/**
+ * Wait until `root` stops changing; return the **accumulated** dirty set since `initial`.
+ * Updates `fingerprints` for `root` as it polls. Does **not** discard `initial`.
+ *
+ * @param {string} root
+ * @param {Map<string, Map<string, string>>} fingerprints
+ * @param {DirtySet} initial
+ * @param {{ sleep?: (ms: number) => Promise<void>, maxRounds?: number, settleMs?: number }} [opts]
+ * @returns {Promise<DirtySet>}
+ */
+export declare function coalesceRootBurst(root: any, fingerprints: any, initial: any, opts?: {}): Promise<{
+    changed: any[];
+    deleted: any[];
+}>;
+/**
+ * Walk up from a file to find a package.json directory.
+ * @param {string} file
+ * @returns {string | null}
+ */
+export declare function findPackageRoot(file: any): string;
+/**
+ * Prefer package/src when present; otherwise the directory containing the source file.
+ * @param {string} sourceFile
+ * @returns {string | null}
+ */
+export declare function watchRootForSourceFile(sourceFile: any): string;
+/**
+ * Absolute roots for workspace / file / link deps that have a src tree.
+ * @param {string} project
+ * @returns {string[]}
+ */
+export declare function localLinkDependencyRoots(project: any): any[];
+/**
+ * Collect watch roots: project src/locales/documents + compile-graph external sources
+ * + local link/workspace package roots. Never adds a bare registry node_modules tree.
+ *
+ * @param {{ project: string, outDir: string }} opts
+ * @returns {{ roots: string[], dependencyRoots: string[], applicationRoots: string[] }}
+ */
+export declare function collectDevWatchRoots(opts: any): {
+    roots: any[];
+    dependencyRoots: unknown[];
+    applicationRoots: any[];
+};
+/**
+ * Classify whether a changed file lives under a dependency watch root (not app src).
+ * @param {string} file
+ * @param {string[]} dependencyRoots
+ */
+export declare function isDependencyPath(file: any, dependencyRoots: any): any;

package/dist/dev-watch-roots.js

@@ -0,0 +1,220 @@
+// @ts-nocheck
+/**
+ * Dev watch helpers: coalesce multi-file bursts without dropping dirty set,
+ * and derive extra watch roots from the compile graph (deployment unit sources).
+ */
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
+/**
+ * @typedef {{ changed: string[], deleted: string[] }} DirtySet
+ */
+/**
+ * Merge dirty sets: later change cancels delete and vice versa.
+ * @param {DirtySet} a
+ * @param {DirtySet} b
+ * @returns {DirtySet}
+ */
+export function mergeDirtySets(a, b) {
+    const changed = new Set(a?.changed || []);
+    const deleted = new Set(a?.deleted || []);
+    for (const f of b?.changed || []) {
+        changed.add(f);
+        deleted.delete(f);
+    }
+    for (const f of b?.deleted || []) {
+        deleted.add(f);
+        changed.delete(f);
+    }
+    return { changed: [...changed], deleted: [...deleted] };
+}
+/**
+ * Wait until `root` stops changing; return the **accumulated** dirty set since `initial`.
+ * Updates `fingerprints` for `root` as it polls. Does **not** discard `initial`.
+ *
+ * @param {string} root
+ * @param {Map<string, Map<string, string>>} fingerprints
+ * @param {DirtySet} initial
+ * @param {{ sleep?: (ms: number) => Promise<void>, maxRounds?: number, settleMs?: number }} [opts]
+ * @returns {Promise<DirtySet>}
+ */
+export async function coalesceRootBurst(root, fingerprints, initial, opts = {}) {
+    const sleepFn = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const maxRounds = opts.maxRounds ?? 20;
+    const settleMs = opts.settleMs ?? 220;
+    let accumulated = {
+        changed: [...(initial?.changed || [])],
+        deleted: [...(initial?.deleted || [])],
+    };
+    let guard = 0;
+    while (guard++ < maxRounds) {
+        await sleepFn(settleMs);
+        const prev = fingerprints.get(root) || new Map();
+        const next = fileFingerprintMap(root);
+        const diff = diffFingerprints(prev, next);
+        fingerprints.set(root, next);
+        if (!diff.changed.length && !diff.deleted.length)
+            break;
+        accumulated = mergeDirtySets(accumulated, diff);
+    }
+    return accumulated;
+}
+/**
+ * Walk up from a file to find a package.json directory.
+ * @param {string} file
+ * @returns {string | null}
+ */
+export function findPackageRoot(file) {
+    let dir = path.dirname(path.resolve(file));
+    for (let i = 0; i < 24; i++) {
+        if (existsSync(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Prefer package/src when present; otherwise the directory containing the source file.
+ * @param {string} sourceFile
+ * @returns {string | null}
+ */
+export function watchRootForSourceFile(sourceFile) {
+    const abs = path.resolve(sourceFile);
+    if (!existsSync(abs))
+        return null;
+    const pkg = findPackageRoot(abs);
+    if (pkg) {
+        const src = path.join(pkg, 'src');
+        if (existsSync(src))
+            return src;
+        return pkg;
+    }
+    return path.dirname(abs);
+}
+/**
+ * Absolute roots for workspace / file / link deps that have a src tree.
+ * @param {string} project
+ * @returns {string[]}
+ */
+export function localLinkDependencyRoots(project) {
+    const pkgPath = path.join(path.resolve(project), 'package.json');
+    if (!existsSync(pkgPath))
+        return [];
+    /** @type {string[]} */
+    const roots = [];
+    try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+        for (const [name, spec] of Object.entries(deps)) {
+            if (typeof spec !== 'string')
+                continue;
+            let target = null;
+            if (spec.startsWith('workspace:')) {
+                // Resolve via node_modules (pnpm links workspace packages there).
+                const nm = path.join(path.resolve(project), 'node_modules', ...name.split('/'));
+                if (existsSync(path.join(nm, 'package.json')))
+                    target = nm;
+            }
+            else if (spec.startsWith('file:') || spec.startsWith('link:')) {
+                const rel = spec.replace(/^(file|link):/, '');
+                target = path.resolve(project, rel);
+            }
+            if (!target)
+                continue;
+            try {
+                target = realpathSync(target);
+            }
+            catch {
+                /* keep as-is */
+            }
+            const src = path.join(target, 'src');
+            if (existsSync(src))
+                roots.push(src);
+            else if (existsSync(target))
+                roots.push(target);
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return roots;
+}
+/**
+ * Collect watch roots: project src/locales/documents + compile-graph external sources
+ * + local link/workspace package roots. Never adds a bare registry node_modules tree.
+ *
+ * @param {{ project: string, outDir: string }} opts
+ * @returns {{ roots: string[], dependencyRoots: string[], applicationRoots: string[] }}
+ */
+export function collectDevWatchRoots(opts) {
+    const project = path.resolve(opts.project);
+    const outDir = path.resolve(opts.outDir);
+    const src = path.join(project, 'src');
+    const docsRoot = path.join(project, 'documents');
+    const localesRoot = path.join(project, 'locales');
+    const designsRoot = path.join(project, 'designs');
+    /** @type {string[]} */
+    const applicationRoots = [];
+    if (existsSync(src))
+        applicationRoots.push(src);
+    if (existsSync(docsRoot))
+        applicationRoots.push(docsRoot);
+    if (existsSync(localesRoot))
+        applicationRoots.push(localesRoot);
+    if (existsSync(designsRoot))
+        applicationRoots.push(designsRoot);
+    /** @type {Set<string>} */
+    const depSet = new Set();
+    const depJson = path.join(outDir, 'vmz-deployment.json');
+    if (existsSync(depJson)) {
+        try {
+            const dep = JSON.parse(readFileSync(depJson, 'utf8'));
+            for (const unit of dep.units || []) {
+                const source = unit?.source;
+                if (typeof source !== 'string' || !source)
+                    continue;
+                let abs = path.resolve(source);
+                try {
+                    abs = realpathSync(abs);
+                }
+                catch {
+                    /* keep */
+                }
+                const underProject = abs === project || abs.startsWith(project + path.sep) || abs.startsWith(project + '/');
+                if (underProject)
+                    continue;
+                const root = watchRootForSourceFile(abs);
+                if (root)
+                    depSet.add(path.resolve(root));
+            }
+        }
+        catch {
+            /* ignore corrupt deployment */
+        }
+    }
+    for (const r of localLinkDependencyRoots(project)) {
+        depSet.add(path.resolve(r));
+    }
+    // Drop dependency roots that are already under an application root.
+    const dependencyRoots = [...depSet].filter((r) => {
+        return !applicationRoots.some((app) => r === app || r.startsWith(app + path.sep) || r.startsWith(app + '/'));
+    });
+    const roots = [...applicationRoots];
+    for (const r of dependencyRoots) {
+        if (!roots.includes(r))
+            roots.push(r);
+    }
+    return { roots, dependencyRoots, applicationRoots };
+}
+/**
+ * Classify whether a changed file lives under a dependency watch root (not app src).
+ * @param {string} file
+ * @param {string[]} dependencyRoots
+ */
+export function isDependencyPath(file, dependencyRoots) {
+    const abs = path.resolve(file);
+    return (dependencyRoots || []).some((r) => abs === r || abs.startsWith(r + path.sep) || abs.startsWith(r + '/'));
+}

package/dist/index.d.ts

@@ -147,6 +147,7 @@ export declare function checkApplicationHostCompositionJson(hostRoot: any, packa
  */
 export declare function checkApplicationDevTestDeployJson(hostRoot: any, packageRoots: any, dirtyPaths?: any[]): any;
 export { createDevSession, listWatchedFiles, srcFingerprint } from './dev-session.js';
+export { coalesceRootBurst, collectDevWatchRoots, mergeDirtySets, localLinkDependencyRoots, watchRootForSourceFile, } from './dev-watch-roots.js';
 export { findAvailablePort } from './port.js';
 export { runCli, parseArgs, printHelp, printGlobalHelp, printProjectHelp } from './cli.js';
 export { findNearestProjectVmz, getInvocationContext, isGlobalAllowedCommand, isUnderNodeModules, resolveThisPackageRoot, resolveVmzBin, gateGlobalProjectCommand, } from './invocation.js';

package/dist/index.js

@@ -369,6 +369,7 @@ export function checkApplicationDevTestDeployJson(hostRoot, packageRoots, dirtyP
     return native.checkApplicationDevTestDeployJson(hostRoot, packageRoots, dirtyPaths);
 }
 export { createDevSession, listWatchedFiles, srcFingerprint } from './dev-session.js';
+export { coalesceRootBurst, collectDevWatchRoots, mergeDirtySets, localLinkDependencyRoots, watchRootForSourceFile, } from './dev-watch-roots.js';
 export { findAvailablePort } from './port.js';
 export { runCli, parseArgs, printHelp, printGlobalHelp, printProjectHelp } from './cli.js';
 export { findNearestProjectVmz, getInvocationContext, isGlobalAllowedCommand, isUnderNodeModules, resolveThisPackageRoot, resolveVmzBin, gateGlobalProjectCommand, } from './invocation.js';

package/package.json

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