@dimina-kit/devtools 0.4.0-dev.20260707110006 → 0.4.0-dev.20260711062001

package/dist/main/index.bundle.js

@@ -27,7 +27,10 @@ var DEFAULTS = {
     port: 7789
   },
   compile: {
-    watch: true
+    autoBuild: true
+  },
+  preview: {
+    autoReload: true
   },
   theme: "system",
   lastCreateBaseDir: null
@@ -35,6 +38,9 @@ var DEFAULTS = {
 function getSettingsFile() {
   return path.join(app.getPath("userData"), "dimina-workbench-settings.json");
 }
+function pickBool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
 function loadWorkbenchSettings() {
   try {
     const data = JSON.parse(fs.readFileSync(getSettingsFile(), "utf-8"));
@@ -49,7 +55,16 @@ function loadWorkbenchSettings() {
         port: data.mcp?.port ?? DEFAULTS.mcp.port
       },
       compile: {
-        watch: data.compile?.watch ?? DEFAULTS.compile.watch
+        // Legacy files persisted a single `compile.watch`; the new schema
+        // splits it into `compile.autoBuild` (recompile on save) and
+        // `preview.autoReload` (reload the simulator afterwards). Prefer the new
+        // key, fall back to the legacy one so an old settings file keeps its
+        // "auto-compile" choice; `preview.autoReload` defaults to true (the old
+        // always-reload behavior) when the file predates the split.
+        autoBuild: pickBool(data.compile?.autoBuild, pickBool(data.compile?.watch, DEFAULTS.compile.autoBuild))
+      },
+      preview: {
+        autoReload: pickBool(data.preview?.autoReload, DEFAULTS.preview.autoReload)
       },
       theme,
       lastCreateBaseDir: typeof data.lastCreateBaseDir === "string" ? data.lastCreateBaseDir : DEFAULTS.lastCreateBaseDir
@@ -59,7 +74,8 @@ function loadWorkbenchSettings() {
       ...DEFAULTS,
       cdp: { ...DEFAULTS.cdp },
       mcp: { ...DEFAULTS.mcp },
-      compile: { ...DEFAULTS.compile }
+      compile: { ...DEFAULTS.compile },
+      preview: { ...DEFAULTS.preview }
     };
   }
 }
@@ -502,12 +518,10 @@ var UpdateChannel = {
 };
 
 // src/main/ipc/project-fs.ts
+import { WATCH_IGNORE_DIRS } from "@dimina-kit/devkit/watch-ignore";
 var LIST_FILE_LIMIT = 5e3;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".svn",
-  ".hg",
+  ...WATCH_IGNORE_DIRS,
   "dist",
   "build",
   ".next",
@@ -665,7 +679,18 @@ async function statWithin(root, rel) {
 }
 async function readdirWithin(root, rel) {
   const safe = await resolveWithinProjectRoot(joinRel(root, rel), root);
-  return fs2.readdir(safe, { withFileTypes: true });
+  const dirents = await fs2.readdir(safe, { withFileTypes: true });
+  return Promise.all(
+    dirents.map(async (d) => {
+      if (d.isDirectory()) return { name: d.name, isDirectory: true };
+      try {
+        const st = await fs2.stat(path2.join(safe, d.name));
+        return { name: d.name, isDirectory: false, size: st.size, mtimeMs: st.mtimeMs };
+      } catch {
+        return { name: d.name, isDirectory: false };
+      }
+    })
+  );
 }
 async function readFileBufferWithin(root, rel) {
   return readFileBuffer(root, joinRel(root, rel));
@@ -4095,16 +4120,18 @@ function createWorkspaceService(ctx) {
     }
   }
   async function runCompile(projectPath, sessionGeneration) {
-    const { compile } = loadWorkbenchSettings();
+    const { compile, preview } = loadWorkbenchSettings();
     try {
       const session5 = await ctx.adapter.openProject({
         projectPath,
         sourcemap: true,
         fileTypes: ctx.fileTypes,
-        watch: compile.watch,
+        // Two independent gates: autoBuild = recompile on save; autoReload = refresh the simulator afterwards (off ⇒ page/form state survives; hotReload below stays false so the native simulator, which has no SSE reload, isn't refreshed).
+        watch: compile.autoBuild,
+        autoReload: preview.autoReload,
         onRebuild: () => {
           const { pages } = getProjectPages(projectPath);
-          sendStatus("ready", "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u91CD\u542F", true, pages.length ? pages : void 0);
+          sendStatus("ready", preview.autoReload ? "\u7F16\u8BD1\u5B8C\u6210\uFF0C\u5DF2\u91CD\u542F" : "\u7F16\u8BD1\u5B8C\u6210", preview.autoReload, pages.length ? pages : void 0);
         },
         onBuildError: (err2) => sendStatus("error", String(err2)),
         // Watcher died mid-session (EMFILE, permission loss, …): non-fatal, so 'ready' stays but `watcher: 'dead'` flags that saves no longer auto-rebuild.
@@ -4631,7 +4658,10 @@ var WorkbenchSettingsSaveSchema = z3.tuple([
       port: z3.number().int().min(0).max(65535)
     }),
     compile: z3.looseObject({
-      watch: z3.boolean()
+      autoBuild: z3.boolean()
+    }),
+    preview: z3.looseObject({
+      autoReload: z3.boolean()
     }),
     theme: z3.enum(["system", "light", "dark"]),
     lastCreateBaseDir: z3.union([z3.string(), z3.null()])
@@ -11044,8 +11074,12 @@ async function fsStat(ctx) {
 }
 async function fsReaddir(ctx) {
   const entries = await readdirWithin(ctx.projectRoot, ctx.rel);
-  const visible = entries.filter((e) => !(e.isDirectory() && SKIP_DIRS.has(e.name)));
-  jsonRes(ctx.res, 200, visible.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
+  const visible = entries.filter((e) => !(e.isDirectory && SKIP_DIRS.has(e.name)));
+  jsonRes(
+    ctx.res,
+    200,
+    visible.map((e) => e.isDirectory ? [e.name, 2] : [e.name, 1, e.size, e.mtimeMs])
+  );
 }
 async function fsRead(ctx) {
   const buf = await readFileBufferWithin(ctx.projectRoot, ctx.rel);

package/dist/main/ipc/project-fs.d.ts

@@ -2,7 +2,13 @@ import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 /** Dependency/VCS/build directories invisible to every project-tree consumer:
  * IPC `listFiles`, the `/__fs/readdir` bridge (so the workbench mirror and the
- * WAL ledger seed never walk into them), and the `/__fs/watch` change stream. */
+ * WAL ledger seed never walk into them), and the `/__fs/watch` change stream.
+ * Derived from devkit's `WATCH_IGNORE_DIRS` (the shared never-source core:
+ * node_modules + VCS) so the `node_modules` omission that once wedged
+ * `watcher.close()` can never drift back on this side, PLUS the editor mirror's
+ * own build-output names (`dist`/`build`/tool caches) — which the devkit
+ * recompile watcher deliberately does NOT ignore, since app.json may declare
+ * pages under such paths. */
 export declare const SKIP_DIRS: ReadonlySet<string>;
 /**
  * Synchronous, string-level guard: reject empty root (ENOACTIVE), NUL bytes
@@ -79,8 +85,31 @@ export declare function writeFile(root: string, p: string, content: string | Buf
  * out-of-sandbox metadata. `rel` is a project-root-relative bridge path.
  */
 export declare function statWithin(root: string, rel: string): Promise<import('node:fs').Stats>;
-/** Realpath-contained `fs.readdir` twin (see {@link statWithin}). */
-export declare function readdirWithin(root: string, rel: string): Promise<import('node:fs').Dirent[]>;
+/**
+ * One `readdirWithin` result entry. Directories carry no stat (the caller —
+ * the `/__fs/readdir` bridge handler — never needs it: a directory recurses
+ * instead of being compared). `size`/`mtimeMs` are omitted (not `null`) when
+ * the entry raced a concurrent delete between `readdir` and `stat` — the
+ * bridge wire format then drops them too, which the sync engine's watch
+ * expansion (dimina-kit workbench's wal-audit-watch-expand.ts) treats as
+ * "always changed" rather than risking a false stat match.
+ */
+export interface ReaddirStatEntry {
+    name: string;
+    isDirectory: boolean;
+    size?: number;
+    mtimeMs?: number;
+}
+/**
+ * Realpath-contained `fs.readdir` twin (see {@link statWithin}) that also
+ * `fs.stat`s every FILE entry (size + mtimeMs) — the disk-side half of the
+ * sync engine's stat-diffing (see wal-audit-watch-expand.ts's module doc):
+ * a watch-reported directory is only worth a full content re-read when a
+ * file's stat inside it actually moved, and the `/__fs/readdir` bridge is
+ * the one HTTP round trip cheap enough to do that check on every watch
+ * event without itself re-reading file bytes.
+ */
+export declare function readdirWithin(root: string, rel: string): Promise<ReaddirStatEntry[]>;
 /**
  * Raw-byte read twin of {@link readFileBuffer} taking a project-root-relative
  * bridge path (the COI `/__fs/read` bridge), with the same realpath +

package/dist/main/ipc/project-fs.js

@@ -47,14 +47,21 @@ import { z } from 'zod';
 import { IpcRegistry } from '../utils/ipc-registry.js';
 import { validate } from '../utils/ipc-schema.js';
 import { ProjectFsChannel } from '../../shared/ipc-channels.js';
+import { WATCH_IGNORE_DIRS } from '@dimina-kit/devkit/watch-ignore';
 /** Cap for `listFiles` — huge monorepos would otherwise stall the renderer. */
 const LIST_FILE_LIMIT = 5000;
 /** Dependency/VCS/build directories invisible to every project-tree consumer:
  * IPC `listFiles`, the `/__fs/readdir` bridge (so the workbench mirror and the
- * WAL ledger seed never walk into them), and the `/__fs/watch` change stream. */
+ * WAL ledger seed never walk into them), and the `/__fs/watch` change stream.
+ * Derived from devkit's `WATCH_IGNORE_DIRS` (the shared never-source core:
+ * node_modules + VCS) so the `node_modules` omission that once wedged
+ * `watcher.close()` can never drift back on this side, PLUS the editor mirror's
+ * own build-output names (`dist`/`build`/tool caches) — which the devkit
+ * recompile watcher deliberately does NOT ignore, since app.json may declare
+ * pages under such paths. */
 export const SKIP_DIRS = new Set([
-    'node_modules', '.git', '.svn', '.hg', 'dist', 'build',
-    '.next', '.cache', '.turbo', '.parcel-cache', '.nuxt', '.output', '.vite',
+    ...WATCH_IGNORE_DIRS,
+    'dist', 'build', '.next', '.cache', '.turbo', '.parcel-cache', '.nuxt', '.output', '.vite',
 ]);
 const PathArg = z.string().min(1);
 const ReadFileSchema = z.tuple([PathArg]);
@@ -319,10 +326,31 @@ export async function statWithin(root, rel) {
     const safe = await resolveWithinProjectRoot(joinRel(root, rel), root);
     return fs.stat(safe);
 }
-/** Realpath-contained `fs.readdir` twin (see {@link statWithin}). */
+/**
+ * Realpath-contained `fs.readdir` twin (see {@link statWithin}) that also
+ * `fs.stat`s every FILE entry (size + mtimeMs) — the disk-side half of the
+ * sync engine's stat-diffing (see wal-audit-watch-expand.ts's module doc):
+ * a watch-reported directory is only worth a full content re-read when a
+ * file's stat inside it actually moved, and the `/__fs/readdir` bridge is
+ * the one HTTP round trip cheap enough to do that check on every watch
+ * event without itself re-reading file bytes.
+ */
 export async function readdirWithin(root, rel) {
     const safe = await resolveWithinProjectRoot(joinRel(root, rel), root);
-    return fs.readdir(safe, { withFileTypes: true });
+    const dirents = await fs.readdir(safe, { withFileTypes: true });
+    return Promise.all(dirents.map(async (d) => {
+        if (d.isDirectory())
+            return { name: d.name, isDirectory: true };
+        try {
+            const st = await fs.stat(path.join(safe, d.name));
+            return { name: d.name, isDirectory: false, size: st.size, mtimeMs: st.mtimeMs };
+        }
+        catch {
+            // Entry vanished (or became unreadable) between readdir and stat —
+            // report it stat-less; see this function's doc for why that is safe.
+            return { name: d.name, isDirectory: false };
+        }
+    }));
 }
 /**
  * Raw-byte read twin of {@link readFileBuffer} taking a project-root-relative

package/dist/main/services/render-inspect/index.d.ts

@@ -16,7 +16,7 @@
 import type { WebContents } from 'electron';
 import type { ConnectionRegistry } from '@dimina-kit/electron-deck/main';
 import type { ElementInspection } from '../../../shared/ipc-channels.js';
-import type { WxmlNode } from '../../../preload/shared/sid-registry.js';
+import type { WxmlNode } from '@dimina-kit/inspect';
 export interface RenderInspector {
     /** Inject (once per wc) the inspector IIFE, then read the WXML tree. */
     getWxml(wc: WebContents): Promise<WxmlNode | null>;

package/dist/main/services/settings/index.d.ts

@@ -10,7 +10,13 @@ export interface WorkbenchSettings {
     };
     compile: {
         /** Watch project files and auto-recompile on change. */
-        watch: boolean;
+        autoBuild: boolean;
+    };
+    preview: {
+        /** Reload the simulator once a watcher-triggered rebuild lands. Independent
+         * of `compile.autoBuild`: "auto-compile on save, reload manually" is valid
+         * and preserves the running page stack / form state across a save. */
+        autoReload: boolean;
     };
     theme: ThemeSource;
     /**

package/dist/main/services/settings/index.js

@@ -12,7 +12,10 @@ const DEFAULTS = {
         port: 7789,
     },
     compile: {
-        watch: true,
+        autoBuild: true,
+    },
+    preview: {
+        autoReload: true,
     },
     theme: 'system',
     lastCreateBaseDir: null,
@@ -20,6 +23,13 @@ const DEFAULTS = {
 function getSettingsFile() {
     return path.join(app.getPath('userData'), 'dimina-workbench-settings.json');
 }
+/** Accept `value` only when it is a real boolean, else `fallback`. A bare `??`
+ * chain guards only null/undefined, so a hand-edited or corrupt config with a
+ * stringy `"false"` would pass through and read as truthy downstream — silently
+ * keeping a toggle ON when the user meant OFF. */
+function pickBool(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
 export function loadWorkbenchSettings() {
     try {
         const data = JSON.parse(fs.readFileSync(getSettingsFile(), 'utf-8'));
@@ -36,7 +46,16 @@ export function loadWorkbenchSettings() {
                 port: data.mcp?.port ?? DEFAULTS.mcp.port,
             },
             compile: {
-                watch: data.compile?.watch ?? DEFAULTS.compile.watch,
+                // Legacy files persisted a single `compile.watch`; the new schema
+                // splits it into `compile.autoBuild` (recompile on save) and
+                // `preview.autoReload` (reload the simulator afterwards). Prefer the new
+                // key, fall back to the legacy one so an old settings file keeps its
+                // "auto-compile" choice; `preview.autoReload` defaults to true (the old
+                // always-reload behavior) when the file predates the split.
+                autoBuild: pickBool(data.compile?.autoBuild, pickBool(data.compile?.watch, DEFAULTS.compile.autoBuild)),
+            },
+            preview: {
+                autoReload: pickBool(data.preview?.autoReload, DEFAULTS.preview.autoReload),
             },
             theme,
             lastCreateBaseDir: typeof data.lastCreateBaseDir === 'string'
@@ -50,6 +69,7 @@ export function loadWorkbenchSettings() {
             cdp: { ...DEFAULTS.cdp },
             mcp: { ...DEFAULTS.mcp },
             compile: { ...DEFAULTS.compile },
+            preview: { ...DEFAULTS.preview },
         };
     }
 }

package/dist/main/services/workbench-coi-server.js

@@ -206,8 +206,15 @@ async function fsReaddir(ctx) {
     // every level: the workbench mirror and the WAL ledger seed walk whatever
     // this returns, so listing them would pull entire dependency trees into the
     // editor memfs and the OPFS ledger. Same-named FILES stay visible.
-    const visible = entries.filter((e) => !(e.isDirectory() && SKIP_DIRS.has(e.name)));
-    jsonRes(ctx.res, 200, visible.map((e) => [e.name, e.isDirectory() ? 2 : 1]));
+    const visible = entries.filter((e) => !(e.isDirectory && SKIP_DIRS.has(e.name)));
+    // Wire shape: `[name, type]` for a directory, `[name, type, size, mtimeMs]`
+    // for a file — the sync engine's watch-batch stat-diffing (workbench's
+    // wal-audit-watch-expand.ts) needs size+mtimeMs to tell a stat-unchanged
+    // survivor from an actually-modified file without re-reading its content.
+    // `size`/`mtimeMs` are simply absent (not `null`) for a stat-less entry
+    // (readdirWithin's readdir/stat race) — the client side then always
+    // treats it as changed.
+    jsonRes(ctx.res, 200, visible.map((e) => (e.isDirectory ? [e.name, 2] : [e.name, 1, e.size, e.mtimeMs])));
 }
 async function fsRead(ctx) {
     const buf = await readFileBufferWithin(ctx.projectRoot, ctx.rel);

package/dist/main/services/workspace/workspace-service.js

@@ -120,20 +120,20 @@ export function createWorkspaceService(ctx) {
      * a superseded session's buffered lines.
      */
     async function runCompile(projectPath, sessionGeneration) {
-        const { compile } = loadWorkbenchSettings();
+        const { compile, preview } = loadWorkbenchSettings();
         try {
             const session = await ctx.adapter.openProject({
                 projectPath,
                 sourcemap: true,
                 fileTypes: ctx.fileTypes,
-                watch: compile.watch,
+                // Two independent gates: autoBuild = recompile on save; autoReload = refresh the simulator afterwards (off ⇒ page/form state survives; hotReload below stays false so the native simulator, which has no SSE reload, isn't refreshed).
+                watch: compile.autoBuild,
+                autoReload: preview.autoReload,
                 onRebuild: () => {
-                    // getProjectPages never throws — failure yields the empty-pages
-                    // shape. Empty means "read failed or degenerate project" (a valid
-                    // app.json names ≥1 page) and is withheld so the renderer keeps its
-                    // previous dropdown instead of blanking; the push is never blocked.
+                    // getProjectPages never throws; empty pages (read failed / degenerate
+                    // project) are withheld so the renderer keeps its previous dropdown.
                     const { pages } = repo.getProjectPages(projectPath);
-                    sendStatus('ready', '编译完成，已重启', true, pages.length ? pages : undefined);
+                    sendStatus('ready', preview.autoReload ? '编译完成，已重启' : '编译完成', preview.autoReload, pages.length ? pages : undefined);
                 },
                 onBuildError: (err) => sendStatus('error', String(err)),
                 // Watcher died mid-session (EMFILE, permission loss, …): non-fatal, so 'ready' stays but `watcher: 'dead'` flags that saves no longer auto-rebuild.

package/dist/preload/instrumentation/wxml.js

@@ -1,6 +1,6 @@
 import { clearWxmlSnapshot, setWxmlSnapshot, unhighlightElement, } from '../runtime/bridge.js';
 import { WXML_DEBOUNCE_MS, WXML_RETRY_INTERVAL_MS, WXML_RETRY_TIMEOUT_MS, NAVIGATION_POLL_INTERVAL_MS, NAVIGATION_TIMEOUT_MS, } from '../shared/constants.js';
-import { walkInstance } from './wxml-extract.js';
+import { walkInstance } from '@dimina-kit/inspect';
 import { getActivePageIframe } from '../shared/page-iframe.js';
 function getVueAppFromIframe(iframe) {
     try {

package/dist/preload/runtime/bridge.d.ts

@@ -1,7 +1,7 @@
 import type { ElementInspection } from '../../shared/ipc-channels.js';
-import { type WxmlNode } from '../shared/sid-registry.js';
-export type { WxmlNode } from '../shared/sid-registry.js';
-export { registerSyntheticSid } from '../shared/sid-registry.js';
+import { type WxmlNode } from '@dimina-kit/inspect';
+export type { WxmlNode } from '@dimina-kit/inspect';
+export { registerSyntheticSid } from '@dimina-kit/inspect';
 export interface Snapshot<T> {
     gen: number;
     ready: boolean;

package/dist/preload/runtime/bridge.js

@@ -1,7 +1,7 @@
 import { exposeOnMainWorld } from '../shared/expose.js';
 import { getActivePageIframe } from '../shared/page-iframe.js';
-import { findElementBySid } from '../shared/sid-registry.js';
-export { registerSyntheticSid } from '../shared/sid-registry.js';
+import { findElementBySid } from '@dimina-kit/inspect';
+export { registerSyntheticSid } from '@dimina-kit/inspect';
 const state = {
     appdata: { gen: 0, ready: true, data: {} },
     storage: { gen: 0, ready: false, namespace: null, data: {} },