@cedarjs/vite 0.0.4

package/dist/cjs/rsc/rscRenderer.js

@@ -0,0 +1,165 @@
+"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 rscRenderer_exports = {};
+__export(rscRenderer_exports, {
+  renderRscToStream: () => renderRscToStream,
+  setClientEntries: () => setClientEntries
+});
+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");
+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 (0, import_entries.getEntriesFromDist)();
+  console.log("rscRenderer.ts serverEntries", serverEntries);
+  const routesPath = import_node_path.default.join(
+    (0, import_project_config.getPaths)().web.distRsc,
+    serverEntries["__rwjs__Routes"]
+  );
+  if (!routesPath) {
+    throw new import_StatusError.StatusError("No entry found for __rwjs__Routes", 404);
+  }
+  const routes = await loadServerFile(routesPath);
+  return routes.default;
+};
+async function setClientEntries() {
+  const entriesFile = (0, import_project_config.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 = import_node_path.default.dirname(entriesFile);
+  absoluteClientEntries = Object.fromEntries(
+    Object.entries(clientEntries).map(([key, val]) => {
+      let fullKey = import_node_path.default.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: (0, import_react.createElement)(serverRoutes)
+  };
+  console.log("rscRenderer.ts renderRsc model", model);
+  return (0, import_server.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 module2 = 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 = module2[actionName] || module2;
+  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: (0, import_react.createElement)(serverRoutes),
+    __rwjs__rsa_data: data
+  };
+  console.log("rscRenderer.ts executeRsa model", model);
+  return (0, import_server.renderToReadableStream)(model, getBundlerConfig());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderRscToStream,
+  setClientEntries
+});

package/dist/cjs/rsc/rscRequestHandler.js

@@ -0,0 +1,162 @@
+"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 rscRequestHandler_exports = {};
+__export(rscRequestHandler_exports, {
+  createRscRequestHandler: () => createRscRequestHandler
+});
+module.exports = __toCommonJS(rscRequestHandler_exports);
+var import_node_stream = require("node:stream");
+var DefaultFetchAPI = __toESM(require("@whatwg-node/fetch"), 1);
+var import_server = require("@whatwg-node/server");
+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) {
+  return async (req, res, next) => {
+    console.log("BASE_PATH", BASE_PATH);
+    console.log("req.originalUrl", req.originalUrl, "req.url", req.url);
+    console.log("req.headers.host", req.headers.host);
+    console.log("req.headers['rw-rsc']", req.headers["rw-rsc"]);
+    const mwRouter = await options.getMiddlewareRouter();
+    if (mwRouter) {
+      const webReq = (0, import_server.normalizeNodeRequest)(req, DefaultFetchAPI);
+      const matchedMw = mwRouter.find(webReq.method, webReq.url);
+      const [mwResponse] = await (0, import_invokeMiddleware.invoke)(
+        webReq,
+        matchedMw?.handler,
+        {
+          params: matchedMw?.params,
+          viteDevServer: options.viteDevServer
+        }
+      );
+      const webRes = mwResponse.toResponse();
+      webRes.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+      });
+      if (mwResponse.isRedirect() || mwResponse.body) {
+        throw new Error(
+          "Not Implemented: What should happen if this RSC handler fails? And which part - Client side router?"
+        );
+      }
+    }
+    if (req.headers["rw-rsc"] !== "1") {
+      return next();
+    }
+    const url = new URL(req.originalUrl || "", "http://" + req.headers.host);
+    let rscId;
+    let rsaId;
+    let args = [];
+    if (url.pathname.startsWith(BASE_PATH)) {
+      rscId = url.pathname.split("/").pop();
+      rsaId = url.searchParams.get("action_id") || void 0;
+      console.log("rscId", rscId);
+      console.log("rsaId", rsaId);
+      if (rscId && rscId !== "_") {
+        res.setHeader("Content-Type", "text/x-component");
+      } else {
+        rscId = void 0;
+      }
+      args = await handleRsa(rsaId, req, args);
+    }
+    console.log("rscRequestHandler: args", args);
+    if (rscId || rsaId) {
+      const handleError = (err) => {
+        console.log("handleError() err", err);
+        if ((0, import_StatusError.hasStatusCode)(err)) {
+          res.statusCode = err.statusCode;
+        } else {
+          console.info("Cannot render RSC", err);
+          res.statusCode = 500;
+        }
+        res.end(String(err));
+      };
+      try {
+        const readable = await (0, import_rscRenderer.renderRscToStream)({ rscId, rsaId, args });
+        import_node_stream.Readable.fromWeb(readable).pipe(res);
+        await (0, import_rscStudioHandlers.sendRscFlightToStudio)({
+          rscId,
+          rsaId,
+          args,
+          basePath: BASE_PATH,
+          req,
+          handleError
+        });
+      } catch (e) {
+        handleError(e);
+      }
+    }
+  };
+}
+async function handleRsa(rsaId, req, args) {
+  if (!rsaId) {
+    return args;
+  }
+  if (req.headers["content-type"]?.startsWith("multipart/form-data")) {
+    console.log("RSA: multipart/form-data");
+    const bb = (0, import_busboy.default)({ headers: req.headers });
+    const reply = (0, import_react_server_dom_webpack_server.decodeReplyFromBusboy)(bb);
+    req.pipe(bb);
+    args = await reply;
+    if (args[0] instanceof FormData) {
+      const serializedFormData = {};
+      for (const [key, value] of args[0]) {
+        if (serializedFormData[key] !== void 0) {
+          if (!Array.isArray(serializedFormData[key])) {
+            serializedFormData[key] = [serializedFormData[key]];
+          }
+          serializedFormData[key].push(value);
+        } else {
+          serializedFormData[key] = value;
+        }
+      }
+      args[0] = {
+        __formData__: true,
+        state: serializedFormData
+      };
+    }
+  } else {
+    console.log("RSA: regular body");
+    let body = "";
+    for await (const chunk of req) {
+      body += chunk;
+    }
+    if (body) {
+      args = await (0, import_react_server_dom_webpack_server.decodeReply)(body);
+    }
+  }
+  return args;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRscRequestHandler
+});

package/dist/cjs/rsc/rscStudioHandlers.js

@@ -0,0 +1,154 @@
+"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 rscStudioHandlers_exports = {};
+__export(rscStudioHandlers_exports, {
+  sendRscFlightToStudio: () => sendRscFlightToStudio
+});
+module.exports = __toCommonJS(rscStudioHandlers_exports);
+var import_node_http = __toESM(require("node:http"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_rscRenderer = require("./rscRenderer.js");
+const isTest = () => {
+  return process.env.NODE_ENV === "test";
+};
+const isDevelopment = () => {
+  return process.env.NODE_ENV !== "production" && !isTest();
+};
+const isStudioEnabled = () => {
+  return (0, import_project_config.getRawConfig)()["studio"] !== void 0;
+};
+const shouldSendToStudio = () => {
+  return isStudioEnabled() && !isDevelopment();
+};
+const getStudioPort = () => {
+  return (0, import_project_config.getConfig)().studio.basePort;
+};
+const processRenderRscStream = async (readable) => {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const writable = new WritableStream({
+      write(chunk) {
+        chunks.push(chunk);
+      },
+      close() {
+        resolve(Buffer.concat(chunks).toString("utf8"));
+      }
+    });
+    readable.pipeTo(writable).catch((error) => reject(error));
+  });
+};
+const postFlightToStudio = (payload, metadata) => {
+  if (!shouldSendToStudio()) {
+    return;
+  }
+  const base64Payload = Buffer.from(payload).toString("base64");
+  const encodedMetadata = Buffer.from(JSON.stringify(metadata)).toString(
+    "base64"
+  );
+  const jsonBody = JSON.stringify({
+    flight: {
+      encodedPayload: base64Payload,
+      encoding: "base64",
+      encodedMetadata
+    }
+  });
+  const options = {
+    hostname: "localhost",
+    port: getStudioPort(),
+    path: "/.redwood/functions/rsc-flight",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(jsonBody)
+    }
+  };
+  const req = import_node_http.default.request(options, (res) => {
+    res.setEncoding("utf8");
+  });
+  req.on("error", (e) => {
+    console.error("An error occurred sending the Flight Payload to Studio");
+    console.error(e);
+  });
+  req.write(jsonBody);
+  req.end();
+};
+const createStudioFlightHandler = (readable, metadata) => {
+  processRenderRscStream(readable).then((payload) => {
+    console.debug("Sending RSC Rendered stream to Studio");
+    postFlightToStudio(payload, metadata);
+    console.debug("Sent RSC Rendered stream to Studio");
+    console.debug("payload to Studio:", payload);
+    console.debug("metadata to Studio:", metadata);
+  }).catch((error) => {
+    console.error("An error occurred getting RSC Rendered steam:", error);
+  });
+};
+const sendRscFlightToStudio = async (input) => {
+  if (!shouldSendToStudio()) {
+    console.debug("Studio is not enabled");
+    return;
+  }
+  const { rscId, rsaId, args, basePath, req, handleError } = input;
+  try {
+    const startedAt = Date.now();
+    const start = performance.now();
+    const readable = await (0, import_rscRenderer.renderRscToStream)({ rscId, rsaId, args });
+    const endedAt = Date.now();
+    const end = performance.now();
+    const duration = end - start;
+    const metadata = {
+      rsc: {
+        rscId,
+        rsaId,
+        args
+      },
+      request: {
+        basePath,
+        originalUrl: req.originalUrl,
+        url: req.url,
+        headers: req.headers
+      },
+      performance: {
+        startedAt,
+        endedAt,
+        duration
+      }
+    };
+    createStudioFlightHandler(readable, metadata);
+  } catch (e) {
+    if (e instanceof Error) {
+      console.error("An error occurred rendering RSC and sending to Studio:", e);
+      handleError(e);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sendRscFlightToStudio
+});

package/dist/cjs/runFeServer.js

@@ -0,0 +1,166 @@
+"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 runFeServer_exports = {};
+__export(runFeServer_exports, {
+  runFeServer: () => runFeServer
+});
+module.exports = __toCommonJS(runFeServer_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = __toESM(require("node:url"), 1);
+var import_server = require("@whatwg-node/server");
+var import_dotenv_defaults = require("dotenv-defaults");
+var import_express = __toESM(require("express"), 1);
+var import_http_proxy_middleware = require("http-proxy-middleware");
+var import_ws = __toESM(require("ws"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_rscCss = require("@cedarjs/router/rscCss");
+var import_server_store = require("@cedarjs/server-store");
+var import_registerFwGlobalsAndShims = require("./lib/registerFwGlobalsAndShims.js");
+var import_invokeMiddleware = require("./middleware/invokeMiddleware.js");
+var import_register = require("./middleware/register.js");
+var import_createReactStreamingHandler = require("./streaming/createReactStreamingHandler.js");
+var import_utils = require("./utils.js");
+(0, import_dotenv_defaults.config)({
+  path: import_node_path.default.join((0, import_project_config.getPaths)().base, ".env"),
+  defaults: import_node_path.default.join((0, import_project_config.getPaths)().base, ".env.defaults"),
+  // @ts-expect-error - Old typings. @types/dotenv-defaults depends on dotenv
+  // v8. dotenv-defaults uses dotenv v14
+  multiline: true
+});
+async function runFeServer() {
+  const app = (0, import_express.default)();
+  const rwPaths = (0, import_project_config.getPaths)();
+  const rwConfig = (0, import_project_config.getConfig)();
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  (0, import_registerFwGlobalsAndShims.registerFwGlobalsAndShims)();
+  if (rscEnabled) {
+    const { setClientEntries } = await import("./rsc/rscRenderer.js");
+    createWebSocketServer();
+    try {
+      await setClientEntries();
+    } catch (e) {
+      console.error("Failed to load client entries");
+      console.error(e);
+      process.exit(1);
+    }
+  }
+  const routeManifestUrl = import_node_url.default.pathToFileURL(rwPaths.web.routeManifest).href;
+  const routeManifest = (await import(routeManifestUrl, { with: { type: "json" } })).default;
+  const clientBuildManifestUrl = import_node_url.default.pathToFileURL(
+    import_node_path.default.join(rwPaths.web.distBrowser, "client-build-manifest.json")
+  ).href;
+  const clientBuildManifest = (await import(clientBuildManifestUrl, { with: { type: "json" } })).default;
+  const clientEntry = rscEnabled ? clientBuildManifest["entry.client.tsx"] || clientBuildManifest["entry.client.jsx"] : Object.values(clientBuildManifest).find(
+    (manifestItem) => manifestItem.isEntry
+  );
+  if (!clientEntry) {
+    throw new Error("Could not find client entry in build manifest");
+  }
+  const middlewareRouter = await (0, import_register.createMiddlewareRouter)();
+  const serverStorage = (0, import_server_store.createServerStorage)();
+  const handleWithMiddleware = () => {
+    return (0, import_server.createServerAdapter)(async (req) => {
+      const matchedMw = middlewareRouter.find(req.method, req.url);
+      const handler = matchedMw?.handler;
+      if (!matchedMw) {
+        return new Response("No middleware found", { status: 404 });
+      }
+      const [mwRes] = await (0, import_invokeMiddleware.invoke)(req, handler, {
+        params: matchedMw?.params
+      });
+      return mwRes.toResponse();
+    });
+  };
+  app.use(
+    "/assets",
+    import_express.default.static(rwPaths.web.distBrowser + "/assets", { index: false })
+  );
+  app.use("*", (req, _res, next) => {
+    const fullUrl = (0, import_utils.getFullUrl)(req, rscEnabled);
+    const headers = (0, import_utils.convertExpressHeaders)(req.headersDistinct);
+    const perReqStore = (0, import_server_store.createPerRequestMap)({ headers, fullUrl });
+    serverStorage.run(perReqStore, next);
+  });
+  app.use(
+    rwConfig.web.apiUrl,
+    (0, import_http_proxy_middleware.createProxyMiddleware)({
+      changeOrigin: false,
+      // Using 127.0.0.1 to force ipv4. With `localhost` you don't really know
+      // if it's going to be ipv4 or ipv6
+      target: `http://127.0.0.1:${rwConfig.api.port}`
+    })
+  );
+  if (rscEnabled) {
+    const { createRscRequestHandler } = await import("./rsc/rscRequestHandler.js");
+    app.use(
+      "/rw-rsc",
+      createRscRequestHandler({
+        getMiddlewareRouter: async () => middlewareRouter
+      })
+    );
+  }
+  app.use(import_express.default.static(rwPaths.web.distBrowser, { index: false }));
+  const getStylesheetLinks = rscEnabled ? (0, import_rscCss.getRscStylesheetLinkGenerator)(clientEntry.css) : () => clientEntry.css || [];
+  const routeHandler = await (0, import_createReactStreamingHandler.createReactStreamingHandler)({
+    routes: Object.values(routeManifest),
+    clientEntryPath: clientEntry.file,
+    getStylesheetLinks,
+    getMiddlewareRouter: async () => middlewareRouter
+  });
+  app.get("*", (0, import_server.createServerAdapter)(routeHandler));
+  app.post("*", handleWithMiddleware());
+  app.listen(rwConfig.web.port);
+  console.log(
+    `Started production FE server on http://localhost:${rwConfig.web.port}`
+  );
+}
+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("runFeServer.ts: Received message:");
+      console.log(message.slice(0, 120) + "...");
+      wsServer.clients.forEach((client) => {
+        if (client.readyState === import_ws.default.OPEN) {
+          client.send(message);
+        }
+      });
+    });
+    ws.on("close", () => {
+      console.log("A client disconnected.");
+    });
+  });
+}
+runFeServer();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runFeServer
+});