vite-plugin-react-server 1.4.0 → 1.4.2

package/dist/plugin/error/index.js

@@ -5,8 +5,7 @@
  */
 export { toError } from './toError.js';
 export { logError } from './logError.js';
-export { createContextualError, enhanceError } from './enhanceError.js';
 export { handleError } from './handleError.js';
 export { PANIC_SYMBOL, isPanic, shouldPanic } from './shouldPanic.js';
-export { assertPanic } from './assertPanic.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OyJ9
+export { handlePanicThreshold, isPanicError, shouldCausePanic } from './panicThresholdHandler.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7In0=

package/dist/plugin/error/panicThresholdHandler.js

@@ -3,11 +3,22 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-import { shouldPanic } from './shouldPanic.js';
+import { isPanic, shouldPanic } from './shouldPanic.js';
 
 function shouldCausePanic(error, options) {
   return shouldPanic(error, options.panicThreshold, options.critical);
 }
+function handlePanicThreshold(error, options) {
+  if (shouldCausePanic(error, options)) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    err[Symbol.for("vite-plugin-react-server.panic")] = true;
+    return err;
+  }
+  return null;
+}
+function isPanicError(error) {
+  return isPanic(error);
+}
 
-export { shouldCausePanic };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFuaWNUaHJlc2hvbGRIYW5kbGVyLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vZXJyb3IvcGFuaWNUaHJlc2hvbGRIYW5kbGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ2VudHJhbGl6ZWQgcGFuaWMgdGhyZXNob2xkIGhhbmRsaW5nIGxvZ2ljXG4gKiBcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGEgc2luZ2xlIHBsYWNlIHRvIGhhbmRsZSBwYW5pYyB0aHJlc2hvbGQgZGVjaXNpb25zXG4gKiBpbnN0ZWFkIG9mIHNjYXR0ZXJpbmcgdGhlIGxvZ2ljIGFjcm9zcyBtdWx0aXBsZSBmaWxlcy5cbiAqL1xuXG5pbXBvcnQgeyBzaG91bGRQYW5pYywgaXNQYW5pYyB9IGZyb20gXCIuL3Nob3VsZFBhbmljLmpzXCI7XG5pbXBvcnQgdHlwZSB7IFBhbmljVGhyZXNob2xkIH0gZnJvbSBcIi4uL3R5cGVzLmpzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGFuaWNUaHJlc2hvbGRPcHRpb25zIHtcbiAgcGFuaWNUaHJlc2hvbGQ6IFBhbmljVGhyZXNob2xkO1xuICBjcml0aWNhbD86IGJvb2xlYW47XG4gIGxvZ2dlcj86IGFueTtcbiAgY29udGV4dD86IHN0cmluZztcbn1cblxuLyoqXG4gKiBEZXRlcm1pbmVzIGlmIGFuIGVycm9yIHNob3VsZCBjYXVzZSBhIHBhbmljIGJhc2VkIG9uIHBhbmljIHRocmVzaG9sZCBzZXR0aW5nc1xuICovXG5leHBvcnQgZnVuY3Rpb24gc2hvdWxkQ2F1c2VQYW5pYyhcbiAgZXJyb3I6IHVua25vd24sXG4gIG9wdGlvbnM6IFBhbmljVGhyZXNob2xkT3B0aW9uc1xuKTogYm9vbGVhbiB7XG4gIHJldHVybiBzaG91bGRQYW5pYyhlcnJvciwgb3B0aW9ucy5wYW5pY1RocmVzaG9sZCwgb3B0aW9ucy5jcml0aWNhbCk7XG59XG5cbi8qKlxuICogSGFuZGxlcyBhbiBlcnJvciBiYXNlZCBvbiBwYW5pYyB0aHJlc2hvbGQgc2V0dGluZ3NcbiAqIFJldHVybnMgdGhlIGVycm9yIGlmIGl0IHNob3VsZCBjYXVzZSBhIHBhbmljLCBudWxsIG90aGVyd2lzZVxuICovXG5leHBvcnQgZnVuY3Rpb24gaGFuZGxlUGFuaWNUaHJlc2hvbGQoXG4gIGVycm9yOiB1bmtub3duLFxuICBvcHRpb25zOiBQYW5pY1RocmVzaG9sZE9wdGlvbnNcbik6IEVycm9yIHwgbnVsbCB7XG4gIGlmIChzaG91bGRDYXVzZVBhbmljKGVycm9yLCBvcHRpb25zKSkge1xuICAgIC8vIE1hcmsgZXJyb3IgZm9yIHBhbmljIGFuZCByZXR1cm4gaXQgdG8gYmUgdGhyb3duXG4gICAgY29uc3QgZXJyID0gZXJyb3IgaW5zdGFuY2VvZiBFcnJvciA/IGVycm9yIDogbmV3IEVycm9yKFN0cmluZyhlcnJvcikpO1xuICAgIChlcnIgYXMgYW55KVtTeW1ib2wuZm9yKCd2aXRlLXBsdWdpbi1yZWFjdC1zZXJ2ZXIucGFuaWMnKV0gPSB0cnVlO1xuICAgIHJldHVybiBlcnI7XG4gIH1cbiAgcmV0dXJuIG51bGw7XG59XG5cbi8qKlxuICogQ2hlY2tzIGlmIGFuIGVycm9yIGlzIGFscmVhZHkgbWFya2VkIGFzIGEgcGFuaWMgZXJyb3JcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzUGFuaWNFcnJvcihlcnJvcjogdW5rbm93bik6IGJvb2xlYW4ge1xuICByZXR1cm4gaXNQYW5pYyhlcnJvcik7XG59XG5cblxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFvQk8sU0FBUyxnQkFBQSxDQUNkLE9BQ0EsT0FDUyxFQUFBO0FBQ1QsRUFBQSxPQUFPLFdBQVksQ0FBQSxLQUFBLEVBQU8sT0FBUSxDQUFBLGNBQUEsRUFBZ0IsUUFBUSxRQUFRLENBQUE7QUFDcEU7Ozs7In0=
+export { handlePanicThreshold, isPanicError, shouldCausePanic };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFuaWNUaHJlc2hvbGRIYW5kbGVyLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vZXJyb3IvcGFuaWNUaHJlc2hvbGRIYW5kbGVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ2VudHJhbGl6ZWQgcGFuaWMgdGhyZXNob2xkIGhhbmRsaW5nIGxvZ2ljXG4gKiBcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGEgc2luZ2xlIHBsYWNlIHRvIGhhbmRsZSBwYW5pYyB0aHJlc2hvbGQgZGVjaXNpb25zXG4gKiBpbnN0ZWFkIG9mIHNjYXR0ZXJpbmcgdGhlIGxvZ2ljIGFjcm9zcyBtdWx0aXBsZSBmaWxlcy5cbiAqL1xuXG5pbXBvcnQgeyBzaG91bGRQYW5pYywgaXNQYW5pYyB9IGZyb20gXCIuL3Nob3VsZFBhbmljLmpzXCI7XG5pbXBvcnQgdHlwZSB7IFBhbmljVGhyZXNob2xkIH0gZnJvbSBcIi4uL3R5cGVzLmpzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGFuaWNUaHJlc2hvbGRPcHRpb25zIHtcbiAgcGFuaWNUaHJlc2hvbGQ6IFBhbmljVGhyZXNob2xkO1xuICBjcml0aWNhbD86IGJvb2xlYW47XG4gIGxvZ2dlcj86IGFueTtcbiAgY29udGV4dD86IHN0cmluZztcbn1cblxuLyoqXG4gKiBEZXRlcm1pbmVzIGlmIGFuIGVycm9yIHNob3VsZCBjYXVzZSBhIHBhbmljIGJhc2VkIG9uIHBhbmljIHRocmVzaG9sZCBzZXR0aW5nc1xuICovXG5leHBvcnQgZnVuY3Rpb24gc2hvdWxkQ2F1c2VQYW5pYyhcbiAgZXJyb3I6IHVua25vd24sXG4gIG9wdGlvbnM6IFBhbmljVGhyZXNob2xkT3B0aW9uc1xuKTogYm9vbGVhbiB7XG4gIHJldHVybiBzaG91bGRQYW5pYyhlcnJvciwgb3B0aW9ucy5wYW5pY1RocmVzaG9sZCwgb3B0aW9ucy5jcml0aWNhbCk7XG59XG5cbi8qKlxuICogSGFuZGxlcyBhbiBlcnJvciBiYXNlZCBvbiBwYW5pYyB0aHJlc2hvbGQgc2V0dGluZ3NcbiAqIFJldHVybnMgdGhlIGVycm9yIGlmIGl0IHNob3VsZCBjYXVzZSBhIHBhbmljLCBudWxsIG90aGVyd2lzZVxuICovXG5leHBvcnQgZnVuY3Rpb24gaGFuZGxlUGFuaWNUaHJlc2hvbGQoXG4gIGVycm9yOiB1bmtub3duLFxuICBvcHRpb25zOiBQYW5pY1RocmVzaG9sZE9wdGlvbnNcbik6IEVycm9yIHwgbnVsbCB7XG4gIGlmIChzaG91bGRDYXVzZVBhbmljKGVycm9yLCBvcHRpb25zKSkge1xuICAgIC8vIE1hcmsgZXJyb3IgZm9yIHBhbmljIGFuZCByZXR1cm4gaXQgdG8gYmUgdGhyb3duXG4gICAgY29uc3QgZXJyID0gZXJyb3IgaW5zdGFuY2VvZiBFcnJvciA/IGVycm9yIDogbmV3IEVycm9yKFN0cmluZyhlcnJvcikpO1xuICAgIChlcnIgYXMgYW55KVtTeW1ib2wuZm9yKCd2aXRlLXBsdWdpbi1yZWFjdC1zZXJ2ZXIucGFuaWMnKV0gPSB0cnVlO1xuICAgIHJldHVybiBlcnI7XG4gIH1cbiAgcmV0dXJuIG51bGw7XG59XG5cbi8qKlxuICogQ2hlY2tzIGlmIGFuIGVycm9yIGlzIGFscmVhZHkgbWFya2VkIGFzIGEgcGFuaWMgZXJyb3JcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzUGFuaWNFcnJvcihlcnJvcjogdW5rbm93bik6IGJvb2xlYW4ge1xuICByZXR1cm4gaXNQYW5pYyhlcnJvcik7XG59XG5cblxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFvQk8sU0FBUyxnQkFBQSxDQUNkLE9BQ0EsT0FDUyxFQUFBO0FBQ1QsRUFBQSxPQUFPLFdBQVksQ0FBQSxLQUFBLEVBQU8sT0FBUSxDQUFBLGNBQUEsRUFBZ0IsUUFBUSxRQUFRLENBQUE7QUFDcEU7QUFNTyxTQUFTLG9CQUFBLENBQ2QsT0FDQSxPQUNjLEVBQUE7QUFDZCxFQUFJLElBQUEsZ0JBQUEsQ0FBaUIsS0FBTyxFQUFBLE9BQU8sQ0FBRyxFQUFBO0FBRXBDLElBQU0sTUFBQSxHQUFBLEdBQU0saUJBQWlCLEtBQVEsR0FBQSxLQUFBLEdBQVEsSUFBSSxLQUFNLENBQUEsTUFBQSxDQUFPLEtBQUssQ0FBQyxDQUFBO0FBQ3BFLElBQUMsR0FBWSxDQUFBLE1BQUEsQ0FBTyxHQUFJLENBQUEsZ0NBQWdDLENBQUMsQ0FBSSxHQUFBLElBQUE7QUFDN0QsSUFBTyxPQUFBLEdBQUE7QUFBQTtBQUVULEVBQU8sT0FBQSxJQUFBO0FBQ1Q7QUFLTyxTQUFTLGFBQWEsS0FBeUIsRUFBQTtBQUNwRCxFQUFBLE9BQU8sUUFBUSxLQUFLLENBQUE7QUFDdEI7Ozs7In0=

package/dist/plugin/error/setupGlobalErrorHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setupGlobalErrorHandler.d.ts","sourceRoot":"","sources":["../../../plugin/error/setupGlobalErrorHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAIpB,eAAO,MAAM,uBAAuB,EAAE,yBAkDnC,CAAC;AAEJ,eAAO,MAAM,yBAAyB,EAAE,2BAWrC,CAAC"}
+{"version":3,"file":"setupGlobalErrorHandler.d.ts","sourceRoot":"","sources":["../../../plugin/error/setupGlobalErrorHandler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAMpB,eAAO,MAAM,uBAAuB,EAAE,yBA0CnC,CAAC;AAEJ,eAAO,MAAM,yBAAyB,EAAE,2BAgBrC,CAAC"}

package/dist/plugin/error/setupGlobalErrorHandler.js

@@ -4,6 +4,8 @@
  * MIT License
  */
 let isGlobalHandlerSetup = false;
+let uncaughtExceptionHandler = null;
+let unhandledRejectionHandler = null;
 const setupGlobalErrorHandler = function _setupGlobalErrorHandler(options) {
   const { panicThreshold, logger, verbose = false } = options;
   if (isGlobalHandlerSetup) {
@@ -14,7 +16,7 @@ const setupGlobalErrorHandler = function _setupGlobalErrorHandler(options) {
       `Setting up global error handler for panic threshold: ${panicThreshold}`
     );
   }
-  process.on("uncaughtException", (error) => {
+  uncaughtExceptionHandler = (error) => {
     if (verbose) {
       logger.info(
         `Global error handler caught uncaught exception: ${error.message}`
@@ -23,30 +25,35 @@ const setupGlobalErrorHandler = function _setupGlobalErrorHandler(options) {
     logger.warn(
       `Uncaught exception handled by panic threshold (${panicThreshold}): ${error.message}`
     );
-  });
-  process.on(
-    "unhandledRejection",
-    (reason, _promise) => {
-      if (verbose) {
-        logger.info(
-          `Global error handler caught unhandled rejection: ${reason}`
-        );
-      }
-      logger.warn(
-        `Unhandled rejection handled by panic threshold (${panicThreshold}): ${reason}`
+  };
+  unhandledRejectionHandler = (reason, _promise) => {
+    if (verbose) {
+      logger.info(
+        `Global error handler caught unhandled rejection: ${reason}`
       );
     }
-  );
+    logger.warn(
+      `Unhandled rejection handled by panic threshold (${panicThreshold}): ${reason}`
+    );
+  };
+  process.on("uncaughtException", uncaughtExceptionHandler);
+  process.on("unhandledRejection", unhandledRejectionHandler);
   isGlobalHandlerSetup = true;
 };
 const cleanupGlobalErrorHandler = function _cleanupGlobalErrorHandler() {
   if (!isGlobalHandlerSetup) {
     return;
   }
-  process.removeAllListeners("uncaughtException");
-  process.removeAllListeners("unhandledRejection");
+  if (uncaughtExceptionHandler) {
+    process.removeListener("uncaughtException", uncaughtExceptionHandler);
+    uncaughtExceptionHandler = null;
+  }
+  if (unhandledRejectionHandler) {
+    process.removeListener("unhandledRejection", unhandledRejectionHandler);
+    unhandledRejectionHandler = null;
+  }
   isGlobalHandlerSetup = false;
 };
 
 export { cleanupGlobalErrorHandler, setupGlobalErrorHandler };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/helpers/createRscRenderHelpers.d.ts

@@ -8,9 +8,4 @@ export declare function createReactElement(options: CreateHandlerOptions, contex
 /**
  * Pure function for storing headless stream data
  */
-export declare function storeHeadlessStreamData(context: RscRenderContext, finalOptions: CreateHandlerOptions): void;
-export declare const createRscRenderHelpers: {
-    createReactElement: typeof createReactElement;
-    storeHeadlessStreamData: typeof storeHeadlessStreamData;
-};
 //# sourceMappingURL=createRscRenderHelpers.d.ts.map

package/dist/plugin/helpers/createRscRenderHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createRscRenderHelpers.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/createRscRenderHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAK3E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,gBAAgB,8FA+B1B;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,gBAAgB,EACzB,YAAY,EAAE,oBAAoB,GACjC,IAAI,CAoBN;AAED,eAAO,MAAM,sBAAsB;;;CAGlC,CAAC"}
+{"version":3,"file":"createRscRenderHelpers.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/createRscRenderHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAK3E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,gBAAgB,8FA+B1B;AAED;;GAEG"}

package/dist/plugin/helpers/createRscRenderHelpers.js

@@ -36,25 +36,3 @@ export function createReactElement(options, context) {
 /**
  * Pure function for storing headless stream data
  */
-export function storeHeadlessStreamData(context, finalOptions) {
-    // Determine if this is a headless stream by checking if htmlPath is empty
-    const isHeadless = finalOptions.htmlPath === "";
-    if (context.headlessStreamElements &&
-        isHeadless &&
-        !context.headlessStreamErrors?.has(context.route)) {
-        // Store the rendered elements for reuse
-        const element = createElementWithReact(React, {
-            ...finalOptions,
-            Html: React.Fragment,
-            as: React.Fragment,
-        });
-        context.headlessStreamElements.set(context.id, {
-            elements: element,
-            errored: false,
-        });
-    }
-}
-export const createRscRenderHelpers = {
-    createReactElement,
-    storeHeadlessStreamData,
-};

package/dist/plugin/helpers/headlessStreamState.d.ts

@@ -30,42 +30,4 @@ export declare function trackHeadlessStreamError(state: HeadlessStreamState, rou
  * @returns true if the route has a headless stream error
  */
 export declare function hasHeadlessStreamError(state: HeadlessStreamState, route: string): boolean;
-/**
- * Gets the headless stream error for a route.
- *
- * @param state - The headless stream state
- * @param route - The route to get the error for
- * @returns The error if it exists, undefined otherwise
- */
-export declare function getHeadlessStreamError(state: HeadlessStreamState, route: string): Error | undefined;
-/**
- * Stores headless stream elements for reuse.
- *
- * @param state - The headless stream state
- * @param streamId - The stream ID
- * @param data - The stream data to store
- */
-export declare function storeHeadlessStreamElements(state: HeadlessStreamState, streamId: string, data: HeadlessStreamData): void;
-/**
- * Gets headless stream elements for reuse.
- *
- * @param state - The headless stream state
- * @param streamId - The stream ID
- * @returns The stream data if it exists, undefined otherwise
- */
-export declare function getHeadlessStreamElements(state: HeadlessStreamState, streamId: string): HeadlessStreamData | undefined;
-/**
- * Cleans up headless stream elements after use.
- *
- * @param state - The headless stream state
- * @param streamId - The stream ID to clean up
- */
-export declare function cleanupHeadlessStreamElements(state: HeadlessStreamState, streamId: string): void;
-/**
- * Clears all headless stream errors for a route.
- *
- * @param state - The headless stream state
- * @param route - The route to clear errors for
- */
-export declare function clearHeadlessStreamErrors(state: HeadlessStreamState, route: string): void;
 //# sourceMappingURL=headlessStreamState.d.ts.map

package/dist/plugin/helpers/headlessStreamState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headlessStreamState.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/headlessStreamState.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,GAAG,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC1C,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,mBAAmB,CAK/D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,GACX,IAAI,CAEN;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,MAAM,GACZ,KAAK,GAAG,SAAS,CAEnB;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,mBAAmB,EAC1B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,kBAAkB,GACvB,IAAI,CAEN;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,mBAAmB,EAC1B,QAAQ,EAAE,MAAM,GACf,kBAAkB,GAAG,SAAS,CAEhC;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,mBAAmB,EAC1B,QAAQ,EAAE,MAAM,GACf,IAAI,CAEN;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,MAAM,GACZ,IAAI,CAEN"}
+{"version":3,"file":"headlessStreamState.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/headlessStreamState.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,GAAG,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC1C,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,mBAAmB,CAK/D;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,GACX,IAAI,CAEN;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,mBAAmB,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAET"}

package/dist/plugin/helpers/headlessStreamState.js

@@ -31,51 +31,3 @@ export function trackHeadlessStreamError(state, route, error) {
 export function hasHeadlessStreamError(state, route) {
     return state.errors.has(route);
 }
-/**
- * Gets the headless stream error for a route.
- *
- * @param state - The headless stream state
- * @param route - The route to get the error for
- * @returns The error if it exists, undefined otherwise
- */
-export function getHeadlessStreamError(state, route) {
-    return state.errors.get(route);
-}
-/**
- * Stores headless stream elements for reuse.
- *
- * @param state - The headless stream state
- * @param streamId - The stream ID
- * @param data - The stream data to store
- */
-export function storeHeadlessStreamElements(state, streamId, data) {
-    state.elements.set(streamId, data);
-}
-/**
- * Gets headless stream elements for reuse.
- *
- * @param state - The headless stream state
- * @param streamId - The stream ID
- * @returns The stream data if it exists, undefined otherwise
- */
-export function getHeadlessStreamElements(state, streamId) {
-    return state.elements.get(streamId);
-}
-/**
- * Cleans up headless stream elements after use.
- *
- * @param state - The headless stream state
- * @param streamId - The stream ID to clean up
- */
-export function cleanupHeadlessStreamElements(state, streamId) {
-    state.elements.delete(streamId);
-}
-/**
- * Clears all headless stream errors for a route.
- *
- * @param state - The headless stream state
- * @param route - The route to clear errors for
- */
-export function clearHeadlessStreamErrors(state, route) {
-    state.errors.delete(route);
-}

package/dist/plugin/helpers/index.d.ts

@@ -16,9 +16,6 @@ export * from "./metrics.js";
 export * from "./tryManifest.js";
 export * from "./getBundleManifest.js";
 export * from "./moduleRefs.js";
-export * from "./moduleResolver.js";
-export * from "./stashReturnValue.js";
-export * from "./workerManager.js";
 export * from "./validateRscRenderMessage.js";
 export * from "./resolveRenderUrl.js";
 export * from "./mergeMessageWithDefaults.js";

package/dist/plugin/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/index.ts"],"names":[],"mappings":"AAGA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AAMpC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAG7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,OAAO,EAAE,iBAAiB,IAAI,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7F,cAAc,qBAAqB,CAAC;AACpC,cAAc,uCAAuC,CAAC;AAEtD,cAAc,2BAA2B,CAAC;AAE1C,cAAc,gCAAgC,CAAC;AAO/C,QAAA,MAAQ,kBAAkB,KAIzB,CAAC;AAEF,OAAO,EAAG,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/index.ts"],"names":[],"mappings":"AAGA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AAMpC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAG7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,iBAAiB,CAAC;AAKhC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oCAAoC,CAAC;AACnD,OAAO,EAAE,iBAAiB,IAAI,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7F,cAAc,qBAAqB,CAAC;AACpC,cAAc,uCAAuC,CAAC;AAEtD,cAAc,2BAA2B,CAAC;AAE1C,cAAc,gCAAgC,CAAC;AAO/C,QAAA,MAAQ,kBAAkB,KAIzB,CAAC;AAEF,OAAO,EAAG,kBAAkB,EAAE,CAAC"}

package/dist/plugin/helpers/index.js

@@ -20,9 +20,6 @@ export { hydrateUserOptions } from './hydrateUserOptions.js';
 export { tryManifest } from './tryManifest.js';
 export { getBundleManifest } from './getBundleManifest.js';
 export { getModuleRef, moduleRefs } from './moduleRefs.js';
-export { getSource, loadClientSource, resolve, resolveClientImport, setStashedGetSource, setStashedResolve } from './moduleResolver.js';
-export { clearStashedReturnValues, stashReturnValue } from './stashReturnValue.js';
-export { clearWorker, getWorker, setWorker } from './workerManager.js';
 export { validateRscRenderMessage } from './validateRscRenderMessage.js';
 export { resolveRenderUrl } from './resolveRenderUrl.js';
 export { mergeMessageWithDefaults } from './mergeMessageWithDefaults.js';
@@ -42,4 +39,4 @@ const dirname = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
 const { handleServerAction } = await import(`${dirname}/handleServerAction.${condition}.js`);
 
 export { handleServerAction };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/helpers/requestInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestInfo.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/requestInfo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAKpC;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,CAAC,eAAe,EAC5B,cAAc,EAAE,IAAI,CAClB,oBAAoB,EAClB,YAAY,GACZ,OAAO,GACP,cAAc,GACd,SAAS,GACT,gBAAgB,GAChB,eAAe,GACf,SAAS,GACT,QAAQ,CACX,EACD,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0MhB"}
+{"version":3,"file":"requestInfo.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/requestInfo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAKpC;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,CAAC,eAAe,EAC5B,cAAc,EAAE,IAAI,CAClB,oBAAoB,EAClB,YAAY,GACZ,OAAO,GACP,cAAc,GACd,SAAS,GACT,gBAAgB,GAChB,eAAe,GACf,SAAS,GACT,QAAQ,CACX,EACD,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4MhB"}

package/dist/plugin/helpers/requestInfo.js

@@ -47,6 +47,7 @@ function requestInfo(req, handlerOptions, hostDir) {
   const hasJsonHeader = req.headers["accept"]?.includes("application/json");
   const hasHtmlHeader = req.headers.accept?.includes("text/html");
   const hasRscHeader = req.headers.accept?.includes("text/x-component");
+  const hasRscQueryParam = /[?&]_rsc\b/.test(req.url || "");
   const hasCssHeader = req.headers.accept?.includes("text/css");
   const isFolder = !ext;
   const isFormContentType = req.headers["content-type"]?.includes(
@@ -58,8 +59,8 @@ function requestInfo(req, handlerOptions, hostDir) {
   const isFormActionRequest = !isServerActionRequest && (req.method === "POST" || isFormContentType && req.headers["sec-fetch-dest"] === "document" && req.headers["sec-fetch-mode"] === "navigate");
   const isJsRequest = !isFormActionRequest && !isJson && !isHtml && !isCss && !isRsc && (isJS || hasJsHeader);
   const isJsonRequest = isJson || hasJsonHeader && !isJsRequest;
-  const isHtmlRequest = isHtml || hasHtmlHeader || isFolder && !hasRscHeader && !isRsc && !isJsRequest && !isFormActionRequest;
-  const isRscRequest = !isJsRequest && !isHtmlRequest && (isRsc || hasRscHeader);
+  const isHtmlRequest = !hasRscQueryParam && (isHtml || hasHtmlHeader || isFolder && !hasRscHeader && !isRsc && !isJsRequest && !isFormActionRequest);
+  const isRscRequest = hasRscQueryParam || !isJsRequest && !isHtmlRequest && (isRsc || hasRscHeader);
   const isCssRequest = !isHtmlRequest && !isRscRequest && !isJsRequest && !isJsonRequest && (isCss || hasCssHeader);
   const routeForFilePath = value;
   let filePath = resolve(hostDir, routeForFilePath);
@@ -105,7 +106,7 @@ function requestInfo(req, handlerOptions, hostDir) {
     if (mimeType) {
       contentType = mimeType + "; charset=utf-8";
     } else {
-      contentType = "application/octet-stream; charset=utf-8";
+      contentType = "application/octet-stream";
     }
   }
   if (handlerOptions.verbose) {
@@ -159,4 +160,4 @@ function requestInfo(req, handlerOptions, hostDir) {
 }
 
 export { requestInfo };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"requestInfo.js","sources":["../../../plugin/helpers/requestInfo.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport type { CreateHandlerOptions } from \"../types.js\";\nimport { type Connect } from \"vite\";\nimport { MIME_TYPES } from \"../config/mimeTypes.js\";\nimport { requestToRoute } from \"./requestToRoute.js\";\nimport { routeToURL } from \"../utils/routeToURL.js\";\n\n/**\n * # Request info\n *\n * Does the initial work to check if the request is for html, rsc, json, js, css, server-action, or something else not handled by this plugin.\n *\n * @param req\n * @param handlerOptions\n * @param hostDir\n * @returns\n */\nexport function requestInfo(\n  req: Connect.IncomingMessage,\n  handlerOptions: Pick<\n    CreateHandlerOptions,\n    | \"normalizer\"\n    | \"build\"\n    | \"autoDiscover\"\n    | \"verbose\"\n    | \"moduleBasePath\"\n    | \"moduleBaseURL\"\n    | \"verbose\"\n    | \"logger\"\n  >,\n  hostDir: string,\n) {\n  const route = requestToRoute(req, {\n    moduleBasePath: handlerOptions.moduleBasePath,\n    moduleBaseURL: handlerOptions.moduleBaseURL,\n    build: handlerOptions.build,\n  });\n\n  if (!route) {\n    return {\n      route: \"/\",\n      url: routeToURL(\"/\", handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),\n      ext: \"\",\n    };\n  }\n\n  // Use the cleaned route for normalization, not the raw req.url\n  // This ensures base URL is properly stripped before normalization\n  const [, value] = handlerOptions.normalizer(route);\n  if (handlerOptions.verbose) {\n    if (value && value !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Value: \\\"${value}\\\"`);\n    }\n    if (hostDir && hostDir !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Host Dir: \\\"${hostDir}\\\"`);\n    }\n    if (req.url && req.url !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Request URL: \\\"${req.url}\\\"`);\n    }\n  }\n\n  const dotIndex = value.lastIndexOf(\".\");\n  const ext = dotIndex === -1 ? \"\" : value.slice(dotIndex);\n  // handle index.html\n  const isVendor = handlerOptions.autoDiscover.vendorPattern.test(value);\n  const isVirtual = handlerOptions.autoDiscover.virtualPattern.test(value);\n  const isJS = handlerOptions.autoDiscover.modulePattern.test(value);\n  const isHtml = handlerOptions.autoDiscover.htmlPattern.test(value);\n  const isCss = handlerOptions.autoDiscover.cssPattern.test(value);\n  const isJson = handlerOptions.autoDiscover.jsonPattern.test(value);\n  const isRsc = handlerOptions.autoDiscover.rscPattern.test(value);\n  const hasJsHeader =\n    req.headers[\"sec-fetch-dest\"] === \"script\" ||\n    req.headers[\"accept\"]?.includes(\"*/*\") ||\n    req.headers[\"accept\"]?.includes(\"text/javascript\");\n  const hasJsonHeader = req.headers[\"accept\"]?.includes(\"application/json\");\n  const hasHtmlHeader = req.headers.accept?.includes(\"text/html\");\n  const hasRscHeader = req.headers.accept?.includes(\"text/x-component\");\n  const hasCssHeader = req.headers.accept?.includes(\"text/css\");\n  const isFolder = !ext;\n  const isFormContentType =\n    req.headers[\"content-type\"]?.includes(\n      \"application/x-www-form-urlencoded\"\n    ) || !!req.headers[\"content-type\"]?.includes(\"multipart/form-data\");\n\n  // Server action detection\n  const hasRscActionHeader = !!req.headers[\"x-rsc-action\"];\n  const hasServerActionHeaders =\n    req.method === \"POST\" &&\n    (hasRscActionHeader || (\n      (req.headers[\"sec-fetch-dest\"] === \"empty\" ||\n        req.headers[\"sec-fetch-dest\"] === \"\") &&\n      req.headers[\"sec-fetch-mode\"] === \"cors\"\n    ));\n  const isServerActionRequest = hasServerActionHeaders;\n\n  const isFormActionRequest =\n    !isServerActionRequest &&\n    (req.method === \"POST\" ||\n      (isFormContentType &&\n        req.headers[\"sec-fetch-dest\"] === \"document\" &&\n        req.headers[\"sec-fetch-mode\"] === \"navigate\"));\n\n  const isJsRequest =\n    !isFormActionRequest &&\n    !isJson &&\n    !isHtml &&\n    !isCss &&\n    !isRsc &&\n    (isJS || hasJsHeader);\n  const isJsonRequest = isJson || (hasJsonHeader && !isJsRequest);\n  // Form action detection\n\n  const isHtmlRequest =\n    isHtml ||\n    hasHtmlHeader ||\n    (isFolder &&\n      !hasRscHeader &&\n      !isRsc &&\n      !isJsRequest &&\n      !isFormActionRequest);\n  const isRscRequest =\n    !isJsRequest && !isHtmlRequest && (isRsc || hasRscHeader);\n  const isCssRequest =\n    !isHtmlRequest &&\n    !isRscRequest &&\n    !isJsRequest &&\n    !isJsonRequest &&\n    (isCss || hasCssHeader);\n\n  // Use the normalized value for file path construction\n  // The normalizer should have already stripped base URLs properly\n  const routeForFilePath = value;\n\n  let filePath = resolve(hostDir, routeForFilePath);\n  let contentType;\n  if (isServerActionRequest) {\n    // For server actions, we'll get the actual file path from the request body\n    // The route is just a placeholder\n    filePath = resolve(hostDir, routeForFilePath);\n    contentType = \"application/json; charset=utf-8\";\n  } else if (isHtmlRequest) {\n    if (!isHtml) {\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.htmlOutputPath\n      );\n    }\n    contentType = \"text/html; charset=utf-8\";\n  } else if (isRscRequest) {\n    if (!isRsc) {\n      // Value doesn't end with .rsc, append the rsc output path\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.rscOutputPath\n      );\n    }\n    contentType = \"text/x-component; charset=utf-8\";\n  } else if (isCssRequest) {\n    if (!isCss) {\n      filePath = resolve(hostDir, routeForFilePath + \".css\");\n    }\n    contentType = \"text/css; charset=utf-8\";\n  } else if (isJsRequest) {\n    if (!isJS) {\n      filePath = resolve(hostDir, routeForFilePath + \".js\");\n    }\n    contentType = \"application/javascript; charset=utf-8\";\n  } else if (isJsonRequest) {\n    if (!isJson) {\n      filePath = resolve(hostDir, routeForFilePath + \".json\");\n    }\n    contentType = \"application/json; charset=utf-8\";\n  } else {\n    const mimeType = MIME_TYPES[ext];\n    if (mimeType) {\n      contentType = mimeType + \"; charset=utf-8\";\n    } else {\n      contentType = \"application/octet-stream; charset=utf-8\";\n    }\n  }\n\n  if (handlerOptions.verbose) {\n    if (isFormActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (form-action) ${route}`);\n    } else if (isServerActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (server-action) ${route}`);\n    } else if (isHtmlRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (html) ${route}`);\n    } else if (isRscRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (rsc) ${route}`);\n    } else if (isCssRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (css) ${route}`);\n    } else if (isJsRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (js) ${route}`);\n    } else if (isJsonRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (json) ${route}`);\n    } else {\n      handlerOptions.logger.info(`[react-dev-server] (other) ${route}`);\n    }\n  }\n  return {\n    route,\n    url: routeToURL(route, handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),\n    ext,\n    isHtmlRequest,\n    isRscRequest,\n    isCssRequest,\n    isCss,\n    isHtml,\n    isRsc,\n    isFolder,\n    contentType,\n    filePath,\n    isJS,\n    isVendor,\n    isVirtual,\n    hasJsHeader,\n    isJsRequest,\n    isJson,\n    isJsonRequest,\n    hasCssHeader,\n    hasJsonHeader,\n    hasHtmlHeader,\n    hasRscHeader,\n    hasServerActionHeaders,\n    isServerActionRequest,\n    isFormContentType,\n    isFormActionRequest,\n  };\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"requestInfo.js","sources":["../../../plugin/helpers/requestInfo.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport type { CreateHandlerOptions } from \"../types.js\";\nimport { type Connect } from \"vite\";\nimport { MIME_TYPES } from \"../config/mimeTypes.js\";\nimport { requestToRoute } from \"./requestToRoute.js\";\nimport { routeToURL } from \"../utils/routeToURL.js\";\n\n/**\n * # Request info\n *\n * Does the initial work to check if the request is for html, rsc, json, js, css, server-action, or something else not handled by this plugin.\n *\n * @param req\n * @param handlerOptions\n * @param hostDir\n * @returns\n */\nexport function requestInfo(\n  req: Connect.IncomingMessage,\n  handlerOptions: Pick<\n    CreateHandlerOptions,\n    | \"normalizer\"\n    | \"build\"\n    | \"autoDiscover\"\n    | \"verbose\"\n    | \"moduleBasePath\"\n    | \"moduleBaseURL\"\n    | \"verbose\"\n    | \"logger\"\n  >,\n  hostDir: string,\n) {\n  const route = requestToRoute(req, {\n    moduleBasePath: handlerOptions.moduleBasePath,\n    moduleBaseURL: handlerOptions.moduleBaseURL,\n    build: handlerOptions.build,\n  });\n\n  if (!route) {\n    return {\n      route: \"/\",\n      url: routeToURL(\"/\", handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),\n      ext: \"\",\n    };\n  }\n\n  // Use the cleaned route for normalization, not the raw req.url\n  // This ensures base URL is properly stripped before normalization\n  const [, value] = handlerOptions.normalizer(route);\n  if (handlerOptions.verbose) {\n    if (value && value !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Value: \\\"${value}\\\"`);\n    }\n    if (hostDir && hostDir !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Host Dir: \\\"${hostDir}\\\"`);\n    }\n    if (req.url && req.url !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Request URL: \\\"${req.url}\\\"`);\n    }\n  }\n\n  const dotIndex = value.lastIndexOf(\".\");\n  const ext = dotIndex === -1 ? \"\" : value.slice(dotIndex);\n  // handle index.html\n  const isVendor = handlerOptions.autoDiscover.vendorPattern.test(value);\n  const isVirtual = handlerOptions.autoDiscover.virtualPattern.test(value);\n  const isJS = handlerOptions.autoDiscover.modulePattern.test(value);\n  const isHtml = handlerOptions.autoDiscover.htmlPattern.test(value);\n  const isCss = handlerOptions.autoDiscover.cssPattern.test(value);\n  const isJson = handlerOptions.autoDiscover.jsonPattern.test(value);\n  const isRsc = handlerOptions.autoDiscover.rscPattern.test(value);\n  const hasJsHeader =\n    req.headers[\"sec-fetch-dest\"] === \"script\" ||\n    req.headers[\"accept\"]?.includes(\"*/*\") ||\n    req.headers[\"accept\"]?.includes(\"text/javascript\");\n  const hasJsonHeader = req.headers[\"accept\"]?.includes(\"application/json\");\n  const hasHtmlHeader = req.headers.accept?.includes(\"text/html\");\n  const hasRscHeader = req.headers.accept?.includes(\"text/x-component\");\n  // Support ?_rsc query param (e.g. /?_rsc for browser debugging) as alternative to Accept header (useful for browser debugging)\n  const hasRscQueryParam = /[?&]_rsc\\b/.test(req.url || \"\");\n  const hasCssHeader = req.headers.accept?.includes(\"text/css\");\n  const isFolder = !ext;\n  const isFormContentType =\n    req.headers[\"content-type\"]?.includes(\n      \"application/x-www-form-urlencoded\"\n    ) || !!req.headers[\"content-type\"]?.includes(\"multipart/form-data\");\n\n  // Server action detection\n  const hasRscActionHeader = !!req.headers[\"x-rsc-action\"];\n  const hasServerActionHeaders =\n    req.method === \"POST\" &&\n    (hasRscActionHeader || (\n      (req.headers[\"sec-fetch-dest\"] === \"empty\" ||\n        req.headers[\"sec-fetch-dest\"] === \"\") &&\n      req.headers[\"sec-fetch-mode\"] === \"cors\"\n    ));\n  const isServerActionRequest = hasServerActionHeaders;\n\n  const isFormActionRequest =\n    !isServerActionRequest &&\n    (req.method === \"POST\" ||\n      (isFormContentType &&\n        req.headers[\"sec-fetch-dest\"] === \"document\" &&\n        req.headers[\"sec-fetch-mode\"] === \"navigate\"));\n\n  const isJsRequest =\n    !isFormActionRequest &&\n    !isJson &&\n    !isHtml &&\n    !isCss &&\n    !isRsc &&\n    (isJS || hasJsHeader);\n  const isJsonRequest = isJson || (hasJsonHeader && !isJsRequest);\n  // Form action detection\n\n  const isHtmlRequest =\n    !hasRscQueryParam && (isHtml ||\n    hasHtmlHeader ||\n    (isFolder &&\n      !hasRscHeader &&\n      !isRsc &&\n      !isJsRequest &&\n      !isFormActionRequest));\n  const isRscRequest =\n    hasRscQueryParam || (!isJsRequest && !isHtmlRequest && (isRsc || hasRscHeader));\n  const isCssRequest =\n    !isHtmlRequest &&\n    !isRscRequest &&\n    !isJsRequest &&\n    !isJsonRequest &&\n    (isCss || hasCssHeader);\n\n  // Use the normalized value for file path construction\n  // The normalizer should have already stripped base URLs properly\n  const routeForFilePath = value;\n\n  let filePath = resolve(hostDir, routeForFilePath);\n  let contentType;\n  if (isServerActionRequest) {\n    // For server actions, we'll get the actual file path from the request body\n    // The route is just a placeholder\n    filePath = resolve(hostDir, routeForFilePath);\n    contentType = \"application/json; charset=utf-8\";\n  } else if (isHtmlRequest) {\n    if (!isHtml) {\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.htmlOutputPath\n      );\n    }\n    contentType = \"text/html; charset=utf-8\";\n  } else if (isRscRequest) {\n    if (!isRsc) {\n      // Value doesn't end with .rsc, append the rsc output path\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.rscOutputPath\n      );\n    }\n    contentType = \"text/x-component; charset=utf-8\";\n  } else if (isCssRequest) {\n    if (!isCss) {\n      filePath = resolve(hostDir, routeForFilePath + \".css\");\n    }\n    contentType = \"text/css; charset=utf-8\";\n  } else if (isJsRequest) {\n    if (!isJS) {\n      filePath = resolve(hostDir, routeForFilePath + \".js\");\n    }\n    contentType = \"application/javascript; charset=utf-8\";\n  } else if (isJsonRequest) {\n    if (!isJson) {\n      filePath = resolve(hostDir, routeForFilePath + \".json\");\n    }\n    contentType = \"application/json; charset=utf-8\";\n  } else {\n    const mimeType = MIME_TYPES[ext];\n    if (mimeType) {\n      contentType = mimeType + \"; charset=utf-8\";\n    } else {\n      contentType = \"application/octet-stream\";\n    }\n  }\n\n  if (handlerOptions.verbose) {\n    if (isFormActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (form-action) ${route}`);\n    } else if (isServerActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (server-action) ${route}`);\n    } else if (isHtmlRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (html) ${route}`);\n    } else if (isRscRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (rsc) ${route}`);\n    } else if (isCssRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (css) ${route}`);\n    } else if (isJsRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (js) ${route}`);\n    } else if (isJsonRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (json) ${route}`);\n    } else {\n      handlerOptions.logger.info(`[react-dev-server] (other) ${route}`);\n    }\n  }\n  return {\n    route,\n    url: routeToURL(route, handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),\n    ext,\n    isHtmlRequest,\n    isRscRequest,\n    isCssRequest,\n    isCss,\n    isHtml,\n    isRsc,\n    isFolder,\n    contentType,\n    filePath,\n    isJS,\n    isVendor,\n    isVirtual,\n    hasJsHeader,\n    isJsRequest,\n    isJson,\n    isJsonRequest,\n    hasCssHeader,\n    hasJsonHeader,\n    hasHtmlHeader,\n    hasRscHeader,\n    hasServerActionHeaders,\n    isServerActionRequest,\n    isFormContentType,\n    isFormActionRequest,\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/plugin/helpers/requestToRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestToRoute.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/requestToRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,wBAAgB,cAAc,CAC5B,GAAG,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,EACrB,cAAc,EAAE,IAAI,CAClB,oBAAoB,EACpB,gBAAgB,GAAG,eAAe,GAAG,OAAO,CAC7C,sBAyCF"}
+{"version":3,"file":"requestToRoute.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/requestToRoute.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAExD,wBAAgB,cAAc,CAC5B,GAAG,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,EACrB,cAAc,EAAE,IAAI,CAClB,oBAAoB,EACpB,gBAAgB,GAAG,eAAe,GAAG,OAAO,CAC7C,sBA0CF"}

package/dist/plugin/helpers/requestToRoute.js

@@ -4,7 +4,7 @@
  * MIT License
  */
 function requestToRoute(req, handlerOptions) {
-  let route = req.url?.replace(
+  let route = req.url?.split("?")[0].replace(
     handlerOptions.moduleBaseURL + handlerOptions.build.rscOutputPath,
     ""
   ).replace(
@@ -29,4 +29,4 @@ function requestToRoute(req, handlerOptions) {
 }
 
 export { requestToRoute };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/helpers/workerCleanup.d.ts

@@ -1,4 +1,4 @@
-import type { Worker, MessagePort } from "node:worker_threads";
+import type { Worker } from "node:worker_threads";
 /**
  * Centralized worker cleanup utilities
  * Provides consistent cleanup patterns across the codebase
@@ -15,15 +15,4 @@ export interface WorkerCleanupOptions {
  * Safely cleans up a worker with consistent error handling
  */
 export declare function cleanupWorker(worker: Worker | null | undefined, options?: WorkerCleanupOptions): void;
-/**
- * Safely cleans up MessagePorts with consistent error handling
- */
-export declare function cleanupMessagePorts(ports: (MessagePort | null | undefined)[], options?: {
-    logErrors?: boolean;
-}): void;
-/**
- * Comprehensive cleanup for worker + MessagePorts combination
- * This is the most common cleanup pattern in the codebase
- */
-export declare function cleanupWorkerAndPorts(worker: Worker | null | undefined, ports: (MessagePort | null | undefined)[], options?: WorkerCleanupOptions): void;
 //# sourceMappingURL=workerCleanup.d.ts.map

package/dist/plugin/helpers/workerCleanup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workerCleanup.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/workerCleanup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE/D;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,sDAAsD;IACtD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qDAAqD;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,OAAO,GAAE,oBAAyB,GACjC,IAAI,CAuBN;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACzC,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACpC,IAAI,CAkBN;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,CAAC,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,EACzC,OAAO,GAAE,oBAAyB,GACjC,IAAI,CAGN"}
+{"version":3,"file":"workerCleanup.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/workerCleanup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD;;;GAGG;AAEH,MAAM,WAAW,oBAAoB;IACnC,sDAAsD;IACtD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qDAAqD;IACrD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,OAAO,GAAE,oBAAyB,GACjC,IAAI,CAuBN"}

package/dist/plugin/helpers/workerCleanup.js

@@ -25,4 +25,4 @@ function cleanupWorker(worker, options = {}) {
 }
 
 export { cleanupWorker };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyQ2xlYW51cC5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2luL2hlbHBlcnMvd29ya2VyQ2xlYW51cC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFdvcmtlciwgTWVzc2FnZVBvcnQgfSBmcm9tIFwibm9kZTp3b3JrZXJfdGhyZWFkc1wiO1xuXG4vKipcbiAqIENlbnRyYWxpemVkIHdvcmtlciBjbGVhbnVwIHV0aWxpdGllc1xuICogUHJvdmlkZXMgY29uc2lzdGVudCBjbGVhbnVwIHBhdHRlcm5zIGFjcm9zcyB0aGUgY29kZWJhc2VcbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFdvcmtlckNsZWFudXBPcHRpb25zIHtcbiAgLyoqIFdoZXRoZXIgdG8gdGVybWluYXRlIHRoZSB3b3JrZXIgKGRlZmF1bHQ6IHRydWUpICovXG4gIHRlcm1pbmF0ZT86IGJvb2xlYW47XG4gIC8qKiBXaGV0aGVyIHRvIHJlbW92ZSBhbGwgbGlzdGVuZXJzIChkZWZhdWx0OiB0cnVlKSAqL1xuICByZW1vdmVMaXN0ZW5lcnM/OiBib29sZWFuO1xuICAvKiogV2hldGhlciB0byBsb2cgY2xlYW51cCBlcnJvcnMgKGRlZmF1bHQ6IGZhbHNlKSAqL1xuICBsb2dFcnJvcnM/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIFNhZmVseSBjbGVhbnMgdXAgYSB3b3JrZXIgd2l0aCBjb25zaXN0ZW50IGVycm9yIGhhbmRsaW5nXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjbGVhbnVwV29ya2VyKFxuICB3b3JrZXI6IFdvcmtlciB8IG51bGwgfCB1bmRlZmluZWQsXG4gIG9wdGlvbnM6IFdvcmtlckNsZWFudXBPcHRpb25zID0ge31cbik6IHZvaWQge1xuICBpZiAoIXdvcmtlcikgcmV0dXJuO1xuXG4gIGNvbnN0IHtcbiAgICB0ZXJtaW5hdGUgPSB0cnVlLFxuICAgIHJlbW92ZUxpc3RlbmVycyA9IHRydWUsXG4gICAgbG9nRXJyb3JzID0gZmFsc2VcbiAgfSA9IG9wdGlvbnM7XG5cbiAgdHJ5IHtcbiAgICBpZiAocmVtb3ZlTGlzdGVuZXJzKSB7XG4gICAgICB3b3JrZXIucmVtb3ZlQWxsTGlzdGVuZXJzKCk7XG4gICAgfVxuICAgIFxuICAgIGlmICh0ZXJtaW5hdGUpIHtcbiAgICAgIHdvcmtlci50ZXJtaW5hdGUoKTtcbiAgICB9XG4gIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgaWYgKGxvZ0Vycm9ycykge1xuICAgICAgY29uc29sZS53YXJuKCdbd29ya2VyQ2xlYW51cF0gRXJyb3IgZHVyaW5nIHdvcmtlciBjbGVhbnVwOicsIGVycm9yKTtcbiAgICB9XG4gICAgLy8gQWx3YXlzIGlnbm9yZSBjbGVhbnVwIGVycm9ycyB0byBwcmV2ZW50IGNhc2NhZGluZyBmYWlsdXJlc1xuICB9XG59XG5cbi8qKlxuICogU2FmZWx5IGNsZWFucyB1cCBNZXNzYWdlUG9ydHMgd2l0aCBjb25zaXN0ZW50IGVycm9yIGhhbmRsaW5nXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjbGVhbnVwTWVzc2FnZVBvcnRzKFxuICBwb3J0czogKE1lc3NhZ2VQb3J0IHwgbnVsbCB8IHVuZGVmaW5lZClbXSxcbiAgb3B0aW9uczogeyBsb2dFcnJvcnM/OiBib29sZWFuIH0gPSB7fVxuKTogdm9pZCB7XG4gIGNvbnN0IHsgbG9nRXJyb3JzID0gZmFsc2UgfSA9IG9wdGlvbnM7XG5cbiAgZm9yIChjb25zdCBwb3J0IG9mIHBvcnRzKSB7XG4gICAgaWYgKCFwb3J0KSBjb250aW51ZTtcblxuICAgIHRyeSB7XG4gICAgICAvLyBSZW1vdmUgb25tZXNzYWdlIGhhbmRsZXJzIChwcm9wZXJ0eSBhc3NpZ25tZW50IGNsZWFudXApXG4gICAgICAocG9ydCBhcyBhbnkpLm9ubWVzc2FnZSA9IG51bGw7XG4gICAgICAvLyBDbG9zZSB0aGUgcG9ydFxuICAgICAgcG9ydC5jbG9zZSgpO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICBpZiAobG9nRXJyb3JzKSB7XG4gICAgICAgIGNvbnNvbGUud2FybignW3dvcmtlckNsZWFudXBdIEVycm9yIGR1cmluZyBNZXNzYWdlUG9ydCBjbGVhbnVwOicsIGVycm9yKTtcbiAgICAgIH1cbiAgICAgIC8vIEFsd2F5cyBpZ25vcmUgY2xlYW51cCBlcnJvcnNcbiAgICB9XG4gIH1cbn1cblxuLyoqXG4gKiBDb21wcmVoZW5zaXZlIGNsZWFudXAgZm9yIHdvcmtlciArIE1lc3NhZ2VQb3J0cyBjb21iaW5hdGlvblxuICogVGhpcyBpcyB0aGUgbW9zdCBjb21tb24gY2xlYW51cCBwYXR0ZXJuIGluIHRoZSBjb2RlYmFzZVxuICovXG5leHBvcnQgZnVuY3Rpb24gY2xlYW51cFdvcmtlckFuZFBvcnRzKFxuICB3b3JrZXI6IFdvcmtlciB8IG51bGwgfCB1bmRlZmluZWQsXG4gIHBvcnRzOiAoTWVzc2FnZVBvcnQgfCBudWxsIHwgdW5kZWZpbmVkKVtdLFxuICBvcHRpb25zOiBXb3JrZXJDbGVhbnVwT3B0aW9ucyA9IHt9XG4pOiB2b2lkIHtcbiAgY2xlYW51cE1lc3NhZ2VQb3J0cyhwb3J0cywgeyBsb2dFcnJvcnM6IG9wdGlvbnMubG9nRXJyb3JzIH0pO1xuICBjbGVhbnVwV29ya2VyKHdvcmtlciwgb3B0aW9ucyk7XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFtQk8sU0FBUyxhQUNkLENBQUEsTUFBQSxFQUNBLE9BQWdDLEdBQUEsRUFDMUIsRUFBQTtBQUNOLEVBQUEsSUFBSSxDQUFDLE1BQVEsRUFBQTtBQUViLEVBQU0sTUFBQTtBQUFBLElBQ0osU0FBWSxHQUFBLElBQUE7QUFBQSxJQUNaLGVBQWtCLEdBQUEsSUFBQTtBQUFBLElBQ2xCLFNBQVksR0FBQTtBQUFBLEdBQ1YsR0FBQSxPQUFBO0FBRUosRUFBSSxJQUFBO0FBQ0YsSUFBQSxJQUFJLGVBQWlCLEVBQUE7QUFDbkIsTUFBQSxNQUFBLENBQU8sa0JBQW1CLEVBQUE7QUFBQTtBQUc1QixJQUFBLElBQUksU0FBVyxFQUFBO0FBQ2IsTUFBQSxNQUFBLENBQU8sU0FBVSxFQUFBO0FBQUE7QUFDbkIsV0FDTyxLQUFPLEVBQUE7QUFDZCxJQUFBLElBQUksU0FBVyxFQUFBO0FBQ2IsTUFBUSxPQUFBLENBQUEsSUFBQSxDQUFLLGdEQUFnRCxLQUFLLENBQUE7QUFBQTtBQUNwRTtBQUdKOzs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/loader/directives/index.d.ts

@@ -1,6 +1,5 @@
 export * from "./addLocalExportedNames.js";
 export * from "./getExports.js";
-export * from "./collectExportsFromModule.js";
 export * from "./analyzeDirectives.js";
 export * from "./analyzeModule.js";
 export * from "./collectExports.js";

package/dist/plugin/loader/directives/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../plugin/loader/directives/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/plugin/loader/directives/index.js

@@ -5,7 +5,6 @@
  */
 export { addLocalExportedNames } from './addLocalExportedNames.js';
 export { getExports } from './getExports.js';
-export { collectExportsFromModule } from './collectExportsFromModule.js';
 export { analyzeDirectives } from './analyzeDirectives.js';
 export { analyzeModule } from './analyzeModule.js';
 export { collectExports } from './collectExports.js';
@@ -15,4 +14,4 @@ export { getQualifiedName } from './getQualifiedName.js';
 export { processFunctionNode } from './processFunctionNode.js';
 export { canHaveDirective, isArrowFunctionExpression, isAsyncFunction, isBlockStatement, isClassBody, isClassDeclaration, isDirective, isExportDeclaration, isExportDefaultDeclaration, isExportNamedDeclaration, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeWithBlock, isFunctionNode, isIdentifier, isLiteral, isMethodDefinition, isNodeWithParent, isObjectExpression, isProgram, isProperty, isPropertyDefinition, isStringLiteral, isVariableDeclaration, isVariableDeclarator } from './typeGuards.js';
 export { getDirectiveValue, isDirectiveAtStart, matchOverlapsDirective } from './utils.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7In0=