@cedarjs/vite 4.0.0-canary.13862 → 4.0.0-canary.13864

package/dist/apiDevServer.d.ts

@@ -0,0 +1,18 @@
+import type { ViteDevServer } from 'vite';
+/**
+ * Start the Cedar API dev server using Vite's SSR module runner for HMR.
+ *
+ * This replaces the previous system of:
+ *   nodemon → api-server-watch (chokidar + esbuild + forked child process)
+ *
+ * With:
+ *   Vite SSR dev server (module graph + HMR) + Fastify (same process)
+ *
+ * When API source files change, Vite invalidates the affected modules and
+ * re-loads them on the next call – no process restart needed.
+ */
+export declare function startApiDevServer(port: number): Promise<{
+    viteServer: ViteDevServer;
+    close: () => Promise<void>;
+}>;
+//# sourceMappingURL=apiDevServer.d.ts.map

package/dist/apiDevServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiDevServer.d.ts","sourceRoot":"","sources":["../src/apiDevServer.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAc,aAAa,EAAE,MAAM,MAAM,CAAA;AAsLrD;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7D,UAAU,EAAE,aAAa,CAAA;IACzB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B,CAAC,CAiCD"}

package/dist/apiDevServer.js

@@ -0,0 +1,335 @@
+import { glob } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import fastifyUrlData from "@fastify/url-data";
+import ansis from "ansis";
+import fastify from "fastify";
+import fastifyRawBody from "fastify-raw-body";
+import { createServer as createViteServer, normalizePath } from "vite";
+import { requestHandler } from "@cedarjs/api-server/requestHandlers";
+import {
+  getApiSideBabelPlugins,
+  transformWithBabel
+} from "@cedarjs/babel-config";
+import { getAsyncStoreInstance } from "@cedarjs/context/dist/store";
+import { createGraphQLYoga } from "@cedarjs/graphql-server";
+import { getConfig, getPaths, projectSideIsEsm } from "@cedarjs/project-config";
+import { getWorkspacePackageAliases } from "./lib/workspacePackageAliases.js";
+const LAMBDA_FUNCTIONS = {};
+let graphqlYoga = null;
+let loadApiFunctionsInFlight = null;
+let needsReloadAfterInFlight = false;
+async function loadApiFunctions(viteServer) {
+  if (loadApiFunctionsInFlight) {
+    needsReloadAfterInFlight = true;
+    return;
+  }
+  do {
+    needsReloadAfterInFlight = false;
+    loadApiFunctionsInFlight = internalLoadApiFunctions(viteServer);
+    try {
+      await loadApiFunctionsInFlight;
+    } finally {
+      loadApiFunctionsInFlight = null;
+    }
+  } while (needsReloadAfterInFlight);
+}
+async function internalLoadApiFunctions(viteServer) {
+  const cedarPaths = getPaths();
+  for (const key of Object.keys(LAMBDA_FUNCTIONS)) {
+    delete LAMBDA_FUNCTIONS[key];
+  }
+  let srcFunctions = [];
+  try {
+    srcFunctions = await Array.fromAsync(
+      glob("**/*.{ts,tsx,js,jsx}", {
+        cwd: cedarPaths.api.functions,
+        exclude: [
+          "**/*.test.{ts,tsx,js,jsx}",
+          "**/*.scenarios.{ts,tsx,js,jsx}",
+          "**/*.fixtures.{ts,tsx,js,jsx}",
+          "**/*.d.ts"
+        ]
+      }),
+      (entry) => path.join(cedarPaths.api.functions, entry)
+    );
+  } catch {
+    srcFunctions = [];
+  }
+  const graphqlFunctionIndex = srcFunctions.findIndex(
+    (f) => path.basename(f).startsWith("graphql.")
+  );
+  if (graphqlFunctionIndex > 0) {
+    const [graphqlFn] = srcFunctions.splice(graphqlFunctionIndex, 1);
+    srcFunctions.unshift(graphqlFn);
+  }
+  console.log(ansis.dim.italic("Importing Server Functions... "));
+  const tsImport = Date.now();
+  let extractedGraphqlOptions = null;
+  const imports = srcFunctions.map(async (fnPath) => {
+    const ts = Date.now();
+    const routeName = path.basename(fnPath).replace(/\.(ts|tsx|js|jsx)$/, "");
+    try {
+      const mod = await viteServer.ssrLoadModule(pathToFileURL(fnPath).href);
+      const handler = (() => {
+        if ("handler" in mod) {
+          return mod.handler;
+        }
+        if ("default" in mod && mod.default && "handler" in mod.default) {
+          return mod.default.handler;
+        }
+        return void 0;
+      })();
+      if (handler) {
+        LAMBDA_FUNCTIONS[routeName] = handler;
+        console.log(
+          ansis.magenta("/" + routeName),
+          ansis.dim.italic(Date.now() - ts + " ms")
+        );
+      } else {
+        console.warn(
+          `[apiDevServer] No handler export found in function: ${fnPath}`
+        );
+      }
+      if (routeName === "graphql" && "__rw_graphqlOptions" in mod) {
+        extractedGraphqlOptions = mod.__rw_graphqlOptions;
+      }
+    } catch (err) {
+      viteServer.ssrFixStacktrace(err);
+      console.error(
+        `[apiDevServer] Failed to load function "${routeName}" from ${fnPath}:`,
+        err
+      );
+    }
+  });
+  await Promise.all(imports);
+  if (extractedGraphqlOptions) {
+    const { yoga } = await createGraphQLYoga(extractedGraphqlOptions);
+    graphqlYoga = yoga;
+  }
+  console.log(
+    ansis.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) {
+  const cedarPaths = getPaths();
+  const cedarConfig = getConfig();
+  const apiPort = port || cedarConfig.api.port || 8911;
+  const apiHost = cedarConfig.api.host || "::";
+  const isEsm = projectSideIsEsm("api");
+  const normalizedBase = normalizePath(cedarPaths.base);
+  const normalizedApiSrc = normalizePath(cedarPaths.api.src);
+  const normalizedApiBase = normalizePath(cedarPaths.api.base);
+  const viteServer = await createViteDevServer(
+    cedarPaths,
+    cedarConfig,
+    isEsm,
+    normalizedBase
+  );
+  console.log(ansis.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 = getApiSideBabelPlugins({
+    openTelemetry: (cedarConfig.experimental?.opentelemetry?.enabled ?? false) && (cedarConfig.experimental?.opentelemetry?.wrapApi ?? false),
+    projectIsEsm
+  });
+  const workspacePkgSourceMap = Object.fromEntries(
+    Object.entries(getWorkspacePackageAliases(cedarPaths, cedarConfig)).map(
+      ([name, sourceFile]) => [name, normalizePath(sourceFile)]
+    )
+  );
+  const viteServer = await createViteServer({
+    configFile: false,
+    root: cedarPaths.api.base,
+    appType: "custom",
+    clearScreen: false,
+    logLevel: "warn",
+    server: {
+      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: [
+      {
+        name: "cedar-api-babel-transform",
+        async transform(_code, id) {
+          if (!/\.(ts|tsx|js|jsx)$/.test(id)) {
+            return null;
+          }
+          if (id.includes("node_modules")) {
+            return null;
+          }
+          if (!id.startsWith(normalizedBase)) {
+            return null;
+          }
+          try {
+            const result = await transformWithBabel(id, babelPlugins);
+            if (!result?.code) {
+              return null;
+            }
+            return {
+              code: result.code,
+              map: result.map ?? null
+            };
+          } catch (err) {
+            this.warn(
+              `[cedar-api-babel-transform] Failed to transform ${id}: ${String(err)}`
+            );
+            return null;
+          }
+        }
+      }
+    ]
+  });
+  return viteServer;
+}
+function invalidateApiModules(viteServer, normalizedApiSrc) {
+  const invalidated = /* @__PURE__ */ new Set();
+  const invalidateWithImporters = (mod) => {
+    if (!mod || invalidated.has(mod.id ?? mod.url)) {
+      return;
+    }
+    invalidated.add(mod.id ?? mod.url);
+    viteServer.moduleGraph.invalidateModule(mod);
+    for (const importer of mod.importers) {
+      invalidateWithImporters(importer);
+    }
+  };
+  for (const mod of viteServer.moduleGraph.idToModuleMap.values()) {
+    if (mod.id?.startsWith(normalizedApiSrc)) {
+      invalidateWithImporters(mod);
+    }
+  }
+}
+function setupHmrHandlers(viteServer, normalizedApiSrc, normalizedApiBase) {
+  viteServer.watcher.on("change", async (filePath) => {
+    const normalizedFilePath = normalizePath(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    const displayPath = path.relative(normalizedApiBase, normalizedFilePath);
+    console.log(ansis.dim(`[change] ${displayPath}`));
+    const fileUrl = pathToFileURL(normalizedFilePath).href;
+    const mod = viteServer.moduleGraph.getModuleById(normalizedFilePath) ?? viteServer.moduleGraph.getModuleById(fileUrl);
+    if (mod) {
+      const invalidated = /* @__PURE__ */ new Set();
+      const invalidateWithImporters = (m) => {
+        if (!m || invalidated.has(m.id ?? m.url)) {
+          return;
+        }
+        invalidated.add(m.id ?? m.url);
+        viteServer.moduleGraph.invalidateModule(m);
+        for (const importer of m.importers) {
+          invalidateWithImporters(importer);
+        }
+      };
+      invalidateWithImporters(mod);
+    }
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("add", async (filePath) => {
+    const normalizedFilePath = normalizePath(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      ansis.dim(
+        `[add] ${path.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("unlink", async (filePath) => {
+    const normalizedFilePath = normalizePath(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      ansis.dim(
+        `[unlink] ${path.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    await loadApiFunctions(viteServer);
+  });
+}
+async function createFastifyApp(apiPort, apiHost) {
+  const logLevel = process.env.NODE_ENV === "development" ? "debug" : "info";
+  const app = fastify({ logger: { level: logLevel } });
+  await app.register(fastifyRawBody);
+  app.register(fastifyUrlData);
+  app.addContentTypeParser(
+    ["application/x-www-form-urlencoded", "multipart/form-data"],
+    { parseAs: "string" },
+    app.defaultTextParser
+  );
+  const lambdaRequestHandler = async (req, reply) => {
+    const { routeName } = req.params;
+    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;
+    }
+    return 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 getAsyncStoreInstance().run(/* @__PURE__ */ new Map(), async () => {
+      return yoga.handle(request, { req, reply });
+    });
+    return response;
+  };
+  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 ${ansis.magenta(`http://localhost:${listenPort}/`)}`
+    );
+    console.log(
+      `GraphQL endpoint at ${ansis.magenta(`http://localhost:${listenPort}/graphql`)}`
+    );
+    done();
+  });
+  await app.listen({ port: apiPort, host: apiHost });
+  return app;
+}
+export {
+  startApiDevServer
+};

package/dist/cedar-unified-dev.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cedar-unified-dev.d.ts.map

package/dist/cedar-unified-dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cedar-unified-dev.d.ts","sourceRoot":"","sources":["../src/cedar-unified-dev.ts"],"names":[],"mappings":""}

package/dist/cedar-unified-dev.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { createServer } from "vite";
+import yargsParser from "yargs-parser";
+import { getPaths, getConfig } from "@cedarjs/project-config";
+import { startApiDevServer } from "./apiDevServer.js";
+const startUnifiedDevServer = async () => {
+  const rwPaths = getPaths();
+  const cedarConfig = getConfig();
+  const configFile = rwPaths.web.viteConfig;
+  if (!configFile) {
+    throw new Error("Could not locate your web/vite.config.{js,ts} file");
+  }
+  const {
+    force: forceOptimize,
+    debug,
+    port: portArg,
+    apiPort: apiPortArg,
+    _: _positional,
+    ...serverArgs
+  } = yargsParser(process.argv.slice(2), {
+    boolean: ["https", "open", "strictPort", "force", "cors", "debug"],
+    number: ["port", "apiPort"]
+  });
+  const webPort = portArg ?? cedarConfig.web.port ?? 8910;
+  const apiPort = apiPortArg ?? cedarConfig.api.port ?? 8911;
+  const { close: closeApi } = await startApiDevServer(apiPort);
+  const devServer = await createServer({
+    configFile,
+    // env file is handled by Cedar's plugins
+    envFile: false,
+    optimizeDeps: {
+      // This is the only value that isn't a server option
+      force: forceOptimize
+    },
+    server: {
+      port: webPort,
+      ...serverArgs
+    },
+    logLevel: debug ? "info" : void 0
+  });
+  await devServer.listen();
+  process.stdin.on("data", async (data) => {
+    const str = data.toString().trim().toLowerCase();
+    if (str === "rs" || str === "restart") {
+      await devServer.restart(true);
+    }
+  });
+  devServer.printUrls();
+  if (debug) {
+    console.log("~~~ Vite Server Config ~~~");
+    console.log(JSON.stringify(devServer.config, null, 2));
+    console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~");
+  }
+  const shutdown = async () => {
+    await devServer.close();
+    await closeApi();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+};
+startUnifiedDevServer().catch((err) => {
+  console.error("Failed to start unified dev server:", err);
+  process.exit(1);
+});

package/dist/cjs/apiDevServer.js

@@ -0,0 +1,366 @@
+"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 apiDevServer_exports = {};
+__export(apiDevServer_exports, {
+  startApiDevServer: () => startApiDevServer
+});
+module.exports = __toCommonJS(apiDevServer_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_babel_config = require("@cedarjs/babel-config");
+var import_store = require("@cedarjs/context/dist/store");
+var import_graphql_server = require("@cedarjs/graphql-server");
+var import_project_config = require("@cedarjs/project-config");
+var import_workspacePackageAliases = require("./lib/workspacePackageAliases.js");
+const LAMBDA_FUNCTIONS = {};
+let graphqlYoga = null;
+let loadApiFunctionsInFlight = null;
+let needsReloadAfterInFlight = false;
+async function loadApiFunctions(viteServer) {
+  if (loadApiFunctionsInFlight) {
+    needsReloadAfterInFlight = true;
+    return;
+  }
+  do {
+    needsReloadAfterInFlight = false;
+    loadApiFunctionsInFlight = internalLoadApiFunctions(viteServer);
+    try {
+      await loadApiFunctionsInFlight;
+    } finally {
+      loadApiFunctionsInFlight = null;
+    }
+  } while (needsReloadAfterInFlight);
+}
+async function internalLoadApiFunctions(viteServer) {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  for (const key of Object.keys(LAMBDA_FUNCTIONS)) {
+    delete LAMBDA_FUNCTIONS[key];
+  }
+  let srcFunctions = [];
+  try {
+    srcFunctions = await Array.fromAsync(
+      (0, import_promises.glob)("**/*.{ts,tsx,js,jsx}", {
+        cwd: cedarPaths.api.functions,
+        exclude: [
+          "**/*.test.{ts,tsx,js,jsx}",
+          "**/*.scenarios.{ts,tsx,js,jsx}",
+          "**/*.fixtures.{ts,tsx,js,jsx}",
+          "**/*.d.ts"
+        ]
+      }),
+      (entry) => import_node_path.default.join(cedarPaths.api.functions, entry)
+    );
+  } 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;
+  const imports = srcFunctions.map(async (fnPath) => {
+    const ts = Date.now();
+    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 = (() => {
+        if ("handler" in mod) {
+          return mod.handler;
+        }
+        if ("default" in mod && mod.default && "handler" in mod.default) {
+          return mod.default.handler;
+        }
+        return void 0;
+      })();
+      if (handler) {
+        LAMBDA_FUNCTIONS[routeName] = handler;
+        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}`
+        );
+      }
+      if (routeName === "graphql" && "__rw_graphqlOptions" in mod) {
+        extractedGraphqlOptions = mod.__rw_graphqlOptions;
+      }
+    } catch (err) {
+      viteServer.ssrFixStacktrace(err);
+      console.error(
+        `[apiDevServer] Failed to load function "${routeName}" from ${fnPath}:`,
+        err
+      );
+    }
+  });
+  await Promise.all(imports);
+  if (extractedGraphqlOptions) {
+    const { yoga } = await (0, import_graphql_server.createGraphQLYoga)(extractedGraphqlOptions);
+    graphqlYoga = yoga;
+  }
+  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) {
+  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
+  });
+  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)({
+    configFile: false,
+    root: cedarPaths.api.base,
+    appType: "custom",
+    clearScreen: false,
+    logLevel: "warn",
+    server: {
+      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: [
+      {
+        name: "cedar-api-babel-transform",
+        async transform(_code, id) {
+          if (!/\.(ts|tsx|js|jsx)$/.test(id)) {
+            return null;
+          }
+          if (id.includes("node_modules")) {
+            return null;
+          }
+          if (!id.startsWith(normalizedBase)) {
+            return null;
+          }
+          try {
+            const result = await (0, import_babel_config.transformWithBabel)(id, babelPlugins);
+            if (!result?.code) {
+              return null;
+            }
+            return {
+              code: result.code,
+              map: result.map ?? null
+            };
+          } catch (err) {
+            this.warn(
+              `[cedar-api-babel-transform] Failed to transform ${id}: ${String(err)}`
+            );
+            return null;
+          }
+        }
+      }
+    ]
+  });
+  return viteServer;
+}
+function invalidateApiModules(viteServer, normalizedApiSrc) {
+  const invalidated = /* @__PURE__ */ new Set();
+  const invalidateWithImporters = (mod) => {
+    if (!mod || invalidated.has(mod.id ?? mod.url)) {
+      return;
+    }
+    invalidated.add(mod.id ?? mod.url);
+    viteServer.moduleGraph.invalidateModule(mod);
+    for (const importer of mod.importers) {
+      invalidateWithImporters(importer);
+    }
+  };
+  for (const mod of viteServer.moduleGraph.idToModuleMap.values()) {
+    if (mod.id?.startsWith(normalizedApiSrc)) {
+      invalidateWithImporters(mod);
+    }
+  }
+}
+function setupHmrHandlers(viteServer, normalizedApiSrc, normalizedApiBase) {
+  viteServer.watcher.on("change", async (filePath) => {
+    const normalizedFilePath = (0, import_vite.normalizePath)(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    const displayPath = import_node_path.default.relative(normalizedApiBase, normalizedFilePath);
+    console.log(import_ansis.default.dim(`[change] ${displayPath}`));
+    const fileUrl = (0, import_node_url.pathToFileURL)(normalizedFilePath).href;
+    const mod = viteServer.moduleGraph.getModuleById(normalizedFilePath) ?? viteServer.moduleGraph.getModuleById(fileUrl);
+    if (mod) {
+      const invalidated = /* @__PURE__ */ new Set();
+      const invalidateWithImporters = (m) => {
+        if (!m || invalidated.has(m.id ?? m.url)) {
+          return;
+        }
+        invalidated.add(m.id ?? m.url);
+        viteServer.moduleGraph.invalidateModule(m);
+        for (const importer of m.importers) {
+          invalidateWithImporters(importer);
+        }
+      };
+      invalidateWithImporters(mod);
+    }
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("add", async (filePath) => {
+    const normalizedFilePath = (0, import_vite.normalizePath)(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      import_ansis.default.dim(
+        `[add] ${import_node_path.default.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    await loadApiFunctions(viteServer);
+  });
+  viteServer.watcher.on("unlink", async (filePath) => {
+    const normalizedFilePath = (0, import_vite.normalizePath)(filePath);
+    if (!normalizedFilePath.startsWith(normalizedApiSrc)) {
+      return;
+    }
+    console.log(
+      import_ansis.default.dim(
+        `[unlink] ${import_node_path.default.relative(normalizedApiBase, normalizedFilePath)}`
+      )
+    );
+    invalidateApiModules(viteServer, normalizedApiSrc);
+    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;
+    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;
+    }
+    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;
+  };
+  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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startApiDevServer
+});

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

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+"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 __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 import_vite = require("vite");
+var import_yargs_parser = __toESM(require("yargs-parser"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_apiDevServer = require("./apiDevServer.js");
+const startUnifiedDevServer = async () => {
+  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 {
+    force: forceOptimize,
+    debug,
+    port: portArg,
+    apiPort: apiPortArg,
+    _: _positional,
+    ...serverArgs
+  } = (0, import_yargs_parser.default)(process.argv.slice(2), {
+    boolean: ["https", "open", "strictPort", "force", "cors", "debug"],
+    number: ["port", "apiPort"]
+  });
+  const webPort = portArg ?? cedarConfig.web.port ?? 8910;
+  const apiPort = apiPortArg ?? cedarConfig.api.port ?? 8911;
+  const { close: closeApi } = await (0, import_apiDevServer.startApiDevServer)(apiPort);
+  const devServer = await (0, import_vite.createServer)({
+    configFile,
+    // env file is handled by Cedar's plugins
+    envFile: false,
+    optimizeDeps: {
+      // This is the only value that isn't a server option
+      force: forceOptimize
+    },
+    server: {
+      port: webPort,
+      ...serverArgs
+    },
+    logLevel: debug ? "info" : void 0
+  });
+  await devServer.listen();
+  process.stdin.on("data", async (data) => {
+    const str = data.toString().trim().toLowerCase();
+    if (str === "rs" || str === "restart") {
+      await devServer.restart(true);
+    }
+  });
+  devServer.printUrls();
+  if (debug) {
+    console.log("~~~ Vite Server Config ~~~");
+    console.log(JSON.stringify(devServer.config, null, 2));
+    console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~");
+  }
+  const shutdown = async () => {
+    await devServer.close();
+    await closeApi();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+};
+startUnifiedDevServer().catch((err) => {
+  console.error("Failed to start unified dev server:", err);
+  process.exit(1);
+});

package/dist/cjs/lib/getMergedConfig.js

@@ -34,8 +34,10 @@ module.exports = __toCommonJS(getMergedConfig_exports);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_vite = require("vite");
 var import_project_config = require("@cedarjs/project-config");
+var import_workspacePackageAliases = require("./workspacePackageAliases.js");
 function getMergedConfig(cedarConfig, cedarPaths) {
   return (userConfig, env) => {
+    const workspaceAliases = env.command === "serve" ? (0, import_workspacePackageAliases.getWorkspacePackageAliases)(cedarPaths, cedarConfig) : {};
     let apiHost = process.env.REDWOOD_API_HOST;
     apiHost ??= cedarConfig.api.host;
     apiHost ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "127.0.0.1";
@@ -49,6 +51,9 @@ function getMergedConfig(cedarConfig, cedarPaths) {
     }
     const defaultCedarViteConfig = {
       root: cedarPaths.web.src,
+      resolve: {
+        alias: workspaceAliases
+      },
       // @MARK: when we have these aliases, the warnings from the FE server go
       // away BUT, if you have imports like this:
       // ```

package/dist/cjs/lib/workspacePackageAliases.js

@@ -0,0 +1,113 @@
+"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 workspacePackageAliases_exports = {};
+__export(workspacePackageAliases_exports, {
+  getWorkspacePackageAliases: () => getWorkspacePackageAliases
+});
+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");
+function findSourceEntry(pkgDir, pkgJson) {
+  let distEntry = null;
+  if (typeof pkgJson.main === "string") {
+    distEntry = pkgJson.main;
+  } else if (pkgJson.exports) {
+    const root = pkgJson.exports["."];
+    if (typeof root === "string") {
+      distEntry = root;
+    } else if (root && typeof root === "object") {
+      const rootObj = root;
+      if (typeof rootObj["default"] === "string") {
+        distEntry = rootObj["default"];
+      }
+    }
+  }
+  if (!distEntry) {
+    return null;
+  }
+  const withoutLeadingDot = distEntry.replace(/^\.\//, "");
+  const withoutExt = withoutLeadingDot.replace(/\.(js|cjs|mjs)$/, "");
+  const srcBase = withoutExt.replace(/^dist\//, "src/");
+  for (const ext of [".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs"]) {
+    const candidate = import_node_path.default.join(pkgDir, srcBase + ext);
+    if (import_node_fs.default.existsSync(candidate)) {
+      return (0, import_vite.normalizePath)(candidate);
+    }
+  }
+  return null;
+}
+function getWorkspacePackageAliases(cedarPaths, cedarConfig) {
+  if (!cedarConfig.experimental?.packagesWorkspace?.enabled) {
+    return {};
+  }
+  if (!cedarPaths.packages || !import_node_fs.default.existsSync(cedarPaths.packages)) {
+    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"
+    );
+    if (nonApiWebWorkspaces.length === 0) {
+      return {};
+    }
+    const entries = import_node_fs.default.readdirSync(cedarPaths.packages, { withFileTypes: true });
+    const aliases = {};
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const pkgDir = import_node_path.default.join(cedarPaths.packages, entry.name);
+      const pkgJsonPath = import_node_path.default.join(pkgDir, "package.json");
+      if (!import_node_fs.default.existsSync(pkgJsonPath)) {
+        continue;
+      }
+      const pkgJson = JSON.parse(import_node_fs.default.readFileSync(pkgJsonPath, "utf-8"));
+      if (!pkgJson.name) {
+        continue;
+      }
+      const sourceEntry = findSourceEntry(pkgDir, pkgJson);
+      if (sourceEntry) {
+        aliases[pkgJson.name] = sourceEntry;
+      }
+    }
+    return aliases;
+  } catch {
+    return {};
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getWorkspacePackageAliases
+});

package/dist/lib/getMergedConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMergedConfig.d.ts","sourceRoot":"","sources":["../../src/lib/getMergedConfig.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAO5D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,IAC5D,YAAY,cAAc,EAAE,KAAK,SAAS,KAAG,cAAc,CA0GpE"}
+{"version":3,"file":"getMergedConfig.d.ts","sourceRoot":"","sources":["../../src/lib/getMergedConfig.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAE9D,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAS5D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,IAC5D,YAAY,cAAc,EAAE,KAAK,SAAS,KAAG,cAAc,CAqHpE"}

package/dist/lib/getMergedConfig.js

@@ -5,8 +5,10 @@ import {
   getEnvVarDefinitions,
   getPaths
 } from "@cedarjs/project-config";
+import { getWorkspacePackageAliases } from "./workspacePackageAliases.js";
 function getMergedConfig(cedarConfig, cedarPaths) {
   return (userConfig, env) => {
+    const workspaceAliases = env.command === "serve" ? getWorkspacePackageAliases(cedarPaths, cedarConfig) : {};
     let apiHost = process.env.REDWOOD_API_HOST;
     apiHost ??= cedarConfig.api.host;
     apiHost ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "127.0.0.1";
@@ -20,6 +22,9 @@ function getMergedConfig(cedarConfig, cedarPaths) {
     }
     const defaultCedarViteConfig = {
       root: cedarPaths.web.src,
+      resolve: {
+        alias: workspaceAliases
+      },
       // @MARK: when we have these aliases, the warnings from the FE server go
       // away BUT, if you have imports like this:
       // ```

package/dist/lib/workspacePackageAliases.d.ts

@@ -0,0 +1,18 @@
+import type { Config, Paths } from '@cedarjs/project-config';
+/**
+ * Mirrors the logic used in buildHandler.ts / buildPackagesTask.js:
+ * - Only runs when `experimental.packagesWorkspace.enabled` is true
+ * - Reads the root package.json workspaces array to find non-api/web entries
+ * - Enumerates the packages/ directory to get each package's name and
+ *   inferred TypeScript source entry
+ *
+ * Returns a map of package name → absolute source file path suitable for use
+ * as Vite `resolve.alias` entries. This allows the Vite dev server to resolve
+ * workspace package imports directly to their TypeScript source without
+ * requiring a prior build step (i.e. without needing `dist/` to exist).
+ *
+ * This is intentionally synchronous so it can be used in contexts such as
+ * `getMergedConfig` which are called synchronously by Vite.
+ */
+export declare function getWorkspacePackageAliases(cedarPaths: Paths, cedarConfig: Config): Record<string, string>;
+//# sourceMappingURL=workspacePackageAliases.d.ts.map

package/dist/lib/workspacePackageAliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspacePackageAliases.d.ts","sourceRoot":"","sources":["../../src/lib/workspacePackageAliases.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AA2D5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,KAAK,EACjB,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiExB"}

package/dist/lib/workspacePackageAliases.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import { normalizePath } from "vite";
+function findSourceEntry(pkgDir, pkgJson) {
+  let distEntry = null;
+  if (typeof pkgJson.main === "string") {
+    distEntry = pkgJson.main;
+  } else if (pkgJson.exports) {
+    const root = pkgJson.exports["."];
+    if (typeof root === "string") {
+      distEntry = root;
+    } else if (root && typeof root === "object") {
+      const rootObj = root;
+      if (typeof rootObj["default"] === "string") {
+        distEntry = rootObj["default"];
+      }
+    }
+  }
+  if (!distEntry) {
+    return null;
+  }
+  const withoutLeadingDot = distEntry.replace(/^\.\//, "");
+  const withoutExt = withoutLeadingDot.replace(/\.(js|cjs|mjs)$/, "");
+  const srcBase = withoutExt.replace(/^dist\//, "src/");
+  for (const ext of [".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs"]) {
+    const candidate = path.join(pkgDir, srcBase + ext);
+    if (fs.existsSync(candidate)) {
+      return normalizePath(candidate);
+    }
+  }
+  return null;
+}
+function getWorkspacePackageAliases(cedarPaths, cedarConfig) {
+  if (!cedarConfig.experimental?.packagesWorkspace?.enabled) {
+    return {};
+  }
+  if (!cedarPaths.packages || !fs.existsSync(cedarPaths.packages)) {
+    return {};
+  }
+  try {
+    const rootPkgPath = path.join(cedarPaths.base, "package.json");
+    const rootPkg = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
+    if (!Array.isArray(rootPkg.workspaces) || rootPkg.workspaces.length <= 2) {
+      return {};
+    }
+    const nonApiWebWorkspaces = rootPkg.workspaces.filter(
+      (w) => w !== "api" && w !== "web"
+    );
+    if (nonApiWebWorkspaces.length === 0) {
+      return {};
+    }
+    const entries = fs.readdirSync(cedarPaths.packages, { withFileTypes: true });
+    const aliases = {};
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const pkgDir = path.join(cedarPaths.packages, entry.name);
+      const pkgJsonPath = path.join(pkgDir, "package.json");
+      if (!fs.existsSync(pkgJsonPath)) {
+        continue;
+      }
+      const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+      if (!pkgJson.name) {
+        continue;
+      }
+      const sourceEntry = findSourceEntry(pkgDir, pkgJson);
+      if (sourceEntry) {
+        aliases[pkgJson.name] = sourceEntry;
+      }
+    }
+    return aliases;
+  } catch {
+    return {};
+  }
+}
+export {
+  getWorkspacePackageAliases
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/vite",
-  "version": "4.0.0-canary.13862+892b5320e6",
+  "version": "4.0.0-canary.13864+6143202249",
   "description": "Vite configuration package for CedarJS",
   "repository": {
     "type": "git",
@@ -25,6 +25,12 @@
       "types": "./dist/api/vite-plugin-cedar-vitest-api-preset.d.ts",
       "default": "./dist/api/vite-plugin-cedar-vitest-api-preset.js"
     },
+    "./apiDevServer": {
+      "import": {
+        "types": "./dist/apiDevServer.d.ts",
+        "default": "./dist/apiDevServer.js"
+      }
+    },
     "./client": {
       "require": "./dist/cjs/client.js",
       "import": "./dist/client.js"
@@ -42,12 +48,14 @@
   "bin": {
     "cedar-dev-fe": "./dist/devFeServer.js",
     "cedar-serve-fe": "./dist/runFeServer.js",
+    "cedar-unified-dev": "./dist/cedar-unified-dev.js",
     "cedar-vite-build": "./bins/cedar-vite-build.mjs",
     "cedar-vite-dev": "./bins/cedar-vite-dev.mjs",
     "vite": "./bins/vite.mjs"
   },
   "files": [
     "dist",
+    "bins",
     "inject"
   ],
   "scripts": {
@@ -64,25 +72,32 @@
     "@babel/generator": "7.29.1",
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
-    "@cedarjs/auth": "4.0.0-canary.13862",
-    "@cedarjs/babel-config": "4.0.0-canary.13862",
-    "@cedarjs/cookie-jar": "4.0.0-canary.13862",
-    "@cedarjs/internal": "4.0.0-canary.13862",
-    "@cedarjs/project-config": "4.0.0-canary.13862",
-    "@cedarjs/server-store": "4.0.0-canary.13862",
-    "@cedarjs/testing": "4.0.0-canary.13862",
-    "@cedarjs/web": "4.0.0-canary.13862",
+    "@cedarjs/api-server": "4.0.0-canary.13864",
+    "@cedarjs/auth": "4.0.0-canary.13864",
+    "@cedarjs/babel-config": "4.0.0-canary.13864",
+    "@cedarjs/context": "4.0.0-canary.13864",
+    "@cedarjs/cookie-jar": "4.0.0-canary.13864",
+    "@cedarjs/graphql-server": "4.0.0-canary.13864",
+    "@cedarjs/internal": "4.0.0-canary.13864",
+    "@cedarjs/project-config": "4.0.0-canary.13864",
+    "@cedarjs/server-store": "4.0.0-canary.13864",
+    "@cedarjs/testing": "4.0.0-canary.13864",
+    "@cedarjs/web": "4.0.0-canary.13864",
+    "@fastify/url-data": "6.0.3",
     "@swc/core": "1.15.30",
     "@vitejs/plugin-react": "4.7.0",
     "@whatwg-node/fetch": "0.10.13",
     "@whatwg-node/server": "0.10.18",
     "acorn-loose": "8.5.2",
+    "ansis": "4.2.0",
     "buffer": "6.0.3",
     "busboy": "^1.6.0",
     "cookie": "1.1.1",
     "dotenv-defaults": "5.0.2",
     "execa": "5.1.1",
     "express": "4.22.1",
+    "fastify": "5.8.5",
+    "fastify-raw-body": "5.0.0",
     "find-my-way": "8.2.2",
     "http-proxy-middleware": "3.0.5",
     "isbot": "5.1.39",
@@ -98,6 +113,7 @@
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.2",
     "@hyrious/esbuild-plugin-commonjs": "0.2.6",
+    "@types/aws-lambda": "8.10.161",
     "@types/busboy": "^1",
     "@types/express": "4",
     "@types/react": "^18.2.55",
@@ -118,5 +134,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "892b5320e602fc6013a521f2dbf1de5dbceb5014"
+  "gitHead": "614320224990c781870b0f412c3fd5a058de64e5"
 }