@dimina-kit/devkit 0.1.2-dev.20260706131625 → 0.1.2-dev.20260707070110

package/dist/compile-log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile-log.d.ts","sourceRoot":"","sources":["../src/compile-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAsBH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO7D"}
+{"version":3,"file":"compile-log.d.ts","sourceRoot":"","sources":["../src/compile-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAgCH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO7D"}

package/dist/compile-log.js

@@ -25,6 +25,16 @@ const DROP_RULES = [
     // Stack-trace frames (esbuild / Node internals) — the message line above
     // them is kept; frames are noise for a compile panel.
     /^\s+at /,
+    // Node process-level DeprecationWarnings + the `--trace-deprecation` hint
+    // Node prints after the first one. The developer's code never runs in the
+    // compile worker, so these are never actionable in a compile panel. Packaged
+    // Electron apps ALWAYS emit one: the asar fs shim's asarStatsToFsStats uses
+    // the deprecated fs.Stats constructor (electron/electron#47390), so the
+    // first stat of an in-asar file prints the DEP0180 pair to stderr. Only the
+    // DeprecationWarning form is dropped — other `(node:pid)` warnings
+    // (MaxListenersExceeded, Experimental) can carry real signal and are kept.
+    /^\(node:\d+\) (?:\[DEP\d+\] )?DeprecationWarning: /,
+    /^\(Use `.+--trace-deprecation .*` to show where the warning was created\)/,
 ];
 /**
  * Strip ANSI escapes, then decide keep/drop. Returns the cleaned line, or

package/dist/compile-log.test.js

@@ -116,6 +116,50 @@ describe('filterDmccLogLine — KEEP rules (real dmcc signal from the spike arch
         }
     });
 });
+describe('filterDmccLogLine — DROP rules (packaged-app Node DeprecationWarning noise, electron/electron#47390)', () => {
+    // Electron's asar fs shim (`asarStatsToFsStats`) uses the deprecated
+    // `fs.Stats` constructor, so Node prints a process-level
+    // DeprecationWarning pair on the compile worker's stderr the first time a
+    // packaged app stats a file inside app.asar. The developer's own code
+    // never runs in the compile worker, so these lines are never actionable
+    // and must be dropped.
+    it('drops the Node process-level DeprecationWarning line, with or without a DEP code', () => {
+        const filter = getFilter();
+        expect(filter('(node:4984) [DEP0180] DeprecationWarning: fs.Stats constructor is deprecated.')).toBeNull();
+        expect(filter('(node:90165) DeprecationWarning: Buffer() is deprecated due to security and usability issues.')).toBeNull();
+    });
+    it('drops the trace-deprecation hint line that follows, regardless of the binary name', () => {
+        const filter = getFilter();
+        expect(filter('(Use `千岛开发者工具 Helper --trace-deprecation ...` to show where the warning was created)')).toBeNull();
+        expect(filter('(Use `node --trace-deprecation ...` to show where the warning was created)')).toBeNull();
+    });
+    it('drops ANSI-colored variants of both lines', () => {
+        const filter = getFilter();
+        expect(filter('(node:4984) [DEP0180] DeprecationWarning: fs.Stats constructor is deprecated.')).toBeNull();
+        expect(filter('(Use `node --trace-deprecation ...` to show where the warning was created)')).toBeNull();
+    });
+});
+describe('filterDmccLogLine — KEEP rules (guards against over-filtering Node warnings)', () => {
+    it('keeps other Node process-level warnings that are not DeprecationWarnings', () => {
+        const filter = getFilter();
+        // These can carry real signal (leak / experimental-API notices) and are
+        // not the asar-shim noise this filter targets.
+        const lines = [
+            '(node:123) MaxListenersExceededWarning: Possible EventEmitter memory leak detected.',
+            '(node:123) ExperimentalWarning: VM Modules is an experimental feature.',
+        ];
+        for (const line of lines) {
+            expect(filter(line), `non-deprecation Node warning must be kept: ${JSON.stringify(line)}`).toBe(line);
+        }
+    });
+    it('keeps a compiler diagnostic that merely mentions DeprecationWarning mid-sentence', () => {
+        const filter = getFilter();
+        // Does not start with the `(node:<pid>)` prefix, so it is not the
+        // Node process-level warning form — default-keep applies.
+        const line = '[logic] esbuild 转换失败 app.js: DeprecationWarning something';
+        expect(filter(line)).toBe(line);
+    });
+});
 describe('filterDmccLogLine — ANSI stripping happens BEFORE rule matching', () => {
     it('strips ANSI from a kept line and returns the cleaned text', () => {
         const filter = getFilter();

package/dist/esbuild-binary-path.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ESBUILD_BINARY_PATH redirect for Electron app.asar hosts.
+ *
+ * esbuild's JS lib computes its native binary path from its own module
+ * location. Packaged via electron-builder that location sits inside app.asar,
+ * and `child_process.spawn` (unlike execFile) is not patched by Electron's
+ * asar shim — spawning an in-asar path always fails ENOENT even though
+ * asarUnpack put the real binary in app.asar.unpacked. esbuild honors the
+ * ESBUILD_BINARY_PATH env var, so devkit points it at the unpacked binary.
+ *
+ * The platform packages lay their binary out differently (esbuild's own
+ * pkgAndSubpathForCurrentPlatform): win32 ships `esbuild.exe` at the package
+ * ROOT — there is no `bin/` directory — while every unix-like platform ships
+ * `bin/esbuild`. Resolving the unix shape on win32 throws, and a swallowed
+ * throw leaves the env var unset, which is exactly the packaged-Windows
+ * failure mode this module guards against.
+ *
+ * All I/O is dependency-injected so the branching is unit-testable; index.ts
+ * wires the real process/require/fs at module load.
+ */
+export interface ApplyEsbuildBinaryPathOptions {
+    /** Caller module's directory — an `app.asar` segment means "packaged". */
+    dirname: string;
+    /** process.env-like map, mutated in place. */
+    env: Record<string, string | undefined>;
+    /** process.platform value. */
+    platform: string;
+    /** process.arch value. */
+    arch: string;
+    /** require.resolve-like; throws when the id cannot be resolved. */
+    resolve: (id: string) => string;
+    /** fs.existsSync-like, probed against the rewritten unpacked path. */
+    exists: (p: string) => boolean;
+    /** Diagnostics sink — every failure path reports here instead of going silent. */
+    warn: (msg: string) => void;
+}
+export declare function applyEsbuildBinaryPath(opts: ApplyEsbuildBinaryPathOptions): void;
+//# sourceMappingURL=esbuild-binary-path.d.ts.map

package/dist/esbuild-binary-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-binary-path.d.ts","sourceRoot":"","sources":["../src/esbuild-binary-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,6BAA6B;IAC7C,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAA;IACf,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;IACvC,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAA;IAC/B,sEAAsE;IACtE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAO,CAAA;IAC9B,kFAAkF;IAClF,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3B;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,6BAA6B,GAAG,IAAI,CA0BhF"}

package/dist/esbuild-binary-path.js

@@ -0,0 +1,29 @@
+export function applyEsbuildBinaryPath(opts) {
+    const { dirname, env, platform, arch, resolve, exists, warn } = opts;
+    if (env.ESBUILD_BINARY_PATH)
+        return;
+    if (!dirname.includes('app.asar'))
+        return;
+    const subpath = platform === 'win32' ? 'esbuild.exe' : 'bin/esbuild';
+    const id = `@esbuild/${platform}-${arch}/${subpath}`;
+    let resolved;
+    try {
+        resolved = resolve(id);
+    }
+    catch {
+        warn(`[devkit] could not resolve ${id} — esbuild's platform binary package is missing `
+            + 'from the packaged app, so the compiler cannot spawn esbuild. Ship the package '
+            + '(electron-builder dependency collection must include it) or set ESBUILD_BINARY_PATH.');
+        return;
+    }
+    // asarUnpack mirrors the archive's layout on disk — only the first app.asar
+    // segment moves to app.asar.unpacked. A path already outside the archive
+    // (or already unpacked) has no `app.asar/` segment and passes through as-is.
+    const unpacked = resolved.replace(/app\.asar([\\/])/, 'app.asar.unpacked$1');
+    if (!exists(unpacked)) {
+        warn(`[devkit] esbuild binary not found at ${unpacked} — the Electron host's packaging must `
+            + "asarUnpack '**/node_modules/esbuild/**' and '**/node_modules/@esbuild/**' so the native "
+            + 'binary exists outside app.asar (spawn cannot execute from inside the archive).');
+    }
+    env.ESBUILD_BINARY_PATH = unpacked;
+}

package/dist/esbuild-binary-path.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=esbuild-binary-path.test.d.ts.map

package/dist/esbuild-binary-path.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-binary-path.test.d.ts","sourceRoot":"","sources":["../src/esbuild-binary-path.test.ts"],"names":[],"mappings":""}

package/dist/esbuild-binary-path.test.js

@@ -0,0 +1,134 @@
+import { describe, expect, it, vi } from 'vitest';
+import { applyEsbuildBinaryPath } from './esbuild-binary-path.js';
+/**
+ * Contract for `applyEsbuildBinaryPath` — the ESBUILD_BINARY_PATH redirect
+ * that lets esbuild spawn its native binary from app.asar.unpacked when
+ * devkit runs packaged inside an Electron app.asar.
+ *
+ * The platform package layout differs by OS:
+ *  - darwin/linux: `@esbuild/<platform>-<arch>/bin/esbuild`
+ *  - win32: `@esbuild/win32-<arch>/esbuild.exe` at the package ROOT, no
+ *    `bin/` dir. Resolving the darwin/linux shape on win32 throws, and a
+ *    swallowed throw means ESBUILD_BINARY_PATH is silently never set —
+ *    packaged Windows apps then fail with
+ *    `spawn ...app.asar\node_modules\@esbuild\win32-x64\esbuild.exe ENOENT`.
+ *
+ * All I/O (require.resolve, fs.existsSync, console.warn, process.env) is
+ * dependency-injected so the tests exercise pure branching logic.
+ */
+function makeOpts(overrides = {}) {
+    return {
+        dirname: 'C:\\Users\\x\\AppData\\Local\\Programs\\myapp\\resources\\app.asar\\packages\\devkit\\dist',
+        env: {},
+        platform: 'win32',
+        arch: 'x64',
+        resolve: vi.fn(() => {
+            throw new Error('resolve not stubbed for this test');
+        }),
+        exists: vi.fn(() => true),
+        warn: vi.fn(),
+        ...overrides,
+    };
+}
+describe('applyEsbuildBinaryPath — no-op guards', () => {
+    it('does nothing when ESBUILD_BINARY_PATH is already set', () => {
+        const env = { ESBUILD_BINARY_PATH: '/already/set/esbuild' };
+        const resolve = vi.fn();
+        const exists = vi.fn();
+        const warn = vi.fn();
+        applyEsbuildBinaryPath(makeOpts({ env, resolve, exists, warn }));
+        expect(env.ESBUILD_BINARY_PATH).toBe('/already/set/esbuild');
+        expect(resolve).not.toHaveBeenCalled();
+        expect(exists).not.toHaveBeenCalled();
+        expect(warn).not.toHaveBeenCalled();
+    });
+    it('does nothing when dirname is not inside an app.asar (unpackaged dev run)', () => {
+        const env = {};
+        const resolve = vi.fn();
+        const exists = vi.fn();
+        const warn = vi.fn();
+        applyEsbuildBinaryPath(makeOpts({
+            dirname: '/Users/dev/code/dimina-kit/packages/devkit/dist',
+            env,
+            resolve,
+            exists,
+            warn,
+        }));
+        expect(env.ESBUILD_BINARY_PATH).toBeUndefined();
+        expect(resolve).not.toHaveBeenCalled();
+        expect(exists).not.toHaveBeenCalled();
+        expect(warn).not.toHaveBeenCalled();
+    });
+});
+describe('applyEsbuildBinaryPath — platform-correct binary subpath', () => {
+    it('resolves the win32 package root exe, not bin/esbuild (the Windows bug)', () => {
+        const resolve = vi.fn(() => 'C:\\app\\app.asar\\node_modules\\@esbuild\\win32-x64\\esbuild.exe');
+        applyEsbuildBinaryPath(makeOpts({ platform: 'win32', arch: 'x64', resolve }));
+        expect(resolve).toHaveBeenCalledWith('@esbuild/win32-x64/esbuild.exe');
+        expect(resolve).not.toHaveBeenCalledWith('@esbuild/win32-x64/bin/esbuild');
+    });
+    it('resolves the darwin bin/esbuild subpath', () => {
+        const resolve = vi.fn(() => '/app/app.asar/node_modules/@esbuild/darwin-arm64/bin/esbuild');
+        applyEsbuildBinaryPath(makeOpts({ platform: 'darwin', arch: 'arm64', resolve }));
+        expect(resolve).toHaveBeenCalledWith('@esbuild/darwin-arm64/bin/esbuild');
+    });
+    it('resolves the linux bin/esbuild subpath', () => {
+        const resolve = vi.fn(() => '/app/app.asar/node_modules/@esbuild/linux-x64/bin/esbuild');
+        applyEsbuildBinaryPath(makeOpts({ platform: 'linux', arch: 'x64', resolve }));
+        expect(resolve).toHaveBeenCalledWith('@esbuild/linux-x64/bin/esbuild');
+    });
+});
+describe('applyEsbuildBinaryPath — app.asar → app.asar.unpacked rewrite', () => {
+    it('rewrites the first app.asar\\ segment to app.asar.unpacked\\ on a Windows backslash path', () => {
+        const env = {};
+        const resolve = vi.fn(() => 'C:\\Users\\x\\AppData\\app.asar\\node_modules\\@esbuild\\win32-x64\\esbuild.exe');
+        applyEsbuildBinaryPath(makeOpts({ platform: 'win32', arch: 'x64', env, resolve }));
+        expect(env.ESBUILD_BINARY_PATH).toBe('C:\\Users\\x\\AppData\\app.asar.unpacked\\node_modules\\@esbuild\\win32-x64\\esbuild.exe');
+    });
+    it('rewrites the first app.asar/ segment to app.asar.unpacked/ on a POSIX forward-slash path', () => {
+        const env = {};
+        const resolve = vi.fn(() => '/Applications/MyApp.app/Contents/Resources/app.asar/node_modules/@esbuild/darwin-arm64/bin/esbuild');
+        applyEsbuildBinaryPath(makeOpts({ platform: 'darwin', arch: 'arm64', dirname: '/Applications/MyApp.app/Contents/Resources/app.asar/packages/devkit/dist', env, resolve }));
+        expect(env.ESBUILD_BINARY_PATH).toBe('/Applications/MyApp.app/Contents/Resources/app.asar.unpacked/node_modules/@esbuild/darwin-arm64/bin/esbuild');
+    });
+    it('does not double-rewrite a resolved path that already contains app.asar.unpacked', () => {
+        const env = {};
+        const resolve = vi.fn(() => '/Applications/MyApp.app/Contents/Resources/app.asar.unpacked/node_modules/@esbuild/darwin-arm64/bin/esbuild');
+        applyEsbuildBinaryPath(makeOpts({ platform: 'darwin', arch: 'arm64', dirname: '/Applications/MyApp.app/Contents/Resources/app.asar/packages/devkit/dist', env, resolve }));
+        expect(env.ESBUILD_BINARY_PATH).toBe('/Applications/MyApp.app/Contents/Resources/app.asar.unpacked/node_modules/@esbuild/darwin-arm64/bin/esbuild');
+    });
+});
+describe('applyEsbuildBinaryPath — resolve failure (the swallowed-throw half of the bug)', () => {
+    it('does not throw, leaves env unset, and warns once naming the platform package when resolve throws', () => {
+        const env = {};
+        const resolve = vi.fn(() => {
+            throw new Error("Cannot find module '@esbuild/win32-x64/esbuild.exe'");
+        });
+        const warn = vi.fn();
+        expect(() => {
+            applyEsbuildBinaryPath(makeOpts({ platform: 'win32', arch: 'x64', env, resolve, warn }));
+        }).not.toThrow();
+        expect(env.ESBUILD_BINARY_PATH).toBeUndefined();
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn.mock.calls[0]?.[0]).toEqual(expect.stringContaining('@esbuild/win32-x64'));
+    });
+});
+describe('applyEsbuildBinaryPath — unpacked-path existence check', () => {
+    it('still sets ESBUILD_BINARY_PATH and warns once with an asarUnpack hint when the unpacked path does not exist', () => {
+        const env = {};
+        const resolve = vi.fn(() => 'C:\\app\\app.asar\\node_modules\\@esbuild\\win32-x64\\esbuild.exe');
+        const exists = vi.fn(() => false);
+        const warn = vi.fn();
+        applyEsbuildBinaryPath(makeOpts({ platform: 'win32', arch: 'x64', env, resolve, exists, warn }));
+        expect(env.ESBUILD_BINARY_PATH).toBe('C:\\app\\app.asar.unpacked\\node_modules\\@esbuild\\win32-x64\\esbuild.exe');
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn.mock.calls[0]?.[0]).toEqual(expect.stringContaining('asarUnpack'));
+    });
+    it('never warns when the unpacked path exists', () => {
+        const resolve = vi.fn(() => 'C:\\app\\app.asar\\node_modules\\@esbuild\\win32-x64\\esbuild.exe');
+        const exists = vi.fn(() => true);
+        const warn = vi.fn();
+        applyEsbuildBinaryPath(makeOpts({ platform: 'win32', arch: 'x64', resolve, exists, warn }));
+        expect(warn).not.toHaveBeenCalled();
+    });
+});

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAgB,eAAe,EAAiB,MAAM,qBAAqB,CAAA;AAEvF,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAEpG,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzD,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AACxE,YAAY,EACX,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,EACZ,YAAY,GACZ,MAAM,6BAA6B,CAAA;AAYpC;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACzC,IAAI,CAAC,EAAE,2BAA2B,GAChC,oBAAoB,CAKtB;AAqDD,MAAM,WAAW,OAAO;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oFAAoF;IACpF,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;IACtB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;IACrC;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IACxC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CACvC;AAuFD,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CA0JnF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACpC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GACrC;IAAE,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CA2DtD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAgB,eAAe,EAAiB,MAAM,qBAAqB,CAAA;AAEvF,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAEpG,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAC/D,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzD,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AACxE,YAAY,EACX,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,EACZ,YAAY,GACZ,MAAM,6BAA6B,CAAA;AAYpC;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACzC,IAAI,CAAC,EAAE,2BAA2B,GAChC,oBAAoB,CAKtB;AAoDD,MAAM,WAAW,OAAO;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,MAAM,WAAW,kBAAkB;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAA;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oFAAoF;IACpF,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;IACtB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;IACrC;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IACxC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CACvC;AAuFD,wBAAsB,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CA0JnF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACpC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GACrC;IAAE,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAiEtD"}

package/dist/index.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { createServer } from 'node:http';
 import { createRequire } from 'node:module';
 import chokidar from 'chokidar';
+import { applyEsbuildBinaryPath } from './esbuild-binary-path.js';
 import { createRebuildScheduler } from './rebuild-scheduler.js';
 import { createCompileWorker } from './compile-worker.js';
 import { createCompileWorkerStandby } from './compile-worker-standby.js';
@@ -50,21 +51,20 @@ function refillStandby() {
 }
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-// esbuild's native binary is shipped inside node_modules, but when packaged
-// via electron-builder it lives in app.asar. asarUnpack puts the real binary
-// in app.asar.unpacked — but esbuild computes its binary path from __dirname,
-// which still points inside app.asar. Redirect it explicitly via require.resolve
-// so we don't hard-code the hoisting depth (pnpm vs npm layouts differ).
-if (!process.env.ESBUILD_BINARY_PATH && __dirname.includes('app.asar')) {
-    const platform = `${process.platform}-${process.arch}`;
-    try {
-        const resolved = require.resolve(`@esbuild/${platform}/bin/esbuild`);
-        process.env.ESBUILD_BINARY_PATH = resolved.replace(/app\.asar([\\/])/, 'app.asar.unpacked$1');
-    }
-    catch {
-        // fall through — esbuild will surface a clearer error if the binary is truly missing
-    }
-}
+// Packaged inside app.asar, esbuild's native binary must be spawned from
+// app.asar.unpacked — resolved via require.resolve so the hoisting depth
+// (pnpm vs npm layouts) is never hard-coded. The per-platform binary layout
+// and every failure diagnostic live in esbuild-binary-path.ts. The env var is
+// set before any compile worker forks, and forks inherit it.
+applyEsbuildBinaryPath({
+    dirname: __dirname,
+    env: process.env,
+    platform: process.platform,
+    arch: process.arch,
+    resolve: require.resolve,
+    exists: fs.existsSync,
+    warn: console.warn,
+});
 function getRandomPort() {
     return new Promise((resolve, reject) => {
         const srv = createServer();
@@ -309,7 +309,13 @@ export function createProjectWatcher(projectPath, onChange, onWatcherError) {
             // (rel starts with '..') must never be ignored.
             if (!rel || rel.startsWith('..'))
                 return false;
-            return rel.split('/').some(seg => seg.startsWith('.'));
+            // `node_modules` (any depth) is excluded like vite/webpack exclude
+            // it: the compiler never reads it directly (its real npm input is
+            // the built `miniprogram_npm/`, which stays watched), while watching
+            // it makes chokidar hold thousands of per-directory fs.watch handles
+            // — a multi-second `watcher.close()` on session close, a slow
+            // initial scan, and spurious rebuilds on dependency churn.
+            return rel.split('/').some(seg => seg.startsWith('.') || seg === 'node_modules');
         },
         persistent: true,
         ignoreInitial: true,

package/dist/project-watcher.test.js

@@ -186,4 +186,72 @@ describe('createProjectWatcher', () => {
         await settle(500);
         expect(onChange).not.toHaveBeenCalled();
     });
+    it('stays quiet when a file inside node_modules changes', async () => {
+        // Why this matters: a project with 87 dependencies puts chokidar under
+        // watch for 1232+ directories inside node_modules, making close() take
+        // seconds and letting dependency-internal file churn (postinstall
+        // scripts, lockfile-driven reinstalls) trigger spurious rebuilds.
+        // node_modules anywhere under the project — not just at the root — must
+        // be excluded from the watch entirely.
+        const nodeModulesDir = path.join(tempDir, 'node_modules', 'lodash');
+        fs.mkdirSync(nodeModulesDir, { recursive: true });
+        const target = path.join(nodeModulesDir, 'index.js');
+        fs.writeFileSync(target, '// vendored');
+        const onChange = vi.fn();
+        handle = createProjectWatcher(tempDir, onChange);
+        await handle.ready;
+        fs.writeFileSync(target, '// vendored, changed');
+        await settle(500);
+        expect(onChange).not.toHaveBeenCalled();
+    });
+    it('stays quiet when a file inside a nested package node_modules changes', async () => {
+        // Why this matters: node_modules can recur at any depth (npm/pnpm
+        // dependency trees, workspace packages with their own node_modules).
+        // A watcher that only ignores the top-level node_modules segment would
+        // still get flooded by these nested trees.
+        const nestedNodeModules = path.join(tempDir, 'packages', 'a', 'node_modules', 'b');
+        fs.mkdirSync(nestedNodeModules, { recursive: true });
+        const target = path.join(nestedNodeModules, 'x.js');
+        fs.writeFileSync(target, '// nested vendored');
+        const onChange = vi.fn();
+        handle = createProjectWatcher(tempDir, onChange);
+        await handle.ready;
+        fs.writeFileSync(target, '// nested vendored, changed');
+        await settle(500);
+        expect(onChange).not.toHaveBeenCalled();
+    });
+    it('fires onChange for changes inside miniprogram_npm', async () => {
+        // Why this matters: miniprogram_npm is the mini-app compiler's real
+        // input — the built npm output that the compiler reads directly, not a
+        // vendor tree to hide. A node_modules-ignoring rule that over-matches
+        // (e.g. any path segment containing "node_modules" as a substring, or a
+        // blanket "*npm*" pattern) would wrongly silence this directory too.
+        const npmDir = path.join(tempDir, 'miniprogram_npm', 'some-pkg');
+        fs.mkdirSync(npmDir, { recursive: true });
+        const target = path.join(npmDir, 'index.js');
+        fs.writeFileSync(target, '// built npm output');
+        const onChange = vi.fn();
+        handle = createProjectWatcher(tempDir, onChange);
+        await settle();
+        fs.writeFileSync(target, '// built npm output, changed');
+        await vi.waitFor(() => expect(onChange).toHaveBeenCalled(), { timeout: 2000 });
+    });
+    it('fires onChange for source edits when the project itself sits under an ancestor node_modules directory', async () => {
+        // Why this matters: same shape as the dotted-ancestor regression above —
+        // a project can legitimately live inside a node_modules directory (e.g.
+        // a demo/fixture project bundled inside a pnpm-installed package). Only
+        // node_modules segments *under* projectPath should be ignored; an
+        // ancestor node_modules segment must not disable the watch for the
+        // project's own source.
+        const ancestorNodeModules = path.join(tempDir, 'node_modules', 'some-demo-pkg');
+        const projectRoot = path.join(ancestorNodeModules, 'demo-app');
+        fs.mkdirSync(projectRoot, { recursive: true });
+        const target = path.join(projectRoot, 'app.json');
+        fs.writeFileSync(target, '{}');
+        const onChange = vi.fn();
+        handle = createProjectWatcher(projectRoot, onChange);
+        await settle();
+        fs.writeFileSync(target, '{"a":1}');
+        await vi.waitFor(() => expect(onChange).toHaveBeenCalled(), { timeout: 2000 });
+    });
 });