@dimina-kit/devkit 0.1.2-dev.20260703101348 → 0.1.2-dev.20260706125036

package/dist/compile-worker.d.ts

@@ -1,3 +1,23 @@
+/**
+ * Parent-side orchestration of the forked compile worker.
+ *
+ * One long-lived worker per `openProject` session: the first compile and
+ * every watcher rebuild are `{ cmd: 'build' }` IPC messages to the SAME
+ * child, so the compiler's module/worker caches stay warm. The parent never
+ * calls `process.chdir` — the worker chdirs in its own process (the root
+ * motive of this architecture).
+ *
+ * Crash handling: an unexpected worker death ('exit', 'close' or a lone
+ * 'error' event — Node does NOT guarantee an 'exit' after 'error') rejects
+ * the in-flight build (so the rebuild scheduler settles instead of hanging)
+ * and the NEXT build lazily re-forks a fresh worker. The death handler is
+ * idempotent and generation-guarded: a dead child's late 'exit' can never
+ * settle a build that belongs to a fresh worker. `close()` kills, rejects
+ * the in-flight build itself, and resolves on the child's first death event
+ * ('exit'/'close', or a lone 'error') — it never re-forks
+ * (refill-on-graceful-close would wedge process teardown).
+ */
+import { type ChildProcess } from 'node:child_process';
 import type { WorkerAppInfo, WorkerBuildOptions } from './compile-worker-entry.js';
 export interface CompileLogEntry {
     stream: 'stdout' | 'stderr';
@@ -6,6 +26,16 @@ export interface CompileLogEntry {
 export interface CompileWorkerOptions {
     /** Filtered dmcc log lines (already through `filterDmccLogLine`). */
     onLog?: (entry: CompileLogEntry) => void;
+    /**
+     * An already-forked compile-worker-entry process to reuse for the first
+     * build (a warm-standby hand-off) instead of paying a fresh fork + compiler
+     * import. Must be an IPC fork with piped stdio — the same shape spawnWorker
+     * produces. Pure accelerator: an adoptee that is already dead (or dies
+     * before the first build) is simply skipped and the next build forks fresh.
+     * Once adopted, the process is owned by this worker exactly like a
+     * self-forked one — close() kills it, its death rejects in-flight builds.
+     */
+    adopt?: ChildProcess;
 }
 export interface BuildRequest {
     projectPath: string;
@@ -29,5 +59,28 @@ export interface CompileWorker {
      */
     close: () => Promise<void>;
 }
+/**
+ * Resolve the fork target. In the published build this is the compiled
+ * `dist/compile-worker-entry.js` sibling; under vitest/dev the module runs
+ * from `src/`, where only the `.ts` source exists — the entry is a
+ * zero-dependency, erasable-syntax-only shell by design, so Node can run it
+ * with type stripping (default since 22.18; behind `--experimental-strip-types`
+ * on 22.6–22.17, which `workerExecArgv` passes for a `.ts` entry).
+ *
+ * Exported (with `workerExecArgv`) as the single authority on the fork shape:
+ * the warm-standby manager forks the SAME entry with the SAME execArgv, so a
+ * spare is indistinguishable from a worker this module forks itself.
+ */
+export declare function resolveWorkerEntry(): string;
+/**
+ * execArgv for the fork. A compiled `.js` entry (the published build, engines
+ * `node >=20`) needs nothing. A `.ts` entry (vitest/dev only) needs Node type
+ * stripping: `--experimental-strip-types` exists since 22.6 — on older Node
+ * the child would die at startup with an opaque ERR_UNKNOWN_FILE_EXTENSION /
+ * bad-option crash, so fail HERE with an actionable message instead. The
+ * ExperimentalWarning is silenced because the child's stderr is the dmcc log
+ * transport. On ≥22.18 (stripping on by default) the flag is still accepted.
+ */
+export declare function workerExecArgv(entry: string): string[];
 export declare function createCompileWorker(opts?: CompileWorkerOptions): CompileWorker;
 //# sourceMappingURL=compile-worker.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compile-worker.d.ts","sourceRoot":"","sources":["../src/compile-worker.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAuB,MAAM,2BAA2B,CAAA;AAIvG,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,oBAAoB;IACpC,qEAAqE;IACrE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;CACxC;AAED,MAAM,WAAW,YAAY;IAC5B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,kBAAkB,CAAA;CAC3B;AAED,MAAM,WAAW,aAAa;IAC7B;;;;;OAKG;IACH,KAAK,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IAC3D;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAsCD,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,oBAAyB,GAAG,aAAa,CA6KlF"}
+{"version":3,"file":"compile-worker.d.ts","sourceRoot":"","sources":["../src/compile-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAQ,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAM5D,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAuB,MAAM,2BAA2B,CAAA;AAIvG,MAAM,WAAW,eAAe;IAC/B,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;CACZ;AAED,MAAM,WAAW,oBAAoB;IACpC,qEAAqE;IACrE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;IACxC;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,YAAY,CAAA;CACpB;AAED,MAAM,WAAW,YAAY;IAC5B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,kBAAkB,CAAA;CAC3B;AAED,MAAM,WAAW,aAAa;IAC7B;;;;;OAKG;IACH,KAAK,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IAC3D;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAI3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAWtD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,oBAAyB,GAAG,aAAa,CA8LlF"}

package/dist/compile-worker.js

@@ -30,8 +30,12 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
  * zero-dependency, erasable-syntax-only shell by design, so Node can run it
  * with type stripping (default since 22.18; behind `--experimental-strip-types`
  * on 22.6–22.17, which `workerExecArgv` passes for a `.ts` entry).
+ *
+ * Exported (with `workerExecArgv`) as the single authority on the fork shape:
+ * the warm-standby manager forks the SAME entry with the SAME execArgv, so a
+ * spare is indistinguishable from a worker this module forks itself.
  */
-function resolveWorkerEntry() {
+export function resolveWorkerEntry() {
     const js = path.join(__dirname, 'compile-worker-entry.js');
     if (fs.existsSync(js))
         return js;
@@ -46,7 +50,7 @@ function resolveWorkerEntry() {
  * ExperimentalWarning is silenced because the child's stderr is the dmcc log
  * transport. On ≥22.18 (stripping on by default) the flag is still accepted.
  */
-function workerExecArgv(entry) {
+export function workerExecArgv(entry) {
     if (!entry.endsWith('.ts'))
         return [];
     const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
@@ -112,15 +116,10 @@ export function createCompileWorker(opts = {}) {
         stream.on('end', flush);
         stream.on('close', flush);
     }
-    function spawnWorker() {
-        const entry = resolveWorkerEntry();
-        const worker = fork(entry, [], {
-            // Pipe stdout/stderr back to the parent — the dmcc log transport.
-            silent: true,
-            // Explicit execArgv, NOT the parent's (vitest/electron loaders would
-            // leak into a plain Node child).
-            execArgv: workerExecArgv(entry),
-        });
+    // Attach the log pipes, result routing and death handling to a worker
+    // process — the SAME wiring whether the process was self-forked or adopted
+    // from a warm standby (an inline copy for one of the two would drift).
+    function wireWorker(worker) {
         attachLineReader(worker.stdout, 'stdout');
         attachLineReader(worker.stderr, 'stderr');
         // Shared, idempotent death handler for 'exit' / 'close' / 'error': the
@@ -177,6 +176,26 @@ export function createCompileWorker(opts = {}) {
         worker.on('error', (err) => settleDeath(`compile worker errored: ${err.message}`));
         return worker;
     }
+    function spawnWorker() {
+        const entry = resolveWorkerEntry();
+        return wireWorker(fork(entry, [], {
+            // Pipe stdout/stderr back to the parent — the dmcc log transport.
+            silent: true,
+            // Explicit execArgv, NOT the parent's (vitest/electron loaders would
+            // leak into a plain Node child).
+            execArgv: workerExecArgv(entry),
+        }));
+    }
+    // Adopt the warm-standby hand-off, if any, at creation time — wiring
+    // immediately (not at the first build) so a spare that dies in the gap is
+    // handled by the normal death path (child cleared → next build re-forks)
+    // instead of being discovered as a broken pipe mid-build. An adoptee that
+    // is ALREADY dead is skipped outright: its death events fired before any
+    // listener could attach, so wiring it would leave a permanently wedged
+    // child slot.
+    if (opts.adopt && opts.adopt.exitCode === null && opts.adopt.signalCode === null && opts.adopt.connected) {
+        child = wireWorker(opts.adopt);
+    }
     function runBuild(req) {
         if (closed) {
             return Promise.reject(new Error('compile worker is closed'));

package/dist/index.d.ts

@@ -1,9 +1,21 @@
 import type { CompileLogEntry } from './compile-worker.js';
+import type { CompileWorkerStandby, CompileWorkerStandbyOptions } from './compile-worker-standby.js';
 export { createRebuildScheduler } from './rebuild-scheduler.js';
 export type { RebuildScheduler } from './rebuild-scheduler.js';
 export { filterDmccLogLine } from './compile-log.js';
 export { createCompileWorker } from './compile-worker.js';
 export type { CompileLogEntry, CompileWorker } from './compile-worker.js';
+export { createCompileWorkerStandby } from './compile-worker-standby.js';
+export type { CompileWorkerStandby, CompileWorkerStandbyOptions, StandbyEvent, StandbyState, } from './compile-worker-standby.js';
+/**
+ * Turn on the warm-standby accelerator and start warming the first spare
+ * immediately. Idempotent while the returned manager is live — repeat calls
+ * return the SAME manager (their opts are ignored). After `dispose()` (host
+ * shutdown, or a test tearing down) a new call builds a fresh manager. The
+ * caller owns disposal; a disposed manager makes every openProject fall back
+ * to cold forks and never spawns again.
+ */
+export declare function enableCompileWorkerStandby(opts?: CompileWorkerStandbyOptions): CompileWorkerStandby;
 export interface AppInfo {
     appId: string;
     name: string;

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,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;AAyCzE,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,CAwInF;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":"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"}

package/dist/index.js

@@ -8,9 +8,46 @@ import { createRequire } from 'node:module';
 import chokidar from 'chokidar';
 import { createRebuildScheduler } from './rebuild-scheduler.js';
 import { createCompileWorker } from './compile-worker.js';
+import { createCompileWorkerStandby } from './compile-worker-standby.js';
 export { createRebuildScheduler } from './rebuild-scheduler.js';
 export { filterDmccLogLine } from './compile-log.js';
 export { createCompileWorker } from './compile-worker.js';
+export { createCompileWorkerStandby } from './compile-worker-standby.js';
+// ── warm standby (opt-in) ──────────────────────────────────────────────────
+//
+// One module-level spare compile worker shared by every `openProject` in this
+// process. While no project is open the spare sits forked + prewarmed
+// (project-agnostic — it never chdirs, see compile-worker-entry); openProject
+// adopts it for the first compile and each session close refills it. Purely
+// additive: hosts that never call `enableCompileWorkerStandby` get exactly the
+// cold-fork behavior they had before.
+let standbyManager = null;
+/**
+ * Turn on the warm-standby accelerator and start warming the first spare
+ * immediately. Idempotent while the returned manager is live — repeat calls
+ * return the SAME manager (their opts are ignored). After `dispose()` (host
+ * shutdown, or a test tearing down) a new call builds a fresh manager. The
+ * caller owns disposal; a disposed manager makes every openProject fall back
+ * to cold forks and never spawns again.
+ */
+export function enableCompileWorkerStandby(opts) {
+    if (standbyManager && standbyManager.state !== 'disposed')
+        return standbyManager;
+    standbyManager = createCompileWorkerStandby(opts);
+    standbyManager.ensure();
+    return standbyManager;
+}
+/**
+ * Refill the spare after a compile worker has been consumed and fully closed.
+ * Fire-and-forget BY DESIGN: the fork happens asynchronously inside the
+ * manager, so a session close never waits on (and can never be wedged by)
+ * standby work — the refill-on-graceful-close deadlock class stays
+ * structurally impossible. No-ops when the standby is off, already warming,
+ * or disposed.
+ */
+function refillStandby() {
+    standbyManager?.ensure();
+}
 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
@@ -125,8 +162,12 @@ export async function openProject(opts) {
     // Compilation runs in a long-lived forked worker — the worker chdirs in
     // its OWN process, so this (host) process never mutates its cwd, and dmcc
     // terminal output arrives on the worker's piped streams (delivered to
-    // `onLog` line-by-line after `filterDmccLogLine`).
-    const compileWorker = createCompileWorker({ onLog });
+    // `onLog` line-by-line after `filterDmccLogLine`). When the warm standby is
+    // enabled and holds a healthy spare, adopt it: the first compile then runs
+    // on an already-forked, toolchain-warm process. adopt() degrades to null on
+    // every failure path, which lands in the normal cold-fork behavior.
+    const adopted = standbyManager ? await standbyManager.adopt() : null;
+    const compileWorker = createCompileWorker({ onLog, ...(adopted ? { adopt: adopted } : {}) });
     const buildRequest = {
         projectPath,
         outputDir: resolvedOutputDir,
@@ -137,13 +178,22 @@ export async function openProject(opts) {
         initialAppInfo = (await compileWorker.build(buildRequest));
     }
     catch (err) {
+        // The first compile failing IS the open failing: a compile error rejects
+        // out of the worker (the pool relays it as a real rejection), and a
+        // session started anyway could only serve 404s (no artifacts in
+        // outputDir) while the real cause stays invisible. Tear down and rethrow
+        // so the host sees the compile error as openProject's failure.
         await compileWorker.close();
+        // A failed open consumed the spare too — refill (fire-and-forget) so the
+        // NEXT open attempt still starts warm.
+        refillStandby();
         throw err;
     }
-    // When the compiler is racing (e.g. opening a project that was just
-    // closed elsewhere in the same Electron process) `build()` can return
-    // null even though the manifest on disk is perfectly readable. The
-    // fallback to `{ appId: 'unknown' }` is load-bearing for
+    // A compile FAILURE rejects above — a resolved null never means "compile
+    // failed". It means the compiler had no app info to report: e.g. racing a
+    // project that was just closed elsewhere in the same Electron process,
+    // where the manifest on disk is perfectly readable. The fallback to
+    // `{ appId: 'unknown' }` is load-bearing for
     // any consumer that calls `wx.setStorageSync` — the dimina runtime
     // stores values under `${appId}_${key}` and the devtools storage panel
     // also derives its IPC prefix from `appInfo.appId`. A stale `unknown`
@@ -164,7 +214,7 @@ export async function openProject(opts) {
         // real cause here, at the point the invalid id is produced, instead of
         // letting it fail opaquely at injection time.
         const reason = `[devkit] could not resolve an appId for ${projectPath}: the compiler produced no app info and project.config.json has no "appid". `
-            + 'Falling back to "unknown" — the mini-program likely failed to compile or is missing its manifest.';
+            + 'Falling back to "unknown" — the mini-program is likely missing its manifest.';
         console.warn(reason);
         onBuildError?.(new Error(reason));
     }
@@ -207,6 +257,7 @@ export async function openProject(opts) {
     }
     catch (err) {
         await cleanupFailedOpen(watcher, compileWorker, server);
+        refillStandby();
         throw err;
     }
     // `server` is always assigned when the try block completes without throwing
@@ -220,9 +271,13 @@ export async function openProject(opts) {
         close: async () => {
             await watcher?.close();
             // Kill the long-lived compile worker and WAIT for the child to be
-            // actually dead — only kill, never re-fork on a graceful close (a
-            // refill here would wedge process teardown).
+            // actually dead — THIS worker is never re-forked on a graceful close
+            // (an awaited refill here would wedge process teardown).
             await compileWorker.close();
+            // The standby refill is different: fire-and-forget into the manager
+            // (nothing here waits on it), sequenced after the old worker's death
+            // so spare + dying worker never hold memory simultaneously.
+            refillStandby();
             liveServer.closeAllConnections?.();
             await new Promise(resolve => liveServer.close(() => resolve()));
         },

package/dist/open-project-compile-log.test.js

@@ -54,17 +54,29 @@ function expectNoNoise(texts) {
     }
 }
 describe('openProject onLog — first compile (integration, real dmcc)', () => {
-    it('streams filtered compile-error lines to onLog when the first compile fails', async () => {
+    it('rejects openProject itself when the first compile fails, after streaming every filtered log line to onLog', async () => {
         const root = makeFixture({ brokenIndexJs: true });
         const entries = [];
         const logOpts = { onLog: (entry) => entries.push(entry) };
-        const session = await devkit.openProject({
-            projectPath: root,
-            watch: false,
-            outputDir: path.join(root, '.out'),
-            ...logOpts,
-        });
-        openSessions.push(session);
+        let caught;
+        try {
+            const session = await devkit.openProject({
+                projectPath: root,
+                watch: false,
+                outputDir: path.join(root, '.out'),
+                ...logOpts,
+            });
+            // Only reached if openProject wrongly resolved — track it for teardown
+            // so a false-negative pass here still doesn't leak a dev server/watcher.
+            openSessions.push(session);
+        }
+        catch (err) {
+            caught = err;
+        }
+        expect(caught, 'openProject must REJECT when the first compile fails — a broken project must never silently open a session').toBeInstanceOf(Error);
+        const message = caught.message;
+        expect(message, 'the rejection must name the failing stage, not a generic wrapper message').toMatch(/stage "logic" failed/);
+        expect(message, 'the rejection must carry the underlying compile reason (esbuild transform failure), not just the stage name').toMatch(/Transform failed/);
         expect(entries.length, 'openProject must wire opts.onLog around the first build() — no lines were captured').toBeGreaterThan(0);
         const texts = entries.map(entry => entry.text);
         expect(texts.some(text => /esbuild 转换失败/.test(text)), 'the `[logic] esbuild 转换失败 <file>` line is the highest-value error line and must be kept').toBe(true);