mikrojs 0.0.7 → 0.0.8

package/dist/cli/cliWrapper.js

@@ -4,6 +4,9 @@ import * as path from 'node:path';
 const cliPath = path.join(import.meta.dirname, '/cli.js');
 function run() {
     const child = fork(cliPath, process.argv.slice(2));
+    // Track whether we're tearing down to start a fresh child (reload) so we
+    // can suppress the wrapper's own exit on the dying child.
+    let restarting = false;
     const onMessage = (message) => {
         if (message === 'exit') {
             exit('SIGTERM', false);
@@ -13,6 +16,7 @@ function run() {
         }
     };
     function exit(signal, restart) {
+        restarting = restart;
         child.kill('SIGTERM');
         child.removeAllListeners('message');
         // eslint-disable-next-line no-console
@@ -21,6 +25,15 @@ function run() {
             run();
         }
     }
+    // Forward the child's exit code to the wrapper. Without this, a child that
+    // calls process.exit(1) (e.g. on a fatal CLI error like a missing env file)
+    // would leave the wrapper exiting 0, masking the failure from shell scripts
+    // and CI. Suppressed during reload so the new child's lifetime drives exit.
+    child.on('exit', (code, signal) => {
+        if (restarting)
+            return;
+        process.exit(code ?? (signal ? 1 : 0));
+    });
     child.on('message', onMessage);
 }
 run();

package/dist/cli/cliWrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"cliWrapper.js","sourceRoot":"","sources":["../../src/cli/cliWrapper.ts"],"names":[],"mappings":";AACA,OAAO,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAA;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;AAEzD,SAAS,GAAG;IACV,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;IAElD,MAAM,SAAS,GAAG,CAAC,OAAe,EAAE,EAAE;QACpC,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;QACxB,CAAC;QACD,IAAI,OAAO,KAAK,QAAQ,EAAE,CAAC;YACzB,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;QACtB,CAAC;IACH,CAAC,CAAA;IACD,SAAS,IAAI,CAAC,MAA4B,EAAE,OAAgB;QAC1D,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACrB,KAAK,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;QACnC,sCAAsC;QACtC,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAA;QACnF,IAAI,OAAO,EAAE,CAAC;YACZ,GAAG,EAAE,CAAA;QACP,CAAC;IACH,CAAC;IACD,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;AAChC,CAAC;AAED,GAAG,EAAE,CAAA"}
+{"version":3,"file":"cliWrapper.js","sourceRoot":"","sources":["../../src/cli/cliWrapper.ts"],"names":[],"mappings":";AACA,OAAO,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAA;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;AAEzD,SAAS,GAAG;IACV,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;IAClD,yEAAyE;IACzE,0DAA0D;IAC1D,IAAI,UAAU,GAAG,KAAK,CAAA;IAEtB,MAAM,SAAS,GAAG,CAAC,OAAe,EAAE,EAAE;QACpC,IAAI,OAAO,KAAK,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;QACxB,CAAC;QACD,IAAI,OAAO,KAAK,QAAQ,EAAE,CAAC;YACzB,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;QACtB,CAAC;IACH,CAAC,CAAA;IACD,SAAS,IAAI,CAAC,MAA4B,EAAE,OAAgB;QAC1D,UAAU,GAAG,OAAO,CAAA;QACpB,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACrB,KAAK,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;QACnC,sCAAsC;QACtC,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,UAAU,EAAE,IAAI,IAAI,EAAE,CAAC,cAAc,EAAE,CAAC,CAAA;QACnF,IAAI,OAAO,EAAE,CAAC;YACZ,GAAG,EAAE,CAAA;QACP,CAAC;IACH,CAAC;IACD,2EAA2E;IAC3E,4EAA4E;IAC5E,4EAA4E;IAC5E,4EAA4E;IAC5E,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;QAChC,IAAI,UAAU;YAAE,OAAM;QACtB,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IACxC,CAAC,CAAC,CAAA;IACF,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;AAChC,CAAC;AAED,GAAG,EAAE,CAAA"}

package/dist/cli/commands/flash.js

@@ -157,7 +157,7 @@ export default function FlashCmd(props) {
                 if (!hasPrebuiltFirmware(resolvedChip)) {
                     throw new Error(`No bundled firmware for ${resolvedChip}. ` +
                         `Build a custom firmware locally and flash with --build-dir, ` +
-                        `or fetch a CI artifact with --from=mikrojs/mikrojs:<sha>.`);
+                        `or fetch a CI artifact with --from=mikrojs/mikrojs@<sha>.`);
                 }
                 const flasherArgs = await readFlasherArgs(prebuiltFirmwareDir(resolvedChip));
                 setInitState({ status: 'ready', flasherArgs, esptoolPath });

package/dist/cli/commands/sim/dev.d.ts

@@ -1,35 +1,47 @@
 export declare const args: import("@optique/core").Parser<"sync", {
     readonly subcommand: "dev";
     readonly entry: string | undefined;
+    readonly forceDeploy: true | undefined;
     readonly noMinify: true | undefined;
     readonly minifier: string | undefined;
     readonly minifyLevel: string | undefined;
     readonly noBytecode: true | undefined;
+    readonly noHooks: true | undefined;
+    readonly logLevel: string | undefined;
     readonly env: string | undefined;
     readonly secrets: string | undefined;
     readonly noEnvFile: true | undefined;
+    readonly noWatch: true | undefined;
     readonly agent: true | undefined;
 }, ["matched", string] | ["parsing", {
     readonly subcommand: "dev";
     readonly entry: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
+    readonly forceDeploy: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
     readonly noMinify: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
     readonly minifier: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
     readonly minifyLevel: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
     readonly noBytecode: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+    readonly noHooks: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+    readonly logLevel: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
     readonly env: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
     readonly secrets: [import("@optique/core").ValueParserResult<string> | undefined] | undefined;
     readonly noEnvFile: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
+    readonly noWatch: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
     readonly agent: [import("@optique/core").ValueParserResult<true> | undefined] | undefined;
 }] | undefined>;
 interface DevConfig {
     entry?: string;
+    forceDeploy?: boolean;
     noMinify?: boolean;
     minifier?: string;
     minifyLevel?: string;
     noBytecode?: boolean;
+    noHooks?: boolean;
+    logLevel?: string;
     env?: string;
     secrets?: string;
     noEnvFile?: boolean;
+    noWatch?: boolean;
     agent?: boolean;
 }
 export declare function run(config: DevConfig): Promise<void>;

package/dist/cli/commands/sim/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/sim/dev.tsx"],"names":[],"mappings":"AA4BA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;eAmChB,CAAA;AAED,UAAU,SAAS;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED,wBAAsB,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CA+G1D;AAaD,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,KAAK,EAAE;IAAC,IAAI,EAAE,SAAS,CAAA;CAAC,2CAetD"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/sim/dev.tsx"],"names":[],"mappings":"AA8BA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAqDhB,CAAA;AAED,UAAU,SAAS;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AA4BD,wBAAsB,GAAG,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAgJ1D;AAQD,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,KAAK,EAAE;IAAC,IAAI,EAAE,SAAS,CAAA;CAAC,2CAEtD"}

package/dist/cli/commands/sim/dev.js

@@ -6,24 +6,22 @@ import { argument, flag, option } from '@optique/core/primitives';
 import { string } from '@optique/core/valueparser';
 import { path } from '@optique/run';
 import spinners from 'cli-spinners';
-import { Text } from 'ink';
-import React from 'react';
-import { catchError, defer, EMPTY, exhaustMap, lastValueFrom } from 'rxjs';
-import { agentEmit, agentError, agentResult, createAgentStdinReader } from '../../lib/agent.js';
-import { build } from '../../lib/build.js';
-import { collectFiles, loadEnvFiles } from '../../lib/deploy.js';
+import { Text, useApp, useInput } from 'ink';
+import { useCallback, useEffect, useState } from 'react';
+import { filter, firstValueFrom, map, Subject } from 'rxjs';
+import { agentEmit, agentError, agentResult, createAgentStdinReader, forwardSessionToAgent, } from '../../lib/agent.js';
 import { openSim } from '../../lib/openSim.js';
-import { parseMinifier, parseMinifyLevel } from '../../lib/parseMinifier.js';
-import { getMikroDir, resolveProjectRoot } from '../../lib/projectRoot.js';
+import { parseLogLevel, parseMinifier, parseMinifyLevel } from '../../lib/parseMinifier.js';
 import { resolveEntry } from '../../lib/resolveEntry.js';
-import { ReplConsole } from '../../lib/serial/ReplConsole.js';
+import { createDevSession } from '../../lib/serial/devSession.js';
+import { InkReplConsole } from '../../lib/serial/InkReplConsole.js';
 import { createRepl } from '../../lib/serial/replStateMachine.js';
 import { SimAlreadyRunningError } from '../../lib/simPid.js';
 import { Spinner } from '../../lib/Spinner.js';
-import { createWatcher } from '../../lib/watcher.js';
 export const args = command('dev', object({
     subcommand: constant('dev'),
     entry: optional(argument(path({ metavar: 'ENTRY', mustExist: true, type: 'file' }))),
+    forceDeploy: optional(flag('--force-deploy', { description: message `Force full deploy, ignoring cached checksums` })),
     noMinify: optional(flag('--no-minify', { description: message `Skip minification` })),
     minifier: optional(option('--minifier', string({ metavar: 'NAME' }), {
         description: message `Minifier: esbuild, terser, or swc (default: esbuild)`,
@@ -32,6 +30,12 @@ export const args = command('dev', object({
         description: message `Minify level: default or max`,
     })),
     noBytecode: optional(flag('--no-bytecode', { description: message `Skip bytecode compilation` })),
+    noHooks: optional(flag('--no-hooks', {
+        description: message `Skip mikrojs.predeploy hooks from package.json`,
+    })),
+    logLevel: optional(option('--loglevel', string({ metavar: 'LEVEL' }), {
+        description: message `Log level: none, error, warn, info, debug. Console calls below this level are eliminated at build time.`,
+    })),
     env: optional(option('--env', string({ metavar: 'FILE' }), {
         description: message `Path to .env file with environment variables`,
     })),
@@ -41,20 +45,43 @@ export const args = command('dev', object({
     noEnvFile: optional(flag('--no-env-file', {
         description: message `Skip auto-loading of .env and .env.simulator from the project root`,
     })),
+    noWatch: optional(flag('--no-watch', {
+        description: message `Deploy once, then drop into the REPL without watching for file changes`,
+    })),
     agent: optional(flag('--agent', { description: message `NDJSON agent protocol over stdio` })),
 }), { description: message `Watch + build + deploy to simulator with REPL` });
+/**
+ * Resolve the user's CLI args into the shape `createDevSession` expects.
+ * `mode: 'simulator'` drives `MIKRO_ENV` and the auto-loaded `.env.simulator`
+ * file, distinguishing sim runs from `mikro dev` (which defaults to
+ * `'development'`).
+ */
+function devSessionOptions(config) {
+    return {
+        entry: resolveEntry(config.entry),
+        forceDeploy: config.forceDeploy === true,
+        minify: !config.noMinify,
+        bytecode: !config.noBytecode,
+        watch: config.noWatch !== true,
+        noHooks: config.noHooks === true,
+        minifier: parseMinifier(config.minifier),
+        minifyLevel: parseMinifyLevel(config.minifyLevel),
+        logLevel: parseLogLevel(config.logLevel),
+        envFile: config.env,
+        secretsFile: config.secrets,
+        noEnvFile: config.noEnvFile === true,
+        mode: 'simulator',
+    };
+}
+// ── Agent mode ─────────────────────────────────────────────────────
 export async function run(config) {
-    const entry = resolveEntry(config.entry);
-    const buildDir = pathlib.join(getMikroDir(), 'build');
-    const watchDir = process.cwd();
-    const minify = !config.noMinify;
-    const minifier = parseMinifier(config.minifier);
-    const minifyLevel = parseMinifyLevel(config.minifyLevel);
-    const bytecode = !config.noBytecode;
     let session;
     let transport;
     try {
-        const conn = await openSim({ claim: true, startDir: pathlib.dirname(entry) });
+        const conn = await openSim({
+            claim: true,
+            startDir: pathlib.dirname(resolveEntry(config.entry)),
+        });
         session = conn.session;
         transport = conn.transport;
     }
@@ -65,59 +92,97 @@ export async function run(config) {
         }
         throw err;
     }
-    session.messages$.subscribe((event) => {
-        switch (event.type) {
-            case 'ready':
-                agentEmit({ type: 'ready', chip: event.chip ?? null, id: event.id ?? null });
+    forwardSessionToAgent(session);
+    const opts = devSessionOptions(config);
+    const deploys$ = new Subject();
+    const dev = createDevSession({
+        session,
+        entry: opts.entry,
+        forceDeploy: opts.forceDeploy,
+        minify: opts.minify,
+        bytecode: opts.bytecode,
+        watch: opts.watch,
+        noHooks: opts.noHooks,
+        minifier: opts.minifier,
+        minifyLevel: opts.minifyLevel,
+        logLevel: opts.logLevel,
+        envFile: opts.envFile,
+        secretsFile: opts.secretsFile,
+        noEnvFile: opts.noEnvFile,
+        externalDeploys$: deploys$.asObservable(),
+        mode: opts.mode,
+    });
+    // Translate DevSessionState transitions into agent NDJSON events. Mirrors
+    // mikro dev's run() so consumers (CI, scripts, AI agents) see the same
+    // event stream regardless of target.
+    const idleStatus = opts.watch ? 'watching' : 'idle';
+    let stateSub = dev.state$.subscribe((state) => {
+        switch (state.status.type) {
+            case 'checking':
+                agentEmit({ type: 'status', status: 'checking', command: state.status.command });
+                break;
+            case 'building':
+            case 'rebuilding':
+                agentEmit({ type: 'status', status: 'building' });
                 break;
-            case 'prompt':
-            case 'disconnect':
+            case 'deploying': {
+                const event = state.status.event;
+                if (event.type === 'uploading' || event.type === 'checking') {
+                    agentEmit({
+                        type: `deploy_${event.type}`,
+                        file: event.file,
+                        index: event.index,
+                        total: event.total,
+                    });
+                }
+                else if (event.type === 'connecting') {
+                    agentEmit({ type: 'status', status: 'deploying' });
+                }
+                break;
+            }
+            case 'watching':
+                agentEmit({ type: 'status', status: idleStatus });
                 break;
-            default:
-                if ('text' in event)
-                    agentEmit({ type: event.type, text: event.text });
+            case 'error':
+                agentEmit({ type: 'status', status: 'error', error: state.status.message });
                 break;
         }
     });
-    async function doBuildAndDeploy() {
-        agentEmit({ type: 'status', status: 'building' });
-        await lastValueFrom(build(entry, buildDir, { minify, bytecode, minifier, minifyLevel }), {
-            defaultValue: undefined,
-        });
-        const allFiles = await collectFiles(buildDir);
-        const envVars = [
-            { key: 'MIKRO_ENV', value: 'simulator', secret: false },
-            ...(await loadEnvFiles({
-                cwd: resolveProjectRoot(),
-                mode: 'simulator',
-                envFile: config.env,
-                secretsFile: config.secrets,
-                noEnvFile: config.noEnvFile === true,
-            })),
-        ];
-        agentEmit({ type: 'status', status: 'deploying' });
-        await lastValueFrom(session.deploy({ files: allFiles, envVars, restart: true }));
-        agentEmit({ type: 'status', status: 'watching' });
-    }
+    const dispose = () => {
+        stateSub?.unsubscribe();
+        stateSub = null;
+        dev.close();
+        try {
+            session.close();
+        }
+        catch {
+            // already closed
+        }
+        try {
+            transport.close();
+        }
+        catch {
+            // already closed
+        }
+    };
+    process.on('exit', dispose);
+    process.on('SIGINT', () => process.exit(0));
+    process.on('SIGTERM', () => process.exit(0));
+    // Await the first non-building state to detect initial-deploy failure.
+    // Match mikro dev's contract: error on the initial path is fatal, exits
+    // with non-zero so CI/scripts see a failure.
     try {
-        await doBuildAndDeploy();
+        await firstValueFrom(dev.state$.pipe(filter((s) => s.status.type === 'watching' || s.status.type === 'error'), map((s) => {
+            if (s.status.type === 'error')
+                throw new Error(s.status.message);
+            return s;
+        })));
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         agentError('sim dev', msg, { fix: 'Check entry file and try again' });
         process.exit(1);
     }
-    process.on('exit', () => session.close());
-    process.on('SIGINT', () => process.exit(0));
-    process.on('SIGTERM', () => process.exit(0));
-    const { changes$, close: closeWatcher } = createWatcher(watchDir);
-    changes$
-        .pipe(exhaustMap(() => defer(() => doBuildAndDeploy()).pipe(catchError((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        agentEmit({ type: 'status', status: 'error', error: msg });
-        return EMPTY;
-    }))))
-        .subscribe();
     for await (const cmd of createAgentStdinReader()) {
         switch (cmd.type) {
             case 'eval':
@@ -135,120 +200,181 @@ export async function run(config) {
             case 'restart':
                 session.restart();
                 break;
+            case 'deploy':
+                deploys$.next({ force: cmd.force === true });
+                break;
             case 'exit':
                 session.exit();
-                session.close();
-                closeWatcher();
-                transport.close();
+                dispose();
                 agentResult('sim dev', null, []);
                 process.exit(0);
         }
     }
+    // stdin closed without explicit 'exit' — clean shutdown.
+    dispose();
+    agentResult('sim dev', null, []);
+    process.exit(0);
 }
 export default function SimDev(props) {
-    const { args: cfg } = props;
-    const entry = resolveEntry(cfg.entry);
-    return (_jsx(SimDevMode, { entry: entry, minify: !cfg.noMinify, bytecode: !cfg.noBytecode, minifier: parseMinifier(cfg.minifier), minifyLevel: parseMinifyLevel(cfg.minifyLevel), envFile: cfg.env, secretsFile: cfg.secrets, noEnvFile: cfg.noEnvFile === true }));
+    return _jsx(SimDevMode, { config: props.args });
 }
+/**
+ * TUI counterpart of `run()`. Connects the simulator session, instantiates
+ * `createDevSession` (the same state machine `mikro dev` uses), and renders
+ * the REPL once the initial deploy completes.
+ *
+ * Initial-setup errors (sim subprocess fails to start, first build/deploy
+ * fails) are fatal — there's nothing for the watcher to fall back to.
+ * Watch-mode rebuild errors stay in the TUI so the user can fix the file
+ * and let the watcher retry.
+ */
 function SimDevMode(props) {
-    const { entry, minify, bytecode, minifier, minifyLevel, envFile, secretsFile, noEnvFile } = props;
-    const buildDir = pathlib.join(getMikroDir(), 'build');
-    const watchDir = process.cwd();
-    const replRef = React.useRef(null);
-    const [repl, setRepl] = React.useState(null);
-    const [error, setError] = React.useState(null);
-    React.useEffect(() => {
+    const { config } = props;
+    const opts = devSessionOptions(config);
+    // We mount the REPL UI as soon as the sim session+repl handle exist, BEFORE
+    // the first deploy completes. This matches the device-side InkReplMode flow
+    // and is required for correctness: the REPL state machine's awaitReady$
+    // / connectionTimeout$ only fire when `repl.state$` has a subscriber. If
+    // the REPL UI doesn't mount until after the first deploy, the state
+    // machine never gets to poll CMD_HELLO during the deploy window and
+    // ends up timing out the moment it does finally mount (because by then
+    // multiple restarts have happened).
+    const [conn, setConn] = useState(null);
+    const [error, setError] = useState(null);
+    const fatal = useCallback((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Error: ${msg}\n`);
+        process.exit(1);
+    }, []);
+    const handleEnd = useCallback(() => {
+        process.stdout.write('\x1b[<u');
+        process.exit(0);
+    }, []);
+    // Ink's `exitOnCtrlC` is disabled at the cli.ts render call; until the REPL
+    // is mounted (or while an error screen is showing), nothing else handles
+    // input — without this, ctrl-c is a black hole. Matches DevicePicker /
+    // InkReplMode / deploy convention (ctrl-c or ctrl-q).
+    const { exit: exitInk } = useApp();
+    useInput((input, key) => {
+        if (key.ctrl && (input === 'c' || input === 'q')) {
+            exitInk();
+            process.exit(error ? 1 : 0);
+        }
+    }, { isActive: !conn });
+    useEffect(() => {
         let disposed = false;
         let cleanup = null;
         void (async () => {
             let session;
             let transport;
             try {
-                const conn = await openSim({ claim: true, startDir: pathlib.dirname(entry) });
-                session = conn.session;
-                transport = conn.transport;
+                const handle = await openSim({
+                    claim: true,
+                    startDir: pathlib.dirname(opts.entry),
+                });
+                session = handle.session;
+                transport = handle.transport;
             }
             catch (err) {
                 if (!disposed)
-                    setError(err instanceof Error ? err : new Error(String(err)));
+                    fatal(err);
                 return;
             }
-            async function buildAndDeploy() {
-                if (disposed)
-                    return;
-                if (replRef.current)
-                    replRef.current.setDisabled(true);
-                setError(null);
-                const envVars = [
-                    { key: 'MIKRO_ENV', value: 'simulator', secret: false },
-                    ...(await loadEnvFiles({
-                        cwd: resolveProjectRoot(),
-                        mode: 'simulator',
-                        envFile,
-                        secretsFile,
-                        noEnvFile,
-                    })),
-                ];
-                await lastValueFrom(build(entry, buildDir, { minify, bytecode, minifier, minifyLevel }), {
-                    defaultValue: undefined,
-                });
-                if (disposed)
-                    return;
-                const allFiles = await collectFiles(buildDir);
-                const handle = createRepl({
-                    session,
-                    port: 'simulator',
-                    onEnd: () => process.exit(0),
-                });
-                handle.state$.subscribe();
-                await lastValueFrom(session.deploy({ files: allFiles, envVars, restart: true }));
-                if (disposed)
-                    return;
-                replRef.current = handle;
-                if (!disposed)
-                    setRepl({ handle, config: session.config });
+            if (disposed) {
+                try {
+                    session.close();
+                    transport.close();
+                }
+                catch {
+                    // already closed
+                }
+                return;
             }
-            buildAndDeploy().catch((err) => {
-                if (!disposed)
-                    setError(err instanceof Error ? err : new Error(String(err)));
+            const repl = createRepl({
+                session,
+                port: 'simulator',
+                onEnd: handleEnd,
+                deployEnabled: true,
+            });
+            const dev = createDevSession({
+                session,
+                repl,
+                entry: opts.entry,
+                forceDeploy: opts.forceDeploy,
+                minify: opts.minify,
+                bytecode: opts.bytecode,
+                watch: opts.watch,
+                noHooks: opts.noHooks,
+                minifier: opts.minifier,
+                minifyLevel: opts.minifyLevel,
+                logLevel: opts.logLevel,
+                envFile: opts.envFile,
+                secretsFile: opts.secretsFile,
+                noEnvFile: opts.noEnvFile,
+                mode: opts.mode,
+            });
+            // Mount the REPL UI immediately so the state machine starts polling
+            // CMD_HELLO and the `connectionTimeout$` can be cancelled by the first
+            // MSG_READY. createDevSession's run is kept alive by the stateSub
+            // subscription below; rendering the REPL is purely a UI concern.
+            setConn({ session, transport, repl, dev });
+            const stateSub = dev.state$.subscribe((state) => {
+                if (state.status.type === 'error') {
+                    // Surface in TUI; the watcher can recover by re-running on next
+                    // file change, so we keep the session alive.
+                    if (!disposed)
+                        setError(new Error(state.status.message));
+                }
+                else if (state.status.type === 'watching' || state.status.type === 'deploying') {
+                    if (!disposed)
+                        setError(null);
+                }
             });
-            const { changes$, close } = createWatcher(watchDir);
-            const sub = changes$
-                .pipe(exhaustMap(() => defer(() => buildAndDeploy()).pipe(catchError((err) => {
-                if (!disposed)
-                    setError(err instanceof Error ? err : new Error(String(err)));
-                return EMPTY;
-            }))))
-                .subscribe();
             cleanup = () => {
-                sub.unsubscribe();
-                close();
-                session.close();
-                transport.close();
+                stateSub.unsubscribe();
+                dev.close();
+                try {
+                    session.close();
+                }
+                catch {
+                    // already closed
+                }
+                try {
+                    transport.close();
+                }
+                catch {
+                    // already closed
+                }
             };
         })();
         return () => {
             disposed = true;
             cleanup?.();
         };
+        // opts is recomputed each render but its values are stable for a given
+        // config (which itself is stable for a session). Deps captured so React
+        // doesn't complain; effective re-runs only happen on real config change.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
-        entry,
-        buildDir,
-        minify,
-        bytecode,
-        minifier,
-        minifyLevel,
-        envFile,
-        secretsFile,
-        noEnvFile,
-        watchDir,
+        opts.entry,
+        opts.forceDeploy,
+        opts.minify,
+        opts.bytecode,
+        opts.watch,
+        opts.noHooks,
+        opts.minifier,
+        opts.minifyLevel,
+        opts.logLevel,
+        opts.envFile,
+        opts.secretsFile,
+        opts.noEnvFile,
     ]);
-    if (error) {
+    if (error && !conn) {
         return _jsxs(Text, { color: "red", children: ["Error: ", error.message] });
     }
-    if (!repl) {
-        return (_jsxs(Text, { children: [_jsx(Spinner, { spinner: spinners.dots }), " Building\u2026"] }));
+    if (!conn) {
+        return (_jsxs(Text, { children: [_jsx(Spinner, { spinner: spinners.dots }), " Starting simulator\u2026"] }));
     }
-    return _jsx(ReplConsole, { repl: repl.handle, config: repl.config });
+    return (_jsx(InkReplConsole, { session: conn.session, devicePath: "simulator", logLevel: opts.logLevel, repl: conn.repl, watch: opts.watch }));
 }
 //# sourceMappingURL=dev.js.map