@cedarjs/vite 4.2.1-next.0 → 4.2.1-next.258

package/dist/cjs/buildApp.js

@@ -33,7 +33,9 @@ __export(buildApp_exports, {
 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_store = require("@universal-deploy/store");
+var import_vite = require("@universal-deploy/vite");
+var import_vite2 = 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");
@@ -52,7 +54,8 @@ function resolveWithExtensions(id) {
 }
 async function buildCedarApp({
   verbose = false,
-  workspace = ["api", "web"]
+  workspace = ["api", "web"],
+  ud = false
 } = {}) {
   const cedarPaths = (0, import_project_config.getPaths)();
   const cedarConfig = (0, import_project_config.getConfig)();
@@ -85,13 +88,13 @@ async function buildCedarApp({
             format,
             preserveModules: true,
             preserveModulesRoot: cedarPaths.api.src,
-            entryFileNames: "[name].js"
+            entryFileNames: "[name].js",
+            exports: "named"
           },
           external: (id) => {
             if (id.startsWith("node:")) {
               return true;
-            }
-            if (!id.startsWith(".") && !import_node_path.default.isAbsolute(id)) {
+            } else if (!id.startsWith(".") && !import_node_path.default.isAbsolute(id)) {
               return true;
             }
             return false;
@@ -99,6 +102,31 @@ async function buildCedarApp({
         }
       }
     };
+    if (ud) {
+      environments["ssr"] = {
+        build: {
+          ssr: true,
+          outDir: import_node_path.default.join(cedarPaths.api.dist, "ud"),
+          emptyOutDir: true,
+          rollupOptions: {
+            input: import_store.catchAllEntry,
+            output: {
+              entryFileNames: "index.js"
+            },
+            external: (id) => {
+              if (id.startsWith("virtual:")) {
+                return false;
+              } else if (id.startsWith("node:")) {
+                return true;
+              } else 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),
@@ -106,10 +134,45 @@ async function buildCedarApp({
   }) : 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)]
+      ([name, sourceFile]) => [name, (0, import_vite2.normalizePath)(sourceFile)]
     )
   ) : {};
   const plugins = [
+    // Suppress noisy warnings from third-party dependencies across all
+    // environments by injecting onwarn into every environment's rollupOptions.
+    {
+      name: "cedar-suppress-third-party-warnings",
+      configResolved(config) {
+        function onwarn(warning, warn) {
+          if (warning.code === "EVAL" && warning.id?.includes("@prisma/internals")) {
+            return;
+          }
+          if (warning.code === "INVALID_ANNOTATION" && warning.id?.includes("graphql-scalars")) {
+            return;
+          }
+          warn(warning);
+        }
+        for (const env of Object.values(config.environments ?? {})) {
+          env.build.rollupOptions ??= {};
+          const existingOnwarn = env.build.rollupOptions.onwarn;
+          env.build.rollupOptions.onwarn = existingOnwarn ? (warning, warn) => {
+            onwarn(warning, (w) => existingOnwarn(w, warn));
+          } : onwarn;
+        }
+      }
+    },
+    // Resolve bare-specifier dynamic imports from node_modules as external
+    // before Rollup attempts resolution, avoiding UNRESOLVED_IMPORT warnings
+    // for optional peer dependencies (e.g. @simplewebauthn/server).
+    {
+      name: "cedar-optional-peer-deps",
+      resolveDynamicImport(specifier, importer) {
+        if (typeof specifier === "string" && !specifier.startsWith(".") && !specifier.startsWith("/") && importer?.includes("node_modules") && this.environment.config.consumer === "server") {
+          return { id: specifier, external: true };
+        }
+        return null;
+      }
+    },
     {
       name: "cedar-build-app-cleanup",
       configResolved(config) {
@@ -120,8 +183,58 @@ async function buildCedarApp({
           delete config.environments.ssr;
         }
       }
+    },
+    {
+      name: "cedar-build-app",
+      buildApp: {
+        order: "pre",
+        async handler(builder2) {
+          if (workspace.includes("web") && builder2.environments.client && !builder2.environments.client.isBuilt) {
+            await builder2.build(builder2.environments.client);
+          }
+          if (workspace.includes("api") && builder2.environments.api && !builder2.environments.api.isBuilt) {
+            await builder2.build(builder2.environments.api);
+          }
+          if (workspace.includes("api") && builder2.environments["ssr"] && !builder2.environments["ssr"].isBuilt) {
+            await builder2.build(builder2.environments["ssr"]);
+          }
+        }
+      }
     }
   ];
+  if (ud) {
+    plugins.push((0, import_vite.catchAll)());
+    plugins.push({
+      name: "cedar-ud-verify-routes",
+      configResolved() {
+        const entries = (0, import_store.getAllEntries)();
+        if (entries.length === 0) {
+          console.warn(
+            "\n",
+            " Warning: No Universal Deploy API routes were registered.\n",
+            " The built server entry will be an empty router (404 for all\n",
+            " requests). Check that you have API functions under\n",
+            " `api/src/functions/` and that your vite config includes\n",
+            " `cedarUniversalDeployPlugin()`.\n"
+          );
+        }
+      }
+    });
+    plugins.push({
+      name: "cedar-ud-write-package-json",
+      applyToEnvironment(env) {
+        return env.name === "ssr";
+      },
+      closeBundle() {
+        const dir = import_node_path.default.join(cedarPaths.api.dist, "ud");
+        import_node_fs.default.mkdirSync(dir, { recursive: true });
+        import_node_fs.default.writeFileSync(
+          import_node_path.default.join(dir, "package.json"),
+          JSON.stringify({ type: "module" }, null, 2)
+        );
+      }
+    });
+  }
   if (workspace.includes("api")) {
     plugins.push({
       name: "cedar-api-src-redirect",
@@ -141,17 +254,23 @@ async function buildCedarApp({
     if (babelPlugins) {
       plugins.push({
         name: "cedar-vite-api-babel-transform",
-        async transform(_code, id) {
+        enforce: "pre",
+        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))) {
+          if (!(0, import_vite2.normalizePath)(id).startsWith((0, import_vite2.normalizePath)(cedarPaths.api.base))) {
             return null;
           }
-          const transformedCode = await (0, import_babel_config.transformWithBabel)(id, babelPlugins);
+          const transformedCode = await (0, import_babel_config.transformWithBabel)(
+            code,
+            id,
+            babelPlugins,
+            true
+          );
           if (transformedCode?.code) {
             return {
               code: transformedCode.code,
@@ -163,7 +282,7 @@ async function buildCedarApp({
       });
     }
   }
-  const builder = await (0, import_vite.createBuilder)({
+  const builder = await (0, import_vite2.createBuilder)({
     configFile: cedarPaths.web.viteConfig,
     envFile: false,
     logLevel: verbose ? "info" : "warn",

package/dist/cjs/buildFeServer.js

@@ -37,7 +37,7 @@ const buildFeServer = async ({ verbose, webDir } = {}) => {
   const streamingSsrEnabled = rwConfig.experimental?.streamingSsr?.enabled;
   if (!viteConfigPath) {
     throw new Error(
-      "Vite config not found. You need to setup your project with Vite using `yarn cedar setup vite`"
+      "Vite config not found. Please set up Vite before building."
     );
   }
   if (!rwPaths.web.entryServer || !rwPaths.web.entryClient) {

package/dist/cjs/buildRouteHooks.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,12 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 buildRouteHooks_exports = {};
 __export(buildRouteHooks_exports, {
   buildRouteHooks: () => buildRouteHooks
 });
 module.exports = __toCommonJS(buildRouteHooks_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
 var import_esbuild = require("esbuild");
 var import_babel_config = require("@cedarjs/babel-config");
 var import_files = require("@cedarjs/internal/dist/files.js");
@@ -31,9 +42,12 @@ async function buildRouteHooks(verbose, rwPaths) {
     name: "rw-esbuild-babel-transform",
     setup(build) {
       build.onLoad({ filter: /\.(js|ts|tsx|jsx)$/ }, async (args) => {
-        const transformedCode = await (0, import_babel_config.transformWithBabel)(args.path, [
-          ...(0, import_babel_config.getRouteHookBabelPlugins)()
-        ]);
+        const fileContents = await import_node_fs.default.promises.readFile(args.path, "utf-8");
+        const transformedCode = await (0, import_babel_config.transformWithBabel)(
+          fileContents,
+          args.path,
+          [...(0, import_babel_config.getRouteHookBabelPlugins)()]
+        );
         if (transformedCode?.code) {
           return {
             contents: transformedCode.code,

package/dist/cjs/cedar-unified-dev.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -6,6 +5,10 @@ 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))
@@ -22,6 +25,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cedar_unified_dev_exports = {};
+__export(cedar_unified_dev_exports, {
+  openDebugger: () => openDebugger,
+  parseCliArgs: () => parseCliArgs,
+  startUnifiedDevServer: () => startUnifiedDevServer
+});
+module.exports = __toCommonJS(cedar_unified_dev_exports);
 var import_server = require("@whatwg-node/server");
 var import_vite = require("vite");
 var import_yargs_parser = __toESM(require("yargs-parser"), 1);
@@ -34,25 +45,180 @@ function isViteInternalRequest(url) {
 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 = (0, import_project_config.getPaths)();
-  const cedarConfig = (0, import_project_config.getConfig)();
-  const configFile = rwPaths.web.viteConfig;
-  if (!configFile) {
-    throw new Error("Could not locate your web/vite.config.{js,ts} file");
-  }
+function parseCliArgs(argv = process.argv) {
   const {
     force: forceOptimize,
     debug,
     port: portArg,
     apiPort: _apiPortArg,
+    "debug-port": debugPort,
+    "debug-brk": debugBrk,
     _: _positional,
     ...serverArgs
-  } = (0, import_yargs_parser.default)(process.argv.slice(2), {
-    boolean: ["https", "open", "strictPort", "force", "cors", "debug"],
-    number: ["port", "apiPort"]
+  } = (0, import_yargs_parser.default)(argv.slice(2), {
+    boolean: [
+      "https",
+      "open",
+      "strictPort",
+      "force",
+      "cors",
+      "debug",
+      "debug-brk"
+    ],
+    number: ["port", "apiPort", "debug-port"]
   });
+  return { forceOptimize, debug, portArg, debugPort, debugBrk, serverArgs };
+}
+async function clearPendingPause() {
+  const inspector = await import("node:inspector");
+  const s = new inspector.Session();
+  try {
+    s.connect();
+    await new Promise((resolve, reject) => {
+      s.post("Debugger.enable", (err) => err ? reject(err) : resolve());
+    });
+    await new Promise((resolve) => {
+      let done = false;
+      s.once("Debugger.paused", () => {
+        s.post("Debugger.resume", () => {
+          done = true;
+          resolve();
+        });
+      });
+      s.post("Runtime.evaluate", { expression: "1" }, () => {
+        if (!done) {
+          resolve();
+        }
+      });
+    });
+  } catch {
+  } finally {
+    s.disconnect();
+  }
+}
+async function openDebugger(port, waitForDebugger = false) {
+  const inspector = await import("node:inspector");
+  inspector.open(port, "127.0.0.1");
+  if (waitForDebugger) {
+    inspector.waitForDebugger();
+    const session = new inspector.Session();
+    session.connect();
+    await session.post("Debugger.enable");
+    let resumedResolve;
+    const resumedPromise = new Promise((resolve) => {
+      resumedResolve = resolve;
+    });
+    const onSessionDead = () => {
+      if (paused) {
+        tryResume();
+      } else {
+        clearPendingPause().then(
+          () => resumedResolve?.(),
+          () => resumedResolve?.()
+        );
+      }
+    };
+    session.once("error", onSessionDead);
+    session.once("Inspector.detached", onSessionDead);
+    let paused = false;
+    session.once("Debugger.paused", () => {
+      paused = true;
+      tryResume();
+    });
+    session.once("Debugger.resumed", () => {
+      resumedResolve?.();
+    });
+    const FIVE_MINUTES_MS = 5 * 60 * 1e3;
+    const timeout = setTimeout(() => {
+      if (paused) {
+        tryResume();
+      } else {
+        resumedResolve?.();
+      }
+    }, FIVE_MINUTES_MS);
+    let hasTriedResume = false;
+    const tryResume = () => {
+      if (hasTriedResume) {
+        return;
+      }
+      if (!paused) {
+        return;
+      }
+      hasTriedResume = true;
+      (async () => {
+        for (let attempt = 0; attempt < 3; attempt++) {
+          const s = attempt === 0 ? session : new inspector.Session();
+          if (attempt > 0) {
+            try {
+              s.connect();
+              await new Promise((resolve, reject) => {
+                s.post(
+                  "Debugger.enable",
+                  (err) => err ? reject(err) : resolve()
+                );
+              });
+            } catch {
+              continue;
+            }
+          }
+          const ok = await new Promise((resolve) => {
+            s.post("Debugger.resume", (err) => resolve(!err));
+          });
+          if (attempt > 0) {
+            s.disconnect();
+          }
+          if (ok) {
+            resumedResolve?.();
+            return;
+          }
+        }
+        console.warn(
+          "[cedar-unified-dev] Failed to clear debugger pause after external debugger disconnect.  API functions may pause on next execution."
+        );
+        resumedResolve?.();
+      })();
+    };
+    void new Promise((resolve, reject) => {
+      session.post("Debugger.pause", (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    }).catch(() => {
+      resumedResolve?.();
+    });
+    void new Promise((resolve, reject) => {
+      session.post("Runtime.evaluate", { expression: "1" }, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    }).catch(() => {
+      clearPendingPause().then(
+        () => resumedResolve?.(),
+        () => resumedResolve?.()
+      );
+    });
+    await resumedPromise;
+    clearTimeout(timeout);
+  }
+}
+async function startUnifiedDevServer() {
+  process.env.__CEDAR_UNIFIED_DEV = "true";
+  const rwPaths = (0, import_project_config.getPaths)();
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const configFile = rwPaths.web.viteConfig;
+  if (!configFile) {
+    throw new Error("Could not locate your web/vite.config.{js,ts} file");
+  }
+  const { forceOptimize, debug, portArg, debugPort, debugBrk, serverArgs } = parseCliArgs();
+  if (debugPort !== void 0) {
+    await openDebugger(debugPort, debugBrk);
+  }
   const webPort = portArg ?? cedarConfig.web.port ?? 8910;
   const { close: closeApi, handler: apiHandler } = await (0, import_apiDevMiddleware.startApiDevMiddleware)();
   const apiAdapter = (0, import_server.createServerAdapter)(apiHandler);
@@ -135,8 +301,10 @@ const startUnifiedDevServer = async () => {
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-};
-startUnifiedDevServer().catch((err) => {
-  console.error("Failed to start unified dev server:", err);
-  process.exit(1);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDebugger,
+  parseCliArgs,
+  startUnifiedDevServer
 });

package/dist/cjs/devFeServer.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -59,7 +60,7 @@ async function createServer() {
   }
   if (!rwPaths.web.viteConfig) {
     throw new Error(
-      "Vite config not found. You need to setup your project with Vite using `yarn cedar setup vite`"
+      "Vite config not found. Please set up Vite before running the dev server."
     );
   }
   const vite = await (0, import_vite.createServer)({

package/dist/cjs/index.js

@@ -37,6 +37,7 @@ __export(index_exports, {
   cedarImportDirPlugin: () => import_vite_plugin_cedar_import_dir.cedarImportDirPlugin,
   cedarMergedConfig: () => import_vite_plugin_merged_config2.cedarMergedConfig,
   cedarNodePolyfills: () => import_vite_plugin_cedar_node_polyfills2.cedarNodePolyfills,
+  cedarRemoveDevFatalErrorPage: () => import_vite_plugin_cedar_remove_dev_fatal_error_page2.cedarRemoveDevFatalErrorPage,
   cedarRemoveFromBundle: () => import_vite_plugin_cedar_remove_from_bundle2.cedarRemoveFromBundle,
   cedarSwapApolloProvider: () => import_vite_plugin_swap_apollo_provider2.cedarSwapApolloProvider,
   cedarTransformJsAsJsx: () => import_vite_plugin_jsx_loader2.cedarTransformJsAsJsx,
@@ -55,6 +56,7 @@ var import_vite_plugin_cedar_cell = require("./plugins/vite-plugin-cedar-cell.js
 var import_vite_plugin_cedar_entry_injection = require("./plugins/vite-plugin-cedar-entry-injection.js");
 var import_vite_plugin_cedar_html_env = require("./plugins/vite-plugin-cedar-html-env.js");
 var import_vite_plugin_cedar_node_polyfills = require("./plugins/vite-plugin-cedar-node-polyfills.js");
+var import_vite_plugin_cedar_remove_dev_fatal_error_page = require("./plugins/vite-plugin-cedar-remove-dev-fatal-error-page.js");
 var import_vite_plugin_cedar_remove_from_bundle = require("./plugins/vite-plugin-cedar-remove-from-bundle.js");
 var import_vite_plugin_cedar_wait_for_api_server = require("./plugins/vite-plugin-cedar-wait-for-api-server.js");
 var import_vite_plugin_cedarjs_resolve_cedar_style_imports = require("./plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js");
@@ -68,6 +70,7 @@ var import_vite_plugin_cedar_entry_injection2 = require("./plugins/vite-plugin-c
 var import_vite_plugin_cedar_html_env2 = require("./plugins/vite-plugin-cedar-html-env.js");
 var import_vite_plugin_cedar_import_dir = require("./plugins/vite-plugin-cedar-import-dir.js");
 var import_vite_plugin_cedar_node_polyfills2 = require("./plugins/vite-plugin-cedar-node-polyfills.js");
+var import_vite_plugin_cedar_remove_dev_fatal_error_page2 = require("./plugins/vite-plugin-cedar-remove-dev-fatal-error-page.js");
 var import_vite_plugin_cedar_remove_from_bundle2 = require("./plugins/vite-plugin-cedar-remove-from-bundle.js");
 var import_vite_plugin_cedarjs_resolve_cedar_style_imports2 = require("./plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js");
 var import_vite_plugin_cedarjs_job_path_injector = require("./plugins/vite-plugin-cedarjs-job-path-injector.js");
@@ -106,6 +109,7 @@ function cedar({ mode } = {}) {
     (0, import_vite_plugin_cedar_cell.cedarCellTransform)(),
     (0, import_vite_plugin_jsx_loader.cedarTransformJsAsJsx)(),
     (0, import_vite_plugin_cedar_remove_from_bundle.cedarRemoveFromBundle)(),
+    (0, import_vite_plugin_cedar_remove_dev_fatal_error_page.cedarRemoveDevFatalErrorPage)(),
     (0, import_plugin_react.default)({ babel: babelConfig })
   ];
 }
@@ -121,6 +125,7 @@ var index_default = cedar;
   cedarImportDirPlugin,
   cedarMergedConfig,
   cedarNodePolyfills,
+  cedarRemoveDevFatalErrorPage,
   cedarRemoveFromBundle,
   cedarSwapApolloProvider,
   cedarTransformJsAsJsx,

package/dist/cjs/lib/getMergedConfig.js

@@ -50,9 +50,14 @@ function getMergedConfig(cedarConfig, cedarPaths) {
       apiPort = cedarConfig.api.port;
     }
     const defaultCedarViteConfig = {
-      root: cedarPaths.web.src,
+      root: cedarPaths.web.base,
       resolve: {
-        alias: workspaceAliases
+        alias: {
+          ...workspaceAliases,
+          // In test mode, register the virtual module alias so that
+          // MockProviders can resolve the user's Routes file
+          ...env.mode === "test" ? { "~__CEDAR__USER_ROUTES_FOR_MOCK": cedarPaths.web.routes } : {}
+        }
       },
       // @MARK: when we have these aliases, the warnings from the FE server go
       // away BUT, if you have imports like this:
@@ -104,7 +109,7 @@ function getMergedConfig(cedarConfig, cedarPaths) {
         // Note that sourcemap can be boolean or 'inline'
         sourcemap: !env.isSsrBuild && cedarConfig.web.sourceMap,
         rollupOptions: {
-          input: getRollupInput(!!env.isSsrBuild)
+          input: getRollupInput(userConfig, !!env.isSsrBuild)
         }
       },
       // @MARK: do not set buildSsrCjsExternalHeuristics here
@@ -137,9 +142,12 @@ function getMergedConfig(cedarConfig, cedarPaths) {
     return (0, import_vite.mergeConfig)(defaultCedarViteConfig, userConfig);
   };
 }
-function getRollupInput(ssr) {
+function getRollupInput(userConfig, ssr) {
   const cedarConfig = (0, import_project_config.getConfig)();
   const cedarPaths = (0, import_project_config.getPaths)();
+  if (userConfig.build?.rollupOptions?.input) {
+    return userConfig.build.rollupOptions.input;
+  }
   if (!cedarPaths.web.entryClient) {
     throw new Error("entryClient not defined");
   }

package/dist/cjs/lib/workspacePackageAliases.js

@@ -34,6 +34,7 @@ module.exports = __toCommonJS(workspacePackageAliases_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_workspaces = require("@cedarjs/project-config/workspaces");
 function findSourceEntry(pkgDir, pkgJson) {
   let distEntry = null;
   if (typeof pkgJson.main === "string") {
@@ -71,14 +72,7 @@ function getWorkspacePackageAliases(cedarPaths, cedarConfig) {
     return {};
   }
   try {
-    const rootPkgPath = import_node_path.default.join(cedarPaths.base, "package.json");
-    const rootPkg = JSON.parse(import_node_fs.default.readFileSync(rootPkgPath, "utf-8"));
-    if (!Array.isArray(rootPkg.workspaces) || rootPkg.workspaces.length <= 2) {
-      return {};
-    }
-    const nonApiWebWorkspaces = rootPkg.workspaces.filter(
-      (w) => w !== "api" && w !== "web"
-    );
+    const nonApiWebWorkspaces = (0, import_workspaces.getNonApiWebWorkspaces)(cedarPaths.base);
     if (nonApiWebWorkspaces.length === 0) {
       return {};
     }

package/dist/cjs/plugins/vite-plugin-cedar-entry-injection.js

@@ -36,21 +36,36 @@ var import_node_path = __toESM(require("node:path"), 1);
 var import_vite = require("vite");
 var import_project_config = require("@cedarjs/project-config");
 function cedarEntryInjectionPlugin() {
-  const rwPaths = (0, import_project_config.getPaths)();
-  const clientEntryPath = rwPaths.web.entryClient;
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const clientEntryPath = cedarPaths.web.entryClient;
   if (!clientEntryPath) {
     throw new Error(
       "Vite client entry point not found. Please check that your project has an entry.client.{jsx,tsx} file in the web/src directory."
     );
   }
-  const relativeEntryPath = import_node_path.default.relative(rwPaths.web.src, clientEntryPath);
+  const relativeEntryPath = (0, import_vite.normalizePath)(
+    import_node_path.default.relative(cedarPaths.web.base, clientEntryPath)
+  );
   return {
     name: "cedar-entry-injection",
+    // Vite's dependency optimizer and dev server resolve the script tag
+    // src="/src/entry.client.{tsx,jsx}" as an absolute filesystem path
+    // (/src/entry.client.tsx) instead of relative to the Vite root.
+    // This hook maps it to the real file path so Vite can find it.
+    resolveId(id) {
+      if (id === "/" + relativeEntryPath) {
+        return clientEntryPath;
+      }
+      return null;
+    },
     // ---------- Bundle injection ----------
     // Used by Vite during dev, to inject the entrypoint.
     transformIndexHtml: {
       order: "pre",
-      handler: (html) => {
+      handler: (html, ctx) => {
+        if (!ctx.filename || (0, import_vite.normalizePath)(ctx.filename) !== (0, import_vite.normalizePath)(cedarPaths.web.html)) {
+          return html;
+        }
         if (import_node_fs.default.existsSync(clientEntryPath)) {
           return html.replace(
             "</head>",
@@ -67,7 +82,7 @@ function cedarEntryInjectionPlugin() {
     // Used by rollup during build to inject the entrypoint
     // but note index.html does not come through as an id during dev
     transform: (code, id) => {
-      if (import_node_fs.default.existsSync(clientEntryPath) && (0, import_vite.normalizePath)(id) === (0, import_vite.normalizePath)(rwPaths.web.html)) {
+      if (import_node_fs.default.existsSync(clientEntryPath) && (0, import_vite.normalizePath)(id) === (0, import_vite.normalizePath)(cedarPaths.web.html)) {
         return {
           code: code.replace(
             "</head>",