@cedarjs/cli 4.1.1-next.1 → 4.1.1-next.55

package/dist/cfw.js

@@ -6,7 +6,7 @@ import execa from "execa";
 import { terminalLink } from "termi-link";
 import { getConfigPath } from "@cedarjs/project-config";
 const config = new Configstore("@cedarjs/cli");
-const CFW_PATH = process.env.CFW_PATH || process.env.RWFW_PATH || process.env.RW_PATH || config.get("CFW_PATH") || config.get("RWFW_PATH");
+const CFW_PATH = process.env.CFW_PATH || config.get("CFW_PATH");
 if (!CFW_PATH) {
   console.error("Error: You must specify the path to Cedar Framework");
   console.error("Usage: `CFW_PATH=~/gh/cedarjs/cedar yarn cfw <command>");

package/dist/commands/build/buildHandler.js

@@ -11,6 +11,7 @@ import {
 } from "@cedarjs/cli-helpers/packageManager/display";
 import { runBin } from "@cedarjs/cli-helpers/packageManager/exec";
 import {
+  buildApi,
   buildApiWithVite,
   cleanApiBuild
 } from "@cedarjs/internal/dist/build/api";
@@ -20,6 +21,7 @@ import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
 import { detectPrerenderRoutes } from "@cedarjs/prerender/detection";
 import {} from "@cedarjs/project-config";
 import { timedTelemetry } from "@cedarjs/telemetry";
+import { buildCedarApp } from "@cedarjs/vite/build";
 import { buildUDApiServer } from "@cedarjs/vite/buildUDApiServer";
 import { generatePrismaCommand } from "../../lib/generatePrismaClient.js";
 import { getPaths, getConfig } from "../../lib/index.js";
@@ -163,25 +165,59 @@ Run ` + c.info(formatCedarCommand(["build"])) + " (without specifying a workspac
       title: "Verifying graphql schema...",
       task: loadAndValidateSdls
     },
-    // The API build has two sequential steps:
-    // 1. esbuild compiles api/src/** → api/dist/ (functions, services, etc.)
-    // 2. Vite wraps api/dist/functions/ into a self-contained UD Node server
-    //    entry at api/dist/ud/index.js for `cedar serve api`
-    // Step 2 depends on step 1 having completed.
-    workspace.includes("api") && {
+    // When streaming SSR is enabled, fall back to the legacy separate build
+    // paths because streaming SSR has its own complex build orchestration.
+    // Phase 7 (SSR/RSC rebuild) will address unifying this path.
+    workspace.includes("api") && getConfig().experimental?.streamingSsr?.enabled && {
       title: "Building API...",
       task: async () => {
         await cleanApiBuild();
         await buildApiWithVite();
       }
     },
-    ud && workspace.includes("api") && {
-      title: "Bundling API server entry (Universal Deploy)...",
+    workspace.includes("web") && getConfig().experimental?.streamingSsr?.enabled && {
+      title: "Building Web...",
       task: async () => {
-        await buildUDApiServer({ verbose });
+        process.env.VITE_CJS_IGNORE_WARNING = "true";
+        const createdRequire = createRequire(import.meta.url);
+        const buildBinPath = createdRequire.resolve(
+          "@cedarjs/vite/bins/cedar-vite-build.mjs"
+        );
+        await execa(
+          `node ${buildBinPath} --webDir="${cedarPaths.web.base}" --verbose=${verbose}`,
+          {
+            stdio: verbose ? "inherit" : "pipe",
+            shell: true,
+            cwd: cedarPaths.web.base
+          }
+        );
+        if (!getConfig().experimental?.streamingSsr?.enabled) {
+          console.log("Creating 200.html...");
+          const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
+          fs.copyFileSync(
+            indexHtmlPath,
+            path.join(getPaths().web.dist, "200.html")
+          );
+        }
+      }
+    },
+    // Legacy separate build path (default when not --ud, non-streaming-SSR)
+    workspace.includes("api") && !ud && !getConfig().experimental?.streamingSsr?.enabled && {
+      title: "Building API...",
+      task: async () => {
+        await cleanApiBuild();
+        const { errors, warnings } = await buildApi();
+        if (warnings.length) {
+          console.warn(warnings);
+        }
+        if (errors.length) {
+          throw new Error(
+            `API build failed with ${errors.length} error(s). See output above for details.`
+          );
+        }
       }
     },
-    workspace.includes("web") && {
+    workspace.includes("web") && !ud && !getConfig().experimental?.streamingSsr?.enabled && {
       title: "Building Web...",
       task: async () => {
         process.env.VITE_CJS_IGNORE_WARNING = "true";
@@ -200,7 +236,30 @@ Run ` + c.info(formatCedarCommand(["build"])) + " (without specifying a workspac
             cwd: cedarPaths.web.base
           }
         );
-        if (!getConfig().experimental?.streamingSsr?.enabled) {
+        console.log("Creating 200.html...");
+        const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
+        fs.copyFileSync(
+          indexHtmlPath,
+          path.join(getPaths().web.dist, "200.html")
+        );
+      }
+    },
+    // Unified build path (experimental, non-streaming-SSR, --ud)
+    (workspace.includes("api") || workspace.includes("web")) && ud && !getConfig().experimental?.streamingSsr?.enabled && {
+      title: workspace.includes("api") && workspace.includes("web") ? "Building App..." : workspace.includes("api") ? "Building API..." : "Building Web...",
+      task: async () => {
+        process.env.VITE_CJS_IGNORE_WARNING = "true";
+        if (workspace.includes("api")) {
+          await cleanApiBuild();
+        }
+        const originalCwd = process.cwd();
+        process.chdir(cedarPaths.web.base);
+        try {
+          await buildCedarApp({ verbose, workspace });
+        } finally {
+          process.chdir(originalCwd);
+        }
+        if (workspace.includes("web")) {
           console.log("Creating 200.html...");
           const indexHtmlPath = path.join(getPaths().web.dist, "index.html");
           fs.copyFileSync(
@@ -209,6 +268,12 @@ Run ` + c.info(formatCedarCommand(["build"])) + " (without specifying a workspac
           );
         }
       }
+    },
+    ud && workspace.includes("api") && {
+      title: "Bundling API server entry (Universal Deploy)...",
+      task: async () => {
+        await buildUDApiServer({ verbose });
+      }
     }
   ].filter((t) => Boolean(t));
   const triggerPrerender = async () => {

package/dist/commands/dev/devHandler.js

@@ -68,19 +68,40 @@ const handler = async ({
     }
     webPortChangeNeeded = webAvailablePort !== webPreferredPort;
   }
-  if (webPortChangeNeeded) {
-    const message = [
-      "The currently configured port for the development server is",
-      "unavailable. Suggested change to your port, which can be changed in",
-      "cedar.toml (or redwood.toml):\n",
-      ` - Web to use port ${webAvailablePort} instead`,
-      "of your currently configured",
-      `${webPreferredPort}
+  if (ud) {
+    if (webPortChangeNeeded) {
+      const message = [
+        "The currently configured port for the development server is",
+        "unavailable. Suggested change to your port, which can be changed in",
+        "cedar.toml (or redwood.toml):\n",
+        ` - Web to use port ${webAvailablePort} instead`,
+        "of your currently configured",
+        `${webPreferredPort}
 `,
-      "\nCannot run the development server until your configured port is",
-      "changed or becomes available."
-    ].filter(Boolean).join(" ");
-    exitWithError(void 0, { message });
+        "\nCannot run the development server until your configured port is",
+        "changed or becomes available."
+      ].filter(Boolean).join(" ");
+      exitWithError(void 0, { message });
+    }
+  } else {
+    if (apiPortChangeNeeded || webPortChangeNeeded) {
+      const message = [
+        "The currently configured ports for the development server are",
+        "unavailable. Suggested changes to your ports, which can be changed in",
+        "cedar.toml (or redwood.toml), are:\n",
+        apiPortChangeNeeded && ` - API to use port ${apiAvailablePort} instead`,
+        apiPortChangeNeeded && "of your currently configured",
+        apiPortChangeNeeded && `${apiPreferredPort}
+`,
+        webPortChangeNeeded && ` - Web to use port ${webAvailablePort} instead`,
+        webPortChangeNeeded && "of your currently configured",
+        webPortChangeNeeded && `${webPreferredPort}
+`,
+        "\nCannot run the development server until your configured ports are",
+        "changed or become available."
+      ].filter(Boolean).join(" ");
+      exitWithError(void 0, { message });
+    }
   }
   if (workspace.includes("api")) {
     try {
@@ -90,6 +111,17 @@ const handler = async ({
       errorTelemetry(process.argv, `Error generating prisma client: ${message}`);
       console.error(c.error(message));
     }
+    if (!ud && !serverFile) {
+      try {
+        await shutdownPort(apiAvailablePort);
+      } catch (e) {
+        const message = getErrorMessage(e);
+        errorTelemetry(process.argv, `Error shutting down "api": ${message}`);
+        console.error(
+          `Error whilst shutting down "api" port: ${c.error(message)}`
+        );
+      }
+    }
   }
   if (workspace.includes("web") && webAvailablePort !== void 0) {
     try {

package/dist/commands/prerenderHandler.js

@@ -151,24 +151,28 @@ const getTasks = async (dryrun, routerPathFilter = null) => {
         }
       ];
     }
-    return routesToPrerender.flatMap((routeToPrerender) => {
-      if (routerPathFilter && routeToPrerender.path !== routerPathFilter) {
-        return [];
-      }
-      const outputHtmlPath = mapRouterPathToHtml(routeToPrerender.path);
-      return {
-        title: `Prerendering ${routeToPrerender.path} -> ${outputHtmlPath}`,
-        task: async () => {
-          await prerenderRoute(
-            prerenderer,
-            queryCache,
-            routeToPrerender,
-            dryrun,
-            outputHtmlPath
-          );
+    return routesToPrerender.flatMap(
+      (routeToPrerender) => {
+        if (routerPathFilter && routeToPrerender.path !== routerPathFilter) {
+          return [];
         }
-      };
-    });
+        const outputHtmlPath = mapRouterPathToHtml(routeToPrerender.path);
+        return [
+          {
+            title: `Prerendering ${routeToPrerender.path} -> ${outputHtmlPath}`,
+            task: async () => {
+              await prerenderRoute(
+                prerenderer,
+                queryCache,
+                routeToPrerender,
+                dryrun,
+                outputHtmlPath
+              );
+            }
+          }
+        ];
+      }
+    );
   });
   return listrTasks;
 };

package/dist/commands/serve.js

@@ -1,5 +1,6 @@
 import { fork } from "node:child_process";
 import fs from "node:fs";
+import net from "node:net";
 import path from "node:path";
 import { terminalLink } from "termi-link";
 import * as apiServerCLIConfig from "@cedarjs/api-server/apiCliConfig";
@@ -18,7 +19,14 @@ const builder = async (yargs) => {
   yargs.command({
     command: "$0",
     description: bothServerCLIConfig.description,
-    builder: bothServerCLIConfig.builder,
+    builder: (yargs2) => {
+      bothServerCLIConfig.builder(yargs2);
+      return yargs2.option("ud", {
+        description: "Use the Universal Deploy server for the API side. The web side is served by the existing static file server. Pass --ud to opt in; the default is Fastify for both sides.",
+        type: "boolean",
+        default: false
+      });
+    },
     handler: async (argv) => {
       recordTelemetryAttributes({
         command: "serve",
@@ -26,6 +34,110 @@ const builder = async (yargs) => {
         host: argv.host,
         socket: argv.socket
       });
+      if (argv.ud) {
+        if (argv.port) {
+          console.error(
+            c.error(
+              "\n The --port flag is not supported with --ud. Use --web-port and --api-port instead.\n"
+            )
+          );
+          process.exit(1);
+        }
+        const udEntryPath = path.join(getPaths().api.dist, "ud", "index.js");
+        if (!fs.existsSync(udEntryPath)) {
+          console.error(
+            c.error(
+              `
+ Universal Deploy server entry not found at ${udEntryPath}.
+ Please run \`yarn cedar build --ud\` before serving.
+`
+            )
+          );
+          process.exit(1);
+        }
+        const webDistIndexHtml = path.join(getPaths().web.dist, "index.html");
+        if (!fs.existsSync(webDistIndexHtml)) {
+          console.error(
+            c.error(
+              "\n Web build artifacts not found.\n Please run `yarn cedar build` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+        if (serverFileExists()) {
+          console.warn(
+            c.warning(
+              "\n Note: api/src/server.ts was detected. This file is a Fastify concept and will be ignored when using --ud. You are testing the experimental UD support, so the behavior will not match your production Fastify setup.\n"
+            )
+          );
+        }
+        const { getAPIHost, getAPIPort, getWebHost, getWebPort } = await import("@cedarjs/api-server/cliHelpers");
+        const apiPort = argv.apiPort ?? getAPIPort();
+        const apiHost = argv.apiHost ?? getAPIHost();
+        const webPort = argv.webPort ?? getWebPort();
+        const webHost = argv.webHost ?? getWebHost();
+        const apiRootPath = argv.apiRootPath ?? "/";
+        const apiProxyTarget = [
+          "http://",
+          apiHost.includes(":") ? `[${apiHost}]` : apiHost,
+          ":",
+          apiPort,
+          apiRootPath
+        ].join("");
+        const { redwoodFastifyWeb } = await import("@cedarjs/fastify-web");
+        const { createFastifyInstance } = await import("@cedarjs/api-server/fastify");
+        const webFastify = await createFastifyInstance();
+        webFastify.register(redwoodFastifyWeb, {
+          redwood: {
+            apiProxyTarget
+          }
+        });
+        await webFastify.listen({
+          port: webPort,
+          host: webHost
+        });
+        const child = fork(
+          udEntryPath,
+          ["--port", String(apiPort), "--host", apiHost],
+          {
+            execArgv: process.execArgv,
+            env: {
+              ...process.env,
+              NODE_ENV: process.env.NODE_ENV ?? "production",
+              PORT: String(apiPort),
+              HOST: apiHost
+            }
+          }
+        );
+        child.on("error", (err) => {
+          console.error(
+            c.error(`
+ Failed to start UD API server: ${err.message}
+`)
+          );
+          process.exit(1);
+        });
+        child.on("exit", (code) => {
+          if (code !== 0) {
+            console.error(
+              c.error(`
+ UD API server exited with code ${code}
+`)
+            );
+            process.exit(1);
+          }
+        });
+        console.log(`Web server listening at http://${webHost}:${webPort}`);
+        process.stdout.write(
+          `API server starting at http://${apiHost}:${apiPort}...`
+        );
+        await waitForPort(apiHost, apiPort);
+        process.stdout.write(
+          `\rAPI server listening at http://${apiHost}:${apiPort}
+`
+        );
+        return;
+      }
       if (serverFileExists()) {
         const serveBothHandlers = await import("./serveBothHandler.js");
         await serveBothHandlers.bothServerFileHandler(argv);
@@ -51,7 +163,7 @@ const builder = async (yargs) => {
       return yargs2.option("ud", {
         // UD serving is opt-in. Pass --ud to use the new srvx server instead
         // of the legacy Fastify server.
-        description: "Use the Universal Deploy server (srvx). Pass --ud to opt in; the default is Fastify.",
+        description: "Use the Universal Deploy server. Pass --ud to opt in; the default is Fastify.",
         type: "boolean",
         default: false
       });
@@ -71,7 +183,7 @@ const builder = async (yargs) => {
             c.error(
               `
  Universal Deploy server entry not found at ${udEntryPath}.
- Please run \`yarn cedar build api\` before serving.
+ Please run \`yarn cedar build --ud\` before serving.
 `
             )
           );
@@ -84,17 +196,34 @@ const builder = async (yargs) => {
         if (argv.host) {
           udArgs.push("--host", argv.host);
         }
+        const child = fork(udEntryPath, udArgs, {
+          execArgv: process.execArgv,
+          env: {
+            ...process.env,
+            NODE_ENV: process.env.NODE_ENV ?? "production",
+            PORT: argv.port ? String(argv.port) : process.env.PORT,
+            HOST: argv.host ?? process.env.HOST
+          }
+        });
+        child.on("error", (err) => {
+          console.error(
+            c.error(`
+ Failed to start UD server: ${err.message}
+`)
+          );
+          process.exit(1);
+        });
+        const apiPort = argv.port ?? parseInt(process.env.PORT ?? "8911", 10);
+        const apiHost = argv.host ?? process.env.HOST ?? "localhost";
+        process.stdout.write(
+          `API server starting at http://${apiHost}:${apiPort}...`
+        );
+        await waitForPort(apiHost, apiPort);
+        process.stdout.write(
+          `\rAPI server listening at http://${apiHost}:${apiPort}
+`
+        );
         await new Promise((resolve, reject) => {
-          const child = fork(udEntryPath, udArgs, {
-            execArgv: process.execArgv,
-            env: {
-              ...process.env,
-              NODE_ENV: process.env.NODE_ENV ?? "production",
-              PORT: argv.port ? String(argv.port) : process.env.PORT,
-              HOST: argv.host ?? process.env.HOST
-            }
-          });
-          child.on("error", reject);
           child.on("exit", (code) => {
             if (code !== 0) {
               reject(new Error(`UD server exited with code ${code}`));
@@ -166,6 +295,20 @@ const builder = async (yargs) => {
         );
         process.exit(1);
       }
+      if (argv.ud) {
+        const udEntryPath = path.join(getPaths().api.dist, "ud", "index.js");
+        if (!fs.existsSync(udEntryPath)) {
+          console.error(
+            c.error(
+              `
+ Universal Deploy server entry not found at ${udEntryPath}.
+ Please run \`yarn cedar build --ud\` before serving.
+`
+            )
+          );
+          process.exit(1);
+        }
+      }
     }
     if (positionalArgs.length === 1) {
       if (!apiSideExists && !rscEnabled) {
@@ -176,14 +319,38 @@ const builder = async (yargs) => {
         );
         process.exit(1);
       }
-      const apiExistsButIsNotBuilt = apiSideExists && !fs.existsSync(getPaths().api.dist);
-      if (apiExistsButIsNotBuilt || !webSideIsBuilt(streamingEnabled || rscEnabled)) {
-        console.error(
-          c.error(
-            "\nPlease run `yarn cedar build` before trying to serve your Cedar app.\n"
-          )
-        );
-        process.exit(1);
+      if (argv.ud) {
+        const udEntryPath = path.join(getPaths().api.dist, "ud", "index.js");
+        if (!fs.existsSync(udEntryPath)) {
+          console.error(
+            c.error(
+              `
+ Universal Deploy server entry not found at ${udEntryPath}.
+ Please run \`yarn cedar build --ud\` before serving.
+`
+            )
+          );
+          process.exit(1);
+        }
+        const webDistIndexHtml = path.join(getPaths().web.dist, "index.html");
+        if (!fs.existsSync(webDistIndexHtml)) {
+          console.error(
+            c.error(
+              "\n Web build artifacts not found.\n Please run `yarn cedar build` before serving.\n"
+            )
+          );
+          process.exit(1);
+        }
+      } else {
+        const apiExistsButIsNotBuilt = apiSideExists && !fs.existsSync(getPaths().api.dist);
+        if (apiExistsButIsNotBuilt || !webSideIsBuilt(streamingEnabled || rscEnabled)) {
+          console.error(
+            c.error(
+              "\nPlease run `yarn cedar build` before trying to serve your Cedar app.\n"
+            )
+          );
+          process.exit(1);
+        }
       }
     }
     if (!process.env.NODE_ENV) {
@@ -205,6 +372,34 @@ function webSideIsBuilt(isStreamingOrRSC) {
     return fs.existsSync(path.join(getPaths().web.dist, "index.html"));
   }
 }
+function waitForPort(host, port) {
+  const maxAttempts = 50;
+  const intervalMs = 200;
+  return new Promise((resolve, reject) => {
+    let attempts = 0;
+    const tryConnect = () => {
+      attempts++;
+      const socket = net.createConnection({ host, port });
+      socket.on("connect", () => {
+        socket.destroy();
+        resolve();
+      });
+      socket.on("error", () => {
+        socket.destroy();
+        if (attempts >= maxAttempts) {
+          reject(
+            new Error(
+              `API server did not become ready on port ${port} after ${maxAttempts * intervalMs}ms`
+            )
+          );
+        } else {
+          setTimeout(tryConnect, intervalMs);
+        }
+      });
+    };
+    tryConnect();
+  });
+}
 export {
   builder,
   command,

package/dist/lib/exec.js

@@ -1,8 +1,6 @@
+import { existsSync } from "node:fs";
 import path from "node:path";
-import { createServer, version as viteVersion } from "vite";
-import { ViteNodeRunner } from "vite-node/client";
-import { ViteNodeServer } from "vite-node/server";
-import { installSourcemapsSupport } from "vite-node/source-map";
+import { createServer, isRunnableDevEnvironment } from "vite";
 import { getPaths, importStatementPath } from "@cedarjs/project-config";
 import {
   cedarCellTransform,
@@ -10,8 +8,21 @@ import {
   cedarjsJobPathInjectorPlugin,
   cedarSwapApolloProvider,
   cedarImportDirPlugin,
-  cedarAutoImportsPlugin
+  cedarAutoImportsPlugin,
+  cedarCjsCompatPlugin
 } from "@cedarjs/vite";
+function resolveExtension(id) {
+  if (existsSync(id)) {
+    return id;
+  }
+  const withoutExt = /\.jsx?$/.test(id) ? id.replace(/\.jsx?$/, "") : id;
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    if (existsSync(withoutExt + ext)) {
+      return withoutExt + ext;
+    }
+  }
+  return id;
+}
 async function runScriptFunction({
   path: scriptPath,
   functionName,
@@ -22,10 +33,16 @@ async function runScriptFunction({
   const server = await createServer({
     mode: "production",
     optimizeDeps: {
-      // This is recommended in the vite-node readme
       noDiscovery: true,
       include: void 0
     },
+    server: {
+      hmr: false,
+      watch: null
+    },
+    environments: {
+      nodeRunnerEnv: {}
+    },
     resolve: {
       alias: [
         {
@@ -52,18 +69,12 @@ async function runScriptFunction({
             const webImportBase = importStatementPath(getPaths().web.base);
             if (importer.startsWith(apiImportBase)) {
               const apiImportSrc = importStatementPath(getPaths().api.src);
-              let resolvedId = id.replace("src", apiImportSrc);
-              if (importer.endsWith(".ts") || importer.endsWith(".tsx")) {
-                resolvedId = resolvedId.replace(/\.jsx?$/, "");
-              }
-              return { id: resolvedId };
+              const resolvedId = id.replace("src", apiImportSrc);
+              return { id: resolveExtension(resolvedId) };
             } else if (importer.startsWith(webImportBase)) {
               const webImportSrc = importStatementPath(getPaths().web.src);
-              let resolvedId = id.replace("src", webImportSrc);
-              if (importer.endsWith(".ts") || importer.endsWith(".tsx")) {
-                resolvedId = resolvedId.replace(/\.jsx?$/, "");
-              }
-              return { id: resolvedId };
+              const resolvedId = id.replace("src", webImportSrc);
+              return { id: resolveExtension(resolvedId) };
             }
             return null;
           }
@@ -71,6 +82,7 @@ async function runScriptFunction({
       ]
     },
     plugins: [
+      cedarCjsCompatPlugin(),
       cedarjsResolveCedarStyleImportsPlugin(),
       cedarCellTransform(),
       cedarjsJobPathInjectorPlugin(),
@@ -79,41 +91,21 @@ async function runScriptFunction({
       cedarAutoImportsPlugin()
     ]
   });
-  if (Number(viteVersion.split(".")[0]) < 6) {
-    await server.pluginContainer.buildStart({});
+  const env = server.environments.nodeRunnerEnv;
+  if (!env || !isRunnableDevEnvironment(env)) {
+    await server.close();
+    throw new Error("Vite environment is not runnable.");
   }
-  const node = new ViteNodeServer(server, {
-    transformMode: {
-      ssr: [/.*/],
-      web: [/\/web\//]
-    },
-    deps: {
-      fallbackCJS: true
-    }
-  });
-  installSourcemapsSupport({
-    getSourceMap: (source) => node.getSourceMap(source)
-  });
-  const runner = new ViteNodeRunner({
-    root: server.config.root,
-    base: server.config.base,
-    fetchModule(id) {
-      return node.fetchModule(id);
-    },
-    resolveId(id, importer) {
-      return node.resolveId(id, importer);
-    }
-  });
   let returnValue;
   let scriptError = null;
   try {
-    const script = await runner.executeFile(scriptPath);
+    const script = await env.runner.import(scriptPath);
     returnValue = await script[functionName](args);
   } catch (error) {
     scriptError = error;
   }
   try {
-    const { db } = await runner.executeFile(path.join(getPaths().api.lib, "db"));
+    const { db } = await env.runner.import(path.join(getPaths().api.lib, "db"));
     db.$disconnect();
   } catch (e) {
   }

package/dist/lib/locking.js

@@ -32,11 +32,15 @@ function unsetLock(identifier) {
 }
 function isLockSet(identifier) {
   const lockfilePath = path.join(getPaths().generated.base, "locks", identifier);
-  const exists = fs.existsSync(lockfilePath);
-  if (!exists) {
-    return false;
+  let createdAt;
+  try {
+    createdAt = fs.statSync(lockfilePath).birthtimeMs;
+  } catch (error) {
+    if (isErrorWithCode(error, "ENOENT")) {
+      return false;
+    }
+    throw error;
   }
-  const createdAt = fs.statSync(lockfilePath).birthtimeMs;
   if (Date.now() - createdAt > 36e5) {
     unsetLock(identifier);
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/cli",
-  "version": "4.1.1-next.1+a867fc51b4",
+  "version": "4.1.1-next.55",
   "description": "The CedarJS Command Line",
   "repository": {
     "type": "git",
@@ -31,18 +31,19 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@babel/parser": "7.29.2",
+    "@babel/parser": "7.29.3",
     "@babel/preset-typescript": "7.28.5",
-    "@cedarjs/api-server": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/cli-helpers": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/fastify-web": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/internal": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/prerender": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/project-config": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/structure": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/telemetry": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/utils": "4.1.1-next.1+a867fc51b4",
-    "@cedarjs/web-server": "4.1.1-next.1+a867fc51b4",
+    "@cedarjs/api-server": "4.1.0",
+    "@cedarjs/cli-helpers": "4.1.0",
+    "@cedarjs/fastify-web": "4.1.0",
+    "@cedarjs/internal": "4.1.0",
+    "@cedarjs/prerender": "4.1.0",
+    "@cedarjs/project-config": "4.1.0",
+    "@cedarjs/structure": "4.1.0",
+    "@cedarjs/telemetry": "4.1.0",
+    "@cedarjs/utils": "4.1.0",
+    "@cedarjs/vite": "4.1.0",
+    "@cedarjs/web-server": "4.1.0",
     "@listr2/prompt-adapter-enquirer": "4.2.1",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/core": "1.30.1",
@@ -88,7 +89,6 @@
     "title-case": "3.0.3",
     "unionfs": "4.6.0",
     "uuid": "11.1.0",
-    "vite-node": "3.2.4",
     "yargs": "17.7.2"
   },
   "devDependencies": {
@@ -108,5 +108,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a867fc51b46741c77baddf329bc84e7339b75ddc"
+  "gitHead": "3905ed045508b861b495f8d5630d76c7a157d8f1"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Cedar
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.