@cedarjs/vite 0.0.4

package/dist/rsc/rscBuildEntriesFile.js

@@ -0,0 +1,81 @@
+import fs from "fs/promises";
+import { normalizePath } from "vite";
+import { getPaths } from "@cedarjs/project-config";
+async function rscBuildEntriesMappings(clientBuildOutput, ssrBuildOutput, serverBuildOutput, clientEntryFiles) {
+  console.log("\n");
+  console.log("6. rscBuildEntriesMapping");
+  console.log("=========================\n");
+  const rwPaths = getPaths();
+  const clientEntries = {};
+  for (const item of clientBuildOutput) {
+    const { name, fileName } = item;
+    const entryFile = name && // TODO (RSC) Can't we just compare the names? `item.name === name`
+    serverBuildOutput.find(
+      (item2) => "moduleIds" in item2 && item2.moduleIds.includes(clientEntryFiles[name])
+    )?.fileName;
+    if (entryFile) {
+      if (process.platform === "win32") {
+        const entryFileSlash = entryFile.replaceAll("\\", "/");
+        clientEntries[entryFileSlash] = fileName;
+      } else {
+        clientEntries[entryFile] = fileName;
+      }
+    }
+  }
+  console.log("clientEntries", clientEntries);
+  const ssrEntries = {};
+  for (const item of ssrBuildOutput) {
+    const { name, fileName } = item;
+    const entryFile = name && // TODO (RSC) Can't we just compare the names? `item.name === name`
+    serverBuildOutput.find(
+      (item2) => "moduleIds" in item2 && item2.moduleIds.includes(clientEntryFiles[name])
+    )?.fileName;
+    if (entryFile) {
+      if (process.platform === "win32") {
+        const entryFileSlash = entryFile.replaceAll("\\", "/");
+        ssrEntries[entryFileSlash] = fileName;
+      } else {
+        ssrEntries[entryFile] = fileName;
+      }
+    }
+  }
+  console.log("ssrEntries", ssrEntries);
+  await fs.appendFile(
+    rwPaths.web.distRscEntries,
+    `// client component mapping (dist/rsc -> dist/browser)
+export const clientEntries = ${JSON.stringify(clientEntries, void 0, 2)};
+
+`
+  );
+  await fs.appendFile(
+    rwPaths.web.distRscEntries,
+    `// client component mapping (dist/rsc -> dist/ssr)
+export const ssrEntries = ${JSON.stringify(ssrEntries, void 0, 2)};
+
+`
+  );
+  const serverEntries = {};
+  const entries = {
+    __rwjs__ServerEntry: getPaths().web.entryServer || "",
+    __rwjs__Routes: getPaths().web.routes
+  };
+  for (const [name, sourceFile] of Object.entries(entries)) {
+    const buildOutputItem = serverBuildOutput.find((item) => {
+      return item.facadeModuleId === normalizePath(sourceFile);
+    });
+    if (buildOutputItem) {
+      serverEntries[name] = buildOutputItem.fileName;
+    }
+  }
+  console.log("serverEntries", serverEntries);
+  await fs.appendFile(
+    rwPaths.web.distRscEntries,
+    `// server component mapping (src -> dist/rsc)
+export const serverEntries = ${JSON.stringify(serverEntries, void 0, 2)};
+
+`
+  );
+}
+export {
+  rscBuildEntriesMappings
+};

package/dist/rsc/rscBuildForServer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RSC build. Step 4.
+ * buildFeServer -> buildRscFeServer -> rscBuildForServer
+ * Generate the output to be used by the rsc worker (not the actual server!)
+ */
+export declare function rscBuildForServer(clientEntryFiles: Record<string, string>, serverEntryFiles: Record<string, string>, customModules: Record<string, string>): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputChunk | import("rollup").OutputAsset)[]]>;
+//# sourceMappingURL=rscBuildForServer.d.ts.map

package/dist/rsc/rscBuildForServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscBuildForServer.d.ts","sourceRoot":"","sources":["../../src/rsc/rscBuildForServer.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,+GAyItC"}

package/dist/rsc/rscBuildForServer.js

@@ -0,0 +1,133 @@
+import { build as viteBuild } from "vite";
+import { getPaths } from "@cedarjs/project-config";
+import { getEntries } from "../lib/entries.js";
+import { onWarn } from "../lib/onWarn.js";
+import { rscRoutesImports } from "../plugins/vite-plugin-rsc-routes-imports.js";
+import { rscTransformUseClientPlugin } from "../plugins/vite-plugin-rsc-transform-client.js";
+import { rscTransformUseServerPlugin } from "../plugins/vite-plugin-rsc-transform-server.js";
+async function rscBuildForServer(clientEntryFiles, serverEntryFiles, customModules) {
+  console.log("\n");
+  console.log("4. rscBuildForServer");
+  console.log("====================\n");
+  const rwPaths = getPaths();
+  const entryFiles = getEntries();
+  const entryFilesKeys = Object.keys(entryFiles);
+  if (!rwPaths.web.entryServer) {
+    throw new Error("Server Entry file not found");
+  }
+  const outDir = rwPaths.web.distRsc;
+  const rscServerBuildOutput = await viteBuild({
+    envFile: false,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV)
+    },
+    ssr: {
+      // Inline every file apart from node built-ins. We want vite/rollup to
+      // inline dependencies in the server build. This gets round runtime
+      // importing of "server-only" and other packages with poisoned imports.
+      //
+      // Files included in `noExternal` are files we want Vite to analyze
+      // As of vite 5.2 `true` here means "all except node built-ins"
+      noExternal: true,
+      // TODO (RSC): Other frameworks build for RSC without `noExternal: true`.
+      // What are we missing here? When/why is that a better choice? I know
+      // we would have to explicitly add a bunch of packages to noExternal, if
+      // we wanted to go that route.
+      // noExternal: ['@tobbe.dev/rsc-test'],
+      // Can't inline prisma client (db calls fail at runtime) or react-dom
+      // (css pre-init failure)
+      // Server store has to be externalized, because it's a singleton (shared between FW and App)
+      external: [
+        "@prisma/client",
+        "@prisma/fetch-engine",
+        "@prisma/internals",
+        "@cedarjs/auth-dbauth-api",
+        "@cedarjs/cookie-jar",
+        "@cedarjs/server-store",
+        "@simplewebauthn/server",
+        "graphql-scalars",
+        "minimatch",
+        "playwright",
+        "react-dom"
+      ],
+      resolve: {
+        // These conditions are used in the plugin pipeline, and only affect non-externalized
+        // dependencies during the SSR build. Which because of `noExternal: true` means all
+        // dependencies apart from node built-ins.
+        // TODO (RSC): What's the difference between `conditions` and
+        // `externalConditions`? When is one used over the other?
+        conditions: ["react-server"],
+        externalConditions: ["react-server"]
+      }
+    },
+    plugins: [
+      // The rscTransformUseClientPlugin maps paths like
+      // /Users/tobbe/.../rw-app/node_modules/@tobbe.dev/rsc-test/dist/rsc-test.es.js
+      // to
+      // /Users/tobbe/.../rw-app/web/dist/ssr/assets/rsc0.js
+      // That's why it needs the `clientEntryFiles` data
+      // (It does other things as well, but that's why it needs clientEntryFiles)
+      rscTransformUseClientPlugin(clientEntryFiles),
+      rscTransformUseServerPlugin(outDir, serverEntryFiles),
+      rscRoutesImports()
+    ],
+    build: {
+      // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+      minify: false,
+      ssr: true,
+      ssrEmitAssets: true,
+      outDir,
+      emptyOutDir: true,
+      // Needed because `outDir` is not inside `root`
+      manifest: "server-build-manifest.json",
+      rollupOptions: {
+        onwarn: onWarn,
+        input: {
+          ...entryFiles,
+          ...clientEntryFiles,
+          ...serverEntryFiles,
+          ...customModules,
+          "entry.server": rwPaths.web.entryServer
+        },
+        output: {
+          banner: (chunk) => {
+            let code = "";
+            const clientValues = Object.values(clientEntryFiles);
+            if (chunk.moduleIds.some((id) => clientValues.includes(id))) {
+              code += '"use client";';
+            }
+            const serverValues = Object.values(serverEntryFiles);
+            if (chunk.moduleIds.some((id) => serverValues.includes(id))) {
+              code += '"use server";';
+            }
+            return code;
+          },
+          entryFileNames: (chunkInfo) => {
+            if (entryFilesKeys.includes(chunkInfo.name)) {
+              return "assets/[name]-[hash].mjs";
+            }
+            if (chunkInfo.name === "entry.server" || customModules[chunkInfo.name]) {
+              return "[name].mjs";
+            }
+            return "assets/[name].mjs";
+          },
+          chunkFileNames: `assets/[name]-[hash].mjs`,
+          // This is not ideal. See
+          // https://rollupjs.org/faqs/#why-do-additional-imports-turn-up-in-my-entry-chunks-when-code-splitting
+          // But we need it to prevent `import 'client-only'` from being
+          // hoisted into App.tsx
+          // TODO (RSC): Fix when https://github.com/rollup/rollup/issues/5235
+          // is resolved
+          hoistTransitiveImports: false
+        }
+      }
+    }
+  });
+  if (!("output" in rscServerBuildOutput)) {
+    throw new Error("Unexpected rsc server build output");
+  }
+  return rscServerBuildOutput.output;
+}
+export {
+  rscBuildForServer
+};

package/dist/rsc/rscBuildForSsr.d.ts

@@ -0,0 +1,9 @@
+/**
+ * RSC build. Step 3
+ * SSR build for when RSC is enabled
+ */
+export declare function rscBuildForSsr({ clientEntryFiles, verbose, }: {
+    clientEntryFiles: Record<string, string>;
+    verbose?: boolean;
+}): Promise<[import("rollup").OutputChunk, ...(import("rollup").OutputChunk | import("rollup").OutputAsset)[]]>;
+//# sourceMappingURL=rscBuildForSsr.d.ts.map

package/dist/rsc/rscBuildForSsr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscBuildForSsr.d.ts","sourceRoot":"","sources":["../../src/rsc/rscBuildForSsr.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,wBAAsB,cAAc,CAAC,EACnC,gBAAgB,EAChB,OAAe,GAChB,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,+GA8IA"}

package/dist/rsc/rscBuildForSsr.js

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import { build as viteBuild } from "vite";
+import { cjsInterop } from "vite-plugin-cjs-interop";
+import { getPaths } from "@cedarjs/project-config";
+import { onWarn } from "../lib/onWarn.js";
+import { rscRoutesAutoLoader } from "../plugins/vite-plugin-rsc-routes-auto-loader.js";
+import { rscSsrRouterImport } from "../plugins/vite-plugin-rsc-ssr-router-import.js";
+async function rscBuildForSsr({
+  clientEntryFiles,
+  verbose = false
+}) {
+  console.log("\n");
+  console.log("3. rscBuildForSsr");
+  console.log("=================\n");
+  const rwPaths = getPaths();
+  if (!rwPaths.web.entryClient) {
+    throw new Error("No client entry file found inside " + rwPaths.web.src);
+  }
+  if (!rwPaths.web.entryServer) {
+    throw new Error("No server entry file found inside " + rwPaths.web.src);
+  }
+  const ssrBuildOutput = await viteBuild({
+    envFile: false,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV)
+    },
+    ssr: {
+      // Inline every file apart from node built-ins. We want vite/rollup to
+      // inline dependencies in the server build. This gets round runtime
+      // importing of "server-only" and other packages with poisoned imports.
+      //
+      // Files included in `noExternal` are files we want Vite to analyze
+      // As of vite 5.2 `true` here means "all except node built-ins"
+      noExternal: true,
+      external: [
+        "@prisma/client",
+        "@prisma/fetch-engine",
+        "@prisma/internals",
+        "@cedarjs/auth-dbauth-api",
+        "@cedarjs/cookie-jar",
+        "@cedarjs/server-store",
+        "@simplewebauthn/server",
+        "graphql-scalars",
+        "minimatch",
+        "playwright"
+      ]
+    },
+    plugins: [
+      cjsInterop({
+        dependencies: [
+          // Skip ESM modules: rwjs/auth, rwjs/web, rwjs/auth-*-middleware, rwjs/router
+          "@cedarjs/forms",
+          "@cedarjs/prerender/*",
+          "@cedarjs/auth-*-api",
+          "@cedarjs/auth-*-web"
+        ]
+      }),
+      rscRoutesAutoLoader(),
+      rscSsrRouterImport()
+    ],
+    build: {
+      // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+      minify: false,
+      outDir: rwPaths.web.distSsr,
+      ssr: true,
+      emptyOutDir: true,
+      // Needed because `outDir` is not inside `root`
+      rollupOptions: {
+        onwarn: onWarn,
+        input: {
+          // @MARK: temporary hack to find the entry client so we can get the
+          // index.css bundle but we don't actually want this on an rsc page!
+          // TODO (RSC): Look into if we can remove this (and perhaps instead
+          // use entry.server)
+          __rwjs__client_entry: rwPaths.web.entryClient,
+          "entry.server": rwPaths.web.entryServer,
+          // we need this, so that the output contains rsc-specific bundles
+          // for the client-only components. They get loaded once the page is
+          // rendered
+          ...clientEntryFiles,
+          // These import redirections are so that we don't bundle multiple versions of react
+          __rwjs__react: "react",
+          __rwjs__location: "@cedarjs/router/location",
+          __rwjs__server_auth_provider: "@cedarjs/auth/ServerAuthProvider",
+          __rwjs__server_inject: "@cedarjs/web/serverInject",
+          "__rwjs__rsdw-client": "react-server-dom-webpack/client.edge",
+          // TODO (RSC): add __rwjs__ prefix to the entry below
+          "rd-server": "react-dom/server.edge",
+          // We need the document for React's fallback
+          Document: rwPaths.web.document
+        },
+        preserveEntrySignatures: "exports-only",
+        output: {
+          // This is not ideal. See
+          // https://rollupjs.org/faqs/#why-do-additional-imports-turn-up-in-my-entry-chunks-when-code-splitting
+          // But we need it to prevent `import 'client-only'` from being
+          // hoisted into App.tsx
+          // TODO (RSC): Fix when https://github.com/rollup/rollup/issues/5235
+          // is resolved
+          hoistTransitiveImports: false,
+          entryFileNames: (chunkInfo) => {
+            if (chunkInfo.name === "rd-server" || chunkInfo.name === "__rwjs__react" || chunkInfo.name === "__rwjs__location" || chunkInfo.name === "__rwjs__server_auth_provider" || chunkInfo.name === "__rwjs__server_inject" || chunkInfo.name === "__rwjs__rsdw-client" || chunkInfo.name === "entry.server" || chunkInfo.name === "Document") {
+              return "[name].mjs";
+            }
+            return "assets/[name]-[hash].mjs";
+          },
+          chunkFileNames: `assets/[name]-[hash].mjs`
+        }
+      },
+      manifest: "client-build-manifest-ssr.json"
+    },
+    esbuild: {
+      logLevel: verbose ? "debug" : "silent",
+      logOverride: {
+        "unsupported-dynamic-import": "silent"
+      }
+    },
+    logLevel: verbose ? "info" : "silent"
+  });
+  if (!("output" in ssrBuildOutput)) {
+    throw new Error("Unexpected vite ssr build output");
+  }
+  const entryServerMjs = fs.readFileSync(
+    rwPaths.web.distSsrEntryServer,
+    "utf-8"
+  );
+  fs.writeFileSync(
+    rwPaths.web.distSsrEntryServer,
+    entryServerMjs.replace(
+      /import (require\S+) from "graphql-scalars";/,
+      'import * as $1 from "graphql-scalars";'
+    )
+  );
+  return ssrBuildOutput.output;
+}
+export {
+  rscBuildForSsr
+};

package/dist/rsc/rscBuildRwEnvVars.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RSC build. Step 7.
+ * Make RW specific env vars available to server components.
+ * For client components this is done as a side-effect of importing from
+ * @cedarjs/web (see packages/web/src/config.ts).
+ * The import of entries.js that we're adding this to is handled by the
+ * RSC worker we've got set up
+ */
+export declare function rscBuildRwEnvVars(): Promise<void>;
+//# sourceMappingURL=rscBuildRwEnvVars.d.ts.map

package/dist/rsc/rscBuildRwEnvVars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscBuildRwEnvVars.d.ts","sourceRoot":"","sources":["../../src/rsc/rscBuildRwEnvVars.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,kBAoCtC"}

package/dist/rsc/rscBuildRwEnvVars.js

@@ -0,0 +1,22 @@
+import fs from "fs/promises";
+import { getPaths } from "@cedarjs/project-config";
+async function rscBuildRwEnvVars() {
+  console.log("\n");
+  console.log("7. rscBuildRwEnvVars");
+  console.log("====================\n");
+  const rwPaths = getPaths();
+  await fs.appendFile(
+    rwPaths.web.distRscEntries,
+    `
+
+globalThis.RWJS_API_GRAPHQL_URL = RWJS_ENV.RWJS_API_GRAPHQL_URL
+globalThis.RWJS_API_URL = RWJS_ENV.RWJS_API_URL
+globalThis.__REDWOOD__APP_TITLE = RWJS_ENV.__REDWOOD__APP_TITLE
+globalThis.RWJS_EXP_STREAMING_SSR = RWJS_ENV.RWJS_EXP_STREAMING_SSR
+globalThis.RWJS_EXP_RSC = RWJS_ENV.RWJS_EXP_RSC
+`
+  );
+}
+export {
+  rscBuildRwEnvVars
+};

package/dist/rsc/rscRenderer.d.ts

@@ -0,0 +1,9 @@
+import type { ReadableStream } from 'node:stream/web';
+export type RenderInput = {
+    rscId?: string | undefined;
+    rsaId?: string | undefined;
+    args?: unknown[] | undefined;
+};
+export declare function renderRscToStream(input: RenderInput): Promise<ReadableStream>;
+export declare function setClientEntries(): Promise<void>;
+//# sourceMappingURL=rscRenderer.d.ts.map

package/dist/rsc/rscRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscRenderer.d.ts","sourceRoot":"","sources":["../../src/rsc/rscRenderer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAWrD,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAA;CAC7B,CAAA;AAID,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAE7E;AAyBD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CA2BtD"}

package/dist/rsc/rscRenderer.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+import { createElement } from "react";
+import { renderToReadableStream } from "react-server-dom-webpack/server.edge";
+import { getPaths } from "@cedarjs/project-config";
+import { getEntriesFromDist } from "../lib/entries.js";
+import { StatusError } from "../lib/StatusError.js";
+let absoluteClientEntries = {};
+function renderRscToStream(input) {
+  return input.rscId ? renderRsc(input) : executeRsa(input);
+}
+async function loadServerFile(filePath) {
+  console.log("rscRenderer.ts loadServerFile filePath", filePath);
+  return import(`file://${filePath}`);
+}
+const getRoutesComponent = async () => {
+  const serverEntries = await getEntriesFromDist();
+  console.log("rscRenderer.ts serverEntries", serverEntries);
+  const routesPath = path.join(
+    getPaths().web.distRsc,
+    serverEntries["__rwjs__Routes"]
+  );
+  if (!routesPath) {
+    throw new StatusError("No entry found for __rwjs__Routes", 404);
+  }
+  const routes = await loadServerFile(routesPath);
+  return routes.default;
+};
+async function setClientEntries() {
+  const entriesFile = getPaths().web.distRscEntries;
+  console.log("setClientEntries :: entriesFile", entriesFile);
+  const { clientEntries } = await loadServerFile(entriesFile);
+  console.log("setClientEntries :: clientEntries", clientEntries);
+  if (!clientEntries) {
+    throw new Error("Failed to load clientEntries");
+  }
+  const baseDir = path.dirname(entriesFile);
+  absoluteClientEntries = Object.fromEntries(
+    Object.entries(clientEntries).map(([key, val]) => {
+      let fullKey = path.join(baseDir, key);
+      if (process.platform === "win32") {
+        fullKey = fullKey.replaceAll("\\", "/");
+      }
+      return [fullKey, "/" + val];
+    })
+  );
+  console.log(
+    "setClientEntries :: absoluteClientEntries",
+    absoluteClientEntries
+  );
+}
+function getBundlerConfig() {
+  const bundlerConfig = new Proxy(
+    {},
+    {
+      get(_target, encodedId) {
+        console.log("Proxy get encodedId", encodedId);
+        const [filePath, name] = encodedId.split("#");
+        const filePathSlash = filePath.replaceAll("\\", "/");
+        const id = absoluteClientEntries[filePathSlash];
+        console.log("absoluteClientEntries", absoluteClientEntries);
+        console.log("filePath", filePathSlash);
+        if (!id) {
+          throw new Error("No client entry found for " + filePathSlash);
+        }
+        console.log("rscRenderer proxy id", id);
+        return { id, chunks: [id], name, async: true };
+      }
+    }
+  );
+  return bundlerConfig;
+}
+async function renderRsc(input) {
+  if (input.rsaId || !input.args) {
+    throw new Error(
+      "Unexpected input. Can't request both RSCs and execute RSAs at the same time."
+    );
+  }
+  if (!input.rscId) {
+    throw new Error("Unexpected input. Missing rscId or props.");
+  }
+  console.log("renderRsc input", input);
+  const serverRoutes = await getRoutesComponent();
+  const model = {
+    __rwjs__Routes: createElement(serverRoutes)
+  };
+  console.log("rscRenderer.ts renderRsc model", model);
+  return renderToReadableStream(model, getBundlerConfig());
+}
+function isSerializedFormData(data) {
+  return !!data && data?.__formData__;
+}
+async function executeRsa(input) {
+  console.log("executeRsa input", input);
+  if (!input.rsaId || !input.args) {
+    throw new Error("Unexpected input");
+  }
+  const [fileName, actionName] = input.rsaId.split("#");
+  console.log("Server Action fileName", fileName, "actionName", actionName);
+  const module = await loadServerFile(fileName);
+  if (isSerializedFormData(input.args[0])) {
+    const formData = new FormData();
+    Object.entries(input.args[0].state).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          formData.append(key, v);
+        });
+      } else {
+        formData.append(key, value);
+      }
+    });
+    input.args[0] = formData;
+  }
+  const method = module[actionName] || module;
+  console.log("rscRenderer.ts method", method);
+  console.log("rscRenderer.ts args", ...input.args);
+  const data = await method(...input.args);
+  console.log("rscRenderer.ts rsa return data", data);
+  const serverRoutes = await getRoutesComponent();
+  console.log("rscRenderer.ts executeRsa serverRoutes", serverRoutes);
+  const model = {
+    __rwjs__Routes: createElement(serverRoutes),
+    __rwjs__rsa_data: data
+  };
+  console.log("rscRenderer.ts executeRsa model", model);
+  return renderToReadableStream(model, getBundlerConfig());
+}
+export {
+  renderRscToStream,
+  setClientEntries
+};

package/dist/rsc/rscRequestHandler.d.ts

@@ -0,0 +1,10 @@
+import type { Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import type Router from 'find-my-way';
+import type { ViteDevServer } from 'vite';
+interface CreateRscRequestHandlerOptions {
+    getMiddlewareRouter: () => Promise<Router.Instance<any>>;
+    viteDevServer?: ViteDevServer;
+}
+export declare function createRscRequestHandler(options: CreateRscRequestHandlerOptions): (req: ExpressRequest, res: ExpressResponse, next: () => void) => Promise<void>;
+export {};
+//# sourceMappingURL=rscRequestHandler.d.ts.map

package/dist/rsc/rscRequestHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscRequestHandler.d.ts","sourceRoot":"","sources":["../../src/rsc/rscRequestHandler.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,OAAO,IAAI,cAAc,EACzB,QAAQ,IAAI,eAAe,EAC5B,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAgBzC,UAAU,8BAA8B;IACtC,mBAAmB,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;IACxD,aAAa,CAAC,EAAE,aAAa,CAAA;CAC9B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,8BAA8B,SAMhC,cAAc,OACd,eAAe,QACd,MAAM,IAAI,mBAqHnB"}