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

package/README.md

@@ -47,6 +47,7 @@ await session.close()
 | `containerDir` | `string`                 | --      | H5 容器静态资源目录；不传则使用内置 `dimina-fe-container`                                    |
 | `outputDir`    | `string`                 | --      | 编译产物输出目录，默认 `<os.tmpdir()>/dimina-kit/<projectPath 哈希前 12 位>`（每个项目独立） |
 | `watch`        | `boolean`                | `true`  | 为 `false` 时跳过 chokidar 文件监听 / 自动重编译循环                                        |
+| `autoReload`   | `boolean`                | `true`  | 为 `false` 时，watch 重编译完成后**不**触发预览 live-reload（`onRebuild` 仍照常回调）——保留当前页面栈 / 表单状态，仅手动刷新。与 `watch` 独立 |
 | `onRebuild`    | `() => void`             | --      | 文件变更触发重新编译后的回调                                                                 |
 | `onBuildError` | `(err: unknown) => void` | --      | watch 重编译出错时的回调；**初次编译失败不走这里，而是直接 reject `openProject` 本身**（见下） |
 | `onLog`        | `(entry) => void`        | --      | 逐行编译日志回调；`entry = { stream: 'stdout' \| 'stderr', text }`，已经过内置噪音过滤（`filterDmccLogLine`） |

package/dist/build-completed-subscriber.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-completed-subscriber.test.d.ts.map

package/dist/build-completed-subscriber.test.d.ts.map

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

package/dist/build-completed-subscriber.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, it, vi } from 'vitest';
+import { composeBuildCompleted } from './index.js';
+/**
+ * Behavior tests for composeBuildCompleted.
+ *
+ * The contract decouples two independent user toggles that both react to a
+ * finished build: live-reloading the simulator, and the caller's own
+ * onRebuild bookkeeping (e.g. compile-log entries, UI badges). A developer
+ * must be able to keep auto-compile ON while turning simulator auto-reload
+ * OFF, so page-stack/form state survives a save. If the two were coupled,
+ * disabling reload would also silence onRebuild (or vice versa).
+ */
+describe('composeBuildCompleted', () => {
+    it('invokes reload before onRebuild when autoReload is true and a reload function is available', () => {
+        const callOrder = [];
+        const reload = vi.fn(() => { callOrder.push('reload'); });
+        const getReload = vi.fn(() => reload);
+        const onRebuild = vi.fn(() => { callOrder.push('onRebuild'); });
+        const subscriber = composeBuildCompleted({ autoReload: true, getReload, onRebuild });
+        subscriber();
+        expect(reload).toHaveBeenCalledTimes(1);
+        expect(onRebuild).toHaveBeenCalledTimes(1);
+        expect(callOrder).toEqual(['reload', 'onRebuild']);
+    });
+    it('does not invoke reload when autoReload is false, but still calls onRebuild', () => {
+        const reload = vi.fn();
+        const getReload = vi.fn(() => reload);
+        const onRebuild = vi.fn();
+        const subscriber = composeBuildCompleted({ autoReload: false, getReload, onRebuild });
+        subscriber();
+        expect(reload).not.toHaveBeenCalled();
+        expect(onRebuild).toHaveBeenCalledTimes(1);
+    });
+    it('does not even call getReload when autoReload is false', () => {
+        // Why this matters: getReload may have side effects or preconditions
+        // (e.g. asserting a live webContents exists) that are only valid to
+        // evaluate when a reload is actually intended.
+        const getReload = vi.fn(() => vi.fn());
+        const onRebuild = vi.fn();
+        const subscriber = composeBuildCompleted({ autoReload: false, getReload, onRebuild });
+        subscriber();
+        expect(getReload).not.toHaveBeenCalled();
+        expect(onRebuild).toHaveBeenCalledTimes(1);
+    });
+    it('does not throw when autoReload is true but getReload returns undefined, and still calls onRebuild', () => {
+        // Why this matters: the simulator's reload function may not be wired up
+        // yet (e.g. build finished before the webview attached). A not-ready
+        // reload must not crash the build-completed pipeline.
+        const getReload = vi.fn(() => undefined);
+        const onRebuild = vi.fn();
+        const subscriber = composeBuildCompleted({ autoReload: true, getReload, onRebuild });
+        expect(() => subscriber()).not.toThrow();
+        expect(getReload).toHaveBeenCalledTimes(1);
+        expect(onRebuild).toHaveBeenCalledTimes(1);
+    });
+    it('does not throw when onRebuild is omitted, with autoReload true', () => {
+        const reload = vi.fn();
+        const getReload = vi.fn(() => reload);
+        const subscriber = composeBuildCompleted({ autoReload: true, getReload });
+        expect(() => subscriber()).not.toThrow();
+        expect(reload).toHaveBeenCalledTimes(1);
+    });
+    it('does not throw when onRebuild is omitted, with autoReload false', () => {
+        const getReload = vi.fn(() => vi.fn());
+        const subscriber = composeBuildCompleted({ autoReload: false, getReload });
+        expect(() => subscriber()).not.toThrow();
+    });
+});

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { CompileLogEntry } from './compile-worker.js';
 import type { CompileWorkerStandby, CompileWorkerStandbyOptions } from './compile-worker-standby.js';
+export { WATCH_IGNORE_DIRS } from './watch-ignore.js';
 export { createRebuildScheduler } from './rebuild-scheduler.js';
 export type { RebuildScheduler } from './rebuild-scheduler.js';
 export { filterDmccLogLine } from './compile-log.js';
@@ -45,6 +46,13 @@ export interface OpenProjectOptions {
     outputDir?: string;
     /** When false, skip the chokidar file-watcher / auto-rebuild loop. Default true. */
     watch?: boolean;
+    /**
+     * When false, a completed watcher rebuild does NOT live-reload the preview
+     * (the SSE `reload` → container `window.location.reload()`); `onRebuild`
+     * still fires so the host learns the build finished, but the page stack /
+     * form state survives. Independent of `watch`. Default true.
+     */
+    autoReload?: boolean;
     onRebuild?: () => void;
     onBuildError?: (err: unknown) => void;
     /**
@@ -62,6 +70,19 @@ export interface OpenProjectOptions {
      */
     onWatcherError?: (err: unknown) => void;
 }
+/**
+ * Compose the "build completed" subscriber — the single place deciding which of
+ * two INDEPENDENT reactions run: live-reloading the preview, and the caller's
+ * `onRebuild`. Reload is attached only when `autoReload` is on (so auto-compile
+ * can stay ON while reload is OFF, preserving page/form state); when off,
+ * `getReload` is not even called. `getReload` is read at call time because the
+ * dev server's `reload` is assigned after this subscriber is wired.
+ */
+export declare function composeBuildCompleted(opts: {
+    autoReload: boolean;
+    getReload: () => (() => void) | undefined;
+    onRebuild?: () => void;
+}): () => void;
 export declare function openProject(opts: OpenProjectOptions): Promise<ProjectSession>;
 /**
  * Watch a project directory and invoke `onChange` whenever a source file is

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -6,10 +6,12 @@ import { fileURLToPath } from 'node:url';
 import { createServer } from 'node:http';
 import { createRequire } from 'node:module';
 import chokidar from 'chokidar';
+import { WATCH_IGNORE_DIRS } from './watch-ignore.js';
 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';
+export { WATCH_IGNORE_DIRS } from './watch-ignore.js';
 export { createRebuildScheduler } from './rebuild-scheduler.js';
 export { filterDmccLogLine } from './compile-log.js';
 export { createCompileWorker } from './compile-worker.js';
@@ -108,20 +110,31 @@ function upsertSessionApp(sessionApps, rebuilt) {
         sessionApps[idx] = rebuilt;
 }
 /**
- * Run one watcher-triggered rebuild. `getReload` is read at call time (not
- * captured eagerly) because `reload` is only assigned once the dev server has
- * started, after this runner is wired into the rebuild scheduler.
+ * Compose the "build completed" subscriber — the single place deciding which of
+ * two INDEPENDENT reactions run: live-reloading the preview, and the caller's
+ * `onRebuild`. Reload is attached only when `autoReload` is on (so auto-compile
+ * can stay ON while reload is OFF, preserving page/form state); when off,
+ * `getReload` is not even called. `getReload` is read at call time because the
+ * dev server's `reload` is assigned after this subscriber is wired.
  */
-async function runRebuild(compileWorker, buildRequest, sessionApps, getReload, onRebuild, onBuildError) {
+export function composeBuildCompleted(opts) {
+    return () => {
+        if (opts.autoReload)
+            opts.getReload()?.();
+        opts.onRebuild?.();
+    };
+}
+/** Run one watcher-triggered rebuild, then fan out to the build-completed
+ * subscriber (reload + onRebuild); a build failure routes to onBuildFailed. */
+async function runRebuild(compileWorker, buildRequest, sessionApps, onBuildCompleted, onBuildFailed) {
     try {
         const rebuilt = (await compileWorker.build(buildRequest));
         if (rebuilt)
             upsertSessionApp(sessionApps, rebuilt);
-        getReload()?.();
-        onRebuild?.();
+        onBuildCompleted();
     }
     catch (e) {
-        onBuildError?.(e);
+        onBuildFailed(e);
     }
 }
 /**
@@ -151,7 +164,7 @@ async function cleanupFailedOpen(watcher, compileWorker, server) {
     }
 }
 export async function openProject(opts) {
-    const { projectPath: rawProjectPath, port = 0, sourcemap = false, fileTypes, simulatorDir, containerDir: overrideContainerDir, outputDir, watch = true, onRebuild, onBuildError, onLog, onWatcherError, } = opts;
+    const { projectPath: rawProjectPath, port = 0, sourcemap = false, fileTypes, simulatorDir, containerDir: overrideContainerDir, outputDir, watch = true, autoReload = true, onRebuild, onBuildError, onLog, onWatcherError, } = opts;
     const projectPath = path.resolve(rawProjectPath);
     const buildOptions = { sourcemap, fileTypes };
     const resolvedPort = port === 0 ? await getRandomPort() : port;
@@ -243,7 +256,12 @@ export async function openProject(opts) {
         // Watcher events are routed through the scheduler so a save landing while
         // a build is in flight is never dropped: it coalesces into exactly one
         // trailing rebuild once the current run settles.
-        const rebuildScheduler = createRebuildScheduler(() => runRebuild(compileWorker, buildRequest, sessionApps, () => reload, onRebuild, onBuildError));
+        const onBuildCompleted = composeBuildCompleted({
+            autoReload,
+            getReload: () => reload,
+            onRebuild,
+        });
+        const rebuildScheduler = createRebuildScheduler(() => runRebuild(compileWorker, buildRequest, sessionApps, onBuildCompleted, err => onBuildError?.(err)));
         watcher = watch
             ? createProjectWatcher(projectPath, () => rebuildScheduler.schedule(), onWatcherError)
             : null;
@@ -309,13 +327,17 @@ export function createProjectWatcher(projectPath, onChange, onWatcherError) {
             // (rel starts with '..') must never be ignored.
             if (!rel || rel.startsWith('..'))
                 return false;
-            // `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');
+            // Ignore all dotfiles/dot-dirs plus the shared never-source core
+            // (`WATCH_IGNORE_DIRS`: node_modules + VCS), kept in one place so the
+            // devtools editor mirror can't drift from this on the load-bearing
+            // `node_modules` omission. NOT build-output dirs like `dist`/`build`
+            // (app.json may put pages there — the compiler must see those edits).
+            // Watching `node_modules` makes chokidar hold thousands of
+            // per-directory handles — a multi-second `watcher.close()`, a slow
+            // initial scan, and spurious rebuilds on dependency churn; the
+            // compiler's real npm input is the built `miniprogram_npm/`, which
+            // stays watched.
+            return rel.split('/').some(seg => seg.startsWith('.') || WATCH_IGNORE_DIRS.has(seg));
         },
         persistent: true,
         ignoreInitial: true,

package/dist/project-watcher.test.js

@@ -236,6 +236,24 @@ describe('createProjectWatcher', () => {
         fs.writeFileSync(target, '// built npm output, changed');
         await vi.waitFor(() => expect(onChange).toHaveBeenCalled(), { timeout: 2000 });
     });
+    it('fires onChange for edits inside a `dist` directory (a mini-app may legitimately name a source dir dist/build)', async () => {
+        // Why this matters: the compile watcher must NOT blanket-ignore build-tool
+        // names like `dist`/`build` — app.json can declare pages/components under
+        // arbitrary paths (e.g. `pages/build/index`), and the compiler reads them
+        // as source. Only the perf-critical, never-source dirs (node_modules, VCS)
+        // are ignored here; hiding `dist`/`build` is the devtools *editor mirror*'s
+        // concern, not the recompile trigger's. The compiler's own output lands in
+        // os.tmpdir(), outside the watched project, so there is no self-loop to fear.
+        const distDir = path.join(tempDir, 'dist');
+        fs.mkdirSync(distDir, { recursive: true });
+        const target = path.join(distDir, 'index.js');
+        fs.writeFileSync(target, '// page source');
+        const onChange = vi.fn();
+        handle = createProjectWatcher(tempDir, onChange);
+        await handle.ready;
+        fs.writeFileSync(target, '// page source, 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.

package/dist/watch-ignore-dirs.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=watch-ignore-dirs.test.d.ts.map

package/dist/watch-ignore-dirs.test.d.ts.map

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

package/dist/watch-ignore-dirs.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { WATCH_IGNORE_DIRS as indexExport } from './index.js';
+import { WATCH_IGNORE_DIRS as leafExport } from './watch-ignore.js';
+/**
+ * Pins down WATCH_IGNORE_DIRS as the single source of truth for the directory
+ * names that are NEVER mini-app source and must be skipped by every project
+ * watcher — the drift-proof core shared by the devkit recompile watcher and
+ * the devtools editor mirror. Deliberately minimal: build-tool output names
+ * like `dist`/`build` are NOT here, because app.json may declare pages under
+ * such paths and the compiler must still see edits to them (hiding build output
+ * from the editor is the devtools mirror's own concern, layered on top). Both
+ * the leaf module and the package index must expose the identical set object —
+ * two equal-membership sets would still let the call sites drift over time.
+ */
+const EXPECTED_MEMBERS = [
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+];
+describe('WATCH_IGNORE_DIRS', () => {
+    it('is re-exported from index.ts as the exact same Set instance as the leaf module', () => {
+        expect(indexExport).toBe(leafExport);
+    });
+    it.each(EXPECTED_MEMBERS)('contains %s', (member) => {
+        expect(leafExport.has(member)).toBe(true);
+    });
+    it('contains exactly the expected members, no more and no fewer', () => {
+        expect(new Set(leafExport)).toEqual(new Set(EXPECTED_MEMBERS));
+    });
+    it.each(['src', 'pages', 'miniprogram_npm', 'dist', 'build'])('does not contain %s', (nonMember) => {
+        expect(leafExport.has(nonMember)).toBe(false);
+    });
+});

package/dist/watch-ignore.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Directory segment names that are NEVER mini-app source and must be skipped by
+ * every project-tree scan, at any depth. The drift-proof CORE shared by the
+ * devkit recompile watcher (createProjectWatcher) and the devtools editor
+ * mirror (project-fs `SKIP_DIRS`, which derives its set from this one): the
+ * `node_modules` omission that once made `watcher.close()` take 2.6s can never
+ * regress in just one of them.
+ *
+ * Deliberately minimal — build-tool OUTPUT names (`dist`, `build`, `.next`,
+ * tool caches …) are intentionally absent: app.json may declare pages under
+ * such paths (e.g. `pages/build/index`), so the recompile watcher must still
+ * see edits to them. Hiding build output is the devtools editor mirror's own
+ * concern, layered ON TOP of this core (see project-fs `SKIP_DIRS`). Each side
+ * also keeps its domain rule: the devkit watcher additionally drops all
+ * dotfiles (they never affect compilation).
+ */
+export declare const WATCH_IGNORE_DIRS: ReadonlySet<string>;
+//# sourceMappingURL=watch-ignore.d.ts.map

package/dist/watch-ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-ignore.d.ts","sourceRoot":"","sources":["../src/watch-ignore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAEhD,CAAA"}

package/dist/watch-ignore.js

@@ -0,0 +1,19 @@
+/**
+ * Directory segment names that are NEVER mini-app source and must be skipped by
+ * every project-tree scan, at any depth. The drift-proof CORE shared by the
+ * devkit recompile watcher (createProjectWatcher) and the devtools editor
+ * mirror (project-fs `SKIP_DIRS`, which derives its set from this one): the
+ * `node_modules` omission that once made `watcher.close()` take 2.6s can never
+ * regress in just one of them.
+ *
+ * Deliberately minimal — build-tool OUTPUT names (`dist`, `build`, `.next`,
+ * tool caches …) are intentionally absent: app.json may declare pages under
+ * such paths (e.g. `pages/build/index`), so the recompile watcher must still
+ * see edits to them. Hiding build output is the devtools editor mirror's own
+ * concern, layered ON TOP of this core (see project-fs `SKIP_DIRS`). Each side
+ * also keeps its domain rule: the devkit watcher additionally drops all
+ * dotfiles (they never affect compilation).
+ */
+export const WATCH_IGNORE_DIRS = new Set([
+    'node_modules', '.git', '.svn', '.hg',
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimina-kit/devkit",
-  "version": "0.1.2-dev.20260707070110",
+  "version": "0.1.2-dev.20260710085051",
   "description": "Development toolkit for Dimina mini-apps with H5 container preview",
   "keywords": [
     "dimina",
@@ -33,6 +33,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./watch-ignore": {
+      "types": "./dist/watch-ignore.d.ts",
+      "default": "./dist/watch-ignore.js"
     }
   },
   "files": [
@@ -62,7 +66,7 @@
     "cors": "^2.8.6",
     "express": "^5.2.1",
     "open": "^11.0.0",
-    "@dimina-kit/compiler": "0.0.1-dev.20260707070110"
+    "@dimina-kit/compiler": "0.0.2-dev.20260710085051"
   },
   "publishConfig": {
     "access": "public"