rwsdk 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -1,8 +1,8 @@
-import path from "path";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import os from "os";
-import { writeFileSync, mkdirSync, mkdtempSync } from "node:fs";
+import path from "path";
+import { VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_CLIENT_BARREL_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_PATH, } from "../lib/constants.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
-import { VENDOR_CLIENT_BARREL_PATH, VENDOR_SERVER_BARREL_PATH, VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH, } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
 export const generateVendorBarrelContent = (files, projectRootDir) => {
     const imports = [...files]
@@ -30,7 +30,7 @@ export const generateAppBarrelContent = (files, projectRootDir) => {
     })
         .join("\n");
 };
-export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) => {
     const { promise: scanPromise, resolve: resolveScanPromise } = Promise.withResolvers();
     const tempDir = mkdtempSync(path.join(os.tmpdir(), "rwsdk-"));
     const APP_CLIENT_BARREL_PATH = path.join(tempDir, "app-client-barrel.js");
@@ -47,6 +47,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 environments: server.environments,
                 clientFiles,
                 serverFiles,
+                entries: [workerEntryPathname],
             }).then(() => {
                 // context(justinvdm, 11 Sep 2025): For vendor barrels, we write the
                 // files directly to disk after the scan. For app barrels, we use a
@@ -83,7 +84,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
                 env.optimizeDeps.include ??= [];
                 const entries = (env.optimizeDeps.entries = castArray(env.optimizeDeps.entries ?? []));
                 env.optimizeDeps.include.push(VENDOR_CLIENT_BARREL_EXPORT_PATH, VENDOR_SERVER_BARREL_EXPORT_PATH);
-                if (envName === "client") {
+                if (envName === "client" || envName === "ssr") {
                     entries.push(APP_CLIENT_BARREL_PATH);
                 }
                 else if (envName === "worker") {

package/dist/vite/directiveModulesDevPlugin.test.mjs

@@ -1,5 +1,5 @@
-import { describe, it, expect } from "vitest";
-import { generateVendorBarrelContent, generateAppBarrelContent, } from "./directiveModulesDevPlugin.mjs";
+import { describe, expect, it } from "vitest";
+import { generateAppBarrelContent, generateVendorBarrelContent, } from "./directiveModulesDevPlugin.mjs";
 describe("directiveModulesDevPlugin helpers", () => {
     const projectRootDir = "/Users/test/project";
     describe("generateVendorBarrelContent", () => {

package/dist/vite/directivesPlugin.mjs

@@ -1,9 +1,9 @@
-import path from "node:path";
-import fs from "node:fs/promises";
 import debug from "debug";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
-import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
 export const getLoader = (filePath) => {
     const ext = path.extname(filePath).slice(1);

package/dist/vite/directivesPlugin.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { getLoader } from "./directivesPlugin.mjs";
 describe("getLoader", () => {
     const testCases = [

package/dist/vite/ensureAliasArray.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
 describe("ensureAliasArray", () => {
     it("should create resolve and alias array if resolve is undefined", () => {

package/dist/vite/findSpecifiers.mjs

@@ -1,4 +1,4 @@
-import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
+import { Lang, Lang as SgLang, parse as sgParse } from "@ast-grep/napi";
 import path from "path";
 // These patterns are used to match import statements in code for SSR transformations.
 export const IMPORT_PATTERNS = [

package/dist/vite/findSpecifiers.test.mjs

@@ -1,5 +1,5 @@
-import { describe, it, expect } from "vitest";
-import { findImportSpecifiers, findExports } from "./findSpecifiers.mjs";
+import { describe, expect, it } from "vitest";
+import { findExports, findImportSpecifiers } from "./findSpecifiers.mjs";
 function dedupeImports(imports) {
     const seen = new Set();
     return imports.filter((imp) => {

package/dist/vite/findSsrSpecifiers.mjs

@@ -1,4 +1,4 @@
-import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
+import { Lang, Lang as SgLang, parse as sgParse } from "@ast-grep/napi";
 import path from "path";
 /**
  * Finds callsites for __vite_ssr_import__ and __vite_ssr_dynamic_import__ with their ranges.

package/dist/vite/findSsrSpecifiers.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
 describe("findSsrImportCallSites", () => {
     it("should find __vite_ssr_import__ with double quotes", () => {

package/dist/vite/getViteEsbuild.mjs

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { createRequire } from "node:module";
+import path from "node:path";
 const require = createRequire(import.meta.url);
 export async function getViteEsbuild(projectRootDir) {
     const vitePath = require.resolve("vite/package.json", {

package/dist/vite/hasDirective.d.mts

@@ -1,7 +1,10 @@
 /**
  * Efficiently checks if a React directive (e.g., "use server", "use client")
- * is present in the code. Optimized for performance with a two-step approach:
- * 1. Quick string search to see if directive exists anywhere
- * 2. Line-by-line check only if the directive might be present
+ * is present in the code.
+ *
+ * This function is optimized for performance by only checking the first few
+ * lines of the code, as directives must appear at the very top of a file.
+ * It handles comments, whitespace, and any valid directive prologue
+ * (e.g., "use strict").
  */
 export declare function hasDirective(code: string, directive: string): boolean;

package/dist/vite/hasDirective.mjs

@@ -1,54 +1,70 @@
 /**
  * Efficiently checks if a React directive (e.g., "use server", "use client")
- * is present in the code. Optimized for performance with a two-step approach:
- * 1. Quick string search to see if directive exists anywhere
- * 2. Line-by-line check only if the directive might be present
+ * is present in the code.
+ *
+ * This function is optimized for performance by only checking the first few
+ * lines of the code, as directives must appear at the very top of a file.
+ * It handles comments, whitespace, and any valid directive prologue
+ * (e.g., "use strict").
  */
 export function hasDirective(code, directive) {
-    // Quick performance check: if directive doesn't exist anywhere, skip line checking
-    const singleQuoteDirective = `'${directive}'`;
-    const doubleQuoteDirective = `"${directive}"`;
-    if (!code.includes(singleQuoteDirective) &&
-        !code.includes(doubleQuoteDirective)) {
-        return false;
-    }
-    // Split into lines and check each one
-    const lines = code.split("\n");
+    const lines = code.slice(0, 512).split("\n"); // Check first ~512 chars
     let inMultiLineComment = false;
+    let foundUseClient = false;
+    let foundTargetDirective = false;
+    const doubleQuoteDirective = `"${directive}"`;
+    const singleQuoteDirective = `'${directive}'`;
+    const doubleQuoteUseClient = `"use client"`;
+    const singleQuoteUseClient = `'use client'`;
     for (const line of lines) {
         const trimmedLine = line.trim();
-        // Skip empty lines
         if (trimmedLine.length === 0) {
             continue;
         }
-        // Handle multi-line comments
-        if (trimmedLine.startsWith("/*")) {
-            inMultiLineComment = true;
-            // Check if the comment ends on the same line
+        if (inMultiLineComment) {
             if (trimmedLine.includes("*/")) {
                 inMultiLineComment = false;
             }
             continue;
         }
-        if (inMultiLineComment) {
-            // Check if this line ends the multi-line comment
-            if (trimmedLine.includes("*/")) {
-                inMultiLineComment = false;
+        if (trimmedLine.startsWith("/*")) {
+            if (!trimmedLine.includes("*/")) {
+                inMultiLineComment = true;
             }
             continue;
         }
-        // Skip single-line comments
         if (trimmedLine.startsWith("//")) {
             continue;
         }
-        // Check if this line starts with the directive
+        const cleanedLine = trimmedLine.endsWith(";")
+            ? trimmedLine.slice(0, -1)
+            : trimmedLine;
+        if (trimmedLine.startsWith(doubleQuoteUseClient) ||
+            trimmedLine.startsWith(singleQuoteUseClient)) {
+            foundUseClient = true;
+            if (directive === "use client") {
+                return true;
+            }
+        }
         if (trimmedLine.startsWith(doubleQuoteDirective) ||
             trimmedLine.startsWith(singleQuoteDirective)) {
-            return true;
+            foundTargetDirective = true;
+            if (directive !== "use server") {
+                return true;
+            }
         }
-        // If we hit a non-empty, non-comment line that's not a directive, we can stop
-        // (directives must be at the top of the file/scope, after comments)
+        // Any other string literal is part of a valid directive prologue.
+        // We can continue searching.
+        if (trimmedLine.startsWith('"') || trimmedLine.startsWith("'")) {
+            continue;
+        }
+        // If we encounter any other non-directive, non-comment, non-string-literal
+        // line of code, the directive prologue is over. Stop.
         break;
     }
-    return false;
+    // If looking for 'use server' and 'use client' was found, return false (client takes priority)
+    if (directive === "use server" && foundUseClient) {
+        return false;
+    }
+    return foundTargetDirective;
 }

package/dist/vite/hasDirective.test.mjs

@@ -1,109 +1,107 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { hasDirective } from "./hasDirective.mjs";
 describe("hasDirective", () => {
-    it('should find "use client" directive with double quotes', () => {
-        const code = `"use client";
-    
-    import React from "react";
-    
-    const MyComponent = () => <div>Hello</div>;
-    export default MyComponent;`;
+    it('should find "use client" directive', () => {
+        const code = `"use client"; import React from "react";`;
         expect(hasDirective(code, "use client")).toBe(true);
     });
-    it("should find 'use server' directive with single quotes", () => {
-        const code = `'use server';
-    
-    export async function myAction() {
-      // ...
-    }`;
+    it('should find "use server" directive', () => {
+        const code = `'use server'; export async function myAction() {}`;
         expect(hasDirective(code, "use server")).toBe(true);
     });
-    it("should find directive with leading whitespace", () => {
-        const code = `    "use client";
-    
-    const MyComponent = () => <div>Hello</div>;`;
+    it("should not find a directive that is not there", () => {
+        const code = `import React from "react";`;
+        expect(hasDirective(code, "use client")).toBe(false);
+    });
+    it('should find "use client" directive with single quotes', () => {
+        const code = `'use client'; import React from "react";`;
         expect(hasDirective(code, "use client")).toBe(true);
     });
-    it("should find directive after single-line comments", () => {
-        const code = `// This is a component
-    "use client";
-    
-    const MyComponent = () => <div>Hello</div>;`;
+    it("should find directive when preceded by comments and whitespace", () => {
+        const code = `
+      // This is a client component
+      /* And here is another comment */
+
+      "use client";
+      import React from 'react';
+      export default () => <div>Hello</div>;
+    `;
         expect(hasDirective(code, "use client")).toBe(true);
     });
-    it("should find directive after multi-line comments", () => {
-        const code = `/* This is a component */
-    "use client";
-    
-    const MyComponent = () => <div>Hello</div>;`;
+    it('should find "use client" directive when preceded by "use strict"', () => {
+        const code = `
+      "use strict";
+      "use client";
+      import React from 'react';
+      export default () => <div>Hello</div>;
+    `;
         expect(hasDirective(code, "use client")).toBe(true);
     });
-    it("should find directive after empty lines", () => {
+    it('should find "use server" directive when preceded by "use strict" and comments', () => {
         const code = `
-
-    "use client";
-    
-    const MyComponent = () => <div>Hello</div>;`;
+      // server stuff
+      "use strict";
+      /* another comment */
+      "use server";
+      export async function myAction() {}
+    `;
+        expect(hasDirective(code, "use server")).toBe(true);
+    });
+    it("should find directive when preceded by another string literal directive", () => {
+        const code = `
+      "use awesome"; // Some other directive
+      "use client";
+      import React from 'react';
+      export default () => <div>Hello</div>;
+    `;
         expect(hasDirective(code, "use client")).toBe(true);
     });
     it("should return false if no directive is present", () => {
         const code = `import React from "react";
-    
-    const MyComponent = () => <div>Hello</div>;`;
+    export default () => <div>Hello</div>;`;
         expect(hasDirective(code, "use client")).toBe(false);
     });
-    it("should return false if directive is not at the top", () => {
-        const code = `import React from "react";
-    "use client";
-    
-    const MyComponent = () => <div>Hello</div>;`;
-        expect(hasDirective(code, "use client")).toBe(false);
-    });
-    it("should return false if directive is inside a single-line comment", () => {
+    it("should return false if the directive is commented out", () => {
         const code = `// "use client";
-    
-    const MyComponent = () => <div>Hello</div>;`;
+    import React from "react";
+    export default () => <div>Hello</div>;`;
         expect(hasDirective(code, "use client")).toBe(false);
     });
-    it("should return false if directive is inside a multi-line comment", () => {
-        const code = `/*
-     * "use client";
-     */
-    
-    const MyComponent = () => <div>Hello</div>;`;
+    it("should return false if the directive appears after code", () => {
+        const code = `import React from "react";
+    "use client";
+    export default () => <div>Hello</div>;`;
         expect(hasDirective(code, "use client")).toBe(false);
     });
-    it("should return false if directive is a substring in other code", () => {
-        const code = `const message = 'please "use client" wisely';`;
+    it("should handle multi-line comments correctly", () => {
+        const code = `
+      /*
+       * "use client";
+       */
+      import React from "react";
+    `;
         expect(hasDirective(code, "use client")).toBe(false);
     });
-    it("should handle a file with only the directive", () => {
-        const code = `"use client"`;
+    it("should handle code with no whitespace", () => {
+        const code = `"use client";import React from "react";`;
         expect(hasDirective(code, "use client")).toBe(true);
     });
-    it("should handle mixed comments, whitespace, and the directive", () => {
-        const code = `// A component
-    
-    /* 
-      Another comment
-    */
-   
-    'use client';
-
-    const MyComponent = () => <div>Hello</div>;
-    `;
-        expect(hasDirective(code, "use client")).toBe(true);
+    it("should handle empty code", () => {
+        const code = "";
+        expect(hasDirective(code, "use client")).toBe(false);
     });
-    it("should handle multi-line comment ending on same line", () => {
-        const code = `/* "use client" */
-    const MyComponent = () => <div>Hello</div>;
-    `;
+    it("should handle code with only whitespace", () => {
+        const code = "  \n\t  ";
         expect(hasDirective(code, "use client")).toBe(false);
     });
-    it("should return false for code where directive appears after a valid line of code", () => {
-        const code = `const a = 1;
-    "use client";
-    `;
+    it("should handle files with only comments", () => {
+        const code = `// comment 1
+    /* comment 2 */`;
         expect(hasDirective(code, "use client")).toBe(false);
     });
+    it("should prioritize 'use client' over 'use server'", () => {
+        const code = `'use client';\n'use server';\nconsole.log('hello');`;
+        expect(hasDirective(code, "use client")).toBe(true);
+        expect(hasDirective(code, "use server")).toBe(false);
+    });
 });

package/dist/vite/index.d.mts

@@ -1 +1 @@
-export { type RedwoodPluginOptions, redwoodPlugin as redwood, } from "./redwoodPlugin.mjs";
+export { redwoodPlugin as redwood, type RedwoodPluginOptions, } from "./redwoodPlugin.mjs";

package/dist/vite/invalidateCacheIfPrismaClientChanged.mjs

@@ -1,6 +1,6 @@
-import { resolve } from "node:path";
-import { remove, pathExists } from "fs-extra";
+import { pathExists, remove } from "fs-extra";
 import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
 export const invalidateCacheIfPrismaClientChanged = async ({ projectRootDir, }) => {
     const viteDepsCachePath = resolve(projectRootDir, "node_modules", ".vite", `deps_worker`, `@prisma_client.js`);
     // Get mtimes for comparison

package/dist/vite/isJsFile.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { isJsFile } from "./isJsFile.mjs";
 describe("isJsFile", () => {
     const matchingExtensions = [

package/dist/vite/{reactConditionsResolverPlugin.d.mts → knownDepsResolverPlugin.d.mts}

@@ -1,6 +1,6 @@
-import { Plugin } from "vite";
 import enhancedResolve from "enhanced-resolve";
-export declare const ENV_REACT_IMPORTS: {
+import { Plugin } from "vite";
+export declare const ENV_PREDEFINED_IMPORTS: {
     worker: string[];
     ssr: string[];
     client: string[];
@@ -10,6 +10,6 @@ export declare const ENV_RESOLVERS: {
     worker: enhancedResolve.ResolveFunction;
     client: enhancedResolve.ResolveFunction;
 };
-export declare const reactConditionsResolverPlugin: ({ projectRootDir, }: {
+export declare const knownDepsResolverPlugin: ({ projectRootDir, }: {
     projectRootDir: string;
 }) => Plugin[];

package/dist/vite/{reactConditionsResolverPlugin.mjs → knownDepsResolverPlugin.mjs}

@@ -1,10 +1,15 @@
 import debug from "debug";
-import { ROOT_DIR } from "../lib/constants.mjs";
 import enhancedResolve from "enhanced-resolve";
+import { ROOT_DIR } from "../lib/constants.mjs";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
-const log = debug("rwsdk:vite:react-conditions-resolver-plugin");
-const REACT_PREFIXES = ["react", "react-dom", "react-server-dom-webpack"];
-export const ENV_REACT_IMPORTS = {
+const log = debug("rwsdk:vite:known-deps-resolver-plugin");
+const KNOWN_PREFIXES = [
+    "react",
+    "react-dom",
+    "react-server-dom-webpack",
+    "rwsdk",
+];
+export const ENV_PREDEFINED_IMPORTS = {
     worker: [
         "react",
         "react-dom",
@@ -42,10 +47,10 @@ export const ENV_RESOLVERS = {
         conditionNames: ["browser", "default"],
     }),
 };
-function resolveReactImport(id, envName, projectRootDir, isReactImportKnown = false) {
-    if (!isReactImportKnown) {
-        const isReactImport = REACT_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
-        if (!isReactImport) {
+function resolveKnownImport(id, envName, projectRootDir, isPrefixedImport = false) {
+    if (!isPrefixedImport) {
+        const isKnownImport = KNOWN_PREFIXES.some((prefix) => id === prefix || id.startsWith(`${prefix}/`));
+        if (!isKnownImport) {
             return undefined;
         }
     }
@@ -70,13 +75,13 @@ function resolveReactImport(id, envName, projectRootDir, isReactImportKnown = fa
     }
     return resolved;
 }
-function resolveEnvImportMappings(env, projectRootDir) {
+function resolvePredefinedEnvImportMappings(env, projectRootDir) {
     process.env.VERBOSE &&
         log("Resolving environment import mappings for env=%s", env);
     const mappings = new Map();
-    const reactImports = ENV_REACT_IMPORTS[env];
-    for (const importRequest of reactImports) {
-        const resolved = resolveReactImport(importRequest, env, projectRootDir, true);
+    const predefinedImports = ENV_PREDEFINED_IMPORTS[env];
+    for (const importRequest of predefinedImports) {
+        const resolved = resolveKnownImport(importRequest, env, projectRootDir, true);
         if (resolved) {
             mappings.set(importRequest, resolved);
             process.env.VERBOSE &&
@@ -87,27 +92,27 @@ function resolveEnvImportMappings(env, projectRootDir) {
         log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
     return mappings;
 }
-export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
-    log("Initializing react conditions resolver plugin");
+export const knownDepsResolverPlugin = ({ projectRootDir, }) => {
+    log("Initializing known dependencies resolver plugin");
     let isBuild = false;
     const ENV_IMPORT_MAPPINGS = Object.fromEntries(Object.keys(ENV_RESOLVERS).map((env) => [
         env,
-        resolveEnvImportMappings(env, projectRootDir),
+        resolvePredefinedEnvImportMappings(env, projectRootDir),
     ]));
     // Log a clean summary instead of all the individual mappings
     const totalMappings = Object.values(ENV_IMPORT_MAPPINGS).reduce((sum, mappings) => sum + mappings.size, 0);
-    log("React conditions resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
+    log("Known dependencies resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
     function createEsbuildResolverPlugin(envName, mappings) {
         if (!mappings) {
             return null;
         }
         return {
-            name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
+            name: `rwsdk:known-dependencies-resolver-esbuild-${envName}`,
             setup(build) {
                 build.onResolve({ filter: /.*/ }, (args) => {
                     let resolved = mappings.get(args.path);
                     if (!resolved) {
-                        resolved = resolveReactImport(args.path, envName, projectRootDir);
+                        resolved = resolveKnownImport(args.path, envName, projectRootDir);
                     }
                     if (resolved && args.importer !== "") {
                         if (args.path === "react-server-dom-webpack/client.edge") {
@@ -123,7 +128,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
     }
     return [
         {
-            name: "rwsdk:react-conditions-resolver:config",
+            name: "rwsdk:known-dependencies-resolver:config",
             enforce: "post",
             config(config, { command }) {
                 isBuild = command === "build";
@@ -133,7 +138,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                 log("Setting up resolve aliases and optimizeDeps for each environment");
                 // Set up aliases and optimizeDeps for each environment
                 for (const [envName, mappings] of Object.entries(ENV_IMPORT_MAPPINGS)) {
-                    const reactImports = ENV_REACT_IMPORTS[envName];
+                    const predefinedImports = ENV_PREDEFINED_IMPORTS[envName];
                     // Ensure environment config exists
                     if (!config.environments) {
                         config.environments = {};
@@ -151,7 +156,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                         envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
                         envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
                         envConfig.optimizeDeps.include ??= [];
-                        envConfig.optimizeDeps.include.push(...reactImports);
+                        envConfig.optimizeDeps.include.push(...predefinedImports);
                         log("Added esbuild plugin and optimizeDeps includes for environment: %s", envName);
                     }
                     const aliases = ensureAliasArray(envConfig);
@@ -161,12 +166,12 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                         process.env.VERBOSE &&
                             log("Added alias for env=%s: %s -> %s", envName, find, replacement);
                     }
-                    log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
+                    log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, predefinedImports.length);
                 }
             },
         },
         {
-            name: "rwsdk:react-conditions-resolver:resolveId",
+            name: "rwsdk:known-dependencies-resolver:resolveId",
             enforce: "pre",
             async resolveId(id, importer) {
                 // Skip during directive scanning to avoid performance issues
@@ -188,7 +193,7 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                 }
                 let resolved = mappings.get(id);
                 if (!resolved) {
-                    resolved = resolveReactImport(id, envName, projectRootDir);
+                    resolved = resolveKnownImport(id, envName, projectRootDir);
                 }
                 if (resolved) {
                     process.env.VERBOSE &&

package/dist/vite/linkerPlugin.mjs

@@ -1,7 +1,7 @@
-import path from "node:path";
+import debug from "debug";
 import fsp from "node:fs/promises";
+import path from "node:path";
 import { CLIENT_MANIFEST_RELATIVE_PATH } from "../lib/constants.mjs";
-import debug from "debug";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:linker-plugin");
 export function linkWorkerBundle({ code, manifestContent, projectRootDir, }) {

package/dist/vite/linkerPlugin.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { linkWorkerBundle } from "./linkerPlugin.mjs";
 describe("linkWorkerBundle", () => {
     const projectRootDir = "/test/project";

package/dist/vite/miniflareHMRPlugin.mjs

@@ -1,13 +1,13 @@
+import debug from "debug";
+import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import colors from "picocolors";
-import { readFile } from "node:fs/promises";
-import debug from "debug";
-import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
+import { getShortName } from "../lib/getShortName.mjs";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
 import { hasDirective as sourceHasDirective } from "./hasDirective.mjs";
-import { isJsFile } from "./isJsFile.mjs";
 import { invalidateModule } from "./invalidateModule.mjs";
-import { getShortName } from "../lib/getShortName.mjs";
+import { isJsFile } from "./isJsFile.mjs";
+import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
 const log = debug("rwsdk:vite:hmr-plugin");
 let hasErrored = false;
 const hasDirective = async (filepath, directive) => {

package/dist/vite/miniflareHMRPlugin.test.mjs

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, expect, it } from "vitest";
 import { hasEntryAsAncestor } from "./miniflareHMRPlugin.mjs";
 const createModule = (file) => ({
     file,