@vmz/vmz 0.1.13 → 0.1.14

package/dist/dev-session.js

@@ -14,9 +14,10 @@ import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { buildIntegratedDocuments, projectHasDocuments } from './document-integrate.js';
-import { createWorkspace } from './index.js';
+import { createWorkspace, resolveNativePath } from './index.js';
 import { emitLocaleRuntimeModules, localeHasErrors } from './locale-check.js';
 import { log } from './log.js';
+import { coalesceRootBurst, collectDevWatchRoots, classifyWatchRoot, isDependencyPath, mergeDirtySets } from './dev-watch-roots.js';
 import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
 /**
  * @typedef {object} DevSessionOptions
@@ -25,6 +26,7 @@ import { diffFingerprints, fileFingerprintMap } from './watch-diff.js';
  * @property {string} [host]
  * @property {number} [port]
  * @property {number} [pollMs]
+ * @property {'browser' | 'mini-program-wechat'} [target]
  * @property {AbortSignal} [signal]
  * @property {typeof createWorkspace} [createWorkspaceFn]
  * @property {(opts: { project: string, outDir: string, host: string, port: number }) => import('node:child_process').ChildProcess} [spawnHostFn]
@@ -39,6 +41,7 @@ export function createDevSession(options) {
     const host = options.host ?? '127.0.0.1';
     const port = options.port ?? 5173;
     const pollMs = Math.max(50, options.pollMs ?? 300);
+    const wechatPreview = options.target === 'mini-program-wechat';
     const createWs = options.createWorkspaceFn ?? createWorkspace;
     const spawnHost = options.spawnHostFn ?? defaultSpawnHost;
     const softReload = options.softReloadFn ?? defaultSoftReload;
@@ -76,6 +79,33 @@ export function createDevSession(options) {
         log.info(`${label} ok (${mode}; chunks=[${chunks}]; ${(report.emitted ?? []).length} emitted)`);
         return true;
     }
+    /**
+     * Rewrite `dist/wechat` so WeChat DevTools (already open) recompiles WXSS.
+     * Preview is vendor compile, not the browser serve-host.
+     */
+    function packWechatPreview() {
+        if (typeof ws.lowerMiniprogramWechatPackaging !== 'function') {
+            log.error('wechat pack: workspace missing lowerMiniprogramWechatPackaging');
+            return false;
+        }
+        let report;
+        try {
+            const raw = ws.lowerMiniprogramWechatPackaging();
+            report = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        }
+        catch (err) {
+            log.error(`wechat pack failed: ${err}`);
+            return false;
+        }
+        log.diagnostics(report.diagnostics ?? []);
+        if (report.status !== 'ready') {
+            log.error(`wechat pack ${report.status || 'failed'}`);
+            return false;
+        }
+        const packRoot = report.packRoot || 'dist/wechat';
+        log.info(`wechat pack ok → ${path.join(project, packRoot)} (WeChat DevTools compiles WXSS here)`);
+        return true;
+    }
     async function waitHostReady(timeoutMs = 8000) {
         const start = Date.now();
         while (Date.now() - start < timeoutMs) {
@@ -143,18 +173,38 @@ export function createDevSession(options) {
                 throw new Error('vmz dev: integrated document build failed');
             }
         }
-        const hostJs = path.join(outDir, 'vmz-serve-host.mjs');
-        if (!existsSync(hostJs)) {
-            throw new Error(`vmz dev: missing ${hostJs}`);
+        if (wechatPreview) {
+            if (!packWechatPreview()) {
+                throw new Error('vmz dev: wechat pack failed');
+            }
+        }
+        else {
+            const hostJs = path.join(outDir, 'vmz-serve-host.mjs');
+            if (!existsSync(hostJs)) {
+                throw new Error(`vmz dev: missing ${hostJs}`);
+            }
+            child = spawnHost({ project, outDir, host, port });
+            await waitHostReady().catch((err) => {
+                log.warn(String(err));
+            });
         }
-        child = spawnHost({ project, outDir, host, port });
-        await waitHostReady().catch((err) => {
-            log.warn(String(err));
-        });
         const docsRoot = path.join(project, 'documents');
         const localesRoot = path.join(project, 'locales');
-        const watchRoots = [src].concat(existsSync(docsRoot) ? [docsRoot] : []).concat(existsSync(localesRoot) ? [localesRoot] : []);
-        log.info(`dev → http://${host}:${port} (watching ${watchRoots.join(', ')})`);
+        const designsRoot = path.join(project, 'designs');
+        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) {
@@ -166,18 +216,57 @@ 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[], designsChanged: string[], designsDeleted: string[], docsDirty: boolean, localesDirty: boolean, designsDirty: boolean }} */
+            const batch = {
+                srcChanged: [],
+                srcDeleted: [],
+                depChanged: [],
+                depDeleted: [],
+                designsChanged: [],
+                designsDeleted: [],
+                docsDirty: false,
+                localesDirty: false,
+                designsDirty: false,
+            };
+            const watchCtx = { src, docsRoot, localesRoot, designsRoot, dependencyRoots };
+            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;
+                const kind = classifyWatchRoot(root, watchCtx);
+                if (kind === 'src') {
+                    batch.srcChanged.push(...diff.changed);
+                    batch.srcDeleted.push(...diff.deleted);
+                }
+                else if (kind === 'locales') {
+                    batch.localesDirty = true;
+                }
+                else if (kind === 'docs') {
+                    batch.docsDirty = true;
+                }
+                else if (kind === 'designs') {
+                    batch.designsDirty = true;
+                    batch.designsChanged.push(...diff.changed);
+                    batch.designsDeleted.push(...diff.deleted);
+                }
+                else if (kind === 'dep') {
+                    batch.depChanged.push(...diff.changed);
+                    batch.depDeleted.push(...diff.deleted);
+                }
+                else {
+                    batch.docsDirty = true;
+                }
+            }
+            return batch;
+        }
+        function commitFingerprints() {
+            for (const root of watchRoots) {
+                fingerprints.set(root, fileFingerprintMap(root));
             }
         }
         try {
@@ -185,65 +274,125 @@ export function createDevSession(options) {
                 await sleep(pollMs);
                 if (stopped || signal?.aborted)
                     break;
-                if (child && child.exitCode != null) {
+                if (!wechatPreview && child && child.exitCode != null) {
                     log.warn(`serve-host exited (${child.exitCode}) — respawning…`);
                     child = spawnHost({ project, outDir, host, port });
                     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;
+                const designsDirty = batch.designsDirty || batch.designsChanged.length + batch.designsDeleted.length;
+                if (!srcDirty && !depDirty && !batch.docsDirty && !batch.localesDirty && !designsDirty)
                     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;
+                    batch.designsDirty = batch.designsDirty || residual.designsDirty;
+                    const designsMerged = mergeDirtySets({ changed: batch.designsChanged, deleted: batch.designsDeleted }, { changed: residual.designsChanged, deleted: residual.designsDeleted });
+                    batch.designsChanged = designsMerged.changed;
+                    batch.designsDeleted = designsMerged.deleted;
+                }
+                commitFingerprints();
+                if (!batch.srcChanged.length &&
+                    !batch.srcDeleted.length &&
+                    !batch.depChanged.length &&
+                    !batch.depDeleted.length &&
+                    !batch.docsDirty &&
+                    !batch.localesDirty &&
+                    !(batch.designsDirty || batch.designsChanged.length || batch.designsDeleted.length)) {
+                    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;
+                    }
+                    // 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 (root === localesRoot) {
-                        if (diff.changed.length || diff.deleted.length)
-                            batch.localesDirty = 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');
                     }
-                    else if (diff.changed.length || diff.deleted.length) {
-                        batch.docsDirty = true;
+                    if (wechatPreview) {
+                        if (!packWechatPreview())
+                            log.warn('wechat pack failed — keeping previous dist/wechat');
+                        continue;
                     }
-                }
-                if (!batch.srcChanged.length && !batch.srcDeleted.length && !batch.docsDirty && !batch.localesDirty)
+                    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;
+                }
+                let needFullReload = batch.docsDirty || batch.designsDirty;
                 if (batch.srcChanged.length || batch.srcDeleted.length) {
                     log.info(`change detected (${batch.srcChanged.length} update, ${batch.srcDeleted.length} delete) — affected rebuild…`);
                     const changes = [
@@ -264,6 +413,12 @@ export function createDevSession(options) {
                             needFullReload = true;
                         }
                     }
+                    if (wechatPreview) {
+                        if (!packWechatPreview()) {
+                            log.warn('wechat pack failed — keeping previous dist/wechat');
+                        }
+                        continue;
+                    }
                     const kind = await reloadAfterBuild({
                         affectedChunks: report.affectedChunks ?? [],
                         seedChunks: report.seedChunks ?? [],
@@ -280,16 +435,56 @@ export function createDevSession(options) {
                                 : 'soft reload ok');
                     continue;
                 }
+                if (batch.designsChanged.length || batch.designsDeleted.length || batch.designsDirty) {
+                    log.info(`designs change detected (${batch.designsChanged.length} update, ${batch.designsDeleted.length} delete) — rebuilding styles…`);
+                    const changes = [
+                        ...batch.designsChanged.map((p) => ({ path: p, kind: /** @type {'update'} */ ('update') })),
+                        ...batch.designsDeleted.map((p) => ({ path: p, kind: /** @type {'delete'} */ ('delete') })),
+                    ];
+                    const report = rebuild(changes.length ? changes : undefined);
+                    if (!printReport(report, 'rebuild')) {
+                        log.warn('designs rebuild failed — keeping previous styles');
+                        continue;
+                    }
+                    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 (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; designs)' : 'soft reload ok (full page; designs)');
+                    continue;
+                }
                 if (batch.localesDirty) {
                     log.info('locales change detected — re-emitting #locales runtime…');
                     if (!emitLocales()) {
                         log.warn('locale runtime emit failed — keeping previous modules');
                         continue;
                     }
-                    const kind = await reloadAfterBuild({ full: true, islandHmr: false, emitted: [] });
-                    log.info(kind === 'respawn' ? 'reload ok (respawned; locales)' : 'soft reload ok (full page; locales)');
-                    if (!batch.docsDirty)
-                        continue;
+                    if (wechatPreview) {
+                        if (!packWechatPreview()) {
+                            log.warn('wechat pack failed — keeping previous dist/wechat');
+                        }
+                        if (!batch.docsDirty)
+                            continue;
+                    }
+                    else {
+                        const kind = await reloadAfterBuild({ full: true, islandHmr: false, emitted: [] });
+                        log.info(kind === 'respawn' ? 'reload ok (respawned; locales)' : 'soft reload ok (full page; locales)');
+                        if (!batch.docsDirty)
+                            continue;
+                    }
                 }
                 if (batch.docsDirty) {
                     log.info('documents change detected — rebuilding document mount…');
@@ -298,8 +493,15 @@ export function createDevSession(options) {
                         log.warn('document mount rebuild failed — keeping previous docs');
                         continue;
                     }
-                    const kind = await reloadAfterBuild({ full: true, islandHmr: false, emitted: [] });
-                    log.info(kind === 'respawn' ? 'reload ok (respawned; docs)' : 'soft reload ok (full page; docs)');
+                    if (wechatPreview) {
+                        if (!packWechatPreview()) {
+                            log.warn('wechat pack failed — keeping previous dist/wechat');
+                        }
+                    }
+                    else {
+                        const kind = await reloadAfterBuild({ full: true, islandHmr: false, emitted: [] });
+                        log.info(kind === 'respawn' ? 'reload ok (respawned; docs)' : 'soft reload ok (full page; docs)');
+                    }
                 }
             }
         }
@@ -350,6 +552,8 @@ function defaultSpawnHost(opts) {
             VMZ_PORT: String(opts.port),
             VMZ_HOST: opts.host,
             VMZ_DEV: '1',
+            VMZ_PROJECT_ROOT: opts.project,
+            VMZ_NATIVE_NODE: resolveNativePath(),
         },
         stdio: ['ignore', 'inherit', 'inherit'],
     });

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

@@ -0,0 +1,80 @@
+/**
+ * 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 which watch bucket a root belongs to.
+ * @param {string} root
+ * @param {{
+ *   src: string,
+ *   docsRoot: string,
+ *   localesRoot: string,
+ *   designsRoot: string,
+ *   dependencyRoots: string[],
+ * }} ctx
+ * @returns {'src' | 'locales' | 'docs' | 'designs' | 'dep' | 'other'}
+ */
+export declare function classifyWatchRoot(root: any, ctx: any): "src" | "locales" | "docs" | "designs" | "dep" | "other";
+/**
+ * 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;