@dimina-kit/devkit 0.1.2-dev.20260618090552 → 0.1.2-dev.20260624084417

package/dist/compile-worker-entry.test.js

@@ -159,21 +159,20 @@ describe('compile-worker-entry — wireCompileWorkerProcess (orphan-safety-net s
     });
 });
 /**
- * CODEX-REVIEW REGRESSION (m9) — the fork-mode self-wiring gate currently
- * uses `process.argv[1].includes('compile-worker-entry')`, a SUBSTRING match.
- * Any unrelated script whose path merely contains that fragment (run with an
- * IPC channel, e.g. itself a fork) would import this module and silently
- * self-wire: a disconnect→exit(0) handler and a message handler hijacking the
- * host's IPC traffic. The gate must engage ONLY when argv[1] is THIS module
- * (same path as import.meta.url) — pinned behaviorally below via a fresh
- * module evaluation under a manipulated argv[1].
+ * The fork-mode self-wiring gate must NOT use a SUBSTRING match on
+ * `process.argv[1]`: any unrelated script whose path merely contains
+ * `compile-worker-entry` (run with an IPC channel, e.g. itself a fork) would
+ * import this module and silently self-wire — a disconnect→exit(0) handler and
+ * a message handler hijacking the host's IPC traffic. The gate must engage
+ * ONLY when argv[1] is THIS module (same path as import.meta.url) — pinned
+ * behaviorally below via a fresh module evaluation under a manipulated argv[1].
  *
  * Observation seam: self-wiring is `process.on('message'|'disconnect', …)` on
  * the REAL process — the tests diff the process listener sets around the
  * import and remove any added listeners again in cleanup (so a failing run
  * can never leak a disconnect→exit(0) handler into the vitest worker).
  */
-describe('compile-worker-entry — fork-mode self-wiring gate (codex m9)', () => {
+describe('compile-worker-entry — fork-mode self-wiring gate', () => {
     function snapshotListeners() {
         return {
             message: process.listeners('message'),
@@ -198,7 +197,7 @@ describe('compile-worker-entry — fork-mode self-wiring gate (codex m9)', () =>
         vi.resetModules();
         await import('./compile-worker-entry.js');
     }
-    it('m9: an argv[1] LOOKALIKE path (substring match) must NOT self-wire the worker IPC handlers', async () => {
+    it('an argv[1] LOOKALIKE path (substring match) must NOT self-wire the worker IPC handlers', async () => {
         const originalArgv1 = process.argv[1] ?? '';
         const originalSend = process.send;
         const before = snapshotListeners();
@@ -222,7 +221,7 @@ describe('compile-worker-entry — fork-mode self-wiring gate (codex m9)', () =>
             vi.resetModules();
         }
     });
-    it('m9 positive control: when argv[1] IS this entry module, the fork-mode self-wiring engages', async () => {
+    it('positive control: when argv[1] IS this entry module, the fork-mode self-wiring engages', async () => {
         const originalArgv1 = process.argv[1] ?? '';
         const originalSend = process.send;
         const before = snapshotListeners();

package/dist/compile-worker-leak.test.js

@@ -15,13 +15,13 @@ import { writeUntilPredicate } from './watch-rebuild.testutil.js';
  * > 0) re-writes the source file until the rebuild's first log line appears.
  */
 /**
- * LEAK-PROOFING WAVE (项目关闭时保证编译子进程同步关闭) — REAL-PROCESS
- * integration contract. Nothing in this file mocks `child_process`: every
- * test forks the actual `compile-worker-entry` (and, for the `openProject`
- * tests, runs the actual `@dimina/compiler`) and asserts on REAL process
- * death via `process.kill(pid, 0)` (ESRCH ⇒ the PID is gone).
+ * REAL-PROCESS integration contract: a closed project must take its compile
+ * worker down with it. Nothing in this file mocks `child_process`: every test
+ * forks the actual `compile-worker-entry` (and, for the `openProject` tests,
+ * runs the actual `@dimina/compiler`) and asserts on REAL process death via
+ * `process.kill(pid, 0)` (ESRCH ⇒ the PID is gone).
  *
- * Why these tests exist on top of the existing mocked-fork suite
+ * Why these tests exist on top of the mocked-fork suite
  * (`compile-worker.test.ts` pins `child.kill` was CALLED): a kill() spy
  * proves intent, not death. The two leak classes this file closes:
  *
@@ -38,12 +38,11 @@ import { writeUntilPredicate } from './watch-rebuild.testutil.js';
  *    actually dead (not merely "kill was invoked"), including when a build
  *    is in flight at close time.
  *
- * PID discovery (decision recorded for the implementer): NO new public API
- * is pinned for exposing the worker PID. The worker is discovered externally
- * via a `ps -axo pid=,ppid=,command=` scan for children of THIS test process
- * whose command line contains `compile-worker-entry`. That keeps the
- * contract purely behavioral — if the implementation later wants to expose
- * `worker.pid`, nothing here constrains it either way.
+ * PID discovery: NO public API is pinned for exposing the worker PID. The
+ * worker is discovered externally via a `ps -axo pid=,ppid=,command=` scan for
+ * children of THIS test process whose command line contains
+ * `compile-worker-entry`. That keeps the contract purely behavioral — exposing
+ * `worker.pid` later is unconstrained either way.
  *
  * CI stability: all death checks are bounded polls (8s deadline, 100ms
  * interval), and every discovered/forked PID is SIGKILLed in cleanup so a
@@ -256,13 +255,12 @@ describe('② session.close() — the worker PID is ACTUALLY dead afterwards (re
             + 'a busy worker that survives close is the classic "compile still running after project closed" leak').toBe(true);
     }, 90_000);
     /**
-     * CODEX-REVIEW REGRESSION (M3): the tests above tolerate an 8s post-close
-     * death poll. The actual contract is stronger — `await session.close()`
-     * must RETURN only after the worker already exited (close() awaits the
-     * child 'exit'), so the await itself is the death guarantee and no caller
-     * ever needs a grace poll.
+     * The tests above tolerate an 8s post-close death poll. The actual contract
+     * is stronger — `await session.close()` must RETURN only after the worker
+     * already exited (close() awaits the child 'exit'), so the await itself is
+     * the death guarantee and no caller ever needs a grace poll.
      */
-    it("M3: await session.close() returns only AFTER the worker PID is already dead — the await IS the guarantee, no grace poll", async () => {
+    it("await session.close() returns only AFTER the worker PID is already dead — the await IS the guarantee, no grace poll", async () => {
         const root = makeFixture();
         const session = await devkit.openProject({
             projectPath: root,

package/dist/compile-worker.test.js

@@ -11,8 +11,7 @@ import { writeUntilPredicate, writeUntilSettled } from './watch-rebuild.testutil
  * below depend on a REAL chokidar inotify watch (fork is mocked, chokidar is
  * not). Under CI load (concurrent real dmcc compile in
  * open-project-compile-log.test.ts pegging CPU) a single fs.writeFileSync's
- * inotify event can be dropped, hanging `await rebuilt`/`vi.waitFor` forever
- * (PR #44 30s timeout at the "fork exactly once across … 2 rebuilds" test).
+ * inotify event can be dropped, hanging `await rebuilt`/`vi.waitFor` forever.
  * Count-agnostic / `>=` waiters are wrapped in writeUntilSettled /
  * writeUntilPredicate, which RE-WRITE the source file (micro-varied content →
  * fresh inotify event) until the rebuild lands; the rebuild scheduler
@@ -21,16 +20,12 @@ import { writeUntilPredicate, writeUntilSettled } from './watch-rebuild.testutil
  * them (see its inline note).
  */
 /**
- * FORK-ARCHITECTURE WAVE (dmcc 编译子进程化) — TDD contract for the PARENT
- * side: `openProject` orchestrating a long-lived forked compile worker
- * (NOT yet implemented).
+ * Contract for the PARENT side: `openProject` orchestrating a long-lived
+ * forked compile worker.
  *
- * ⚠️ ARCHITECTURE-DECISION CHANGE (user-approved, 2026-06-12):
- * Compilation moves from the in-process `require('@dimina/compiler')` call
- * (src/index.ts:104-105 with its host-global `process.chdir`) into a forked
- * long-lived child process. The tee-style `withCapturedStdio` contract from
- * ROUND 2 was deleted (see compile-log.test.ts header); THIS file pins its
- * replacement. Explicit architecture correction, not goalpost-moving.
+ * Compilation runs in a forked long-lived child process (which chdirs in its
+ * own process) rather than the in-process `require('@dimina/compiler')` call
+ * with its host-global `process.chdir`.
  *
  * Parent-side contract pinned here (child_process.fork is mocked; the fake
  * child is an EventEmitter with PassThrough stdout/stderr + send/kill spies):
@@ -476,10 +471,10 @@ describe('openProject — fork-based compile worker orchestration', () => {
     }, 45_000);
 });
 /**
- * LEAK-PROOFING WAVE (项目关闭时保证编译子进程同步关闭) — close-time guards on
- * the exported `createCompileWorker` directly (same mocked fork as above).
- * Real process death is pinned by `compile-worker-leak.test.ts`; these pin
- * the parent-side STATE MACHINE around close:
+ * Close-time guards on the exported `createCompileWorker` directly (same
+ * mocked fork as above). Real process death is pinned by
+ * `compile-worker-leak.test.ts`; these pin the parent-side STATE MACHINE
+ * around close:
  *   - close with a build in flight kills immediately and SETTLES the pending
  *     promise (a hung promise wedges the rebuild scheduler — and a scheduler
  *     wedged at close time is itself a teardown leak),
@@ -546,23 +541,22 @@ describe('createCompileWorker — close-time leak guards (direct use)', () => {
     }, 45_000);
 });
 /**
- * CODEX-REVIEW REGRESSION WAVE (fix/editor-hot-reload-and-simulator-leftovers)
- * — failing regression tests for review findings M1 / M2 / M3 / m7. Same
- * mocked-fork harness as above; each test names the finding it pins.
+ * Regression guards for worker error replies, fork errors, close semantics,
+ * and the trailing line. Same mocked-fork harness as above.
  *
- *  M1  a `{ type:'result', error }` reply is currently resolved as a SUCCESS
- *      with appInfo:null — it must reject the in-flight build (message passed
- *      through) and surface via onBuildError on the rebuild path.
- *  M2  a child 'error' event (spawn/IPC failure) is swallowed; Node does NOT
- *      guarantee an accompanying 'exit', so the in-flight build hangs forever
- *      and the dead child is never replaced.
- *  M3  close() kills and returns immediately — it must return a promise that
- *      resolves only after the child actually exited, and must settle the
- *      in-flight build itself (not rely on the child cooperating with exit).
- *  m7  a final line without a trailing newline is buffered forever — it must
- *      be flushed to onLog exactly once when the stream ends.
+ *  - a `{ type:'result', error }` reply must NOT resolve as a SUCCESS with
+ *    appInfo:null — it must reject the in-flight build (message passed
+ *    through) and surface via onBuildError on the rebuild path.
+ *  - a child 'error' event (spawn/IPC failure) must not be swallowed; Node
+ *    does NOT guarantee an accompanying 'exit', so the in-flight build would
+ *    hang forever and the dead child would never be replaced.
+ *  - close() must return a promise that resolves only after the child actually
+ *    exited, and must settle the in-flight build itself (not rely on the child
+ *    cooperating with exit).
+ *  - a final line without a trailing newline must be flushed to onLog exactly
+ *    once when the stream ends (not buffered forever).
  */
-describe('codex review regressions — worker error replies, fork errors, close semantics, trailing line (M1/M2/M3/m7)', () => {
+describe('worker error replies, fork errors, close semantics, trailing line', () => {
     const REQUEST = {
         projectPath: '/tmp/p',
         outputDir: '/tmp/out',
@@ -583,7 +577,7 @@ describe('codex review regressions — worker error replies, fork errors, close
             return child;
         });
     }
-    it('M1: build() rejects (error message passed through) when the worker reply carries an error — not a silent appInfo:null success', async () => {
+    it('build() rejects (error message passed through) when the worker reply carries an error — not a silent appInfo:null success', async () => {
         useSilentChildren();
         const worker = devkit.createCompileWorker({});
         const pending = worker.build(REQUEST);
@@ -600,7 +594,7 @@ describe('codex review regressions — worker error replies, fork errors, close
         });
         await settled;
     }, 45_000);
-    it('M1: a rebuild whose worker reply carries an error settles through onBuildError — NOT through onRebuild as a fake hot-reload success', async () => {
+    it('a rebuild whose worker reply carries an error settles through onBuildError — NOT through onRebuild as a fake hot-reload success', async () => {
         const root = makeFixture();
         const buildErrors = [];
         const rebuilds = [];
@@ -632,7 +626,7 @@ describe('codex review regressions — worker error replies, fork errors, close
         expect(String(buildErrors[0].message), 'the worker-reported error message must pass through to onBuildError (the devtools panel renders it)').toMatch(/esbuild exploded/);
         expect(rebuilds, 'the failed rebuild must NOT fire onRebuild — onRebuild triggers the hot-reload toast').toHaveLength(0);
     }, 45_000);
-    it("M2: a fork 'error' event with NO accompanying 'exit' settles the in-flight build (bounded) and the next build re-forks a fresh worker", async () => {
+    it("a fork 'error' event with NO accompanying 'exit' settles the in-flight build (bounded) and the next build re-forks a fresh worker", async () => {
         useSilentChildren();
         const worker = devkit.createCompileWorker({});
         const pending = worker.build(REQUEST);
@@ -657,7 +651,7 @@ describe('codex review regressions — worker error replies, fork errors, close
         fresh.respondToBuild('/tmp/p');
         await expect(second).resolves.toEqual(expect.objectContaining({ appId: WORKER_APP.appId }));
     }, 45_000);
-    it("M2: 'error' followed by a LATE 'exit' is idempotent — the stale exit must not settle the NEXT build on the fresh worker", async () => {
+    it("'error' followed by a LATE 'exit' is idempotent — the stale exit must not settle the NEXT build on the fresh worker", async () => {
         useSilentChildren();
         const worker = devkit.createCompileWorker({});
         const pending = worker.build(REQUEST);
@@ -666,7 +660,7 @@ describe('codex review regressions — worker error replies, fork errors, close
         }, { timeout: 5000 });
         const first = children[0];
         first.emit('error', new Error('spawn failure'));
-        expect(await raceSettle(pending, 2000), "the 'error' event alone must settle the in-flight build (see the companion M2 test)").toBe('rejected');
+        expect(await raceSettle(pending, 2000), "the 'error' event alone must settle the in-flight build").toBe('rejected');
         // Start the recovery build, THEN let the dead child's 'exit' fire late
         // (the real-world double-fire). The stale exit must not reject the new
         // in-flight build that belongs to the fresh worker.
@@ -683,7 +677,7 @@ describe('codex review regressions — worker error replies, fork errors, close
         fresh.respondToBuild('/tmp/p');
         await expect(second, "the dead child's late 'exit' must be a no-op for the new generation — error+exit double-fire settles ONE build, once").resolves.toEqual(expect.objectContaining({ appId: WORKER_APP.appId }));
     }, 45_000);
-    it("M3: close() returns a promise that resolves only AFTER the child actually exited — kill-and-return is not a close", async () => {
+    it("close() returns a promise that resolves only AFTER the child actually exited — kill-and-return is not a close", async () => {
         const worker = devkit.createCompileWorker({});
         await worker.build(REQUEST);
         const child = children[0];
@@ -702,7 +696,7 @@ describe('codex review regressions — worker error replies, fork errors, close
         child.emit('exit', null, 'SIGTERM');
         await closeResult;
     }, 45_000);
-    it('M3: close() itself rejects the in-flight build — even when the child never emits exit', async () => {
+    it('close() itself rejects the in-flight build — even when the child never emits exit', async () => {
         useSilentChildren();
         const worker = devkit.createCompileWorker({});
         const pending = worker.build(REQUEST);
@@ -717,18 +711,17 @@ describe('codex review regressions — worker error replies, fork errors, close
             + 'come leaves the rebuild scheduler hanging at teardown').toBe('rejected');
     }, 45_000);
     /**
-     * CODEX RE-REVIEW — M3 NOT-RESOLVED follow-up. `settleDeath`'s
-     * `removeAllListeners()` also strips the `once('exit', resolve)` that
-     * close() registered on the SAME child: when a child dies through the
-     * 'error' path while a close() is in flight (kill sent, exit not yet
-     * emitted), the closePromise loses its only resolver and hangs forever.
-     * Contract: a child 'error' during an in-flight close is a death signal
-     * (Node does NOT guarantee an 'exit' after 'error' — see M2) — the close
+     * `settleDeath`'s `removeAllListeners()` must not strip the
+     * `once('exit', resolve)` that close() registered on the SAME child: when a
+     * child dies through the 'error' path while a close() is in flight (kill
+     * sent, exit not yet emitted), the closePromise must not lose its only
+     * resolver and hang forever. A child 'error' during an in-flight close is a
+     * death signal (Node does NOT guarantee an 'exit' after 'error') — the close
      * promise must still resolve, whether a late 'exit' follows or never comes.
-     * The normal-exit-resolves case is already pinned above ("M3: close()
-     * returns a promise that resolves only AFTER the child actually exited").
+     * The normal-exit-resolves case is pinned above ("close() returns a promise
+     * that resolves only AFTER the child actually exited").
      */
-    it("M3 follow-up: a child 'error' during an in-flight close() must not strip the close resolver — closePromise resolves even though only a LATE 'exit' follows", async () => {
+    it("a child 'error' during an in-flight close() must not strip the close resolver — closePromise resolves even though only a LATE 'exit' follows", async () => {
         const worker = devkit.createCompileWorker({});
         await worker.build(REQUEST);
         const child = children[0];
@@ -746,21 +739,21 @@ describe('codex review regressions — worker error replies, fork errors, close
         expect(await raceSettle(closeResult, 1500), "settleDeath's removeAllListeners must not strip close()'s exit resolver — a child that dies via "
             + "'error' mid-close leaves closePromise hanging forever, wedging every awaiter of session.close()").toBe('resolved');
     }, 45_000);
-    it("M3 follow-up: a child 'error' during an in-flight close() with NO 'exit' ever resolves the close too — 'error' is a death signal, not a wait-longer signal", async () => {
+    it("a child 'error' during an in-flight close() with NO 'exit' ever resolves the close too — 'error' is a death signal, not a wait-longer signal", async () => {
         const worker = devkit.createCompileWorker({});
         await worker.build(REQUEST);
         const child = children[0];
         child.manualExit = true;
         const closeResult = worker.close();
         expect(child.kill).toHaveBeenCalled();
-        // Node does NOT guarantee an 'exit' after 'error' (the exact premise M2
-        // pinned for builds): the lone 'error' must settle the close as well.
+        // Node does NOT guarantee an 'exit' after 'error': the lone 'error' must
+        // settle the close as well.
         child.emit('error', new Error('spawn EAGAIN'));
         expect(await raceSettle(closeResult, 1500), "a lone child 'error' during close() must resolve the close promise — settleDeath already treats "
             + "'error' as death everywhere else (clears the child, rejects builds); close() waiting for an 'exit' "
             + 'that Node never guarantees hangs teardown forever').toBe('resolved');
     }, 45_000);
-    it('m7: a final line WITHOUT a trailing newline is flushed to onLog exactly once when the stream ends', async () => {
+    it('a final line WITHOUT a trailing newline is flushed to onLog exactly once when the stream ends', async () => {
         const root = makeFixture();
         const entries = [];
         const logOpts = { onLog: (entry) => entries.push(entry) };

package/dist/index.js

@@ -68,7 +68,7 @@ export async function openProject(opts) {
     // 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
-    // pre-existing fallback to `{ appId: 'unknown' }` was load-bearing for
+    // 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`

package/dist/open-project-cleanup.test.js

@@ -6,17 +6,16 @@ import { PassThrough } from 'node:stream';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import * as devkit from './index.js';
 /**
- * CODEX-REVIEW REGRESSION WAVE (fix/editor-hot-reload-and-simulator-leftovers)
- * — failing regression tests for review findings M4 / M6: resource cleanup
- * when `openProject` fails AFTER the compile worker was already forked.
+ * Resource cleanup when `openProject` fails AFTER the compile worker was
+ * already forked.
  *
- *  M4  the worker is created before the dev server starts; a server-start
- *      failure propagates out of openProject but never kills the worker — a
- *      leaked compiler process per failed open.
- *  M6  `createProjectWatcher().ready` only resolves on chokidar's 'ready';
- *      a watcher 'error' (EMFILE, permission loss, …) before ready leaves
- *      `await watcher?.ready` — and therefore openProject — hung forever,
- *      leaking the worker AND the already-listening dev server.
+ *  - the worker is created before the dev server starts; a server-start
+ *    failure that propagates out of openProject must still kill the worker
+ *    (otherwise a leaked compiler process per failed open).
+ *  - `createProjectWatcher().ready` only resolves on chokidar's 'ready'; a
+ *    watcher 'error' (EMFILE, permission loss, …) before ready must REJECT
+ *    `ready` — otherwise `await watcher?.ready` (and openProject) hangs
+ *    forever, leaking the worker AND the already-listening dev server.
  *
  * Harness: same fake-fork pattern as compile-worker.test.ts, plus this file
  * mocks the fe dev-server module and chokidar so the failure point of each
@@ -125,8 +124,8 @@ function makeFixture() {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-describe('openProject failure cleanup — no leaked compile worker (codex M4/M6)', () => {
-    it('M4: a dev-server start failure AFTER the worker was forked rejects openProject AND kills the worker', async () => {
+describe('openProject failure cleanup — no leaked compile worker', () => {
+    it('a dev-server start failure AFTER the worker was forked rejects openProject AND kills the worker', async () => {
         const root = makeFixture();
         mocks.feStart.mockReset();
         mocks.feStart.mockRejectedValue(new Error('listen EADDRINUSE: address already in use'));
@@ -139,7 +138,7 @@ describe('openProject failure cleanup — no leaked compile worker (codex M4/M6)
         expect(children[0].kill, 'a server-start failure must kill the already-forked compile worker — today the error propagates but the '
             + 'worker (a whole compiler process) is leaked on every failed open').toHaveBeenCalled();
     }, 15_000);
-    it("M6: a watcher 'error' before 'ready' rejects openProject within a bounded time and kills the worker (no eternal hang)", async () => {
+    it("a watcher 'error' before 'ready' rejects openProject within a bounded time and kills the worker (no eternal hang)", async () => {
         const root = makeFixture();
         mocks.watch.mockReset();
         mocks.watch.mockImplementation(() => {

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

@@ -65,7 +65,7 @@ describe('openProject onLog — first compile (integration, real dmcc)', () => {
             ...logOpts,
         });
         openSessions.push(session);
-        expect(entries.length, 'openProject must wire opts.onLog through withCapturedStdio around the first build() — no lines were captured').toBeGreaterThan(0);
+        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);
         expect(texts.some(text => /^✖ /.test(text)), '`✖ …[FAILED: …]` listr failure lines must be kept').toBe(true);
@@ -124,7 +124,7 @@ describe('openProject onLog — watcher rebuild (integration, real dmcc)', () =>
         // Count-agnostic (entries.length > 0): re-write until the rebuild lands so
         // a dropped inotify event under CI load can't hang `await rebuilt`.
         await writeUntilSettled(rebuilt, path.join(root, 'pages', 'index', 'index.js'), attempt => `Page({ data: { msg: "updated-${attempt}" } })\n`);
-        expect(entries.length, 'the rebuild() build() call must ALSO be wrapped with withCapturedStdio — no rebuild lines reached onLog').toBeGreaterThan(0);
+        expect(entries.length, 'the rebuild() build() call must ALSO deliver to onLog — no rebuild lines reached onLog').toBeGreaterThan(0);
         const texts = entries.map(entry => entry.text);
         expect(texts.some(text => /^✔ /.test(text)), 'rebuild stage-completion lines must be kept').toBe(true);
         expectNoNoise(texts);

package/dist/rebuild-scheduler.test.js

@@ -120,10 +120,10 @@ describe('createRebuildScheduler — saves during an in-flight build must not be
         expect(run).toHaveBeenCalledTimes(2);
     });
 });
-// ─── ROUND 2 — `run` throwing SYNCHRONOUSLY (not rejecting) ──────────────────
+// ─── `run` throwing SYNCHRONOUSLY (not rejecting) ──────────────────
 //
-// Regression tests for the wedge found in review: `start()` sets
-// `running = true` and then calls `run()` bare. If `run` throws synchronously
+// Regression tests for a wedge: `start()` sets `running = true` and then calls
+// `run()` bare. If `run` throws synchronously
 // (e.g. a config/IO error raised before the build's first await — no promise
 // ever exists), the `.catch().then()` settle chain is never attached, so:
 //   - the exception escapes through `schedule()` to the watcher callsite,
@@ -135,7 +135,7 @@ describe('createRebuildScheduler — saves during an in-flight build must not be
 // drops a pending dirty flag", with failures being `run`'s responsibility to
 // report) must hold regardless of HOW the run fails: rejection and synchronous
 // throw are the same event to the scheduler.
-describe('ROUND 2 — createRebuildScheduler: run() throwing synchronously must not wedge the scheduler', () => {
+describe('createRebuildScheduler: run() throwing synchronously must not wedge the scheduler', () => {
     /** A `run` that throws synchronously on the i-th call(s), resolves otherwise. */
     function makeSyncThrowingRun(throwOnCalls) {
         const run = vi.fn(() => {

package/dist/watch-rebuild.testutil.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch-rebuild.testutil.d.ts","sourceRoot":"","sources":["../src/watch-rebuild.testutil.ts"],"names":[],"mappings":"AA+BA;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACzB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GACrC,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACxC,SAAS,EAAE,MAAM,OAAO,EACxB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GACrC,OAAO,CAAC,IAAI,CAAC,CAYf"}
+{"version":3,"file":"watch-rebuild.testutil.d.ts","sourceRoot":"","sources":["../src/watch-rebuild.testutil.ts"],"names":[],"mappings":"AA8BA;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACzB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GACrC,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACxC,SAAS,EAAE,MAAM,OAAO,EACxB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GACrC,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/watch-rebuild.testutil.js

@@ -10,8 +10,7 @@ import fs from 'node:fs';
  * watch. A single `fs.writeFileSync` produces a single inotify `change` event,
  * and under CI load (Linux inotify + a concurrent REAL dmcc compile in
  * open-project-compile-log.test.ts pegging the CPU) chokidar can DROP that lone
- * event — the rebuild never fires and the test waits forever (PR #44's 30s
- * timeout at compile-worker.test.ts:297).
+ * event — the rebuild never fires and the test waits forever until timeout.
  *
  * The fix is NOT a longer timeout (the event is lost, not slow): re-issue the
  * filesystem write — with micro-varied content so size+mtime change and a fresh
@@ -20,8 +19,8 @@ import fs from 'node:fs';
  * write into exactly ONE trailing build, so re-writing is safe for the
  * count-agnostic / `>=` assertions these helpers are applied to.
  *
- * ⚠️ This is flake hardening, NOT goalpost-moving: no assertion is touched.
- * Only apply these helpers where the assertion is count-agnostic or `>=`
+ * This is flake hardening only: no assertion is touched. Only apply these
+ * helpers where the assertion is count-agnostic or `>=`
  * (re-triggering an extra coalesced rebuild cannot change the outcome). Tests
  * that pin an EXACT rebuild/build-send count must not use them.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimina-kit/devkit",
-  "version": "0.1.2-dev.20260618090552",
+  "version": "0.1.2-dev.20260624084417",
   "description": "Development toolkit for Dimina mini-apps with H5 container preview",
   "keywords": [
     "dimina",
@@ -49,11 +49,12 @@
   ],
   "devDependencies": {
     "@types/node": "^22.15.3",
+    "@vitest/coverage-v8": "^4.1.4",
     "eslint": "^10.2.1",
     "typescript": "5.9.2",
     "vitest": "^4.1.4",
-    "@dimina-kit/eslint-config": "0.1.0",
-    "@dimina-kit/typescript-config": "0.1.0"
+    "@dimina-kit/typescript-config": "0.1.0",
+    "@dimina-kit/eslint-config": "0.1.0"
   },
   "dependencies": {
     "@dimina/compiler": "1.0.16",
@@ -71,6 +72,7 @@
     "check-types": "tsc --noEmit",
     "lint": "eslint . --max-warnings 0",
     "test": "vitest run",
-    "test:dev": "vitest"
+    "test:dev": "vitest",
+    "test:coverage": "vitest run --coverage"
   }
 }