rwsdk 1.0.8 → 1.0.9

package/dist/lib/normalizeModulePath.d.mts

@@ -1,3 +1,4 @@
+import path from "node:path";
 /**
  * Find the number of common ancestor segments between two absolute paths.
  * Returns the count of shared directory segments from the root.
@@ -28,4 +29,4 @@ export declare function findCommonAncestorDepth(path1: string, path2: string): n
 export declare function normalizeModulePath(modulePath: string, projectRootDir: string, options?: {
     absolute?: boolean;
     isViteStyle?: boolean;
-}): string;
+}, _path?: typeof path): string;

package/dist/lib/normalizeModulePath.mjs

@@ -1,5 +1,10 @@
-import { posix as path } from "node:path";
-import { normalizePath as normalizePathSeparators } from "vite";
+import path from "node:path";
+import { normalizePath } from "vite";
+const windowsDriveAbsoluteRE = /^[A-Za-z]:\//;
+// Vite's normalizePath only converts backslashes on Windows. This wrapper
+// ensures forward slashes regardless of platform, which matters when win32
+// path functions are injected for testing on Linux.
+const normalizePathSeparators = (p) => normalizePath(p.replace(/\\/g, "/"));
 /**
  * Find the number of common ancestor segments between two absolute paths.
  * Returns the count of shared directory segments from the root.
@@ -41,16 +46,16 @@ export function findCommonAncestorDepth(path1, path2) {
  *   /opt/tools/logger.ts                  → /opt/tools/logger.ts (resolved as Vite-style)
  *   /src/page.tsx, { absolute: true }     → /Users/justin/my-app/src/page.tsx
  */
-export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
+export function normalizeModulePath(modulePath, projectRootDir, options = {}, _path = path) {
     modulePath = normalizePathSeparators(modulePath);
-    projectRootDir = normalizePathSeparators(path.resolve(projectRootDir));
+    projectRootDir = normalizePathSeparators(_path.resolve(projectRootDir));
     // Handle empty string or current directory
     if (modulePath === "" || modulePath === ".") {
         return options.absolute ? projectRootDir : "/";
     }
     // For relative paths, resolve them first
     let resolved;
-    if (path.isAbsolute(modulePath)) {
+    if (_path.isAbsolute(modulePath)) {
         if (modulePath.startsWith(projectRootDir + "/") ||
             modulePath === projectRootDir) {
             // Path starts with project root - it's a real absolute path inside project
@@ -61,7 +66,7 @@ export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
             if (options.isViteStyle !== undefined) {
                 // User explicitly specified whether this should be treated as Vite-style
                 if (options.isViteStyle) {
-                    resolved = path.resolve(projectRootDir, modulePath.slice(1));
+                    resolved = _path.resolve(projectRootDir, modulePath.slice(1));
                 }
                 else {
                     resolved = modulePath;
@@ -70,19 +75,20 @@ export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
             else {
                 // Fall back to heuristics using common ancestor depth
                 const commonDepth = findCommonAncestorDepth(modulePath, projectRootDir);
-                if (commonDepth > 0) {
-                    // Paths share meaningful common ancestor - treat as real absolute path
+                if (commonDepth > 0 || windowsDriveAbsoluteRE.test(modulePath)) {
+                    // Paths share meaningful common ancestor, or this is a Windows absolute
+                    // path on a different drive — treat as a real external absolute path
                     resolved = modulePath;
                 }
                 else {
                     // No meaningful common ancestor - assume Vite-style path within project
-                    resolved = path.resolve(projectRootDir, modulePath.slice(1));
+                    resolved = _path.resolve(projectRootDir, modulePath.slice(1));
                 }
             }
         }
     }
     else {
-        resolved = path.resolve(projectRootDir, modulePath);
+        resolved = _path.resolve(projectRootDir, modulePath);
     }
     resolved = normalizePathSeparators(resolved);
     // If absolute option is set, always return absolute paths
@@ -90,9 +96,10 @@ export function normalizeModulePath(modulePath, projectRootDir, options = {}) {
         return resolved;
     }
     // Check if the resolved path is within the project root
-    const relative = path.relative(projectRootDir, resolved);
-    // If the path goes outside the project root (starts with ..), return absolute
-    if (relative.startsWith("..")) {
+    const relative = _path.relative(projectRootDir, resolved);
+    // If the path goes outside the project root (starts with ..) or is on a
+    // different drive (Windows: path.relative returns an absolute path), return absolute
+    if (relative.startsWith("..") || _path.isAbsolute(relative)) {
         return resolved;
     }
     // Path is within project root, return as Vite-style relative path

package/dist/lib/normalizeModulePath.test.mjs

@@ -1,3 +1,4 @@
+import { win32 as windowsPath } from "node:path";
 import { describe, expect, it } from "vitest";
 import { findCommonAncestorDepth, normalizeModulePath, } from "./normalizeModulePath.mjs";
 describe("findCommonAncestorDepth", () => {
@@ -220,3 +221,21 @@ describe("normalizeModulePath", () => {
         });
     });
 });
+describe("Windows paths (path.win32)", () => {
+    const root = "C:/Projects/app";
+    it("Windows absolute path inside project", () => {
+        expect(normalizeModulePath("C:/Projects/app/src/page.tsx", root, {}, windowsPath)).toBe("/src/page.tsx");
+    });
+    it("Windows absolute path outside project (same drive)", () => {
+        expect(normalizeModulePath("C:/other/utils.ts", root, {}, windowsPath)).toBe("C:/other/utils.ts");
+    });
+    it("Cross-drive path is treated as external", () => {
+        expect(normalizeModulePath("D:/other/utils.ts", root, {}, windowsPath)).toBe("D:/other/utils.ts");
+    });
+    it("Relative path resolves correctly", () => {
+        expect(normalizeModulePath("src/page.tsx", root, {}, windowsPath)).toBe("/src/page.tsx");
+    });
+    it("Windows absolute path inside project with absolute option", () => {
+        expect(normalizeModulePath("C:/Projects/app/src/page.tsx", root, { absolute: true }, windowsPath)).toBe("C:/Projects/app/src/page.tsx");
+    });
+});

package/dist/vite/redwoodPlugin.mjs

@@ -1,5 +1,6 @@
 import { cloudflare } from "@cloudflare/vite-plugin";
-import { resolve } from "node:path/posix";
+import { resolve } from "node:path";
+import { normalizePath } from "vite";
 import { unstable_readConfig } from "wrangler";
 import { devServerConstantPlugin } from "./devServerConstant.mjs";
 import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
@@ -32,10 +33,10 @@ import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
 import { vitePreamblePlugin } from "./vitePreamblePlugin.mjs";
 export const determineWorkerEntryPathname = async ({ projectRootDir, workerConfigPath, options, readConfig = unstable_readConfig, }) => {
     if (options.entry?.worker) {
-        return resolve(projectRootDir, options.entry.worker);
+        return normalizePath(resolve(projectRootDir, options.entry.worker));
     }
     const workerConfig = readConfig({ config: workerConfigPath });
-    return resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx");
+    return normalizePath(resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx"));
 };
 const clientFiles = new Set();
 const serverFiles = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {