@cedarjs/vite 4.0.0-rc.129 → 5.0.0-canary.0

package/dist/cjs/devFeServer.js

@@ -21,6 +21,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var import_node_http = __toESM(require("node:http"), 1);
 var import_server = require("@whatwg-node/server");
 var import_express = __toESM(require("express"), 1);
 var import_vite = require("vite");
@@ -32,14 +33,22 @@ var import_registerFwGlobalsAndShims = require("./lib/registerFwGlobalsAndShims.
 var import_invokeMiddleware = require("./middleware/invokeMiddleware.js");
 var import_register = require("./middleware/register.js");
 var import_vite_plugin_rsc_routes_auto_loader = require("./plugins/vite-plugin-rsc-routes-auto-loader.js");
+var import_vite_plugin_rsc_routes_imports = require("./plugins/vite-plugin-rsc-routes-imports.js");
+var import_vite_plugin_rsc_ssr_router_import = require("./plugins/vite-plugin-rsc-ssr-router-import.js");
+var import_vite_plugin_rsc_transform_server = require("./plugins/vite-plugin-rsc-transform-server.js");
+var import_rscWebSocketServer = require("./rsc/rscWebSocketServer.js");
 var import_collectCss = require("./streaming/collectCss.js");
 var import_createReactStreamingHandler = require("./streaming/createReactStreamingHandler.js");
 var import_utils = require("./utils.js");
+const import_meta = {};
 globalThis.__REDWOOD__PRERENDER_PAGES = {};
+globalThis.__cedarjs__vite_ssr_runtime = void 0;
+globalThis.__cedarjs__vite_rsc_runtime = void 0;
 async function createServer() {
   (0, import_utils.ensureProcessDirWeb)();
   (0, import_registerFwGlobalsAndShims.registerFwGlobalsAndShims)();
   const app = (0, import_express.default)();
+  const server = import_node_http.default.createServer(app);
   const rwPaths = (0, import_project_config.getPaths)();
   const rscEnabled = (0, import_project_config.getConfig)().experimental.rsc?.enabled ?? false;
   const serverStorage = (0, import_server_store.createServerStorage)();
@@ -62,8 +71,78 @@ async function createServer() {
       "Vite config not found. You need to setup your project with Vite using `yarn cedar setup vite`"
     );
   }
-  const vite = await (0, import_vite.createServer)({
+  const viteSsrDevServer = await (0, import_vite.createServer)({
     configFile: rwPaths.web.viteConfig,
+    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/adapter-better-sqlite3",
+        "@prisma/fetch-engine",
+        "@prisma/internals",
+        "better-sqlite3",
+        "@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'],
+      },
+      optimizeDeps: {
+        // We need Vite to optimize these dependencies so that they are resolved
+        // with the correct conditions. And so that CJS modules work correctly.
+        // include: [
+        //   'react/**/*',
+        //   'react-dom/server',
+        //   'react-dom/server.edge',
+        //   'rehackt',
+        //   'react-server-dom-webpack/server',
+        //   'react-server-dom-webpack/client',
+        //   '@apollo/client/cache/*',
+        //   '@apollo/client/utilities/*',
+        //   '@apollo/client/react/hooks/*',
+        //   'react-fast-compare',
+        //   'invariant',
+        //   'shallowequal',
+        //   'graphql/language/*',
+        //   'stacktracey',
+        //   'deepmerge',
+        //   'fast-glob',
+        // ],
+      }
+    },
+    resolve: {
+      // conditions: ['react-server'],
+    },
     plugins: [
       (0, import_vite_plugin_cjs_interop.cjsInterop)({
         dependencies: [
@@ -77,16 +156,195 @@ async function createServer() {
           "@cedarjs/auth-!(dbauth)-web"
         ]
       }),
-      rscEnabled && (0, import_vite_plugin_rsc_routes_auto_loader.rscRoutesAutoLoader)()
+      rscEnabled && (0, import_vite_plugin_rsc_routes_auto_loader.rscRoutesAutoLoader)(),
+      rscEnabled && (0, import_vite_plugin_rsc_ssr_router_import.rscSsrRouterImport)()
     ],
     server: { middlewareMode: true },
     logLevel: "info",
     clearScreen: false,
     appType: "custom"
   });
+  globalThis.__cedarjs__vite_ssr_runtime = (0, import_vite.createServerModuleRunner)(
+    viteSsrDevServer.environments.ssr
+  );
+  globalThis.__cedarjs__client_references = /* @__PURE__ */ new Set();
+  globalThis.__cedarjs__server_references = /* @__PURE__ */ new Set();
+  const viteRscServer = await (0, import_vite.createServer)({
+    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/adapter-better-sqlite3",
+        "@prisma/fetch-engine",
+        "@prisma/internals",
+        "better-sqlite3",
+        "@cedarjs/auth-dbauth-api",
+        "@cedarjs/cookie-jar",
+        "@cedarjs/server-store",
+        "@cedarjs/structure",
+        "@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?
+        // In Vite 6, we must include `defaultServerConditions` alongside
+        // `react-server` so that nested condition maps (e.g. the `node`
+        // sub-condition inside `react-server-dom-webpack/server`'s exports)
+        // can still be resolved. Without `node` (or another environment
+        // condition), the resolver throws "No known conditions for
+        // './server' specifier in 'react-server-dom-webpack' package".
+        conditions: ["react-server", ...import_vite.defaultServerConditions],
+        externalConditions: ["react-server", ...import_vite.defaultServerConditions]
+      },
+      optimizeDeps: {
+        // We need Vite to optimize these dependencies so that they are resolved
+        // with the correct conditions. And so that CJS modules work correctly.
+        include: [
+          "react/**/*",
+          "react-dom/server",
+          "react-dom/server.edge",
+          "rehackt",
+          "react-server-dom-webpack/server",
+          "react-server-dom-webpack/server.edge",
+          "react-server-dom-webpack/client",
+          "react-server-dom-webpack/client.edge",
+          "@apollo/client/cache/*",
+          "@apollo/client/utilities/*",
+          "@apollo/client/react/hooks/*",
+          "react-fast-compare",
+          "invariant",
+          "shallowequal",
+          "graphql/language/*",
+          "stacktracey",
+          "deepmerge",
+          "fast-glob",
+          "@whatwg-node/fetch",
+          "busboy",
+          "cookie"
+        ],
+        // Without excluding `util` we get "TypeError: util.TextEncoder is not
+        // a constructor" in react-server-dom-webpack.server because it'll try
+        // to use Browserify's `util` instead of Node's. And Browserify's
+        // polyfill is missing TextEncoder+TextDecoder. The reason it's using
+        // the Browserify polyfill is because we have
+        // `vite-plugin-node-polyfills` as a dependency, and that'll add
+        // Browserify's `node-util` to `node_modules`, so when Vite goes to
+        // resolve `import { TextEncoder } from 'util` it'll find the one in
+        // `node_modules` instead of Node's internal version.
+        // We only see this in dev, and not in prod. I'm not entirely sure why
+        // but I have two guesses: 1. When RSC is enabled we don't actually use
+        // `vite-plugin-node-polyfill`, so some kind of tree shaking is
+        // happening, which prevents the issue from occurring. 2. In prod we
+        // only use Node's dependency resolution. Vite is not involved. And
+        // that difference in resolution is what prevents the issue from
+        // occurring.
+        exclude: ["util"]
+      }
+    },
+    resolve: {
+      // See comment above in ssr.resolve for why we include defaultServerConditions.
+      conditions: ["react-server", ...import_vite.defaultServerConditions]
+    },
+    plugins: [
+      {
+        name: "rsc-record-and-tranform-use-client-plugin",
+        transform(code, id, _options) {
+          globalThis.__cedarjs__client_references?.delete(id);
+          if (!/^(["'])use client\1/.test(code)) {
+            return void 0;
+          }
+          console.log(
+            "rsc-record-and-transform-use-client-plugin: adding client reference",
+            id
+          );
+          globalThis.__cedarjs__client_references?.add(id);
+          const fns = code.matchAll(/export function (\w+)\(/g);
+          const consts = code.matchAll(/export const (\w+) = \(/g);
+          const names = [...fns, ...consts].map(([, name]) => name);
+          const result = [
+            `import { registerClientReference } from "react-server-dom-webpack/server.edge";`,
+            "",
+            ...names.map((name) => {
+              return name === "default" ? `export default registerClientReference({}, "${id}", "${name}");` : `export const ${name} = registerClientReference({}, "${id}", "${name}");`;
+            })
+          ].join("\n");
+          console.log("rsc-record-and-transform-use-client-plugin result");
+          console.log(
+            result.split("\n").map((line, i) => `  ${i + 1}: ${line}`).join("\n")
+          );
+          return { code: result, map: null };
+        }
+      },
+      (0, import_vite_plugin_rsc_transform_server.rscTransformUseServerPlugin)("", {}),
+      // 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),
+      (0, import_vite_plugin_rsc_routes_imports.rscRoutesImports)(),
+      {
+        name: "rsc-hot-update",
+        handleHotUpdate(ctx) {
+          console.log("rsc-hot-update ctx.modules", ctx.modules);
+          return [];
+        }
+      }
+    ],
+    build: {
+      ssr: true
+    },
+    server: {
+      // We never call `viteRscServer.listen()`, so we should run this in
+      // middleware mode
+      middlewareMode: true,
+      // The hmr/fast-refresh websocket in this server collides with the one in
+      // the other Vite server. So we can either disable it or run it on a
+      // different port.
+      // TODO (RSC): Figure out if we should disable or just pick a different
+      // port
+      ws: false
+      // hmr: {
+      //   port: 24679,
+      // },
+    },
+    appType: "custom",
+    // Using a unique cache dir here to not clash with our other vite server
+    cacheDir: "../node_modules/.vite-rsc"
+  });
+  globalThis.__cedarjs__vite_rsc_runtime = (0, import_vite.createServerModuleRunner)(
+    viteRscServer.environments.ssr
+  );
   const handleWithMiddleware = (route) => {
     return (0, import_server.createServerAdapter)(async (req) => {
-      const middlewareRouter = await (0, import_register.createMiddlewareRouter)(vite);
+      const middlewareRouter = await (0, import_register.createMiddlewareRouter)(viteSsrDevServer);
       const middleware = middlewareRouter.find(
         req.method,
         req.url
@@ -96,19 +354,22 @@ async function createServer() {
       }
       const [mwRes] = await (0, import_invokeMiddleware.invoke)(req, middleware, {
         route,
-        viteDevServer: vite
+        viteSsrDevServer
       });
       return mwRes.toResponse();
     });
   };
-  app.use(vite.middlewares);
+  app.use(viteSsrDevServer.middlewares);
   if (rscEnabled) {
-    const { createRscRequestHandler } = await import("./rsc/rscRequestHandler.js");
+    (0, import_rscWebSocketServer.createWebSocketServer)();
+    const { createRscRequestHandler } = await globalThis.__cedarjs__vite_rsc_runtime.import(
+      new URL("./rsc/rscRequestHandler.js", import_meta.url).pathname
+    );
     app.use(
       "/rw-rsc",
-      createRscRequestHandler({
-        getMiddlewareRouter: async () => (0, import_register.createMiddlewareRouter)(vite),
-        viteDevServer: vite
+      await createRscRequestHandler({
+        getMiddlewareRouter: async () => (0, import_register.createMiddlewareRouter)(viteSsrDevServer),
+        viteSsrDevServer
       })
     );
   }
@@ -118,18 +379,22 @@ async function createServer() {
       routes,
       clientEntryPath: rwPaths.web.entryClient,
       getStylesheetLinks: (route) => {
-        return getCssLinks({ rwPaths, route, vite });
+        return getCssLinks({
+          rwPaths,
+          route,
+          viteSsrDevServer
+        });
       },
       // Recreate middleware router on each request in dev
-      getMiddlewareRouter: async () => (0, import_register.createMiddlewareRouter)(vite)
+      getMiddlewareRouter: async () => (0, import_register.createMiddlewareRouter)(viteSsrDevServer)
     },
-    vite
+    viteSsrDevServer
   );
   app.get("*", (0, import_server.createServerAdapter)(routeHandler));
   app.post("*", handleWithMiddleware());
   const port = (0, import_project_config.getConfig)().web.port;
   console.log(`Started server on http://localhost:${port}`);
-  return app.listen(port);
+  return server.listen(port);
 }
 let devApp = createServer();
 process.stdin.on("data", async (data) => {
@@ -144,11 +409,11 @@ process.stdin.on("data", async (data) => {
 function getCssLinks({
   rwPaths,
   route,
-  vite
+  viteSsrDevServer
 }) {
   const appAndRouteModules = (0, import_collectCss.componentsModules)(
     [rwPaths.web.app, route?.filePath].filter(Boolean),
-    vite
+    viteSsrDevServer
   );
   const collectedCss = (0, import_collectCss.collectCssPaths)(appAndRouteModules);
   const cssLinks = Array.from(collectedCss);

package/dist/cjs/lib/registerFwGlobalsAndShims.js

@@ -79,6 +79,15 @@ function registerFwShims() {
   globalThis.__rw_module_cache__ ||= /* @__PURE__ */ new Map();
   globalThis.__webpack_chunk_load__ ||= async (id) => {
     console.log("registerFwShims chunk load id", id);
+    if (globalThis.__cedarjs__vite_ssr_runtime) {
+      return globalThis.__cedarjs__vite_ssr_runtime?.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);
+      });
+    }
     return import(id).then((mod) => {
       console.log("registerFwShims chunk load mod", mod);
       if (mod.default && typeof mod.default === "object") {

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,

package/dist/cjs/rsc/rscWebSocketServer.js

@@ -0,0 +1,56 @@
+"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 rscWebSocketServer_exports = {};
+__export(rscWebSocketServer_exports, {
+  createWebSocketServer: () => createWebSocketServer
+});
+module.exports = __toCommonJS(rscWebSocketServer_exports);
+var import_ws = __toESM(require("ws"), 1);
+function createWebSocketServer() {
+  const wsServer = new import_ws.WebSocketServer({ port: 18998 });
+  wsServer.on("connection", (ws) => {
+    console.log("A new client connected.");
+    ws.on("message", (data) => {
+      const message = data.toString();
+      console.log("Received message:", message);
+      wsServer.clients.forEach((client) => {
+        if (client.readyState === import_ws.default.OPEN) {
+          client.send(message);
+        }
+      });
+    });
+    ws.on("close", () => {
+      console.log("A client disconnected.");
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWebSocketServer
+});

package/dist/cjs/rsc/utils.js

@@ -0,0 +1,56 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  importRscReact: () => importRscReact,
+  importRsdwServer: () => importRsdwServer
+});
+module.exports = __toCommonJS(utils_exports);
+async function importRscReact() {
+  if (globalThis.__cedarjs__vite_rsc_runtime) {
+    const reactMod = await globalThis.__cedarjs__vite_rsc_runtime.import("react");
+    return reactMod.default;
+  }
+  return import("react");
+}
+async function importRsdwServer() {
+  if (globalThis.__cedarjs__vite_rsc_runtime) {
+    const rsdwServerMod = await globalThis.__cedarjs__vite_rsc_runtime.import(
+      "react-server-dom-webpack/server.edge"
+    );
+    return rsdwServerMod.default;
+  } else {
+    return import("react-server-dom-webpack/server.edge");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importRscReact,
+  importRsdwServer
+});