@cedarjs/vite 5.0.2-rc.5 → 6.0.0-canary.2619

package/dist/cjs/plugins/vite-plugin-cedar-gqlorm-inject.js

@@ -0,0 +1,106 @@
+"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 vite_plugin_cedar_gqlorm_inject_exports = {};
+__export(vite_plugin_cedar_gqlorm_inject_exports, {
+  cedarGqlormInjectPlugin: () => cedarGqlormInjectPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_gqlorm_inject_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function cedarGqlormInjectPlugin() {
+  return {
+    name: "cedar-gqlorm-inject",
+    transform(code, id) {
+      if (!id.endsWith("/graphql.ts") && !id.endsWith("/graphql.js")) {
+        return null;
+      }
+      if (code.includes("__gqlorm_sdl__")) {
+        return null;
+      }
+      if (!code.includes("createGraphQLHandler")) {
+        return null;
+      }
+      let config;
+      try {
+        config = (0, import_project_config.getConfig)();
+      } catch {
+        return null;
+      }
+      if (!config.experimental?.gqlorm?.enabled) {
+        return null;
+      }
+      let paths;
+      try {
+        paths = (0, import_project_config.getPaths)();
+      } catch {
+        return null;
+      }
+      const backendPathWithoutExt = import_node_path.default.join(
+        paths.generated.base,
+        "gqlorm",
+        "backend"
+      );
+      if (!import_node_fs.default.existsSync(backendPathWithoutExt + ".ts")) {
+        return null;
+      }
+      const handlerPattern = /^export\s+const\s+(\w+)\s*=\s*createGraphQLHandler\s*\(/m;
+      const handlerMatch = handlerPattern.exec(code);
+      if (!handlerMatch) {
+        return null;
+      }
+      const handlerLineStart = code.lastIndexOf("\n", handlerMatch.index) + 1;
+      const relPath = (0, import_project_config.importStatementPath)(
+        import_node_path.default.relative(import_node_path.default.dirname(id), backendPathWithoutExt)
+      ) + ".ts";
+      const dbSrcPath = import_node_path.default.join(paths.api.src, "lib", "db");
+      const relDbPath = (0, import_project_config.importStatementPath)(import_node_path.default.relative(import_node_path.default.dirname(id), dbSrcPath)) + ".ts";
+      const importDb = `import { db as __gqlorm_db__ } from '${relDbPath}'`;
+      const importSdl = `import * as __gqlorm_sdl__ from '${relPath}'`;
+      const importsToAdd = `${importDb}
+${importSdl}
+`;
+      const sdlsMutation = `Object.assign(sdls, {
+    __gqlorm__: {
+      schema: __gqlorm_sdl__.schema,
+      resolvers: __gqlorm_sdl__.createGqlormResolvers(__gqlorm_db__),
+    },
+  })
+  `;
+      const transformed = importsToAdd + code.slice(0, handlerLineStart) + sdlsMutation + code.slice(handlerLineStart);
+      return {
+        code: transformed
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarGqlormInjectPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-graphql-options-extract.js

@@ -0,0 +1,113 @@
+"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 vite_plugin_cedar_graphql_options_extract_exports = {};
+__export(vite_plugin_cedar_graphql_options_extract_exports, {
+  applyGraphqlOptionsExtract: () => applyGraphqlOptionsExtract,
+  cedarGraphqlOptionsExtractPlugin: () => cedarGraphqlOptionsExtractPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_graphql_options_extract_exports);
+var import_oxc_parser = require("oxc-parser");
+function cedarGraphqlOptionsExtractPlugin() {
+  return {
+    name: "cedar-graphql-options-extract",
+    transform(code, id) {
+      if (!id.endsWith("/graphql.ts") && !id.endsWith("/graphql.js")) {
+        return null;
+      }
+      if (!code.includes("createGraphQLHandler")) {
+        return null;
+      }
+      const transformed = applyGraphqlOptionsExtract(code);
+      if (!transformed || transformed === code) {
+        return null;
+      }
+      return {
+        code: transformed
+      };
+    }
+  };
+}
+function applyGraphqlOptionsExtract(code) {
+  if (code.includes("__cedar_graphqlOptions")) {
+    return null;
+  }
+  const { program } = (0, import_oxc_parser.parseSync)("graphql.ts", code, {
+    // lang is only a parse hint; 'ts' also parses JS (the graphql handler can
+    // be graphql.js in JS projects), so this is safe for both file types.
+    lang: "ts",
+    sourceType: "module"
+  });
+  const importNames = /* @__PURE__ */ new Set();
+  for (const node of program.body) {
+    if (node.type === "ImportDeclaration") {
+      if (node.source.value !== "@cedarjs/graphql-server") {
+        continue;
+      }
+      for (const specifier of node.specifiers) {
+        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "createGraphQLHandler") {
+          importNames.add(specifier.local.name);
+        }
+      }
+    }
+  }
+  if (importNames.size === 0) {
+    return null;
+  }
+  const callExpressionPaths = [];
+  new import_oxc_parser.Visitor({
+    CallExpression(node) {
+      if (node.callee.type === "Identifier" && importNames.has(node.callee.name)) {
+        callExpressionPaths.push(node);
+      }
+    }
+  }).visit(program);
+  if (callExpressionPaths.length > 1) {
+    return null;
+  }
+  const callExpression = callExpressionPaths[0];
+  if (!callExpression) {
+    return null;
+  }
+  const options = callExpression.arguments[0];
+  if (!options) {
+    return null;
+  }
+  if (options.type !== "Identifier" && options.type !== "ObjectExpression" && options.type !== "CallExpression" && options.type !== "ConditionalExpression") {
+    return null;
+  }
+  const optionsStart = options.start;
+  const optionsEnd = options.end;
+  const lineStart = code.lastIndexOf("\n", callExpression.start) + 1;
+  const indentMatch = /^[ \t]*/.exec(code.slice(lineStart));
+  const indent = indentMatch ? indentMatch[0] : "";
+  const optionsConst = `${indent}export const __cedar_graphqlOptions = ${code.slice(
+    optionsStart,
+    optionsEnd
+  )}
+`;
+  const before = code.slice(0, lineStart);
+  const between = code.slice(lineStart, optionsStart);
+  const after = code.slice(optionsEnd);
+  return before + optionsConst + between + "__cedar_graphqlOptions" + after;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyGraphqlOptionsExtract,
+  cedarGraphqlOptionsExtractPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-otel-wrapping.js

@@ -0,0 +1,225 @@
+"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 vite_plugin_cedar_otel_wrapping_exports = {};
+__export(vite_plugin_cedar_otel_wrapping_exports, {
+  applyOtelWrapping: () => applyOtelWrapping,
+  cedarOtelWrappingPlugin: () => cedarOtelWrappingPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_otel_wrapping_exports);
+var import_oxc_parser = require("oxc-parser");
+var import_vite = require("vite");
+var import_project_config = require("@cedarjs/project-config");
+function cedarOtelWrappingPlugin() {
+  return {
+    name: "cedar-otel-wrapping",
+    transform(code, id) {
+      let apiSrc;
+      try {
+        apiSrc = (0, import_vite.normalizePath)((0, import_project_config.getPaths)().api.src);
+      } catch {
+        return null;
+      }
+      if (!(0, import_vite.normalizePath)(id).startsWith(apiSrc + "/")) {
+        return null;
+      }
+      const relativePath = (0, import_vite.normalizePath)(id).slice(apiSrc.length + 1);
+      const apiFolder = relativePath.split("/")[0] ?? "?";
+      const result = applyOtelWrapping(code, id, apiFolder);
+      return result ? { code: result, map: null } : null;
+    }
+  };
+}
+function applyOtelWrapping(code, filename, apiFolder) {
+  const parseResult = (0, import_oxc_parser.parseSync)(filename, code, { sourceType: "module" });
+  const replacements = [];
+  for (const node of parseResult.program.body) {
+    if (node.type !== "ExportNamedDeclaration") {
+      continue;
+    }
+    const decl = node.declaration;
+    if (decl?.type !== "VariableDeclaration") {
+      continue;
+    }
+    const declarator = decl.declarations[0];
+    if (!declarator) {
+      continue;
+    }
+    const fn = declarator.init;
+    if (fn?.type !== "ArrowFunctionExpression") {
+      continue;
+    }
+    if (declarator.id.type !== "Identifier") {
+      continue;
+    }
+    const fnName = declarator.id.name;
+    const innerArgs = buildInnerArgs(fn.params);
+    if (innerArgs === null) {
+      continue;
+    }
+    const fnHeader = code.slice(fn.start, fn.body.start);
+    const originalFnSrc = code.slice(fn.start, fn.end);
+    const isAsync = fn.async;
+    const awaitKw = isAsync ? "await " : "";
+    const asyncKw = isAsync ? "async " : "";
+    replacements.push({
+      start: node.start,
+      end: node.end,
+      src: buildWrappedExport(
+        fnName,
+        fnHeader,
+        originalFnSrc,
+        innerArgs,
+        awaitKw,
+        asyncKw,
+        apiFolder,
+        filename
+      )
+    });
+  }
+  if (replacements.length === 0) {
+    return null;
+  }
+  let output = code;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const r = replacements[i];
+    output = output.slice(0, r.start) + r.src + output.slice(r.end);
+  }
+  return `import { trace as OTEL_TRACE } from '@opentelemetry/api'
+` + output;
+}
+function buildInnerArgs(params) {
+  const args = [];
+  for (const param of params) {
+    if (param.type === "RestElement" || param.type === "ArrayPattern" || param.type === "TSParameterProperty") {
+      return null;
+    }
+    if (param.type === "Identifier") {
+      args.push(param.name);
+      continue;
+    }
+    if (param.type === "ObjectPattern") {
+      for (const prop of param.properties) {
+        if (prop.type === "RestElement") {
+          return null;
+        }
+        if (prop.key.type !== "Identifier") {
+          return null;
+        }
+        const value = prop.value;
+        if (value.type !== "Identifier" && value.type !== "AssignmentPattern" && value.type !== "ObjectPattern") {
+          return null;
+        }
+        if (value.type === "AssignmentPattern") {
+          if (value.left.type !== "Identifier" && value.left.type !== "ObjectPattern") {
+            return null;
+          }
+        }
+      }
+      const obj = buildObjectCallArg(param);
+      if (obj === null) {
+        return null;
+      }
+      args.push(obj);
+      continue;
+    }
+    if (param.type === "AssignmentPattern") {
+      const ap = param;
+      if (ap.left.type === "Identifier") {
+        args.push(ap.left.name);
+      } else if (ap.left.type === "ObjectPattern") {
+        const obj = buildObjectCallArg(ap.left);
+        if (obj === null) {
+          return null;
+        }
+        args.push(obj);
+      } else {
+        return null;
+      }
+      continue;
+    }
+    return null;
+  }
+  return args.join(", ");
+}
+function buildObjectCallArg(pattern) {
+  const keys = [];
+  for (const prop of pattern.properties) {
+    if (prop.type === "RestElement") {
+      return null;
+    }
+    if (prop.key.type !== "Identifier") {
+      return null;
+    }
+    const keyName = prop.key.name;
+    let valueName = null;
+    if (prop.value.type === "Identifier") {
+      valueName = prop.value.name;
+    } else if (prop.value.type === "AssignmentPattern") {
+      if (prop.value.left.type === "Identifier") {
+        valueName = prop.value.left.name;
+      } else {
+        return null;
+      }
+    } else {
+      return null;
+    }
+    if (valueName !== keyName) {
+      keys.push(`${keyName}: ${valueName}`);
+    } else {
+      keys.push(keyName);
+    }
+  }
+  return `{ ${keys.join(", ")} }`;
+}
+function buildWrappedExport(fnName, fnHeader, originalFnSrc, innerArgs, awaitKw, asyncKw, apiFolder, filename) {
+  const privateName = `__${fnName}`;
+  const spanName = `redwoodjs:api:${apiFolder}:${fnName}`;
+  return `export const ${fnName} = ${fnHeader}{
+  const ${privateName} = ${originalFnSrc}
+  const OTEL_TRACER = OTEL_TRACE.getTracer('redwoodjs')
+  const OTEL_RESULT = ${awaitKw}OTEL_TRACER.startActiveSpan(
+    '${spanName}',
+    ${asyncKw}(span) => {
+      span.setAttribute('code.function', '${fnName}')
+      span.setAttribute('code.filepath', ${JSON.stringify(filename)})
+      try {
+        const OTEL_INNER_RESULT = ${awaitKw}${privateName}(${innerArgs})
+        span.end()
+        return OTEL_INNER_RESULT
+      } catch (error) {
+        span.recordException(error)
+        span.setStatus({
+          code: 2,
+          message:
+            error?.message?.split('\\n')[0] ??
+            error?.toString()?.split('\\n')[0],
+        })
+        span.end()
+        throw error
+      }
+    }
+  )
+  return OTEL_RESULT
+}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyOtelWrapping,
+  cedarOtelWrappingPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-universal-deploy.js

@@ -329,7 +329,7 @@ async function generateFunctionModule(distPath) {
         const ctx = await buildCedarContext(request);
         // Wrap the handler in an AsyncLocalStorage run so the global
         // @cedarjs/context is available inside it (and isolated per request).
-        // Mirrors the GraphQL module above and the cedarContextWrappingPlugin
+        // Mirrors the GraphQL module above and the handlerAlsWrappingPlugin
         // used for non-UD builds.
         const { getAsyncStoreInstance } = await import(
           '@cedarjs/context/dist/store'

package/dist/cjs/plugins/{vite-plugin-cedar-context-wrapping.js → vite-plugin-handler-als-wrapping.js}

@@ -26,20 +26,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var vite_plugin_cedar_context_wrapping_exports = {};
-__export(vite_plugin_cedar_context_wrapping_exports, {
-  applyContextWrapping: () => applyContextWrapping,
-  cedarContextWrappingPlugin: () => cedarContextWrappingPlugin
+var vite_plugin_handler_als_wrapping_exports = {};
+__export(vite_plugin_handler_als_wrapping_exports, {
+  applyHandlerAlsWrapping: () => applyHandlerAlsWrapping,
+  handlerAlsWrappingPlugin: () => handlerAlsWrappingPlugin
 });
-module.exports = __toCommonJS(vite_plugin_cedar_context_wrapping_exports);
+module.exports = __toCommonJS(vite_plugin_handler_als_wrapping_exports);
 var import_node_path = __toESM(require("node:path"), 1);
 var import_vite = require("vite");
 var import_project_config = require("@cedarjs/project-config");
-function cedarContextWrappingPlugin({
+function handlerAlsWrappingPlugin({
   projectIsEsm = false
 } = {}) {
   return {
-    name: "cedar-context-wrapping",
+    name: "handler-als-wrapping",
     transform(code, id) {
       let paths;
       try {
@@ -51,12 +51,12 @@ function cedarContextWrappingPlugin({
       if (!(0, import_vite.normalizePath)(id).startsWith(functionsDir + "/")) {
         return null;
       }
-      const wrapped = applyContextWrapping(code, { projectIsEsm });
+      const wrapped = applyHandlerAlsWrapping(code, { projectIsEsm });
       return wrapped ? { code: wrapped, map: null } : null;
     }
   };
 }
-function applyContextWrapping(code, { projectIsEsm = false } = {}) {
+function applyHandlerAlsWrapping(code, { projectIsEsm = false } = {}) {
   const handlerRe = /^export\s+(?:const|let|var)\s+handler(?:[^=]|=>)*?=(?![>=])/m;
   const handlerMatch = handlerRe.exec(code);
   if (!handlerMatch) {
@@ -65,31 +65,31 @@ function applyContextWrapping(code, { projectIsEsm = false } = {}) {
   const afterEquals = code.slice(handlerMatch.index + handlerMatch[0].length).trimStart();
   const isAsync = /^async(?:\s*[\(\*]|\s+function)/.test(afterEquals);
   const storePath = projectIsEsm ? "@cedarjs/context/dist/store.js" : "@cedarjs/context/dist/store";
-  const importStatement = `import { getAsyncStoreInstance as __rw_getAsyncStoreInstance } from '${storePath}'
+  const importStatement = `import { getAsyncStoreInstance as __cedar_getAsyncStoreInstance } from '${storePath}'
 `;
   const handlerStart = handlerMatch.index;
   const before = code.slice(0, handlerStart);
   const after = code.slice(handlerStart);
-  const renamed = after.replace(handlerRe, "const __rw_handler =");
+  const renamed = after.replace(handlerRe, "const __cedar_handler =");
   const wrappedHandler = `
-export const handler = ${isAsync ? "async " : ""}(__rw_event, __rw__context) => {
+export const handler = ${isAsync ? "async " : ""}(__cedar_event, __cedar_context) => {
   // The store will be undefined if no context isolation has been performed yet
-  const __rw_contextStore = __rw_getAsyncStoreInstance().getStore()
-  if (__rw_contextStore === undefined) {
-    return __rw_getAsyncStoreInstance().run(
+  const __cedar_contextStore = __cedar_getAsyncStoreInstance().getStore()
+  if (__cedar_contextStore === undefined) {
+    return __cedar_getAsyncStoreInstance().run(
       new Map(),
-      __rw_handler,
-      __rw_event,
-      __rw__context
+      __cedar_handler,
+      __cedar_event,
+      __cedar_context
     )
   }
-  return __rw_handler(__rw_event, __rw__context)
+  return __cedar_handler(__cedar_event, __cedar_context)
 }
 `;
   return before + importStatement + renamed + wrappedHandler;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  applyContextWrapping,
-  cedarContextWrappingPlugin
+  applyHandlerAlsWrapping,
+  handlerAlsWrappingPlugin
 });

package/dist/cjs/plugins/vite-plugin-rsc-ssr-router-import.js

@@ -44,8 +44,8 @@ function rscSsrRouterImport() {
   const routesFileId = (0, import_vite.normalizePath)((0, import_project_config.getPaths)().web.routes);
   return {
     name: "rsc-ssr-router-import",
-    transform: async function(code, id) {
-      if (id !== routesFileId) {
+    transform: async function(code, id, options) {
+      if (!options?.ssr || id !== routesFileId) {
         return null;
       }
       const ext = import_node_path.default.extname(id);

package/dist/cjs/plugins/vite-plugin-rsc-transform-server.js

@@ -41,6 +41,10 @@ function rscTransformUseServerPlugin(outDir, serverEntryFiles) {
       if (!code.includes("use server")) {
         return code;
       }
+      if (id.includes("node_modules/.vite") || id.includes("/react-server-dom-webpack/") || id.includes("/react-server-dom-webpack.server")) {
+        console.log("vite-plugin-rsc-transform-server.ts: Skipping", id);
+        return code;
+      }
       let mod;
       const isTypescript = id.endsWith(".ts") || id.endsWith(".tsx");
       try {

package/dist/cjs/rsc/rscRenderer.js

@@ -33,20 +33,28 @@ __export(rscRenderer_exports, {
 });
 module.exports = __toCommonJS(rscRenderer_exports);
 var import_node_path = __toESM(require("node:path"), 1);
-var import_react = require("react");
-var import_server = require("react-server-dom-webpack/server.edge");
 var import_project_config = require("@cedarjs/project-config");
 var import_entries = require("../lib/entries.js");
 var import_StatusError = require("../lib/StatusError.js");
+var import_utils = require("./utils.js");
 let absoluteClientEntries = {};
-function renderRscToStream(input) {
+async function renderRscToStream(input) {
   return input.rscId ? renderRsc(input) : executeRsa(input);
 }
 async function loadServerFile(filePath) {
   console.log("rscRenderer.ts loadServerFile filePath", filePath);
+  if (globalThis.__cedarjs__vite_rsc_runtime) {
+    const serverMod = await globalThis.__cedarjs__vite_rsc_runtime.import(filePath);
+    return serverMod.default ? serverMod.default : serverMod;
+  }
   return import(`file://${filePath}`);
 }
 const getRoutesComponent = async () => {
+  if (globalThis.__cedarjs__vite_rsc_runtime) {
+    const routesPath2 = (0, import_project_config.getPaths)().web.routes;
+    const routesMod = await globalThis.__cedarjs__vite_rsc_runtime.import(routesPath2);
+    return routesMod.default;
+  }
   const serverEntries = await (0, import_entries.getEntriesFromDist)();
   console.log("rscRenderer.ts serverEntries", serverEntries);
   const routesPath = import_node_path.default.join(
@@ -87,10 +95,12 @@ function getBundlerConfig() {
     {},
     {
       get(_target, encodedId) {
-        console.log("Proxy get encodedId", encodedId);
+        console.log("rscRenderer.ts Proxy get encodedId", encodedId);
         const [filePath, name] = encodedId.split("#");
+        console.log("filePath", filePath);
+        console.log("name", name);
         const filePathSlash = filePath.replaceAll("\\", "/");
-        const id = absoluteClientEntries[filePathSlash];
+        const id = globalThis.__cedarjs__vite_rsc_runtime ? filePath : absoluteClientEntries[filePathSlash];
         console.log("absoluteClientEntries", absoluteClientEntries);
         console.log("filePath", filePathSlash);
         if (!id) {
@@ -113,12 +123,14 @@ async function renderRsc(input) {
     throw new Error("Unexpected input. Missing rscId or props.");
   }
   console.log("renderRsc input", input);
+  const { createElement } = await (0, import_utils.importRscReact)();
+  const { renderToReadableStream } = await (0, import_utils.importRsdwServer)();
   const serverRoutes = await getRoutesComponent();
   const model = {
-    __cedarjs__Routes: (0, import_react.createElement)(serverRoutes)
+    __cedarjs__Routes: createElement(serverRoutes)
   };
   console.log("rscRenderer.ts renderRsc model", model);
-  return (0, import_server.renderToReadableStream)(model, getBundlerConfig());
+  return renderToReadableStream(model, getBundlerConfig());
 }
 function isSerializedFormData(data) {
   return !!data && data?.__formData__;
@@ -149,14 +161,16 @@ async function executeRsa(input) {
   console.log("rscRenderer.ts args", ...input.args);
   const data = await method(...input.args);
   console.log("rscRenderer.ts rsa return data", data);
+  const { createElement } = await (0, import_utils.importRscReact)();
+  const { renderToReadableStream } = await (0, import_utils.importRsdwServer)();
   const serverRoutes = await getRoutesComponent();
   console.log("rscRenderer.ts executeRsa serverRoutes", serverRoutes);
   const model = {
-    __cedarjs__Routes: (0, import_react.createElement)(serverRoutes),
+    __cedarjs__Routes: createElement(serverRoutes),
     __cedarjs__rsa_data: data
   };
   console.log("rscRenderer.ts executeRsa model", model);
-  return (0, import_server.renderToReadableStream)(model, getBundlerConfig());
+  return renderToReadableStream(model, getBundlerConfig());
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/rsc/rscRequestHandler.js

@@ -38,10 +38,10 @@ var import_busboy = __toESM(require("busboy"), 1);
 var import_react_server_dom_webpack_server = require("../bundled/react-server-dom-webpack.server.js");
 var import_StatusError = require("../lib/StatusError.js");
 var import_invokeMiddleware = require("../middleware/invokeMiddleware.js");
-var import_rscRenderer = require("./rscRenderer.js");
-var import_rscStudioHandlers = require("./rscStudioHandlers.js");
 const BASE_PATH = "/rw-rsc/";
-function createRscRequestHandler(options) {
+async function createRscRequestHandler(options) {
+  const { renderRscToStream } = await import("./rscRenderer.js");
+  const { sendRscFlightToStudio } = await import("./rscStudioHandlers.js");
   return async (req, res, next) => {
     console.log("BASE_PATH", BASE_PATH);
     console.log("req.originalUrl", req.originalUrl, "req.url", req.url);
@@ -56,7 +56,7 @@ function createRscRequestHandler(options) {
         matchedMw?.handler,
         {
           params: matchedMw?.params,
-          viteDevServer: options.viteDevServer
+          viteSsrDevServer: options.viteSsrDevServer
         }
       );
       const webRes = mwResponse.toResponse();
@@ -101,9 +101,9 @@ function createRscRequestHandler(options) {
         res.end(String(err));
       };
       try {
-        const readable = await (0, import_rscRenderer.renderRscToStream)({ rscId, rsaId, args });
+        const readable = await renderRscToStream({ rscId, rsaId, args });
         import_node_stream.Readable.fromWeb(readable).pipe(res);
-        await (0, import_rscStudioHandlers.sendRscFlightToStudio)({
+        await sendRscFlightToStudio({
           rscId,
           rsaId,
           args,