@cedarjs/vite 5.0.7-next.338 → 5.0.7

package/dist/cjs/lib/entries.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var entries_exports = {};
+__export(entries_exports, {
+  getEntries: () => getEntries,
+  getEntriesFromDist: () => getEntriesFromDist
+});
+module.exports = __toCommonJS(entries_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_dist = require("@cedarjs/structure/dist/index.js");
+var import_utils = require("../utils.js");
+function getEntries() {
+  const entries = {};
+  const routes = (0, import_dist.getProject)().getRouter().routes;
+  const pages = routes.map((route) => route.page);
+  for (const page of pages) {
+    entries[page.constName] = (0, import_project_config.ensurePosixPath)((0, import_project_config.importStatementPath)(page.path));
+  }
+  const serverEntry = (0, import_project_config.getPaths)().web.entryServer;
+  if (!serverEntry) {
+    throw new Error("Server Entry file not found");
+  }
+  entries["__cedarjs__ServerEntry"] = serverEntry;
+  entries["__cedarjs__Routes"] = (0, import_project_config.getPaths)().web.routes;
+  return entries;
+}
+async function getEntriesFromDist() {
+  const entriesDist = (0, import_project_config.getPaths)().web.distRscEntries;
+  const { serverEntries } = await import((0, import_utils.makeFilePath)(entriesDist));
+  return serverEntries;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEntries,
+  getEntriesFromDist
+});

package/dist/cjs/lib/getMergedConfig.js

@@ -0,0 +1,185 @@
+"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 getMergedConfig_exports = {};
+__export(getMergedConfig_exports, {
+  getMergedConfig: () => getMergedConfig
+});
+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";
+    const streamingSsrEnabled = cedarConfig.experimental.streamingSsr?.enabled;
+    const rscEnabled = cedarConfig.experimental.rsc?.enabled;
+    let apiPort;
+    if (process.env.REDWOOD_API_PORT) {
+      apiPort = parseInt(process.env.REDWOOD_API_PORT);
+    } else {
+      apiPort = cedarConfig.api.port;
+    }
+    const defaultCedarViteConfig = {
+      root: cedarPaths.web.base,
+      resolve: {
+        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:
+      // ```
+      // import RandomNumberServerCell from
+      //   'src/components/RandomNumberServerCell/RandomNumberServerCell'
+      // ```
+      // they start failing (can't have the double
+      // `/RandomNumberServerCell/RandomNumberServerCell` at the end)
+      //
+      // resolve: {
+      //   alias: [
+      //     {
+      //       find: 'src',
+      //       replacement: cedarPaths.web.src,
+      //     },
+      //   ],
+      // },
+      envPrefix: "REDWOOD_ENV_",
+      publicDir: import_node_path.default.join(cedarPaths.web.base, "public"),
+      define: (0, import_project_config.getEnvVarDefinitions)(),
+      css: {
+        // @NOTE config path is relative to where vite.config.js is if you use
+        // a relative path
+        postcss: cedarPaths.web.config
+      },
+      server: {
+        open: cedarConfig.browser.open,
+        port: cedarConfig.web.port,
+        host: true,
+        // Listen to all hosts
+        proxy: {
+          [cedarConfig.web.apiUrl]: {
+            target: `http://${apiHost}:${apiPort}`,
+            changeOrigin: false,
+            rewrite: (path2) => {
+              return path2.replace(cedarConfig.web.apiUrl, "");
+            }
+          }
+        }
+      },
+      build: {
+        // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+        minify: false,
+        // NOTE this gets overridden when build gets called anyway!
+        outDir: streamingSsrEnabled || rscEnabled ? cedarPaths.web.distBrowser : cedarPaths.web.dist,
+        emptyOutDir: true,
+        manifest: !env.isSsrBuild ? "client-build-manifest.json" : void 0,
+        // Note that sourcemap can be boolean or 'inline'
+        sourcemap: !env.isSsrBuild && cedarConfig.web.sourceMap,
+        rollupOptions: {
+          input: getRollupInput(userConfig, !!env.isSsrBuild)
+        }
+      },
+      // @MARK: do not set buildSsrCjsExternalHeuristics here
+      // because rsc builds want false, client and server build wants true
+      optimizeDeps: {
+        esbuildOptions: {
+          // @MARK this is because JS projects in Cedar don't have .jsx
+          // extensions
+          loader: {
+            ".js": "jsx"
+          },
+          // Node.js global to browser globalThis
+          // @MARK unsure why we need this, but required for DevFatalErrorPage
+          // at least
+          define: {
+            global: "globalThis"
+          }
+        }
+      },
+      ssr: {
+        // `@cedarjs/testing` is not externalized in order to support
+        // `import.meta.glob`, which we use in one of the files in the package
+        noExternal: env.mode === "test" ? ["@cedarjs/testing"] : []
+      },
+      test: {
+        globals: false,
+        environment: "jsdom"
+      }
+    };
+    return (0, import_vite.mergeConfig)(defaultCedarViteConfig, userConfig);
+  };
+}
+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");
+  }
+  const streamingEnabled = cedarConfig.experimental?.streamingSsr?.enabled;
+  const rscEnabled = cedarConfig.experimental?.rsc?.enabled;
+  if (streamingEnabled) {
+    if (ssr) {
+      if (!cedarPaths.web.entryServer) {
+        throw new Error("entryServer not defined");
+      }
+      if (rscEnabled) {
+        return {
+          Document: cedarPaths.web.document,
+          "entry.server": cedarPaths.web.entryServer
+        };
+      }
+      return {
+        // NOTE: We're building the server entry *without* the react-server
+        // condition when we include it here. This works when only SSR is
+        // enabled, but not when RSC + SSR are both enabled
+        // For RSC we have this configured in rscBuildForServer.ts to get a
+        // build with the proper resolution conditions set.
+        "entry.server": cedarPaths.web.entryServer,
+        // We need the document for React's fallback
+        Document: cedarPaths.web.document
+      };
+    }
+    return cedarPaths.web.entryClient;
+  }
+  return cedarPaths.web.html;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMergedConfig
+});

package/dist/cjs/lib/onWarn.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var onWarn_exports = {};
+__export(onWarn_exports, {
+  onWarn: () => onWarn
+});
+module.exports = __toCommonJS(onWarn_exports);
+function onWarn(warning, defaultHandler) {
+  const fileName = warning.loc?.file;
+  if (warning.code === "MODULE_LEVEL_DIRECTIVE" && /"use (client|server)"/.test(warning.message)) {
+    return;
+  } else if (warning.code === "SOURCEMAP_ERROR" && (fileName?.endsWith(".tsx") || fileName?.endsWith(".ts")) && warning.loc?.column === 0 && warning.loc?.line === 1) {
+    return;
+  }
+  defaultHandler(warning);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onWarn
+});

package/dist/cjs/lib/registerFwGlobalsAndShims.js

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registerFwGlobalsAndShims_exports = {};
+__export(registerFwGlobalsAndShims_exports, {
+  registerFwGlobalsAndShims: () => registerFwGlobalsAndShims
+});
+module.exports = __toCommonJS(registerFwGlobalsAndShims_exports);
+var import_node_module = require("node:module");
+var import_project_config = require("@cedarjs/project-config");
+const import_meta = {};
+const registerFwGlobalsAndShims = () => {
+  registerFwGlobals();
+  registerFwShims();
+};
+function registerFwGlobals() {
+  const rwConfig = (0, import_project_config.getConfig)();
+  const envVars = (0, import_project_config.getEnvVarDefinitions)();
+  globalThis.RWJS_ENV = {
+    ...envVars.RWJS_ENV,
+    RWJS_EXP_SSR_GRAPHQL_ENDPOINT: (() => {
+      const apiPath = rwConfig.web.apiGraphQLUrl ?? rwConfig.web.apiUrl + "/graphql";
+      if (/^[a-zA-Z][a-zA-Z\d+\-.]*?:/.test(apiPath)) {
+        return apiPath;
+      } else {
+        let webHost = process.env.REDWOOD_WEB_HOST;
+        webHost ??= rwConfig.web.host;
+        webHost ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "[::]";
+        let webPort;
+        if (process.env.REDWOOD_WEB_PORT) {
+          webPort = parseInt(process.env.REDWOOD_WEB_PORT);
+        } else {
+          webPort = rwConfig.web.port;
+        }
+        const proxiedApiUrl = swapLocalhostFor127(
+          "http://" + webHost + ":" + webPort + apiPath
+        );
+        if (process.env.NODE_ENV === "production" && !process.env.RWJS_EXP_SSR_GRAPHQL_ENDPOINT?.length) {
+          console.log("------------------ WARNING ! -------------------------");
+          console.warn();
+          console.warn();
+          console.warn(`You haven't configured your API absolute url.`);
+          console.warn(`Using ${proxiedApiUrl}`);
+          console.warn();
+          console.warn(
+            "You can override this for SSR by setting RWJS_EXP_SSR_GRAPHQL_ENDPOINT in your environment vars"
+          );
+          console.warn();
+          console.log("------------------ WARNING ! -------------------------");
+          return proxiedApiUrl;
+        }
+        return swapLocalhostFor127(
+          process.env.RWJS_EXP_SSR_GRAPHQL_ENDPOINT ?? proxiedApiUrl
+        );
+      }
+    })()
+  };
+  globalThis.RWJS_DEBUG_ENV = envVars.RWJS_DEBUG_ENV;
+}
+function registerFwShims() {
+  if (!(0, import_project_config.getConfig)().experimental?.rsc?.enabled) {
+    return;
+  }
+  globalThis.__rw_module_cache__ ||= /* @__PURE__ */ new Map();
+  globalThis.__webpack_chunk_load__ ||= async (id) => {
+    console.log("registerFwShims chunk load id", id);
+    return import(id).then((mod) => {
+      console.log("registerFwShims chunk load mod", mod);
+      if (mod.default && typeof mod.default === "object") {
+        return globalThis.__rw_module_cache__.set(id, mod.default);
+      }
+      return globalThis.__rw_module_cache__.set(id, mod);
+    });
+  };
+  globalThis.__webpack_require__ ||= (id) => {
+    console.log("registerFwShims require id", id);
+    return globalThis.__rw_module_cache__.get(id);
+  };
+  globalThis.__non_webpack_require__ ||= (0, import_node_module.createRequire)(import_meta.url);
+}
+function swapLocalhostFor127(hostString) {
+  return hostString.replace("localhost", "127.0.0.1");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerFwGlobalsAndShims
+});

package/dist/cjs/lib/workspacePackageAliases.js

@@ -0,0 +1,107 @@
+"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");
+var import_workspaces = require("@cedarjs/project-config/workspaces");
+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 nonApiWebWorkspaces = (0, import_workspaces.getNonApiWebWorkspaces)(cedarPaths.base);
+    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/cjs/middleware/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+module.exports = __toCommonJS(middleware_exports);
+__reExport(middleware_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types.js")
+});

package/dist/cjs/middleware/invokeMiddleware.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var invokeMiddleware_exports = {};
+__export(invokeMiddleware_exports, {
+  invoke: () => invoke
+});
+module.exports = __toCommonJS(invokeMiddleware_exports);
+var import_server_store = require("@cedarjs/server-store");
+var import_middleware = require("@cedarjs/web/dist/server/middleware");
+const invoke = async (req, middleware, options) => {
+  const mwReq = new import_middleware.MiddlewareRequest(req);
+  if (typeof middleware !== "function") {
+    (0, import_server_store.setServerAuthState)(mwReq.serverAuthState.get());
+    return [import_middleware.MiddlewareResponse.next(), mwReq.serverAuthState.get()];
+  }
+  let mwRes = import_middleware.MiddlewareResponse.next();
+  try {
+    const output = await middleware(mwReq, import_middleware.MiddlewareResponse.next(), options) || import_middleware.MiddlewareResponse.next();
+    mwRes = output;
+  } catch (e) {
+    if (e instanceof import_middleware.MiddlewareShortCircuit) {
+      return [e.mwResponse, mwReq.serverAuthState.get()];
+    }
+    console.error("Error executing middleware > \n");
+    console.error("~".repeat(80));
+    console.error(e);
+    console.error("~".repeat(80));
+  } finally {
+    (0, import_server_store.setServerAuthState)(mwReq.serverAuthState.get());
+  }
+  return [mwRes, mwReq.serverAuthState.get()];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  invoke
+});

package/dist/cjs/middleware/register.js

@@ -0,0 +1,105 @@
+"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 register_exports = {};
+__export(register_exports, {
+  addMiddlewareHandlers: () => addMiddlewareHandlers,
+  chain: () => chain,
+  createMiddlewareRouter: () => createMiddlewareRouter,
+  groupByRoutePatterns: () => groupByRoutePatterns
+});
+module.exports = __toCommonJS(register_exports);
+var import_find_my_way = __toESM(require("find-my-way"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_middleware = require("@cedarjs/web/middleware");
+var import_utils = require("../utils.js");
+const validateMw = (mw) => {
+  if (typeof mw === "function") {
+    return mw;
+  } else if (typeof mw === "object" && typeof mw.invoke === "function") {
+    return mw.invoke.bind(mw);
+  } else {
+    console.error("Received as middleware: ", mw);
+    throw new Error(
+      "Please check the return on registerMiddleware. Must be a Middleware function, Class or tuple of [Middleware, string]"
+    );
+  }
+};
+const groupByRoutePatterns = (mwRegList) => {
+  const grouped = {};
+  mwRegList.forEach((mwReg) => {
+    if (Array.isArray(mwReg)) {
+      const [mw, pattern = "*"] = mwReg;
+      const mwFunction = validateMw(mw);
+      if (!grouped[pattern]) {
+        grouped[pattern] = [];
+      }
+      grouped[pattern].push(mwFunction);
+    } else {
+      grouped["*"] = [...grouped["*"] || [], validateMw(mwReg)];
+    }
+  });
+  return grouped;
+};
+const chain = (mwList) => {
+  return async (req, res = import_middleware.MiddlewareResponse.next(), options) => {
+    let response = res;
+    for (const mw of mwList) {
+      const mwOutput = await mw(req, response, options);
+      if (mwOutput) {
+        response = mwOutput;
+      }
+    }
+    return response;
+  };
+};
+const addMiddlewareHandlers = (mwRegList = []) => {
+  const groupedMw = groupByRoutePatterns(mwRegList);
+  const mwRouter = (0, import_find_my_way.default)();
+  for (const pattern in groupedMw) {
+    const mwList = groupedMw[pattern];
+    const chainedMw = chain(mwList);
+    mwRouter.on(["GET", "POST"], pattern, chainedMw);
+  }
+  return mwRouter;
+};
+const createMiddlewareRouter = async (vite) => {
+  const entryServerImport = vite ? await (0, import_utils.ssrLoadEntryServer)(vite) : await import((0, import_utils.makeFilePath)((0, import_project_config.getBuiltServerEntryFile)()));
+  const { registerMiddleware } = entryServerImport;
+  if (!registerMiddleware) {
+    return (0, import_find_my_way.default)();
+  }
+  return addMiddlewareHandlers(await registerMiddleware());
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addMiddlewareHandlers,
+  chain,
+  createMiddlewareRouter,
+  groupByRoutePatterns
+});

package/dist/cjs/middleware/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);