@orion-js/core 4.3.3 → 4.4.1

package/dist/index.cjs

@@ -23,7 +23,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_chalk15 = __toESM(require("chalk"), 1);
+var import_chalk14 = __toESM(require("chalk"), 1);
 var import_commander = require("commander");
 
 // src/helpers/execute.ts
@@ -56,7 +56,7 @@ async function create_default({ name, kit }) {
 }
 
 // src/dev/index.ts
-var import_chalk5 = __toESM(require("chalk"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
 
 // src/dev/runner/index.ts
 var import_chalk2 = __toESM(require("chalk"), 1);
@@ -68,10 +68,10 @@ var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var ensureDirectory = (filePath) => {
-  const dirname2 = import_node_path.default.dirname(filePath);
-  if (import_node_fs.default.existsSync(dirname2)) return true;
-  ensureDirectory(dirname2);
-  import_node_fs.default.mkdirSync(dirname2);
+  const dirname3 = import_node_path.default.dirname(filePath);
+  if (import_node_fs.default.existsSync(dirname3)) return true;
+  ensureDirectory(dirname3);
+  import_node_fs.default.mkdirSync(dirname3);
 };
 var ensureDirectory_default = ensureDirectory;
 
@@ -85,15 +85,18 @@ async function writeFile_default(path3, content) {
 var import_node_child_process2 = require("child_process");
 var import_chalk = __toESM(require("chalk"), 1);
 
+// src/dev/devBuildPath.ts
+var devBuildPath = "./.orion/build/index.js";
+
 // src/dev/runner/getArgs.ts
 function getArgs(options, command) {
   if (options.node) {
-    const startCommand2 = "tsx";
-    const args2 = ["watch", "--clear-screen=false", ...command.args, "./app/index.ts"];
+    const startCommand2 = "node";
+    const args2 = ["--enable-source-maps", ...command.args, devBuildPath];
     return { startCommand: startCommand2, args: args2 };
   }
   const startCommand = "bun";
-  const args = ["--watch", ...command.args, "./app/index.ts"];
+  const args = ["--watch", ...command.args, devBuildPath];
   return { startCommand, args };
 }
 
@@ -121,14 +124,16 @@ function getRunner(options, command) {
     console.log(import_chalk2.default.bold("=> Cleaning directory...\n"));
   }
   const startApp = () => {
-    appProcess = startProcess(options, command);
-    appProcess.on("exit", (code, signal) => {
+    const startedProcess = startProcess(options, command);
+    appProcess = startedProcess;
+    startedProcess.on("exit", (code, signal) => {
+      if (appProcess === startedProcess) appProcess = null;
       if (!code || code === 143 || code === 0 || signal === "SIGTERM" || signal === "SIGINT") {
       } else {
         console.log(import_chalk2.default.bold(`=> Error running app. Exit code: ${code}`));
       }
     });
-    writeFile_default(".orion/process", `${appProcess.pid}`);
+    writeFile_default(".orion/process", `${startedProcess.pid}`);
   };
   const stop = () => {
     if (appProcess) {
@@ -154,9 +159,6 @@ function getRunner(options, command) {
   };
 }
 
-// src/dev/watchAndCompile/index.ts
-var import_typescript4 = __toESM(require("typescript"), 1);
-
 // src/dev/watchAndCompile/cleanDirectory.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
@@ -181,20 +183,129 @@ async function cleanDirectory(directory) {
   }
 }
 
-// src/dev/watchAndCompile/getHost.ts
-var import_typescript3 = __toESM(require("typescript"), 1);
+// src/dev/watchAndCompile/watchAndBundle.ts
+var import_node_fs4 = require("fs");
+var import_node_module = require("module");
+var import_node_path3 = require("path");
+var import_chokidar = __toESM(require("chokidar"), 1);
+var esbuild = __toESM(require("esbuild"), 1);
+function getPackageName(specifier) {
+  const segments = specifier.split("/");
+  return specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+}
+function nodeExternalCompatibilityPlugin() {
+  const requireFromApp = (0, import_node_module.createRequire)((0, import_node_path3.join)(process.cwd(), "package.json"));
+  return {
+    name: "orion-node-external-compatibility",
+    setup(build3) {
+      build3.onResolve({ filter: /^[^./].*\.json$/ }, (args) => {
+        try {
+          return { path: requireFromApp.resolve(args.path) };
+        } catch {
+          return void 0;
+        }
+      });
+      build3.onResolve({ filter: /^[^./]/ }, (args) => {
+        const packageName = getPackageName(args.path);
+        if (args.path === packageName || (0, import_node_path3.extname)(args.path)) return void 0;
+        try {
+          const packageJsonPath = requireFromApp.resolve(`${packageName}/package.json`);
+          const packageJson = JSON.parse((0, import_node_fs4.readFileSync)(packageJsonPath, "utf8"));
+          if (packageJson.exports) return void 0;
+          const resolvedExtension = (0, import_node_path3.extname)(requireFromApp.resolve(args.path));
+          if (!resolvedExtension) return void 0;
+          return { path: `${args.path}${resolvedExtension}`, external: true };
+        } catch {
+          return void 0;
+        }
+      });
+    }
+  };
+}
+async function watchAndBundle(runner, options, onFilesChanged) {
+  let hasSuccessfulBuild = false;
+  let buildStartedAt = Date.now();
+  let rebuildInProgress = false;
+  let rebuildRequested = false;
+  let rebuildTimer;
+  const context2 = await esbuild.context({
+    entryPoints: ["./app/index.ts"],
+    outfile: devBuildPath,
+    tsconfig: "./tsconfig.json",
+    format: "esm",
+    platform: "node",
+    bundle: true,
+    target: "node22",
+    sourcemap: true,
+    packages: "external",
+    plugins: [
+      nodeExternalCompatibilityPlugin(),
+      {
+        name: "orion-dev-restart",
+        setup(build3) {
+          build3.onStart(() => {
+            buildStartedAt = Date.now();
+          });
+          build3.onEnd((result) => {
+            if (result.errors.length > 0) {
+              runner.stop();
+              return;
+            }
+            console.log(`=> Application bundled in ${Date.now() - buildStartedAt}ms`);
+            if (hasSuccessfulBuild && options.node) {
+              runner.restart();
+            } else if (!hasSuccessfulBuild) {
+              hasSuccessfulBuild = true;
+              runner.start();
+            } else {
+              runner.start();
+            }
+          });
+        }
+      }
+    ]
+  });
+  const rebuild = async () => {
+    if (rebuildInProgress) {
+      rebuildRequested = true;
+      return;
+    }
+    rebuildInProgress = true;
+    do {
+      rebuildRequested = false;
+      try {
+        await context2.rebuild();
+      } catch {
+      }
+    } while (rebuildRequested);
+    rebuildInProgress = false;
+  };
+  await rebuild();
+  const watcher = import_chokidar.default.watch(["./app", "./tsconfig.json"], { ignoreInitial: true });
+  watcher.on("all", () => {
+    onFilesChanged == null ? void 0 : onFilesChanged();
+    clearTimeout(rebuildTimer);
+    rebuildTimer = setTimeout(rebuild, 20);
+  });
+  watcher.on("error", (error) => console.error(`Unable to watch application files: ${error.message}`));
+  return { context: context2, watcher };
+}
+
+// src/dev/watchAndCompile/watchAndTypecheck.ts
+var import_node_child_process3 = require("child_process");
 
 // src/dev/watchAndCompile/getConfigPath.ts
-var import_typescript = __toESM(require("typescript"), 1);
+var import_node_fs6 = require("fs");
+var import_node_path4 = require("path");
 
 // src/dev/watchAndCompile/ensureConfigComplies.ts
 var import_comment_json = require("comment-json");
 
 // src/helpers/getFileContents.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
 function readFile(filePath) {
-  if (!import_node_fs4.default.existsSync(filePath)) return null;
-  return import_node_fs4.default.readFileSync(filePath).toString();
+  if (!import_node_fs5.default.existsSync(filePath)) return null;
+  return import_node_fs5.default.readFileSync(filePath).toString();
 }
 
 // src/dev/watchAndCompile/ensureConfigComplies.ts
@@ -203,11 +314,15 @@ function ensureConfigComplies(configPath) {
   try {
     const configJSON = readFile(configPath);
     const config = (0, import_comment_json.parse)(configJSON);
+    const { baseUrl: _baseUrl, ...compilerOptions } = config.compilerOptions ?? {};
     const newConfig = {
       ...config,
       compilerOptions: {
-        ...config.compilerOptions,
-        baseUrl: "./",
+        ...compilerOptions,
+        paths: {
+          "*": ["./*"],
+          ...compilerOptions.paths
+        },
         noEmit: true
       }
     };
@@ -224,9 +339,19 @@ function ensureConfigComplies(configPath) {
 }
 
 // src/dev/watchAndCompile/getConfigPath.ts
+function findConfigFile(startDirectory, fileName) {
+  let directory = startDirectory;
+  while (true) {
+    const candidate = (0, import_node_path4.join)(directory, fileName);
+    if ((0, import_node_fs6.existsSync)(candidate)) return candidate;
+    const parent = (0, import_node_path4.dirname)(directory);
+    if (parent === directory) return void 0;
+    directory = parent;
+  }
+}
 function getConfigPath() {
   const appBasePath = process.cwd();
-  const configPath = import_typescript.default.findConfigFile(appBasePath, import_typescript.default.sys.fileExists, "tsconfig.server.json") || import_typescript.default.findConfigFile(appBasePath, import_typescript.default.sys.fileExists, "tsconfig.json");
+  const configPath = findConfigFile(appBasePath, "tsconfig.server.json") || findConfigFile(appBasePath, "tsconfig.json");
   if (!configPath) {
     throw new Error("Could not find a valid 'tsconfig.json'.");
   }
@@ -234,106 +359,106 @@ function getConfigPath() {
   return configPath;
 }
 
-// src/dev/watchAndCompile/reports.ts
-var import_typescript2 = __toESM(require("typescript"), 1);
-var format = {
-  getCanonicalFileName: (fileName) => fileName,
-  getCurrentDirectory: () => process.cwd(),
-  getNewLine: () => import_typescript2.default.sys.newLine
-};
-function reportDiagnostic(diagnostic) {
-  console.log(import_typescript2.default.formatDiagnosticsWithColorAndContext([diagnostic], format));
-}
-
-// src/dev/watchAndCompile/getHost.ts
-var import_chalk3 = __toESM(require("chalk"), 1);
-function getHost(runner) {
-  let isStopped = true;
-  const reportWatchStatusChanged = (diagnostic) => {
-    if (diagnostic.category !== 3) return;
-    if (diagnostic.code === 6031 || diagnostic.code === 6032) {
-      return;
-    }
-    if (diagnostic.code === 6193) {
-      runner.stop();
-      isStopped = true;
+// src/dev/watchAndCompile/watchAndTypecheck.ts
+function watchAndTypecheck(runner) {
+  const configPath = getConfigPath();
+  let checkInProgress = false;
+  let checkRequested = false;
+  const runCheck = () => {
+    if (checkInProgress) {
+      checkRequested = true;
       return;
     }
-    if (diagnostic.code === 6194) {
-      if (/^Found .+ errors?/.test(diagnostic.messageText.toString())) {
-        if (!diagnostic.messageText.toString().includes("Found 0 errors.")) {
-          runner.stop();
-          isStopped = true;
-          return;
-        }
+    checkInProgress = true;
+    const startedAt = Date.now();
+    const checker = (0, import_node_child_process3.spawn)("tsc", ["--noEmit", "--project", configPath], {
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    let spawnError;
+    checker.stdout.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    checker.stderr.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    checker.on("error", (error) => {
+      spawnError = error;
+    });
+    checker.on("close", (code) => {
+      checkInProgress = false;
+      if (checkRequested) {
+        checkRequested = false;
+        runCheck();
+        return;
       }
-      if (isStopped) {
-        isStopped = false;
+      if (spawnError) {
+        runner.stop();
+        console.error(`Unable to run TypeScript: ${spawnError.message}`);
+        return;
+      }
+      const duration = Date.now() - startedAt;
+      if (code === 0) {
+        console.log(`=> TypeScript checked in ${duration}ms`);
         runner.start();
+        return;
       }
-      return;
-    }
-    console.log(import_chalk3.default.bold(`=> ${diagnostic.messageText} [${diagnostic.code}]`));
+      if (output.trim()) console.error(output.trimEnd());
+      console.error(`=> TypeScript found errors in ${duration}ms`);
+      runner.stop();
+    });
   };
-  const configPath = getConfigPath();
-  const createProgram = import_typescript3.default.createEmitAndSemanticDiagnosticsBuilderProgram;
-  const host = import_typescript3.default.createWatchCompilerHost(
-    configPath,
-    {},
-    import_typescript3.default.sys,
-    createProgram,
-    reportDiagnostic,
-    reportWatchStatusChanged
-  );
-  return host;
+  return runCheck;
 }
 
 // src/dev/watchAndCompile/writeEnvFile.ts
 var import_env = require("@orion-js/env");
-var import_chalk4 = __toESM(require("chalk"), 1);
-var import_chokidar = __toESM(require("chokidar"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
+var import_chokidar2 = __toESM(require("chokidar"), 1);
 var envFilePath = process.env.ORION_ENV_FILE_PATH;
 var dtsFilePath = "./app/env.d.ts";
 var watchEnvFile = async (runner) => {
   if (!envFilePath) return;
   (0, import_env.writeDtsFileFromConfigFile)(envFilePath, dtsFilePath);
-  import_chokidar.default.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
-    console.log(import_chalk4.default.bold("=> Environment file changed. Restarting..."));
+  import_chokidar2.default.watch(envFilePath, { ignoreInitial: true }).on("change", async () => {
+    console.log(import_chalk3.default.bold("=> Environment file changed. Restarting..."));
     (0, import_env.writeDtsFileFromConfigFile)(envFilePath, dtsFilePath);
     runner.restart();
   });
 };
 
 // src/dev/watchAndCompile/index.ts
-async function watchAndCompile(runner) {
+async function watchAndCompile(runner, options) {
   await cleanDirectory();
-  const host = getHost(runner);
-  import_typescript4.default.createWatchProgram(host);
+  const requestTypecheck = options.typecheck ? watchAndTypecheck(runner) : void 0;
+  await watchAndBundle(runner, options, requestTypecheck);
+  requestTypecheck == null ? void 0 : requestTypecheck();
   watchEnvFile(runner);
 }
 
 // src/dev/index.ts
 async function dev_default(options, command) {
-  console.log(import_chalk5.default.bold(`
-Orionjs App ${import_chalk5.default.green(import_chalk5.default.bold("V4"))} Dev mode 
+  console.log(import_chalk4.default.bold(`
+Orionjs App ${import_chalk4.default.green(import_chalk4.default.bold("V4"))} Dev mode 
 `));
   const runner = getRunner(options, command);
-  watchAndCompile(runner);
+  await watchAndCompile(runner, options);
 }
 
 // src/prod/index.ts
-var import_chalk9 = __toESM(require("chalk"), 1);
+var import_chalk8 = __toESM(require("chalk"), 1);
 
 // src/build/index.ts
-var import_chalk8 = __toESM(require("chalk"), 1);
+var import_chalk7 = __toESM(require("chalk"), 1);
 
 // src/build/build.ts
-var import_chalk6 = __toESM(require("chalk"), 1);
-var esbuild = __toESM(require("esbuild"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
+var esbuild2 = __toESM(require("esbuild"), 1);
 async function build2(options) {
   const { output } = options;
   console.log(`Building with esbuild to ${output}`);
-  await esbuild.build({
+  await esbuild2.build({
     entryPoints: ["./app/index.ts"],
     tsconfig: "./tsconfig.json",
     format: "esm",
@@ -346,14 +471,14 @@ async function build2(options) {
     minify: true,
     packages: "external"
   });
-  console.log(import_chalk6.default.green.bold("Build successful"));
+  console.log(import_chalk5.default.green.bold("Build successful"));
 }
 
 // src/build/checkTs.ts
-var import_chalk7 = __toESM(require("chalk"), 1);
-var import_node_child_process3 = require("child_process");
+var import_chalk6 = __toESM(require("chalk"), 1);
+var import_node_child_process4 = require("child_process");
 var import_node_util = require("util");
-var execPromise = (0, import_node_util.promisify)(import_node_child_process3.exec);
+var execPromise = (0, import_node_util.promisify)(import_node_child_process4.exec);
 async function checkTs() {
   try {
     console.log("Checking TypeScript...");
@@ -365,9 +490,9 @@ async function checkTs() {
       gid: process.getgid(),
       uid: process.getuid()
     });
-    console.log(import_chalk7.default.green.bold("TypeScript check passed"));
+    console.log(import_chalk6.default.green.bold("TypeScript check passed"));
   } catch (error) {
-    console.log(import_chalk7.default.red.bold("TypeScript compilation failed"));
+    console.log(import_chalk6.default.red.bold("TypeScript compilation failed"));
     console.log(error.stderr || error.stdout || error.message);
     process.exit(1);
   }
@@ -375,23 +500,23 @@ async function checkTs() {
 
 // src/build/index.ts
 async function build_default(options) {
-  console.log(import_chalk8.default.bold(`Building Orionjs App ${import_chalk8.default.green(import_chalk8.default.bold("V4"))}...`));
+  console.log(import_chalk7.default.bold(`Building Orionjs App ${import_chalk7.default.green(import_chalk7.default.bold("V4"))}...`));
   if (!options.output) {
     options.output = "./build";
   }
   await cleanDirectory(options.output);
   await checkTs();
   await build2(options);
-  console.log(import_chalk8.default.bold("Build completed"));
+  console.log(import_chalk7.default.bold("Build completed"));
 }
 
 // src/prod/runProd.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 function runProd(options, command) {
   if (options.node) {
     const indexPath = `${options.path}/index.js`;
     const args2 = ["--import=tsx", ...command.args, indexPath];
-    (0, import_node_child_process4.spawn)("node", args2, {
+    (0, import_node_child_process5.spawn)("node", args2, {
       env: {
         NODE_ENV: "production",
         ...process.env
@@ -405,7 +530,7 @@ function runProd(options, command) {
     return;
   }
   const args = [...command.args, "./app/index.ts"];
-  (0, import_node_child_process4.spawn)("bun", args, {
+  (0, import_node_child_process5.spawn)("bun", args, {
     env: {
       NODE_ENV: "production",
       ...process.env
@@ -420,8 +545,8 @@ function runProd(options, command) {
 
 // src/prod/index.ts
 async function prod_default(options, command) {
-  console.log(import_chalk9.default.bold(`
-Orionjs App ${import_chalk9.default.green(import_chalk9.default.bold("V4"))} Prod mode
+  console.log(import_chalk8.default.bold(`
+Orionjs App ${import_chalk8.default.green(import_chalk8.default.bold("V4"))} Prod mode
 `));
   if (options.node) {
     if (!options.path) {
@@ -433,29 +558,29 @@ Orionjs App ${import_chalk9.default.green(import_chalk9.default.bold("V4"))} Pro
 }
 
 // src/handleErrors.ts
-var import_chalk10 = __toESM(require("chalk"), 1);
+var import_chalk9 = __toESM(require("chalk"), 1);
 process.on("unhandledRejection", (error) => {
   if (error.codeFrame) {
-    console.error(import_chalk10.default.red(error.message));
+    console.error(import_chalk9.default.red(error.message));
     console.log(error.codeFrame);
   } else {
-    console.error(import_chalk10.default.red(error.message), import_chalk10.default.red("Unhandled promise rejection"));
+    console.error(import_chalk9.default.red(error.message), import_chalk9.default.red("Unhandled promise rejection"));
   }
 }).on("uncaughtException", (error) => {
-  console.error(import_chalk10.default.red(error.message));
+  console.error(import_chalk9.default.red(error.message));
   process.exit(1);
 });
 
 // src/version.ts
-var import_node_fs5 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path5 = require("path");
 var import_node_url = require("url");
 var import_meta = {};
 function getVersion() {
   try {
-    const dir = (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-    const pkgPath = (0, import_node_path3.resolve)(dir, "..", "package.json");
-    const pkg = JSON.parse((0, import_node_fs5.readFileSync)(pkgPath, "utf-8"));
+    const dir = (0, import_node_path5.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+    const pkgPath = (0, import_node_path5.resolve)(dir, "..", "package.json");
+    const pkg = JSON.parse((0, import_node_fs7.readFileSync)(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "unknown";
@@ -467,14 +592,14 @@ var version_default = getVersion();
 var import_config = require("dotenv/config");
 
 // src/check/index.ts
-var import_chalk12 = __toESM(require("chalk"), 1);
+var import_chalk11 = __toESM(require("chalk"), 1);
 
 // src/check/checkTs.ts
-var import_chalk11 = __toESM(require("chalk"), 1);
-var import_node_child_process5 = require("child_process");
+var import_chalk10 = __toESM(require("chalk"), 1);
+var import_node_child_process6 = require("child_process");
 function checkTs2() {
   try {
-    (0, import_node_child_process5.execSync)("tsc --noEmit", {
+    (0, import_node_child_process6.execSync)("tsc --noEmit", {
       cwd: process.cwd(),
       env: {
         ...process.env
@@ -484,27 +609,27 @@ function checkTs2() {
       stdio: "inherit"
     });
   } catch {
-    console.log(import_chalk11.default.red.bold("TypeScript compilation failed"));
+    console.log(import_chalk10.default.red.bold("TypeScript compilation failed"));
     process.exit(1);
   }
 }
 
 // src/check/index.ts
 async function check_default() {
-  console.log(import_chalk12.default.bold(`Orionjs App ${import_chalk12.default.green(import_chalk12.default.bold("V4"))}
+  console.log(import_chalk11.default.bold(`Orionjs App ${import_chalk11.default.green(import_chalk11.default.bold("V4"))}
 `));
   console.log("Checking typescript...");
   checkTs2();
-  console.log(import_chalk12.default.bold.green("Check passed\n"));
+  console.log(import_chalk11.default.bold.green("Check passed\n"));
 }
 
 // src/info.ts
-var import_chalk13 = __toESM(require("chalk"), 1);
-var import_node_child_process6 = require("child_process");
+var import_chalk12 = __toESM(require("chalk"), 1);
+var import_node_child_process7 = require("child_process");
 function detectRuntime() {
   const runtimes = [];
   try {
-    const bunVersion = (0, import_node_child_process6.execSync)("bun --version", { encoding: "utf-8" }).trim();
+    const bunVersion = (0, import_node_child_process7.execSync)("bun --version", { encoding: "utf-8" }).trim();
     runtimes.push(`Bun ${bunVersion}`);
   } catch {
   }
@@ -512,21 +637,21 @@ function detectRuntime() {
   return runtimes.join(", ");
 }
 function info() {
-  console.log(`Orion CLI v${version_default} \u2014 Available runtimes: ${import_chalk13.default.bold(detectRuntime())}`);
-  console.log(`Default runtime: ${import_chalk13.default.bold("Bun")} (use --node flag to switch to Node.js)`);
+  console.log(`Orion CLI v${version_default} \u2014 Available runtimes: ${import_chalk12.default.bold(detectRuntime())}`);
+  console.log(`Default runtime: ${import_chalk12.default.bold("Bun")} (use --node flag to switch to Node.js)`);
 }
 
 // src/repl/index.ts
-var import_node_fs6 = require("fs");
-var import_node_path4 = require("path");
-var import_chalk14 = __toESM(require("chalk"), 1);
+var import_node_fs8 = require("fs");
+var import_node_path6 = require("path");
+var import_chalk13 = __toESM(require("chalk"), 1);
 function resolvePort(options) {
   if (options.port) {
     return Number(options.port);
   }
   try {
-    const portFile = (0, import_node_path4.resolve)(process.cwd(), ".orion/port");
-    const port = (0, import_node_fs6.readFileSync)(portFile, "utf-8").trim();
+    const portFile = (0, import_node_path6.resolve)(process.cwd(), ".orion/port");
+    const port = (0, import_node_fs8.readFileSync)(portFile, "utf-8").trim();
     return Number(port);
   } catch {
   }
@@ -539,7 +664,7 @@ async function repl(options) {
   var _a;
   const expression = options.expression;
   if (!expression) {
-    console.error(import_chalk14.default.red('Error: expression is required. Use -e "<expression>"'));
+    console.error(import_chalk13.default.red('Error: expression is required. Use -e "<expression>"'));
     process.exit(1);
   }
   const port = resolvePort(options);
@@ -551,9 +676,9 @@ async function repl(options) {
     });
     const data = await response.json();
     if (!data.success) {
-      console.error(import_chalk14.default.red(`Error: ${data.error}`));
+      console.error(import_chalk13.default.red(`Error: ${data.error}`));
       if (data.stack) {
-        console.error(import_chalk14.default.dim(data.stack));
+        console.error(import_chalk13.default.dim(data.stack));
       }
       process.exit(1);
     }
@@ -563,14 +688,15 @@ async function repl(options) {
       );
     }
   } catch (error) {
-    if (error.code === "ECONNREFUSED" || ((_a = error.cause) == null ? void 0 : _a.code) === "ECONNREFUSED") {
+    const nodeError = error;
+    if (nodeError.code === "ECONNREFUSED" || ((_a = nodeError.cause) == null ? void 0 : _a.code) === "ECONNREFUSED") {
       console.error(
-        import_chalk14.default.red(
+        import_chalk13.default.red(
           `Could not connect to dev server on port ${port}. Make sure "orion dev --repl" is running.`
         )
       );
     } else {
-      console.error(import_chalk14.default.red(`Error: ${error.message}`));
+      console.error(import_chalk13.default.red(`Error: ${nodeError.message}`));
     }
     process.exit(1);
   }
@@ -582,10 +708,10 @@ var run = (action) => async (...args) => {
   try {
     await action(...args);
   } catch (e) {
-    console.error(import_chalk15.default.red(`Error: ${e.message}`));
+    console.error(import_chalk14.default.red(`Error: ${e.message}`));
   }
 };
-program.command("dev").description("Run the Orionjs app in development mode").option("--node", "Use Node.js runtime instead of Bun").option("--repl", "Enable REPL endpoint for orion repl").allowUnknownOption().action(run(dev_default));
+program.command("dev").description("Run the Orionjs app in development mode").option("--node", "Use Node.js runtime instead of Bun").option("--repl", "Enable REPL endpoint for orion repl").option("--no-typecheck", "Disable continuous TypeScript diagnostics").allowUnknownOption().action(run(dev_default));
 program.command("check").description("Runs a typescript check").action(run(check_default));
 program.command("build").description("Build the Orionjs app for production").option("--output [path]", "Path of the output file").action(run(build_default));
 program.command("prod").allowUnknownOption().option("--node", "Use Node.js runtime instead of Bun").option(