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

package/dist/cedar-unified-dev.js

@@ -1,9 +1,18 @@
 #!/usr/bin/env node
+import { createServerAdapter } from "@whatwg-node/server";
 import { createServer } from "vite";
 import yargsParser from "yargs-parser";
 import { getPaths, getConfig } from "@cedarjs/project-config";
-import { startApiDevServer } from "./apiDevServer.js";
+import { startApiDevMiddleware } from "./apiDevMiddleware.js";
+function isViteInternalRequest(url) {
+  const pathname = url.split("?")[0];
+  return pathname.startsWith("/@") || pathname.startsWith("/__vite") || pathname.startsWith("/__hmr");
+}
+function isApiRequest(url, apiUrl, apiGqlUrl) {
+  return url === apiUrl || url.startsWith(apiUrl + "/") || url.startsWith(apiUrl + "?") || url === apiGqlUrl || url.startsWith(apiGqlUrl + "/") || url.startsWith(apiGqlUrl + "?");
+}
 const startUnifiedDevServer = async () => {
+  process.env.__CEDAR_UNIFIED_DEV = "true";
   const rwPaths = getPaths();
   const cedarConfig = getConfig();
   const configFile = rwPaths.web.viteConfig;
@@ -14,7 +23,7 @@ const startUnifiedDevServer = async () => {
     force: forceOptimize,
     debug,
     port: portArg,
-    apiPort: apiPortArg,
+    apiPort: _apiPortArg,
     _: _positional,
     ...serverArgs
   } = yargsParser(process.argv.slice(2), {
@@ -22,8 +31,8 @@ const startUnifiedDevServer = async () => {
     number: ["port", "apiPort"]
   });
   const webPort = portArg ?? cedarConfig.web.port ?? 8910;
-  const apiPort = apiPortArg ?? cedarConfig.api.port ?? 8911;
-  const { close: closeApi } = await startApiDevServer(apiPort);
+  const { close: closeApi, handler: apiHandler } = await startApiDevMiddleware();
+  const apiAdapter = createServerAdapter(apiHandler);
   const devServer = await createServer({
     configFile,
     // env file is handled by Cedar's plugins
@@ -36,7 +45,52 @@ const startUnifiedDevServer = async () => {
       port: webPort,
       ...serverArgs
     },
-    logLevel: debug ? "info" : void 0
+    logLevel: debug ? "info" : void 0,
+    plugins: [
+      {
+        name: "cedar-api-middleware",
+        apply: "serve",
+        configureServer(server) {
+          const apiUrl = cedarConfig.web.apiUrl.replace(/\/$/, "");
+          const apiGqlUrl = cedarConfig.web.apiGraphQLUrl ?? apiUrl + "/graphql";
+          server.middlewares.use(
+            async (req, res, next) => {
+              const url = req.url ?? "/";
+              if (isViteInternalRequest(url)) {
+                return next();
+              }
+              if (!isApiRequest(url, apiUrl, apiGqlUrl)) {
+                return next();
+              }
+              try {
+                await apiAdapter(req, res);
+              } catch (err) {
+                console.error(
+                  "[cedar-api-middleware] Error handling API request:",
+                  err
+                );
+                if (!res.headersSent) {
+                  res.writeHead(500, { "Content-Type": "application/json" });
+                }
+                res.end(
+                  JSON.stringify(
+                    {
+                      errors: [
+                        {
+                          message: err instanceof Error ? err.message : "Internal Server Error"
+                        }
+                      ]
+                    },
+                    null,
+                    2
+                  )
+                );
+              }
+            }
+          );
+        }
+      }
+    ]
   });
   await devServer.listen();
   process.stdin.on("data", async (data) => {

package/dist/cjs/{apiDevServer.js → apiDevMiddleware.js}

@@ -26,20 +26,21 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var apiDevServer_exports = {};
-__export(apiDevServer_exports, {
-  startApiDevServer: () => startApiDevServer
+var apiDevMiddleware_exports = {};
+__export(apiDevMiddleware_exports, {
+  createApiFetchHandler: () => createApiFetchHandler,
+  createApiViteServer: () => createApiViteServer,
+  loadApiFunctions: () => loadApiFunctions,
+  setupHmrHandlers: () => setupHmrHandlers,
+  startApiDevMiddleware: () => startApiDevMiddleware
 });
-module.exports = __toCommonJS(apiDevServer_exports);
+module.exports = __toCommonJS(apiDevMiddleware_exports);
 var import_promises = require("node:fs/promises");
 var import_node_path = __toESM(require("node:path"), 1);
 var import_node_url = require("node:url");
-var import_url_data = __toESM(require("@fastify/url-data"), 1);
 var import_ansis = __toESM(require("ansis"), 1);
-var import_fastify = __toESM(require("fastify"), 1);
-var import_fastify_raw_body = __toESM(require("fastify-raw-body"), 1);
 var import_vite = require("vite");
-var import_requestHandlers = require("@cedarjs/api-server/requestHandlers");
+var import_runtime = require("@cedarjs/api/runtime");
 var import_babel_config = require("@cedarjs/babel-config");
 var import_store = require("@cedarjs/context/dist/store");
 var import_graphql_server = require("@cedarjs/graphql-server");
@@ -86,13 +87,6 @@ async function internalLoadApiFunctions(viteServer) {
   } catch {
     srcFunctions = [];
   }
-  const graphqlFunctionIndex = srcFunctions.findIndex(
-    (f) => import_node_path.default.basename(f).startsWith("graphql.")
-  );
-  if (graphqlFunctionIndex > 0) {
-    const [graphqlFn] = srcFunctions.splice(graphqlFunctionIndex, 1);
-    srcFunctions.unshift(graphqlFn);
-  }
   console.log(import_ansis.default.dim.italic("Importing Server Functions... "));
   const tsImport = Date.now();
   let extractedGraphqlOptions = null;
@@ -101,24 +95,33 @@ async function internalLoadApiFunctions(viteServer) {
     const routeName = import_node_path.default.basename(fnPath).replace(/\.(ts|tsx|js|jsx)$/, "");
     try {
       const mod = await viteServer.ssrLoadModule((0, import_node_url.pathToFileURL)(fnPath).href);
-      const handler = (() => {
+      const cedarHandler = (() => {
+        if ("handleRequest" in mod) {
+          return mod.handleRequest;
+        }
+        if ("default" in mod && mod.default && "handleRequest" in mod.default) {
+          return mod.default.handleRequest;
+        }
+        let legacyHandler;
         if ("handler" in mod) {
-          return mod.handler;
+          legacyHandler = mod.handler;
+        } else if ("default" in mod && mod.default && "handler" in mod.default) {
+          legacyHandler = mod.default.handler;
         }
-        if ("default" in mod && mod.default && "handler" in mod.default) {
-          return mod.default.handler;
+        if (legacyHandler) {
+          return (0, import_runtime.wrapLegacyHandler)(legacyHandler);
         }
         return void 0;
       })();
-      if (handler) {
-        LAMBDA_FUNCTIONS[routeName] = handler;
+      if (cedarHandler) {
+        LAMBDA_FUNCTIONS[routeName] = cedarHandler;
         console.log(
           import_ansis.default.magenta("/" + routeName),
           import_ansis.default.dim.italic(Date.now() - ts + " ms")
         );
       } else {
         console.warn(
-          `[apiDevServer] No handler export found in function: ${fnPath}`
+          `[apiDevMiddleware] No handler or handleRequest export found in function: ${fnPath}`
         );
       }
       if (routeName === "graphql" && "__rw_graphqlOptions" in mod) {
@@ -127,7 +130,7 @@ async function internalLoadApiFunctions(viteServer) {
     } catch (err) {
       viteServer.ssrFixStacktrace(err);
       console.error(
-        `[apiDevServer] Failed to load function "${routeName}" from ${fnPath}:`,
+        `[apiDevMiddleware] Failed to load function "${routeName}" from ${fnPath}:`,
         err
       );
     }
@@ -136,56 +139,29 @@ async function internalLoadApiFunctions(viteServer) {
   if (extractedGraphqlOptions) {
     const { yoga } = await (0, import_graphql_server.createGraphQLYoga)(extractedGraphqlOptions);
     graphqlYoga = yoga;
+  } else {
+    graphqlYoga = null;
   }
   console.log(
     import_ansis.default.dim.italic("...Done importing in " + (Date.now() - tsImport) + " ms")
   );
 }
-function createFetchRequestFromFastify(req) {
-  const requestBody = req.method === "GET" || req.method === "HEAD" ? void 0 : typeof req.body === "string" ? req.body : req.body ? JSON.stringify(req.body) : void 0;
-  const href = `${req.protocol}://${req.host}${req.raw.url ?? "/"}`;
-  return new Request(href, {
-    method: req.method,
-    headers: req.headers,
-    body: requestBody
-  });
-}
-async function startApiDevServer(port) {
+async function createApiViteServer() {
   const cedarPaths = (0, import_project_config.getPaths)();
   const cedarConfig = (0, import_project_config.getConfig)();
-  const apiPort = port || cedarConfig.api.port || 8911;
-  const apiHost = cedarConfig.api.host || "::";
   const isEsm = (0, import_project_config.projectSideIsEsm)("api");
   const normalizedBase = (0, import_vite.normalizePath)(cedarPaths.base);
-  const normalizedApiSrc = (0, import_vite.normalizePath)(cedarPaths.api.src);
-  const normalizedApiBase = (0, import_vite.normalizePath)(cedarPaths.api.base);
-  const viteServer = await createViteDevServer(
-    cedarPaths,
-    cedarConfig,
-    isEsm,
-    normalizedBase
-  );
-  console.log(import_ansis.default.dim.italic("Starting API dev server..."));
-  await loadApiFunctions(viteServer);
-  setupHmrHandlers(viteServer, normalizedApiSrc, normalizedApiBase);
-  const app = await createFastifyApp(apiPort, apiHost);
-  const close = async () => {
-    await app.close();
-    await viteServer.close();
-  };
-  return { viteServer, close };
-}
-async function createViteDevServer(cedarPaths, cedarConfig, projectIsEsm, normalizedBase) {
   const babelPlugins = (0, import_babel_config.getApiSideBabelPlugins)({
     openTelemetry: (cedarConfig.experimental?.opentelemetry?.enabled ?? false) && (cedarConfig.experimental?.opentelemetry?.wrapApi ?? false),
-    projectIsEsm
+    projectIsEsm: isEsm
   });
   const workspacePkgSourceMap = Object.fromEntries(
     Object.entries((0, import_workspacePackageAliases.getWorkspacePackageAliases)(cedarPaths, cedarConfig)).map(
       ([name, sourceFile]) => [name, (0, import_vite.normalizePath)(sourceFile)]
     )
   );
-  const viteServer = await (0, import_vite.createServer)({
+  const { createServer: createViteServer } = await import("vite");
+  return createViteServer({
     configFile: false,
     root: cedarPaths.api.base,
     appType: "custom",
@@ -195,10 +171,6 @@ async function createViteDevServer(cedarPaths, cedarConfig, projectIsEsm, normal
       middlewareMode: true
     },
     resolve: {
-      // Map workspace package names directly to their TypeScript source entry
-      // files. This is processed by Vite's built-in alias plugin (enforce:
-      // 'pre') which runs before vite:resolve and correctly intercepts imports
-      // in the SSR module runner context.
       alias: workspacePkgSourceMap
     },
     plugins: [
@@ -233,7 +205,6 @@ async function createViteDevServer(cedarPaths, cedarConfig, projectIsEsm, normal
       }
     ]
   });
-  return viteServer;
 }
 function invalidateApiModules(viteServer, normalizedApiSrc) {
   const invalidated = /* @__PURE__ */ new Set();
@@ -253,7 +224,10 @@ function invalidateApiModules(viteServer, normalizedApiSrc) {
     }
   }
 }
-function setupHmrHandlers(viteServer, normalizedApiSrc, normalizedApiBase) {
+function setupHmrHandlers(viteServer) {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const normalizedApiSrc = (0, import_vite.normalizePath)(cedarPaths.api.src);
+  const normalizedApiBase = (0, import_vite.normalizePath)(cedarPaths.api.base);
   viteServer.watcher.on("change", async (filePath) => {
     const normalizedFilePath = (0, import_vite.normalizePath)(filePath);
     if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
@@ -306,61 +280,79 @@ function setupHmrHandlers(viteServer, normalizedApiSrc, normalizedApiBase) {
     await loadApiFunctions(viteServer);
   });
 }
-async function createFastifyApp(apiPort, apiHost) {
-  const logLevel = process.env.NODE_ENV === "development" ? "debug" : "info";
-  const app = (0, import_fastify.default)({ logger: { level: logLevel } });
-  await app.register(import_fastify_raw_body.default);
-  app.register(import_url_data.default);
-  app.addContentTypeParser(
-    ["application/x-www-form-urlencoded", "multipart/form-data"],
-    { parseAs: "string" },
-    app.defaultTextParser
-  );
-  const lambdaRequestHandler = async (req, reply) => {
-    const { routeName } = req.params;
+function createApiFetchHandler() {
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const apiUrlPrefix = cedarConfig.web.apiUrl.replace(/\/$/, "");
+  return async (request) => {
+    const url = new URL(request.url);
+    let pathname = url.pathname;
+    if (pathname.startsWith(apiUrlPrefix + "/")) {
+      pathname = pathname.slice(apiUrlPrefix.length);
+    } else if (pathname === apiUrlPrefix) {
+      pathname = "/";
+    }
+    if (pathname === "/graphql" || pathname.startsWith("/graphql/")) {
+      if (!graphqlYoga) {
+        return new Response(
+          JSON.stringify({ error: "GraphQL Yoga instance not initialized" }),
+          { status: 503, headers: { "Content-Type": "application/json" } }
+        );
+      }
+      const yoga = graphqlYoga;
+      return (0, import_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), async () => {
+        return yoga.handle(request, { request });
+      });
+    }
+    const match = pathname.match(/^\/([^/]+)(?:\/.*)?$/);
+    if (!match) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const routeName = match[1];
     const handler = LAMBDA_FUNCTIONS[routeName];
     if (!handler) {
-      const errorMessage = `Function "${routeName}" was not found.`;
-      req.log.error(errorMessage);
-      reply.status(404);
-      reply.send({
-        error: errorMessage,
-        availableFunctions: Object.keys(LAMBDA_FUNCTIONS)
+      return new Response(
+        JSON.stringify({
+          error: `Function "${routeName}" was not found.`,
+          availableFunctions: Object.keys(LAMBDA_FUNCTIONS)
+        }),
+        { status: 404, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    try {
+      const ctx = await (0, import_runtime.buildCedarContext)(request, {
+        params: { routeName }
       });
-      return;
+      return await handler(request, ctx);
+    } catch (err) {
+      console.error(
+        `[apiDevMiddleware] Error handling function "${routeName}":`,
+        err
+      );
+      return new Response(
+        JSON.stringify({
+          error: err instanceof Error ? err.message : "Internal Server Error"
+        }),
+        { status: 500, headers: { "Content-Type": "application/json" } }
+      );
     }
-    return (0, import_requestHandlers.requestHandler)(req, reply, handler);
   };
-  const graphqlHandler = async (req, reply) => {
-    if (!graphqlYoga) {
-      return reply.status(503).send({ error: "GraphQL Yoga instance not initialized" });
-    }
-    const request = createFetchRequestFromFastify(req);
-    const yoga = graphqlYoga;
-    const response = await (0, import_store.getAsyncStoreInstance)().run(/* @__PURE__ */ new Map(), async () => {
-      return yoga.handle(request, { req, reply });
-    });
-    return response;
+}
+async function startApiDevMiddleware() {
+  const viteServer = await createApiViteServer();
+  console.log(import_ansis.default.dim.italic("Starting API dev server..."));
+  await loadApiFunctions(viteServer);
+  setupHmrHandlers(viteServer);
+  const close = async () => {
+    await viteServer.close();
   };
-  app.all("/graphql", graphqlHandler);
-  app.all("/graphql/*", graphqlHandler);
-  app.all("/:routeName", lambdaRequestHandler);
-  app.all("/:routeName/*", lambdaRequestHandler);
-  app.addHook("onListen", (done) => {
-    const addr = app.server.address();
-    const listenPort = addr && typeof addr === "object" ? addr.port : apiPort;
-    console.log(
-      `API dev server listening at ${import_ansis.default.magenta(`http://localhost:${listenPort}/`)}`
-    );
-    console.log(
-      `GraphQL endpoint at ${import_ansis.default.magenta(`http://localhost:${listenPort}/graphql`)}`
-    );
-    done();
-  });
-  await app.listen({ port: apiPort, host: apiHost });
-  return app;
+  const handler = createApiFetchHandler();
+  return { viteServer, close, handler };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  startApiDevServer
+  createApiFetchHandler,
+  createApiViteServer,
+  loadApiFunctions,
+  setupHmrHandlers,
+  startApiDevMiddleware
 });

package/dist/cjs/build/build.js

@@ -28,10 +28,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var build_exports = {};
 __export(build_exports, {
+  buildCedarApp: () => import_buildApp.buildCedarApp,
   buildWeb: () => buildWeb
 });
 module.exports = __toCommonJS(build_exports);
 var import_project_config = require("@cedarjs/project-config");
+var import_buildApp = require("../buildApp.js");
 const buildWeb = async ({ verbose }) => {
   const { build } = await import("vite");
   const viteConfig = (0, import_project_config.getPaths)().web.viteConfig;
@@ -51,5 +53,6 @@ const buildWeb = async ({ verbose }) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildCedarApp,
   buildWeb
 });

package/dist/cjs/buildApp.js

@@ -0,0 +1,181 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildApp_exports = {};
+__export(buildApp_exports, {
+  buildCedarApp: () => buildCedarApp
+});
+module.exports = __toCommonJS(buildApp_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_vite = require("vite");
+var import_babel_config = require("@cedarjs/babel-config");
+var import_files = require("@cedarjs/internal/dist/files.js");
+var import_project_config = require("@cedarjs/project-config");
+var import_workspacePackageAliases = require("./lib/workspacePackageAliases.js");
+function resolveWithExtensions(id) {
+  if (import_node_fs.default.existsSync(id)) {
+    return id;
+  }
+  for (const ext of [".js", ".ts", ".jsx", ".tsx", ".mjs", ".mts"]) {
+    const withExt = id + ext;
+    if (import_node_fs.default.existsSync(withExt)) {
+      return withExt;
+    }
+  }
+  return id;
+}
+async function buildCedarApp({
+  verbose = false,
+  workspace = ["api", "web"]
+} = {}) {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const environments = {};
+  if (workspace.includes("web")) {
+    environments.client = {
+      build: {
+        outDir: cedarPaths.web.dist
+      }
+    };
+  }
+  if (workspace.includes("api")) {
+    const isEsm = (0, import_project_config.projectSideIsEsm)("api");
+    const format = isEsm ? "es" : "cjs";
+    const apiFiles = (0, import_files.findApiFiles)();
+    const input = {};
+    for (const f of apiFiles) {
+      const key = import_node_path.default.relative(cedarPaths.api.src, f).replace(/\.(ts|tsx|mts|js|jsx|mjs)$/, "");
+      input[key] = f;
+    }
+    environments.api = {
+      build: {
+        ssr: true,
+        sourcemap: true,
+        outDir: cedarPaths.api.dist,
+        emptyOutDir: true,
+        rollupOptions: {
+          input,
+          output: {
+            format,
+            preserveModules: true,
+            preserveModulesRoot: cedarPaths.api.src,
+            entryFileNames: "[name].js"
+          },
+          external: (id) => {
+            if (id.startsWith("node:")) {
+              return true;
+            }
+            if (!id.startsWith(".") && !import_node_path.default.isAbsolute(id)) {
+              return true;
+            }
+            return false;
+          }
+        }
+      }
+    };
+  }
+  const babelPlugins = workspace.includes("api") ? (0, import_babel_config.getApiSideBabelPlugins)({
+    openTelemetry: (cedarConfig.experimental?.opentelemetry?.enabled ?? false) && (cedarConfig.experimental?.opentelemetry?.wrapApi ?? false),
+    projectIsEsm: (0, import_project_config.projectSideIsEsm)("api")
+  }) : null;
+  const workspacePkgSourceMap = workspace.includes("api") ? Object.fromEntries(
+    Object.entries((0, import_workspacePackageAliases.getWorkspacePackageAliases)(cedarPaths, cedarConfig)).map(
+      ([name, sourceFile]) => [name, (0, import_vite.normalizePath)(sourceFile)]
+    )
+  ) : {};
+  const plugins = [
+    {
+      name: "cedar-build-app-cleanup",
+      configResolved(config) {
+        if (!workspace.includes("web") && config.environments.client) {
+          delete config.environments.client;
+        }
+        if (!environments.ssr && config.environments.ssr) {
+          delete config.environments.ssr;
+        }
+      }
+    }
+  ];
+  if (workspace.includes("api")) {
+    plugins.push({
+      name: "cedar-api-src-redirect",
+      enforce: "pre",
+      resolveId(id, importer) {
+        if (!importer?.startsWith(cedarPaths.api.src)) {
+          return null;
+        }
+        if (id.startsWith("src/")) {
+          return resolveWithExtensions(
+            import_node_path.default.join(cedarPaths.api.src, id.slice(4))
+          );
+        }
+        return null;
+      }
+    });
+    if (babelPlugins) {
+      plugins.push({
+        name: "cedar-vite-api-babel-transform",
+        async transform(_code, id) {
+          if (!/\.(js|ts|tsx|jsx)$/.test(id)) {
+            return null;
+          }
+          if (id.includes("node_modules")) {
+            return null;
+          }
+          if (!(0, import_vite.normalizePath)(id).startsWith((0, import_vite.normalizePath)(cedarPaths.api.base))) {
+            return null;
+          }
+          const transformedCode = await (0, import_babel_config.transformWithBabel)(id, babelPlugins);
+          if (transformedCode?.code) {
+            return {
+              code: transformedCode.code,
+              map: transformedCode.map ?? null
+            };
+          }
+          return null;
+        }
+      });
+    }
+  }
+  const builder = await (0, import_vite.createBuilder)({
+    configFile: cedarPaths.web.viteConfig,
+    envFile: false,
+    logLevel: verbose ? "info" : "warn",
+    environments,
+    resolve: {
+      alias: workspacePkgSourceMap
+    },
+    plugins
+  });
+  return builder.buildApp();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCedarApp
+});

package/dist/cjs/buildUDApiServer.js

@@ -39,23 +39,19 @@ const buildUDApiServer = async ({
 } = {}) => {
   const { build } = await import("vite");
   const { cedarUniversalDeployPlugin } = await import("./plugins/vite-plugin-cedar-universal-deploy.js");
-  const { node } = await import("@universal-deploy/node/vite");
+  const { default: universalDeploy } = await import("@universal-deploy/vite");
   const rwPaths = (0, import_project_config.getPaths)();
   const outDir = import_node_path.default.join(rwPaths.api.dist, "ud");
   await build({
-    // No configFile — we configure everything inline so this build is
-    // self-contained and does not require a vite.config.ts in api/.
-    configFile: false,
-    envFile: false,
     logLevel: verbose ? "info" : "warn",
     plugins: [
-      // Registers virtual:cedar-api with @universal-deploy/store and resolves
-      // virtual:ud:catch-all → virtual:cedar-api → Cedar's aggregate fetchable.
+      // Registers per-route API entries with @universal-deploy/store.
       cedarUniversalDeployPlugin({ apiRootPath }),
-      // Emits a self-contained Node server entry (api/dist/ud/index.js) that
-      // imports virtual:ud:catch-all and starts an srvx HTTP server.
-      // This is a Vite server-build concern, not Cedar HTML SSR.
-      ...node()
+      // Includes catchAll(), devServer(), and auto-detection of
+      // deployment targets. Enables @universal-deploy/node by default
+      // when no other target (Netlify, Vercel, Cloudflare) is detected
+      // in the user's Vite config.
+      universalDeploy()
     ],
     // The ssr environment is the Vite mechanism for server-side builds.
     // Reminder: "ssr" here means "server-side module execution", NOT
@@ -63,21 +59,7 @@ const buildUDApiServer = async ({
     environments: {
       ssr: {
         build: {
-          outDir,
-          // Ensure @universal-deploy/node is bundled into the output so the
-          // emitted entry is self-contained.
-          rollupOptions: {
-            output: {
-              // Produce a single-file entry where possible; srvx chunks are
-              // split by the node() plugin automatically.
-              entryFileNames: "[name].js"
-            }
-          }
-        },
-        resolve: {
-          // Do not externalise @universal-deploy/node — the node() plugin
-          // requires it to be bundled into the server entry.
-          noExternal: ["@universal-deploy/node"]
+          outDir
         }
       }
     },