vite-plugin-react-server 1.2.0-alpha.0 → 1.2.0

package/dist/plugin/stream/createRscStream.client.js

@@ -0,0 +1,79 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createSerializableHandlerOptions } from '../helpers/createSerializableHandlerOptions.js';
+import { assertNonReactServer } from '../config/getCondition.js';
+import { validateRscStreamOptions } from './createRscStream.utils.js';
+import { toError } from '../error/toError.js';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
+import { createMessageChannels } from './createMessageChannels.js';
+import { MessagePortReadable } from './MessagePortReadable.js';
+
+assertNonReactServer();
+const createRscStream = function _createRscStreamClient(options) {
+  validateRscStreamOptions(options, "createRscStream.client");
+  if (!options.rscWorker) {
+    throw new Error("RSC worker is required for client-side RSC streaming");
+  }
+  const { dataPort1, dataPort2, controlPort1, controlPort2 } = createMessageChannels();
+  const rscStream = new MessagePortReadable(dataPort1, controlPort1);
+  controlPort1.on("message", (message) => {
+    switch (message.type) {
+      case "ERROR":
+        const error = toError(message.error, message.errorInfo);
+        if (options.onEvent) {
+          options.onEvent({
+            type: "route.error",
+            data: {
+              error,
+              route: options.route,
+              panicThreshold: options.panicThreshold
+            }
+          });
+        }
+        rscStream.destroy();
+        break;
+    }
+  });
+  const serializedOptions = createSerializableHandlerOptions({
+    ...options,
+    dataPort: dataPort2,
+    controlPort: controlPort2
+  });
+  options.rscWorker.postMessage({
+    type: "INIT",
+    id: options.route,
+    dataPort: dataPort2,
+    controlPort: controlPort2,
+    options: serializedOptions
+  }, [dataPort2, controlPort2]);
+  const metrics = createStreamMetrics({
+    route: options.route,
+    startTime: Date.now()
+  });
+  const clientResult = {
+    type: "client",
+    id: options.id || `${options.route}-${Date.now()}`,
+    rscStream,
+    metrics,
+    pipe: (destination) => {
+      return rscStream.pipe(destination);
+    },
+    abort: (reason) => {
+      try {
+        controlPort1.postMessage({ type: "ABORT", reason });
+      } catch (error) {
+      }
+      try {
+        rscStream.destroy();
+      } catch (error) {
+      }
+    }
+  };
+  return clientResult;
+};
+
+export { createRscStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createRscStream.client.js","sources":["../../../plugin/stream/createRscStream.client.ts"],"sourcesContent":["import { createSerializableHandlerOptions } from \"../helpers/createSerializableHandlerOptions.js\";\nimport type { CreateRscStreamFn, ClientRscStreamResult } from \"./createRscStream.types.js\";\nimport { assertNonReactServer } from \"../config/getCondition.js\";\nimport { validateRscStreamOptions } from \"./createRscStream.utils.js\";\nimport { toError } from \"../error/toError.js\";\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\nimport { createMessageChannels } from \"./createMessageChannels.js\";\nimport { MessagePortReadable } from \"./MessagePortReadable.js\";\n\nassertNonReactServer();\n\n/**\n * Creates an RSC stream by communicating with the RSC worker.\n * \n * **Purpose**: Creates RSC streams by offloading React rendering to a separate worker thread.\n * **When to use**: \n * - You need to create RSC streams in a client environment\n * - You want to avoid blocking the main thread during React rendering\n * - You're building static sites and need RSC content for multiple routes\n * - You need to create .rsc files for client-side navigation\n * \n * **Flow**: Route + Components → RSC Worker → RSC Stream\n * \n * @param options - Options for RSC stream creation\n * @returns RSC stream with pipe/abort interface\n */\nexport const createRscStream: CreateRscStreamFn<\"client\"> = function _createRscStreamClient(options) {\n  // Validate options\n  validateRscStreamOptions(options, \"createRscStream.client\");\n\n  if (!options.rscWorker) {\n    throw new Error(\"RSC worker is required for client-side RSC streaming\");\n  }\n\n  // Create two separate MessagePorts for clean separation of concerns\n  const { dataPort1, dataPort2, controlPort1, controlPort2 } = createMessageChannels();\n\n  // Create the RSC output stream\n  const rscStream = new MessagePortReadable(dataPort1, controlPort1);\n\n  // Control port - handles control messages\n  controlPort1.on('message', (message: any) => {\n    switch (message.type) {\n      case 'ERROR':\n        const error = toError(message.error, message.errorInfo);\n        \n        // Emit route.error event for panic handling\n        if (options.onEvent) {\n          options.onEvent({\n            type: \"route.error\",\n            data: {\n              error: error,\n              route: options.route,\n              panicThreshold: options.panicThreshold\n            }\n          });\n        }\n        \n        // End the stream normally\n        rscStream.destroy();\n        break;\n      case 'RSC_END':\n        // Worker has finished sending data - don't close ports yet\n        // Let the MessagePortReadable handle the natural end of stream\n        break;\n      case 'METRICS':\n        // Metrics are handled by the worker internally\n        break;\n    }\n  });\n\n  // Create serializable handler options for the worker\n  const serializedOptions = createSerializableHandlerOptions({\n    ...options,\n    dataPort: dataPort2,\n    controlPort: controlPort2,\n  });\n\n  // Send initialization to worker\n  options.rscWorker.postMessage({\n    type: \"INIT\",\n    id: options.route,\n    dataPort: dataPort2,\n    controlPort: controlPort2,\n    options: serializedOptions,\n  }, [dataPort2, controlPort2] as any);\n\n  // Create stream metrics\n  const metrics = createStreamMetrics({\n    route: options.route,\n    startTime: Date.now(),\n  });\n\n  // Return client result with consistent interface\n  const clientResult: ClientRscStreamResult = {\n    type: \"client\" as const,\n    id: options.id || `${options.route}-${Date.now()}`,\n    rscStream,\n    metrics,\n    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => {\n      return rscStream.pipe(destination);\n    },\n    abort: (reason?: unknown) => {\n      try {\n        controlPort1.postMessage({ type: \"ABORT\", reason });\n      } catch (error) {\n        // Port may already be closed\n      }\n      \n      // Immediate cleanup for abort to prevent hanging\n      try {\n        rscStream.destroy();\n      } catch (error) {\n        // Stream may already be destroyed, ignore\n      }\n      // Don't close ports - let React handle cleanup to prevent \"Connection closed\" errors\n      // Ports will be cleaned up when worker terminates\n    },\n  };\n\n  return clientResult;\n};"],"names":[],"mappings":";;;;;;;;;;;;;AASA,oBAAqB,EAAA;AAiBR,MAAA,eAAA,GAA+C,SAAS,sBAAA,CAAuB,OAAS,EAAA;AAEnG,EAAA,wBAAA,CAAyB,SAAS,wBAAwB,CAAA;AAE1D,EAAI,IAAA,CAAC,QAAQ,SAAW,EAAA;AACtB,IAAM,MAAA,IAAI,MAAM,sDAAsD,CAAA;AAAA;AAIxE,EAAA,MAAM,EAAE,SAAW,EAAA,SAAA,EAAW,YAAc,EAAA,YAAA,KAAiB,qBAAsB,EAAA;AAGnF,EAAA,MAAM,SAAY,GAAA,IAAI,mBAAoB,CAAA,SAAA,EAAW,YAAY,CAAA;AAGjE,EAAa,YAAA,CAAA,EAAA,CAAG,SAAW,EAAA,CAAC,OAAiB,KAAA;AAC3C,IAAA,QAAQ,QAAQ,IAAM;AAAA,MACpB,KAAK,OAAA;AACH,QAAA,MAAM,KAAQ,GAAA,OAAA,CAAQ,OAAQ,CAAA,KAAA,EAAO,QAAQ,SAAS,CAAA;AAGtD,QAAA,IAAI,QAAQ,OAAS,EAAA;AACnB,UAAA,OAAA,CAAQ,OAAQ,CAAA;AAAA,YACd,IAAM,EAAA,aAAA;AAAA,YACN,IAAM,EAAA;AAAA,cACJ,KAAA;AAAA,cACA,OAAO,OAAQ,CAAA,KAAA;AAAA,cACf,gBAAgB,OAAQ,CAAA;AAAA;AAC1B,WACD,CAAA;AAAA;AAIH,QAAA,SAAA,CAAU,OAAQ,EAAA;AAClB,QAAA;AAOA;AACJ,GACD,CAAA;AAGD,EAAA,MAAM,oBAAoB,gCAAiC,CAAA;AAAA,IACzD,GAAG,OAAA;AAAA,IACH,QAAU,EAAA,SAAA;AAAA,IACV,WAAa,EAAA;AAAA,GACd,CAAA;AAGD,EAAA,OAAA,CAAQ,UAAU,WAAY,CAAA;AAAA,IAC5B,IAAM,EAAA,MAAA;AAAA,IACN,IAAI,OAAQ,CAAA,KAAA;AAAA,IACZ,QAAU,EAAA,SAAA;AAAA,IACV,WAAa,EAAA,YAAA;AAAA,IACb,OAAS,EAAA;AAAA,GACR,EAAA,CAAC,SAAW,EAAA,YAAY,CAAQ,CAAA;AAGnC,EAAA,MAAM,UAAU,mBAAoB,CAAA;AAAA,IAClC,OAAO,OAAQ,CAAA,KAAA;AAAA,IACf,SAAA,EAAW,KAAK,GAAI;AAAA,GACrB,CAAA;AAGD,EAAA,MAAM,YAAsC,GAAA;AAAA,IAC1C,IAAM,EAAA,QAAA;AAAA,IACN,EAAA,EAAI,QAAQ,EAAM,IAAA,CAAA,EAAG,QAAQ,KAAK,CAAA,CAAA,EAAI,IAAK,CAAA,GAAA,EAAK,CAAA,CAAA;AAAA,IAChD,SAAA;AAAA,IACA,OAAA;AAAA,IACA,IAAA,EAAM,CAAyC,WAA0B,KAAA;AACvE,MAAO,OAAA,SAAA,CAAU,KAAK,WAAW,CAAA;AAAA,KACnC;AAAA,IACA,KAAA,EAAO,CAAC,MAAqB,KAAA;AAC3B,MAAI,IAAA;AACF,QAAA,YAAA,CAAa,WAAY,CAAA,EAAE,IAAM,EAAA,OAAA,EAAS,QAAQ,CAAA;AAAA,eAC3C,KAAO,EAAA;AAAA;AAKhB,MAAI,IAAA;AACF,QAAA,SAAA,CAAU,OAAQ,EAAA;AAAA,eACX,KAAO,EAAA;AAAA;AAEhB;AAGF,GACF;AAEA,EAAO,OAAA,YAAA;AACT;;;;"}

package/dist/plugin/stream/createRscStream.d.ts

@@ -0,0 +1,2 @@
+export declare const createRscStream: any;
+//# sourceMappingURL=createRscStream.d.ts.map

package/dist/plugin/stream/createRscStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRscStream.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createRscStream.ts"],"names":[],"mappings":"AAKA,eAAO,MAAQ,eAAe,KAE7B,CAAC"}

package/dist/plugin/stream/createRscStream.js

@@ -0,0 +1,13 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { getCondition } from '../config/getCondition.js';
+
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+const condition = getCondition("");
+const { createRscStream } = await import(`${dir}/createRscStream.${condition}.js`);
+
+export { createRscStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlUnNjU3RyZWFtLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vc3RyZWFtL2NyZWF0ZVJzY1N0cmVhbS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBnZXRDb25kaXRpb24gfSBmcm9tIFwiLi4vY29uZmlnL2dldENvbmRpdGlvbi5qc1wiO1xuXG5jb25zdCBkaXIgPSBuZXcgVVJMKFwiLi9cIiwgaW1wb3J0Lm1ldGEudXJsKS5wYXRobmFtZS5yZXBsYWNlKC9cXC8kLywgXCJcIik7XG5jb25zdCBjb25kaXRpb24gPSBnZXRDb25kaXRpb24oXCJcIik7XG5cbmV4cG9ydCBjb25zdCB7IGNyZWF0ZVJzY1N0cmVhbSB9ID0gKGF3YWl0IGltcG9ydChgJHtkaXJ9L2NyZWF0ZVJzY1N0cmVhbS4ke2NvbmRpdGlvbn0uanNgKSkgYXMge1xuICBjcmVhdGVSc2NTdHJlYW06IGFueTtcbn07ICJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBRUEsTUFBTSxHQUFBLEdBQU0sSUFBSSxHQUFBLENBQUksSUFBTSxFQUFBLE1BQUEsQ0FBQSxJQUFBLENBQVksR0FBRyxDQUFFLENBQUEsUUFBQSxDQUFTLE9BQVEsQ0FBQSxLQUFBLEVBQU8sRUFBRSxDQUFBO0FBQ3JFLE1BQU0sU0FBQSxHQUFZLGFBQWEsRUFBRSxDQUFBO0FBRXBCLE1BQUEsRUFBRSxpQkFBcUIsR0FBQSxNQUFNLE9BQU8sQ0FBRyxFQUFBLEdBQUcsb0JBQW9CLFNBQVMsQ0FBQSxHQUFBLENBQUE7Ozs7In0=

package/dist/plugin/stream/createRscStream.server.d.ts

@@ -0,0 +1,46 @@
+import type { CreateRscStreamFn } from "./createRscStream.types.js";
+/**
+ * Creates an RSC stream using the server-side render handler.
+ *
+ * **Purpose**: Creates RSC streams directly in the server environment without worker threads.
+ * **When to use**:
+ * - You're in a server environment (Node.js server)
+ * - You want to create RSC streams synchronously without worker overhead
+ * - You need RSC streams for server-side rendering or API responses
+ * - You're in a development server and want direct RSC generation
+ *
+ * **Flow**: Route + Components → RSC Stream (direct server rendering)
+ *
+ * @example
+ * ```typescript
+ * // Create RSC stream for server-side rendering
+ * const rscStream = createRscStream({
+ *   route: "/api/data",
+ *   PageComponent: DataPage,
+ *   RootComponent: RootLayout,
+ *   HtmlComponent: React.Fragment, // Headless for API
+ *   pageProps: { data: apiData },
+ *   logger: myLogger,
+ * });
+ *
+ * // Pipe to response
+ * rscStream.pipe(response);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create full RSC with HTML wrapper
+ * const rscFull = createRscStream({
+ *   route: "/about",
+ *   PageComponent: AboutPage,
+ *   RootComponent: RootLayout,
+ *   HtmlComponent: HtmlDocument, // Full HTML wrapper
+ *   pageProps: { title: "About Us" },
+ * });
+ * ```
+ *
+ * @param options - Options for RSC stream creation
+ * @returns RSC stream with pipe/abort interface
+ */
+export declare const createRscStream: CreateRscStreamFn<"server">;
+//# sourceMappingURL=createRscStream.server.d.ts.map

package/dist/plugin/stream/createRscStream.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRscStream.server.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createRscStream.server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,4BAA4B,CAAC;AAapC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,eAAe,EAAE,iBAAiB,CAAC,QAAQ,CA+HrD,CAAC"}

package/dist/plugin/stream/createRscStream.server.js

@@ -0,0 +1,113 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createRenderToPipeableStreamHandler } from './createRenderToPipeableStreamHandler.server.js';
+import { assertReactServer } from '../config/getCondition.js';
+import { validateRscStreamOptions, createBaseRscStreamResult, handleRscStreamError } from './createRscStream.utils.js';
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
+import { createRscWorkerStream } from './createRscWorkerStream.js';
+
+assertReactServer();
+const createRscStream = function _createRscStreamServer(options) {
+  const logger = options.logger;
+  const verbose = options.verbose || false;
+  validateRscStreamOptions(options, "createRscStream.server");
+  if (verbose) {
+    logger?.info(
+      `[createRscStream.server:${options.route}] Creating RSC stream for route: ${options.route}`
+    );
+  }
+  try {
+    if (verbose) {
+      logger?.info(`[createRscStream.server:${options.route}] Checking for rscWorker: ${!!options.rscWorker}`);
+    }
+    if (options.rscWorker) {
+      if (verbose) {
+        logger?.info(
+          `[createRscStream.server:${options.route}] Using worker-based RSC stream`
+        );
+      }
+      const workerStreamResult = createRscWorkerStream({
+        worker: options.rscWorker,
+        route: options.route,
+        url: options.url,
+        moduleBasePath: options.moduleBasePath,
+        moduleBaseURL: options.moduleBaseURL,
+        moduleRootPath: options.moduleRootPath,
+        projectRoot: options.projectRoot,
+        verbose,
+        logger,
+        panicThreshold: options.panicThreshold,
+        rscTimeout: options.rscTimeout,
+        serverPipeableStreamOptions: options.serverPipeableStreamOptions,
+        build: options.build,
+        pagePath: options.pagePath,
+        propsPath: options.propsPath,
+        rootPath: options.rootPath,
+        htmlPath: options.htmlPath
+      });
+      const { stream: workerStream, dataPort1, controlPort1 } = workerStreamResult;
+      const serverResult2 = {
+        type: "server",
+        rscStream: workerStream,
+        id: options.id || options.route,
+        pipe: (destination) => {
+          workerStream.pipe(destination);
+          return destination;
+        },
+        abort: () => {
+          try {
+            workerStream.destroy();
+          } catch (error) {
+          }
+          try {
+            dataPort1.onmessage = null;
+            controlPort1.onmessage = null;
+            dataPort1.close();
+            controlPort1.close();
+          } catch (error) {
+          }
+        },
+        metrics: createStreamMetrics()
+        // Worker will provide real metrics
+      };
+      return serverResult2;
+    }
+    const result = createRenderToPipeableStreamHandler(options);
+    if (!result || typeof result.pipe !== "function") {
+      throw new Error(
+        "createHandler returned invalid result - missing pipe function"
+      );
+    }
+    if (!result.rscStream) {
+      throw new Error(
+        "createHandler returned invalid result - missing stream"
+      );
+    }
+    const baseResult = createBaseRscStreamResult(
+      result.rscStream,
+      result.pipe,
+      result.abort,
+      result.metrics,
+      options.id || options.route
+    );
+    const serverResult = {
+      ...baseResult,
+      type: "server"
+    };
+    if (verbose) {
+      logger?.info(
+        `[createRscStream.server:${options.route}] RSC stream created successfully`
+      );
+    }
+    return serverResult;
+  } catch (error) {
+    handleRscStreamError(error, options, "RSC stream creation error");
+    throw error;
+  }
+};
+
+export { createRscStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createRscStream.server.js","sources":["../../../plugin/stream/createRscStream.server.ts"],"sourcesContent":["import { createRenderToPipeableStreamHandler } from \"./createRenderToPipeableStreamHandler.server.js\";\nimport type {\n  CreateRscStreamFn,\n  ServerRscStreamResult,\n} from \"./createRscStream.types.js\";\nimport { assertReactServer } from \"../config/getCondition.js\";\nimport {\n  validateRscStreamOptions,\n  createBaseRscStreamResult,\n  handleRscStreamError,\n} from \"./createRscStream.utils.js\";\n\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\nimport { createRscWorkerStream } from \"./createRscWorkerStream.js\";\n\nassertReactServer();\n\n/**\n * Creates an RSC stream using the server-side render handler.\n *\n * **Purpose**: Creates RSC streams directly in the server environment without worker threads.\n * **When to use**:\n * - You're in a server environment (Node.js server)\n * - You want to create RSC streams synchronously without worker overhead\n * - You need RSC streams for server-side rendering or API responses\n * - You're in a development server and want direct RSC generation\n *\n * **Flow**: Route + Components → RSC Stream (direct server rendering)\n *\n * @example\n * ```typescript\n * // Create RSC stream for server-side rendering\n * const rscStream = createRscStream({\n *   route: \"/api/data\",\n *   PageComponent: DataPage,\n *   RootComponent: RootLayout,\n *   HtmlComponent: React.Fragment, // Headless for API\n *   pageProps: { data: apiData },\n *   logger: myLogger,\n * });\n *\n * // Pipe to response\n * rscStream.pipe(response);\n * ```\n *\n * @example\n * ```typescript\n * // Create full RSC with HTML wrapper\n * const rscFull = createRscStream({\n *   route: \"/about\",\n *   PageComponent: AboutPage,\n *   RootComponent: RootLayout,\n *   HtmlComponent: HtmlDocument, // Full HTML wrapper\n *   pageProps: { title: \"About Us\" },\n * });\n * ```\n *\n * @param options - Options for RSC stream creation\n * @returns RSC stream with pipe/abort interface\n */\nexport const createRscStream: CreateRscStreamFn<\"server\"> =\n  function _createRscStreamServer(options) {\n    const logger = options.logger;\n    const verbose = options.verbose || false;\n\n    // Validate common options\n    validateRscStreamOptions(options, \"createRscStream.server\");\n\n    if (verbose) {\n      logger?.info(\n        `[createRscStream.server:${options.route}] Creating RSC stream for route: ${options.route}`\n      );\n    }\n\n    try {\n      // If worker is provided, use worker-based RSC stream\n      // note: don't use the main \"worker\" prop here, which is always the inverse worker (html-worker in server case)\n      if (verbose) {\n        logger?.info(`[createRscStream.server:${options.route}] Checking for rscWorker: ${!!options.rscWorker}`);\n      }\n      if (options.rscWorker) {\n        if (verbose) {\n          logger?.info(\n            `[createRscStream.server:${options.route}] Using worker-based RSC stream`\n          );\n        }\n\n        const workerStreamResult = createRscWorkerStream({\n          worker: options.rscWorker,\n          route: options.route,\n          url: options.url,\n          moduleBasePath: options.moduleBasePath,\n          moduleBaseURL: options.moduleBaseURL,\n          moduleRootPath: options.moduleRootPath,\n          projectRoot: options.projectRoot,\n          verbose,\n          logger,\n          panicThreshold: options.panicThreshold,\n          rscTimeout: options.rscTimeout,\n          serverPipeableStreamOptions: options.serverPipeableStreamOptions,\n          build: options.build,\n          pagePath: options.pagePath,\n          propsPath: options.propsPath,\n          rootPath: options.rootPath,\n          htmlPath: options.htmlPath,\n        });\n\n        const { stream: workerStream, dataPort1, controlPort1 } = workerStreamResult;\n\n        // Return worker stream with consistent interface\n        const serverResult: ServerRscStreamResult = {\n          type: \"server\" as const,\n          rscStream: workerStream,\n          id: options.id || options.route,\n          pipe: <Writable extends NodeJS.WritableStream>(\n            destination: Writable\n          ) => {\n            workerStream.pipe(destination);\n            return destination;\n          },\n          abort: () => {\n            try {\n              workerStream.destroy();\n            } catch (error) {\n              // Stream may already be destroyed, ignore\n            }\n            // Clean up MessagePort listeners to prevent memory leaks\n            try {\n              // Remove onmessage handlers (property assignment cleanup)\n              dataPort1.onmessage = null;\n              controlPort1.onmessage = null;\n              // Close MessagePorts\n              dataPort1.close();\n              controlPort1.close();\n            } catch (error) {\n              // Ignore cleanup errors\n            }\n          },\n          metrics: createStreamMetrics(), // Worker will provide real metrics\n        };\n\n        return serverResult;\n      }\n\n      // Otherwise, use direct server rendering\n      const result = createRenderToPipeableStreamHandler(options);\n\n      // Validate the result\n      if (!result || typeof result.pipe !== \"function\") {\n        throw new Error(\n          \"createHandler returned invalid result - missing pipe function\"\n        );\n      }\n\n      if (!result.rscStream) {\n        throw new Error(\n          \"createHandler returned invalid result - missing stream\"\n        );\n      }\n\n      // Create base result structure\n      const baseResult = createBaseRscStreamResult(\n        result.rscStream,\n        result.pipe,\n        result.abort,\n        result.metrics,\n        options.id || options.route\n      );\n\n      // Return server-specific results\n      const serverResult: ServerRscStreamResult = {\n        ...baseResult,\n        type: \"server\" as const,\n      };\n\n      if (verbose) {\n        logger?.info(\n          `[createRscStream.server:${options.route}] RSC stream created successfully`\n        );\n      }\n\n      return serverResult;\n    } catch (error) {\n      handleRscStreamError(error, options, \"RSC stream creation error\");\n      // This will never be reached as handleRscStreamError either throws or re-throws\n      throw error;\n    }\n  };\n"],"names":["serverResult"],"mappings":"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"}

package/dist/plugin/stream/createRscStream.types.d.ts

@@ -0,0 +1,134 @@
+import type { StreamMetrics } from "../helpers/metrics.js";
+import type { Stream } from "node:stream";
+import type { OnMetrics, PanicThreshold } from "../types.js";
+import type { SerializableHandlerOptions } from "../helpers/createSerializableHandlerOptions.js";
+/**
+ * Base RSC Stream Result - common interface for both client and server
+ */
+export interface BaseRscStreamResult {
+    id: string;
+    rscStream: Stream.Readable;
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+    abort: (reason?: unknown) => void;
+    metrics: StreamMetrics;
+}
+/**
+ * Client-specific RSC Stream Result
+ */
+export interface ClientRscStreamResult extends BaseRscStreamResult {
+    type: "client";
+}
+/**
+ * Server-specific RSC Stream Result
+ */
+export interface ServerRscStreamResult extends BaseRscStreamResult {
+    type: "server";
+}
+/**
+ * RSC Stream Result - union type for both environments
+ */
+export type RscStreamResult = ClientRscStreamResult | ServerRscStreamResult;
+/**
+ * Client-specific RSC Stream Options
+ */
+export type ClientRscStreamOptions = SerializableHandlerOptions & {
+    route: string;
+    pagePath: string | undefined;
+    projectRoot: string;
+    moduleBaseURL: string;
+    build: SerializableHandlerOptions['build'];
+    dev: SerializableHandlerOptions['dev'];
+    cssFiles: Map<string, any>;
+    globalCss: Map<string, any>;
+    manifest: any;
+    id?: string;
+    moduleRootPath?: string;
+    moduleBasePath?: string;
+    verbose?: boolean;
+    panicThreshold?: PanicThreshold;
+    propsPath?: string;
+    rootPath?: string;
+    htmlPath?: string;
+    pageExportName: string;
+    propsExportName: string;
+    rootExportName: string;
+    htmlExportName: string;
+    moduleBase: string;
+    publicOrigin: string;
+    rscTimeout: number;
+    rscWorker?: any;
+    htmlWorker?: any;
+    htmlWorkerPath?: string;
+    rscWorkerPath?: string;
+    worker?: any;
+    clientPipeableStreamOptions?: any;
+    serverPipeableStreamOptions?: any;
+    url: string;
+    onMetrics?: OnMetrics;
+    onEvent?: (event: any) => void;
+    reuseHeadlessStreamId?: string;
+};
+/**
+ * Server-specific RSC Stream Options
+ */
+export interface ServerRscStreamOptions {
+    route: string;
+    pagePath: string;
+    logger: any;
+    loader: any;
+    build: any;
+    id?: string;
+    projectRoot: string;
+    moduleRootPath: string;
+    moduleBasePath: string;
+    moduleBaseURL: string;
+    verbose: boolean;
+    panicThreshold?: PanicThreshold;
+    propsPath?: string;
+    rootPath?: string;
+    htmlPath?: string;
+    pageExportName: string;
+    propsExportName: string;
+    rootExportName: string;
+    htmlExportName: string;
+    moduleBase: string;
+    publicOrigin: string;
+    rscTimeout: number;
+    cssFiles: Map<string, any>;
+    globalCss: Map<string, any>;
+    manifest: any;
+    worker?: any;
+    rscWorker?: any;
+    rscWorkerPath?: string;
+    htmlWorker?: any;
+    htmlWorkerPath?: string;
+    clientPipeableStreamOptions?: any;
+    serverPipeableStreamOptions?: any;
+    url: string;
+    htmlTimeout?: number;
+    fileWriteTimeout?: number;
+    workerShutdownTimeout?: number;
+    css?: any;
+    onEvent?: (event: any) => void;
+}
+/**
+ * Environment-specific RSC Stream Options
+ */
+export type CreateRscStreamOptions<Env extends "client" | "server" = "client" | "server"> = Env extends "client" ? ClientRscStreamOptions : ServerRscStreamOptions;
+/**
+ * RSC Stream Function - creates React Server Components streams
+ *
+ * **Purpose**: Creates RSC streams for both client and server environments
+ * **When to use**:
+ * - You need to create RSC streams for static generation or server-side rendering
+ * - You want environment-specific optimizations (worker-based vs direct rendering)
+ * - You need to serialize React components for client-side hydration
+ *
+ * **Flow**: Route + Components → RSC Stream (with environment-specific processing)
+ */
+export type CreateRscStreamFn<Env extends "client" | "server" = "client" | "server"> = <Opt extends CreateRscStreamOptions<Env> = CreateRscStreamOptions<Env>>(options: Opt) => Env extends "client" ? ClientRscStreamResult : ServerRscStreamResult;
+/**
+ * Unified RSC Stream Function - automatically chooses environment
+ */
+export type CreateRscStreamFnUnified = <Env extends "client" | "server", Opt extends CreateRscStreamOptions<Env>>(options: Opt) => RscStreamResult;
+//# sourceMappingURL=createRscStream.types.d.ts.map

package/dist/plugin/stream/createRscStream.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRscStream.types.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createRscStream.types.ts"],"names":[],"mappings":"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"}

package/dist/plugin/stream/createRscStream.types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugin/stream/createRscStream.utils.d.ts

@@ -0,0 +1,54 @@
+import { createStreamMetrics } from "../helpers/metrics.js";
+import type { ClientRscStreamOptions, ServerRscStreamOptions, BaseRscStreamResult } from "./createRscStream.types.js";
+import type { PassThrough } from "node:stream";
+import { type Logger } from "vite";
+/**
+ * Validates common RSC stream options
+ *
+ * @param options - RSC stream options to validate
+ * @param context - Context for error messages
+ * @throws Error if validation fails
+ */
+export declare function validateRscStreamOptions(options: ClientRscStreamOptions | ServerRscStreamOptions, context: string): void;
+/**
+ * Creates common RSC stream result structure
+ *
+ * @param rscStream - The RSC stream
+ * @param elements - React elements
+ * @param pipe - Pipe function
+ * @param abort - Abort function
+ * @param metrics - Stream metrics
+ * @returns Base RSC stream result
+ */
+export declare function createBaseRscStreamResult(rscStream: PassThrough, pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable, abort: (reason?: unknown) => void, metrics: ReturnType<typeof createStreamMetrics>, id: string): BaseRscStreamResult;
+/**
+ * Handles RSC stream errors with consistent error handling
+ *
+ * @param error - The error that occurred
+ * @param options - RSC stream options for context
+ * @param context - Additional context for error handling
+ * @throws Error if panic threshold is met
+ */
+export declare function handleRscStreamError(error: unknown, options: ClientRscStreamOptions | ServerRscStreamOptions, context: string): void;
+/**
+ * Creates stream metrics with common setup
+ *
+ * @param route - Route for logging context
+ * @param verbose - Whether to enable verbose logging
+ * @returns Stream metrics instance
+ */
+export declare function createRscStreamMetrics(): ReturnType<typeof createStreamMetrics>;
+/**
+ * Sets up common stream event handlers for metrics collection
+ *
+ * @param stream - The stream to monitor
+ * @param metrics - Metrics to update
+ * @param options - Configuration options
+ * @returns Cleanup function
+ */
+export declare function setupRscStreamEventHandlers(stream: PassThrough, metrics: ReturnType<typeof createStreamMetrics>, options: {
+    route: string;
+    verbose?: boolean;
+    logger?: Logger;
+}): () => void;
+//# sourceMappingURL=createRscStream.utils.d.ts.map

package/dist/plugin/stream/createRscStream.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRscStream.utils.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createRscStream.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,MAAM,CAAC;AAEjD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,sBAAsB,GAAG,sBAAsB,EACxD,OAAO,EAAE,MAAM,GACd,IAAI,CAQN;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,WAAW,EACtB,IAAI,EAAE,CAAC,QAAQ,SAAS,MAAM,CAAC,cAAc,EAC3C,WAAW,EAAE,QAAQ,KAClB,QAAQ,EACb,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,EACjC,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,EAC/C,EAAE,EAAE,MAAM,GACT,mBAAmB,CAQrB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,sBAAsB,GAAG,sBAAsB,EACxD,OAAO,EAAE,MAAM,GACd,IAAI,CAcN;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,IAAI,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAI/E;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,EAC/C,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GACA,MAAM,IAAI,CAsDZ"}

package/dist/plugin/stream/createRscStream.utils.js

@@ -0,0 +1,91 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
+import { handleError } from '../error/handleError.js';
+import { getNodeEnv } from '../config/getNodeEnv.js';
+import { createLogger } from 'vite';
+
+function validateRscStreamOptions(options, context) {
+  if (!options.route) {
+    throw new Error(`${context}: Route is required for RSC stream creation`);
+  }
+  if (!options.pagePath) {
+    throw new Error(`${context}: pagePath is required for RSC stream creation`);
+  }
+}
+function createBaseRscStreamResult(rscStream, pipe, abort, metrics, id) {
+  return {
+    id,
+    rscStream,
+    pipe,
+    abort,
+    metrics
+  };
+}
+function handleRscStreamError(error, options, context) {
+  const panicError = handleError({
+    error,
+    logger: options.logger,
+    mode: getNodeEnv(),
+    panicThreshold: options.panicThreshold || "none",
+    context: `${context} for route ${options.route}`
+  });
+  if (panicError != null) {
+    throw panicError;
+  }
+  throw error;
+}
+function createRscStreamMetrics() {
+  const metrics = createStreamMetrics();
+  metrics.startTime = performance.now();
+  return metrics;
+}
+function setupRscStreamEventHandlers(stream, metrics, options) {
+  const { route, verbose = false, logger = createLogger() } = options;
+  stream.on("data", (chunk) => {
+    if (verbose) {
+      logger.info(
+        `[createRscStream:${route}] Received data chunk: ${chunk.length} bytes`
+      );
+    }
+    metrics.chunks++;
+    metrics.bytes += chunk.length;
+  });
+  stream.on("end", () => {
+    if (verbose) {
+      logger.info(`[createRscStream:${route}] Stream ended`);
+    }
+    metrics.duration = performance.now() - metrics.startTime;
+    metrics.endTime = performance.now();
+  });
+  stream.on("error", (error) => {
+    logger.error(`[createRscStream:${route}] Stream error: ${error}`);
+  });
+  stream.on("drain", () => {
+    if (verbose) {
+      logger.info(
+        `[createRscStream:${route}] Stream drain - backpressure resolved`
+      );
+    }
+  });
+  const originalWrite = stream.write.bind(stream);
+  stream.write = function(chunk, encoding, callback) {
+    const result = originalWrite(chunk, encoding, callback);
+    if (!result) {
+      metrics.backpressureCount++;
+      if (verbose) {
+        logger.warn(`[createRscStream:${route}] Backpressure detected`);
+      }
+    }
+    return result;
+  };
+  return () => {
+    stream.removeAllListeners();
+  };
+}
+
+export { createBaseRscStreamResult, createRscStreamMetrics, handleRscStreamError, setupRscStreamEventHandlers, validateRscStreamOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createRscStream.utils.js","sources":["../../../plugin/stream/createRscStream.utils.ts"],"sourcesContent":["import { createStreamMetrics } from \"../helpers/metrics.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { getNodeEnv } from \"../config/getNodeEnv.js\";\nimport type {\n  ClientRscStreamOptions,\n  ServerRscStreamOptions,\n  BaseRscStreamResult,\n} from \"./createRscStream.types.js\";\nimport type { PassThrough } from \"node:stream\";\nimport { createLogger, type Logger } from \"vite\";\n\n/**\n * Validates common RSC stream options\n *\n * @param options - RSC stream options to validate\n * @param context - Context for error messages\n * @throws Error if validation fails\n */\nexport function validateRscStreamOptions(\n  options: ClientRscStreamOptions | ServerRscStreamOptions,\n  context: string\n): void {\n  if (!options.route) {\n    throw new Error(`${context}: Route is required for RSC stream creation`);\n  }\n\n  if (!options.pagePath) {\n    throw new Error(`${context}: pagePath is required for RSC stream creation`);\n  }\n}\n\n/**\n * Creates common RSC stream result structure\n *\n * @param rscStream - The RSC stream\n * @param elements - React elements\n * @param pipe - Pipe function\n * @param abort - Abort function\n * @param metrics - Stream metrics\n * @returns Base RSC stream result\n */\nexport function createBaseRscStreamResult(\n  rscStream: PassThrough,\n  pipe: <Writable extends NodeJS.WritableStream>(\n    destination: Writable\n  ) => Writable,\n  abort: (reason?: unknown) => void,\n  metrics: ReturnType<typeof createStreamMetrics>,\n  id: string\n): BaseRscStreamResult {\n  return {\n    id,\n    rscStream,\n    pipe,\n    abort,\n    metrics,\n  };\n}\n\n/**\n * Handles RSC stream errors with consistent error handling\n *\n * @param error - The error that occurred\n * @param options - RSC stream options for context\n * @param context - Additional context for error handling\n * @throws Error if panic threshold is met\n */\nexport function handleRscStreamError(\n  error: unknown,\n  options: ClientRscStreamOptions | ServerRscStreamOptions,\n  context: string\n): void {\n  const panicError = handleError({\n    error,\n    logger: (options as any).logger,\n    mode: getNodeEnv(),\n    panicThreshold: options.panicThreshold || \"none\",\n    context: `${context} for route ${options.route}`,\n  });\n\n  if (panicError != null) {\n    throw panicError;\n  }\n\n  throw error;\n}\n\n/**\n * Creates stream metrics with common setup\n *\n * @param route - Route for logging context\n * @param verbose - Whether to enable verbose logging\n * @returns Stream metrics instance\n */\nexport function createRscStreamMetrics(): ReturnType<typeof createStreamMetrics> {\n  const metrics = createStreamMetrics();\n  metrics.startTime = performance.now();\n  return metrics;\n}\n\n/**\n * Sets up common stream event handlers for metrics collection\n *\n * @param stream - The stream to monitor\n * @param metrics - Metrics to update\n * @param options - Configuration options\n * @returns Cleanup function\n */\nexport function setupRscStreamEventHandlers(\n  stream: PassThrough,\n  metrics: ReturnType<typeof createStreamMetrics>,\n  options: {\n    route: string;\n    verbose?: boolean;\n    logger?: Logger;\n  }\n): () => void {\n  const { route, verbose = false, logger = createLogger() } = options;\n\n  stream.on(\"data\", (chunk: Buffer) => {\n    if (verbose) {\n      logger.info(\n        `[createRscStream:${route}] Received data chunk: ${chunk.length} bytes`\n      );\n    }\n    metrics.chunks++;\n    metrics.bytes += chunk.length;\n  });\n\n  stream.on(\"end\", () => {\n    if (verbose) {\n      logger.info(`[createRscStream:${route}] Stream ended`);\n    }\n    metrics.duration = performance.now() - metrics.startTime;\n    metrics.endTime = performance.now();\n  });\n\n  stream.on(\"error\", (error: unknown) => {\n    logger.error(`[createRscStream:${route}] Stream error: ${error}`);\n  });\n\n  stream.on(\"drain\", () => {\n    if (verbose) {\n      logger.info(\n        `[createRscStream:${route}] Stream drain - backpressure resolved`\n      );\n    }\n  });\n\n  // Track backpressure when write buffer is full\n  const originalWrite = stream.write.bind(stream);\n  stream.write = function (\n    chunk: any,\n    encoding?: BufferEncoding | ((error: Error | null | undefined) => void),\n    callback?: (error: Error | null | undefined) => void\n  ) {\n    const result = originalWrite(chunk, encoding as any, callback);\n    if (!result) {\n      metrics.backpressureCount++;\n      if (verbose) {\n        logger.warn(`[createRscStream:${route}] Backpressure detected`);\n      }\n    }\n    return result;\n  };\n\n  return () => {\n    // No cleanup needed since we removed the timeout\n    stream.removeAllListeners();\n  };\n}\n"],"names":[],"mappings":";;;;;;;;;;AAkBO,SAAS,wBAAA,CACd,SACA,OACM,EAAA;AACN,EAAI,IAAA,CAAC,QAAQ,KAAO,EAAA;AAClB,IAAA,MAAM,IAAI,KAAA,CAAM,CAAG,EAAA,OAAO,CAA6C,2CAAA,CAAA,CAAA;AAAA;AAGzE,EAAI,IAAA,CAAC,QAAQ,QAAU,EAAA;AACrB,IAAA,MAAM,IAAI,KAAA,CAAM,CAAG,EAAA,OAAO,CAAgD,8CAAA,CAAA,CAAA;AAAA;AAE9E;AAYO,SAAS,yBACd,CAAA,SAAA,EACA,IAGA,EAAA,KAAA,EACA,SACA,EACqB,EAAA;AACrB,EAAO,OAAA;AAAA,IACL,EAAA;AAAA,IACA,SAAA;AAAA,IACA,IAAA;AAAA,IACA,KAAA;AAAA,IACA;AAAA,GACF;AACF;AAUO,SAAS,oBAAA,CACd,KACA,EAAA,OAAA,EACA,OACM,EAAA;AACN,EAAA,MAAM,aAAa,WAAY,CAAA;AAAA,IAC7B,KAAA;AAAA,IACA,QAAS,OAAgB,CAAA,MAAA;AAAA,IACzB,MAAM,UAAW,EAAA;AAAA,IACjB,cAAA,EAAgB,QAAQ,cAAkB,IAAA,MAAA;AAAA,IAC1C,OAAS,EAAA,CAAA,EAAG,OAAO,CAAA,WAAA,EAAc,QAAQ,KAAK,CAAA;AAAA,GAC/C,CAAA;AAED,EAAA,IAAI,cAAc,IAAM,EAAA;AACtB,IAAM,MAAA,UAAA;AAAA;AAGR,EAAM,MAAA,KAAA;AACR;AASO,SAAS,sBAAiE,GAAA;AAC/E,EAAA,MAAM,UAAU,mBAAoB,EAAA;AACpC,EAAQ,OAAA,CAAA,SAAA,GAAY,YAAY,GAAI,EAAA;AACpC,EAAO,OAAA,OAAA;AACT;AAUO,SAAS,2BAAA,CACd,MACA,EAAA,OAAA,EACA,OAKY,EAAA;AACZ,EAAA,MAAM,EAAE,KAAO,EAAA,OAAA,GAAU,OAAO,MAAS,GAAA,YAAA,IAAmB,GAAA,OAAA;AAE5D,EAAO,MAAA,CAAA,EAAA,CAAG,MAAQ,EAAA,CAAC,KAAkB,KAAA;AACnC,IAAA,IAAI,OAAS,EAAA;AACX,MAAO,MAAA,CAAA,IAAA;AAAA,QACL,CAAoB,iBAAA,EAAA,KAAK,CAA0B,uBAAA,EAAA,KAAA,CAAM,MAAM,CAAA,MAAA;AAAA,OACjE;AAAA;AAEF,IAAQ,OAAA,CAAA,MAAA,EAAA;AACR,IAAA,OAAA,CAAQ,SAAS,KAAM,CAAA,MAAA;AAAA,GACxB,CAAA;AAED,EAAO,MAAA,CAAA,EAAA,CAAG,OAAO,MAAM;AACrB,IAAA,IAAI,OAAS,EAAA;AACX,MAAO,MAAA,CAAA,IAAA,CAAK,CAAoB,iBAAA,EAAA,KAAK,CAAgB,cAAA,CAAA,CAAA;AAAA;AAEvD,IAAA,OAAA,CAAQ,QAAW,GAAA,WAAA,CAAY,GAAI,EAAA,GAAI,OAAQ,CAAA,SAAA;AAC/C,IAAQ,OAAA,CAAA,OAAA,GAAU,YAAY,GAAI,EAAA;AAAA,GACnC,CAAA;AAED,EAAO,MAAA,CAAA,EAAA,CAAG,OAAS,EAAA,CAAC,KAAmB,KAAA;AACrC,IAAA,MAAA,CAAO,KAAM,CAAA,CAAA,iBAAA,EAAoB,KAAK,CAAA,gBAAA,EAAmB,KAAK,CAAE,CAAA,CAAA;AAAA,GACjE,CAAA;AAED,EAAO,MAAA,CAAA,EAAA,CAAG,SAAS,MAAM;AACvB,IAAA,IAAI,OAAS,EAAA;AACX,MAAO,MAAA,CAAA,IAAA;AAAA,QACL,oBAAoB,KAAK,CAAA,sCAAA;AAAA,OAC3B;AAAA;AACF,GACD,CAAA;AAGD,EAAA,MAAM,aAAgB,GAAA,MAAA,CAAO,KAAM,CAAA,IAAA,CAAK,MAAM,CAAA;AAC9C,EAAA,MAAA,CAAO,KAAQ,GAAA,SACb,KACA,EAAA,QAAA,EACA,QACA,EAAA;AACA,IAAA,MAAM,MAAS,GAAA,aAAA,CAAc,KAAO,EAAA,QAAA,EAAiB,QAAQ,CAAA;AAC7D,IAAA,IAAI,CAAC,MAAQ,EAAA;AACX,MAAQ,OAAA,CAAA,iBAAA,EAAA;AACR,MAAA,IAAI,OAAS,EAAA;AACX,QAAO,MAAA,CAAA,IAAA,CAAK,CAAoB,iBAAA,EAAA,KAAK,CAAyB,uBAAA,CAAA,CAAA;AAAA;AAChE;AAEF,IAAO,OAAA,MAAA;AAAA,GACT;AAEA,EAAA,OAAO,MAAM;AAEX,IAAA,MAAA,CAAO,kBAAmB,EAAA;AAAA,GAC5B;AACF;;;;"}