rwsdk 1.0.1 → 1.0.3

package/dist/lib/stripBase.d.mts

@@ -0,0 +1 @@
+export declare function stripBase(path: string, base: string): string;

package/dist/lib/stripBase.mjs

@@ -0,0 +1,5 @@
+export function stripBase(path, base) {
+    return base && base !== "/" && path.startsWith(base)
+        ? "/" + path.slice(base.length)
+        : path;
+}

package/dist/lib/stripBase.test.d.mts

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

package/dist/lib/stripBase.test.mjs

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { stripBase } from "./stripBase.mjs";
+describe("stripBase", () => {
+    it("should strip base prefix from path", () => {
+        expect(stripBase("/auth/src/client.tsx", "/auth/")).toBe("/src/client.tsx");
+    });
+    it("should be a no-op when base is /", () => {
+        expect(stripBase("/src/client.tsx", "/")).toBe("/src/client.tsx");
+    });
+    it("should be a no-op when path does not start with base", () => {
+        expect(stripBase("/src/client.tsx", "/auth/")).toBe("/src/client.tsx");
+    });
+    it("should handle path equal to base", () => {
+        expect(stripBase("/auth/", "/auth/")).toBe("/");
+    });
+    it("should handle multi-level base paths", () => {
+        expect(stripBase("/org/app/src/client.tsx", "/org/app/")).toBe("/src/client.tsx");
+    });
+    it("should be a no-op when base is empty string", () => {
+        expect(stripBase("/src/client.tsx", "")).toBe("/src/client.tsx");
+    });
+});

package/dist/runtime/lib/router.js

@@ -317,7 +317,17 @@ export function defineRoutes(routes) {
                                 if (!isClientReference(componentHandler) && !requestInfo.rw.pageRouteResolved) {
                                     requestInfo.rw.pageRouteResolved = Promise.withResolvers();
                                 }
-                                return await renderPage(requestInfo, WrappedComponent, onError);
+                                const response = await renderPage(requestInfo, WrappedComponent, onError);
+                                // context(justinvdm, 2026-03-17): renderPage stores rendering
+                                // errors on rw.renderError instead of throwing, to avoid
+                                // corrupting React's internal RSC stream state. We check for
+                                // it here and throw so except handlers can process it.
+                                if (requestInfo.rw.renderError) {
+                                    const error = requestInfo.rw.renderError;
+                                    requestInfo.rw.renderError = undefined;
+                                    throw error;
+                                }
+                                return response;
                             }
                             // Handle non-component final handler (e.g., returns new Response)
                             const tailResult = await componentHandler(getRequestInfo());
@@ -347,6 +357,10 @@ Route handlers must return one of:
                         });
                     }
                     catch (error) {
+                        // context(justinvdm, 2026-03-17): If pageRouteResolved was set up for
+                        // the component that threw, resolve it so the worker doesn't hang
+                        // waiting on it after the except handler returns its response.
+                        getRequestInfo().rw.pageRouteResolved?.resolve();
                         return await executeExceptHandlers(error, currentRouteIndex);
                     }
                 }

package/dist/runtime/lib/types.d.ts

@@ -13,6 +13,7 @@ export type RwContext = {
     inlineScripts: Set<string>;
     pageRouteResolved: PromiseWithResolvers<void> | undefined;
     actionResult?: unknown;
+    renderError?: unknown;
 };
 export type DocumentProps<T extends RequestInfo = RequestInfo> = T & {
     children: React.ReactNode;

package/dist/runtime/worker.js

@@ -16,6 +16,17 @@ export const defineApp = (routes) => {
         __rwRoutes: routes,
         fetch: async (request, env, cf) => {
             globalThis.__webpack_require__ = ssrWebpackRequire;
+            // context(justinvdm, 17 Mar 2026): Strip the Vite base path from the
+            // request URL so that routes defined as "/" match requests to "/app/"
+            // when base: '/app/' is configured. Vite injects BASE_URL automatically.
+            const base = import.meta.env.BASE_URL;
+            if (base && base !== "/") {
+                const url = new URL(request.url);
+                if (url.pathname.startsWith(base)) {
+                    url.pathname = "/" + url.pathname.slice(base.length);
+                    request = new Request(url.toString(), request);
+                }
+            }
             // context(justinvdm, 5 Feb 2025): Serve assets requests using the assets service binding
             // todo(justinvdm, 5 Feb 2025): Find a way to avoid this so asset requests are served directly
             // rather than first needing to go through the worker
@@ -107,7 +118,7 @@ export const defineApp = (routes) => {
                     }
                     return pageElement;
                 };
-                const renderPage = async (requestInfo, Page, onError) => {
+                const renderPage = async (requestInfo, Page, _onError) => {
                     if (isClientReference(requestInfo.rw.Document)) {
                         if (import.meta.env.DEV) {
                             console.error("Document cannot be a client component");
@@ -116,6 +127,17 @@ export const defineApp = (routes) => {
                             status: 500,
                         });
                     }
+                    // context(justinvdm, 2026-03-17): Capture rendering errors so the
+                    // router can throw them and route to except handlers. We store the
+                    // error on rw.renderError instead of throwing from renderPage, because
+                    // throwing mid-render corrupts React's internal RSC stream state
+                    // (causing "chunk.reason.enqueueModel is not a function" in subsequent
+                    // renders). By returning normally, streams are cleaned up properly.
+                    const onError = (error) => {
+                        if (!rw.renderError) {
+                            rw.renderError = error;
+                        }
+                    };
                     const actionResult = normalizeActionResult(requestInfo.rw.actionResult);
                     const isDataOnly = request.headers.get("x-rsc-data-only") === "true";
                     const pageElement = isDataOnly && actionResult !== undefined
@@ -149,13 +171,28 @@ export const defineApp = (routes) => {
                             nonce: rw.nonce,
                         });
                     }
-                    let html = await renderDocumentHtmlStream({
-                        rscPayloadStream: rscPayloadStream,
-                        Document: rw.Document,
-                        requestInfo: requestInfo,
-                        onError,
-                        shouldSSR: rw.ssr,
-                    });
+                    let html;
+                    try {
+                        html = await renderDocumentHtmlStream({
+                            rscPayloadStream: rscPayloadStream,
+                            Document: rw.Document,
+                            requestInfo: requestInfo,
+                            onError,
+                            shouldSSR: rw.ssr,
+                        });
+                    }
+                    catch (renderError) {
+                        // context(justinvdm, 2026-03-17): If renderDocumentHtmlStream throws
+                        // AND we already captured the error via onError, return a minimal
+                        // response. The router will detect rw.renderError and route to
+                        // except handlers. We must not re-throw here because throwing from
+                        // renderPage corrupts React's internal RSC stream state, preventing
+                        // the except handler from rendering its error page.
+                        if (rw.renderError) {
+                            return new Response(null, { status: 500 });
+                        }
+                        throw renderError;
+                    }
                     if (injectRSCPayloadStream) {
                         html = html.pipeThrough(injectRSCPayloadStream);
                     }
@@ -167,20 +204,13 @@ export const defineApp = (routes) => {
                         headers: responseHeaders,
                     });
                 };
-                const response = await runWithRequestInfo(outerRequestInfo, async () => new Promise(async (resolve, reject) => {
-                    try {
-                        resolve(await router.handle({
-                            request,
-                            renderPage,
-                            getRequestInfo: getRequestInfo,
-                            runWithRequestInfoOverrides,
-                            onError: reject,
-                            rscActionHandler,
-                        }));
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
+                const response = await runWithRequestInfo(outerRequestInfo, () => router.handle({
+                    request,
+                    renderPage,
+                    getRequestInfo: getRequestInfo,
+                    runWithRequestInfoOverrides,
+                    onError: () => { },
+                    rscActionHandler,
                 }));
                 // context(justinvdm, 18 Mar 2025): In some cases, such as a .fetch() call to a durable object instance, or Response.redirect(),
                 // we need to return a mutable response object.

package/dist/vite/buildApp.mjs

@@ -1,7 +1,7 @@
 import debug from "debug";
 import { existsSync } from "node:fs";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
 import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
 const log = debug("rwsdk:vite:build-app");
@@ -87,4 +87,47 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
     };
     await builder.build(workerEnv);
     console.log("Build complete!");
+    // context(zshannon, 16 Mar 2026): Nest client output under base subdirectory
+    // for Cloudflare's assets module, which maps URL paths directly to file paths.
+    const base = builder.config.base || "/";
+    if (base !== "/") {
+        const subdir = base.replace(/^\/|\/$/g, "");
+        const clientDir = resolve(projectRootDir, "dist", "client");
+        const tmpDir = resolve(projectRootDir, "dist", "_client_tmp");
+        const nestDir = join(clientDir, subdir);
+        await rm(tmpDir, { force: true, recursive: true });
+        await cp(clientDir, tmpDir, { recursive: true });
+        await rm(clientDir, { force: true, recursive: true });
+        await mkdir(nestDir, { recursive: true });
+        for (const entry of await readdir(tmpDir)) {
+            await cp(join(tmpDir, entry), join(nestDir, entry), { recursive: true });
+        }
+        await rm(tmpDir, { force: true, recursive: true });
+        // context(justinvdm, 17 Mar 2026): The Cloudflare Vite plugin generates a
+        // wrangler.json in the dist output. We need to patch its assets.directory
+        // to account for the nesting we just did.
+        const workerDistDir = resolve(projectRootDir, "dist", "worker");
+        const wranglerCandidates = ["wrangler.json", "wrangler.jsonc", "wrangler.toml"];
+        for (const candidate of wranglerCandidates) {
+            const wranglerPath = join(workerDistDir, candidate);
+            if (existsSync(wranglerPath) && candidate !== "wrangler.toml") {
+                const content = await readFile(wranglerPath, "utf-8");
+                const wrangler = JSON.parse(content);
+                if (wrangler.assets?.directory) {
+                    const currentDir = wrangler.assets.directory;
+                    const fixedDir = currentDir.replace(`/${subdir}`, "");
+                    if (fixedDir !== currentDir) {
+                        wrangler.assets.directory = fixedDir;
+                        await writeFile(wranglerPath, JSON.stringify(wrangler, null, 2));
+                    }
+                    else {
+                        console.warn(`Warning: ${candidate} assets.directory "${currentDir}" ` +
+                            `did not contain expected "/${subdir}" segment`);
+                    }
+                }
+                break;
+            }
+        }
+        console.log(`Nested client assets under ${subdir}/`);
+    }
 }

package/dist/vite/linkerPlugin.mjs

@@ -23,8 +23,11 @@ export function linkWorkerBundle({ code, manifestContent, projectRootDir, base,
     }
     // 3. Deprefix any remaining placeholders that were not in the manifest.
     // This handles public assets that don't go through the bundler.
+    // context(justinvdm, 17 Mar 2026): Prepend base (without trailing slash)
+    // so public asset paths are correct under a non-default base.
     log("Deprefixing remaining asset placeholders");
-    newCode = newCode.replaceAll("rwsdk_asset:", "");
+    const basePrefix = (base ? base : "/").replace(/\/$/, "");
+    newCode = newCode.replaceAll("rwsdk_asset:", basePrefix);
     return {
         code: newCode,
         map: null,

package/dist/vite/linkerPlugin.test.mjs

@@ -53,4 +53,14 @@ describe("linkWorkerBundle", () => {
         });
         expect(result.code).toContain(`const publicImg = "/images/photo.jpg";`);
     });
+    it("should deprefix remaining asset placeholders with base prefix", () => {
+        const code = `const publicImg = "rwsdk_asset:/images/photo.jpg";`;
+        const result = linkWorkerBundle({
+            code,
+            manifestContent,
+            projectRootDir,
+            base: "/app/",
+        });
+        expect(result.code).toContain(`const publicImg = "/app/images/photo.jpg";`);
+    });
 });

package/dist/vite/transformJsxScriptTagsPlugin.d.mts

@@ -1,5 +1,5 @@
 import { type Plugin } from "vite";
-export declare function transformJsxScriptTagsCode(code: string, clientEntryPoints: Set<string>, manifest: Record<string, any> | undefined, projectRootDir: string): Promise<{
+export declare function transformJsxScriptTagsCode(code: string, clientEntryPoints: Set<string>, manifest: Record<string, any> | undefined, projectRootDir: string, base: string): Promise<{
     code: string;
     map: null;
 } | undefined>;

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -1,12 +1,19 @@
 import debug from "debug";
 import { Node, Project, SyntaxKind, } from "ts-morph";
 import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+import { stripBase } from "../lib/stripBase.mjs";
 const log = debug("rwsdk:vite:transform-jsx-script-tags");
-function transformAssetPath(importPath, projectRootDir) {
+function transformAssetPath(importPath, projectRootDir, base) {
     if (process.env.VITE_IS_DEV_SERVER === "1") {
+        // context(justinvdm, 17 Mar 2026): In dev mode with a non-default base,
+        // prefix the path so Vite can resolve it under the base URL.
+        if (base && base !== "/" && importPath.startsWith("/") && !importPath.startsWith(base)) {
+            return base.replace(/\/$/, "") + importPath;
+        }
         return importPath;
     }
-    const normalizedImportPath = normalizeModulePath(importPath, projectRootDir);
+    const strippedPath = stripBase(importPath, base);
+    const normalizedImportPath = normalizeModulePath(strippedPath, projectRootDir);
     return `rwsdk_asset:${normalizedImportPath}`;
 }
 // Note: This plugin only runs during discovery phase (Phase 1)
@@ -25,7 +32,7 @@ function hasJsxFunctions(text) {
         text.includes('jsxDEV("link"') ||
         text.includes("jsxDEV('link'"));
 }
-function transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir) {
+function transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir, base) {
     const scriptProject = new Project({ useInMemoryFileSystem: true });
     try {
         const wrappedContent = `function __wrapper() {${scriptContent}}`;
@@ -45,9 +52,10 @@ function transformScriptImports(scriptContent, clientEntryPoints, manifest, proj
                     const importPath = args[0].getLiteralValue();
                     if (importPath.startsWith("/")) {
                         log("Found dynamic import with root-relative path: %s", importPath);
-                        entryPoints.push(importPath);
-                        clientEntryPoints.add(importPath);
-                        const transformedImportPath = transformAssetPath(importPath, projectRootDir);
+                        const normalizedEntry = stripBase(importPath, base);
+                        entryPoints.push(normalizedEntry);
+                        clientEntryPoints.add(normalizedEntry);
+                        const transformedImportPath = transformAssetPath(importPath, projectRootDir, base);
                         args[0].setLiteralValue(transformedImportPath);
                         hasChanges = true;
                     }
@@ -68,7 +76,7 @@ function transformScriptImports(scriptContent, clientEntryPoints, manifest, proj
         return { content: undefined, hasChanges: false, entryPoints: [] };
     }
 }
-export async function transformJsxScriptTagsCode(code, clientEntryPoints, manifest = {}, projectRootDir) {
+export async function transformJsxScriptTagsCode(code, clientEntryPoints, manifest = {}, projectRootDir, base) {
     // context(justinvdm, 15 Jun 2025): Optimization to exit early
     // to avoidunnecessary ts-morph parsing
     if (!hasJsxFunctions(code)) {
@@ -136,9 +144,10 @@ export async function transformJsxScriptTagsCode(code, clientEntryPoints, manife
                                 Node.isNoSubstitutionTemplateLiteral(initializer)) {
                                 const srcValue = initializer.getLiteralValue();
                                 if (srcValue.startsWith("/")) {
-                                    entryPoints.push(srcValue);
-                                    clientEntryPoints.add(srcValue);
-                                    const transformedSrc = transformAssetPath(srcValue, projectRootDir);
+                                    const normalizedSrcEntry = stripBase(srcValue, base);
+                                    entryPoints.push(normalizedSrcEntry);
+                                    clientEntryPoints.add(normalizedSrcEntry);
+                                    const transformedSrc = transformAssetPath(srcValue, projectRootDir, base);
                                     modifications.push({
                                         type: "literalValue",
                                         node: initializer,
@@ -153,7 +162,7 @@ export async function transformJsxScriptTagsCode(code, clientEntryPoints, manife
                                 Node.isNoSubstitutionTemplateLiteral(initializer))) {
                             hasStringLiteralChildren = true;
                             const scriptContent = initializer.getLiteralValue();
-                            const { content: transformedContent, hasChanges: contentHasChanges, entryPoints: dynamicEntryPoints, } = transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir);
+                            const { content: transformedContent, hasChanges: contentHasChanges, entryPoints: dynamicEntryPoints, } = transformScriptImports(scriptContent, clientEntryPoints, manifest, projectRootDir, base);
                             entryPoints.push(...dynamicEntryPoints);
                             if (contentHasChanges && transformedContent) {
                                 const isTemplateLiteral = Node.isNoSubstitutionTemplateLiteral(initializer);
@@ -189,7 +198,7 @@ export async function transformJsxScriptTagsCode(code, clientEntryPoints, manife
                             Node.isNoSubstitutionTemplateLiteral(initializer))) {
                         const hrefValue = initializer.getLiteralValue();
                         if (hrefValue.startsWith("/")) {
-                            const transformedHref = transformAssetPath(hrefValue, projectRootDir);
+                            const transformedHref = transformAssetPath(hrefValue, projectRootDir, base);
                             modifications.push({
                                 type: "literalValue",
                                 node: initializer,
@@ -313,10 +322,12 @@ ${mod.callExprText}
 }
 export const transformJsxScriptTagsPlugin = ({ clientEntryPoints, projectRootDir, }) => {
     let isBuild = false;
+    let base = "/";
     return {
         name: "rwsdk:vite:transform-jsx-script-tags",
         configResolved(config) {
             isBuild = config.command === "build";
+            base = config.base || "/";
         },
         async transform(code, id) {
             if (isBuild &&
@@ -331,7 +342,7 @@ export const transformJsxScriptTagsPlugin = ({ clientEntryPoints, projectRootDir
                 process.env.VERBOSE && log("Code:\n%s", code);
                 // During discovery phase, never use manifest - it doesn't exist yet
                 const result = await transformJsxScriptTagsCode(code, clientEntryPoints, {}, // Empty manifest during discovery
-                projectRootDir);
+                projectRootDir, base);
                 if (result) {
                     log("Transformed JSX script tags in %s", id);
                     process.env.VERBOSE &&

package/dist/vite/transformJsxScriptTagsPlugin.test.mjs

@@ -24,7 +24,7 @@ describe("transformJsxScriptTagsCode", () => {
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/Users/justin/rw/forks/workers-sdk/sdk/sdk");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/Users/justin/rw/forks/workers-sdk/sdk/sdk", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -45,7 +45,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -63,7 +63,7 @@ nonce: requestInfo.rw.nonce
       jsx("script", { type: "module", children: "import('/src/client.tsx')" })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -89,7 +89,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -120,7 +120,7 @@ import('/src/entry.js');
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -146,7 +146,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `
       jsx("link", {
         rel: "preload",
@@ -165,7 +165,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `
       jsx("link", {
         href: "rwsdk_asset:/src/client.tsx",
@@ -197,7 +197,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 jsx("html", {
@@ -231,7 +231,7 @@ nonce: requestInfo.rw.nonce
       jsx("div", { children: "No scripts or links here" })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         expect(result).toBeUndefined();
     });
     it("handles paths not found in manifest", async () => {
@@ -242,7 +242,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -263,7 +263,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -284,7 +284,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         expect(result?.code).toEqual(`import { requestInfo } from "rwsdk/worker";
 
       jsx("script", {
@@ -302,7 +302,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         expect(result?.code).toEqual(undefined);
     });
     it("does not add nonce to script tags that already have nonce", async () => {
@@ -314,7 +314,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         expect(result?.code).toEqual(undefined);
     });
     it("uses existing requestInfo import if already present", async () => {
@@ -328,7 +328,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         expect(result?.code).toEqual(`
       import { foo } from 'bar';
       import { requestInfo, someOtherThing } from "rwsdk/worker";
@@ -355,7 +355,7 @@ nonce: requestInfo.rw.nonce
       })
     `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         expect(result?.code).toEqual(`
       import { foo } from 'bar';
       import { someOtherThing, requestInfo } from "rwsdk/worker";
@@ -376,7 +376,7 @@ nonce: requestInfo.rw.nonce
     `;
         // Call without providing manifest (simulating dev mode)
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         const expected = `import { requestInfo } from "rwsdk/worker";
 
 (
@@ -496,7 +496,7 @@ export const Document = ({
 }, this);
 `;
         const clientEntryPoints = new Set();
-        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir");
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
         // For this complex test, we'll just verify the key transformations
         const expected = `
 import { jsxDEV } from "react/jsx-dev-runtime";
@@ -616,4 +616,54 @@ columnNumber: 2
 }, this);`;
         expect(normalizeCode(result?.code || "")).toEqual(normalizeCode(expected));
     });
+    it("strips base prefix from script src entry points", async () => {
+        const code = `
+      jsx("script", {
+        src: "/auth/src/client.tsx",
+        type: "module"
+      })
+    `;
+        const clientEntryPoints = new Set();
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/auth/");
+        expect(clientEntryPoints.has("/src/client.tsx")).toBe(true);
+        expect(clientEntryPoints.has("/auth/src/client.tsx")).toBe(false);
+        expect(result?.code).toContain('scriptsToBeLoaded.add("/src/client.tsx")');
+        expect(result?.code).not.toContain('scriptsToBeLoaded.add("/auth/src/client.tsx")');
+    });
+    it("strips base prefix from dynamic imports in inline scripts", async () => {
+        const code = `
+      jsx("script", {
+        type: "module",
+        children: "import('/auth/src/client.tsx')"
+      })
+    `;
+        const clientEntryPoints = new Set();
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/auth/");
+        expect(clientEntryPoints.has("/src/client.tsx")).toBe(true);
+        expect(clientEntryPoints.has("/auth/src/client.tsx")).toBe(false);
+        expect(result?.code).toContain('scriptsToBeLoaded.add("/src/client.tsx")');
+    });
+    it("strips base prefix from link preload href in asset paths", async () => {
+        const code = `
+      jsx("link", {
+        rel: "modulepreload",
+        href: "/auth/src/client.tsx"
+      })
+    `;
+        const clientEntryPoints = new Set();
+        const result = await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/auth/");
+        expect(result?.code).toContain("rwsdk_asset:/src/client.tsx");
+        expect(result?.code).not.toContain("rwsdk_asset:/auth/src/client.tsx");
+    });
+    it("does not strip when base is /", async () => {
+        const code = `
+      jsx("script", {
+        src: "/src/client.tsx",
+        type: "module"
+      })
+    `;
+        const clientEntryPoints = new Set();
+        await transformJsxScriptTagsCode(code, clientEntryPoints, mockManifest, "/project/root/dir", "/");
+        expect(clientEntryPoints.has("/src/client.tsx")).toBe(true);
+    });
 });

package/dist/vite/vitePreamblePlugin.d.mts

@@ -1 +1,153 @@
-export declare const vitePreamblePlugin: () => import("vite").Plugin<any>;
+import type { ResolvedConfig } from "vite";
+export declare const vitePreamblePlugin: () => {
+    configResolved(config: ResolvedConfig): void;
+    hotUpdate?: import("rollup").ObjectHook<(this: import("rollup").MinimalPluginContext & {
+        environment: import("vite").DevEnvironment;
+    }, options: import("vite").HotUpdateOptions) => Array<import("vite").EnvironmentModuleNode> | void | Promise<Array<import("vite").EnvironmentModuleNode> | void>>;
+    resolveId?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, source: string, importer: string | undefined, options: {
+        attributes: Record<string, string>;
+        custom?: import("rollup").CustomPluginOptions;
+        ssr?: boolean | undefined;
+        isEntry: boolean;
+    }) => Promise<import("rollup").ResolveIdResult> | import("rollup").ResolveIdResult, {
+        filter?: {
+            id?: RegExp | RegExp[] | {
+                include?: RegExp | RegExp[] | undefined;
+                exclude?: RegExp | RegExp[] | undefined;
+            };
+        };
+    }>;
+    load?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, id: string, options?: {
+        ssr?: boolean | undefined;
+    }) => Promise<import("rollup").LoadResult> | import("rollup").LoadResult, {
+        filter?: {
+            id?: string | RegExp | (string | RegExp)[] | {
+                include?: string | RegExp | (string | RegExp)[] | undefined;
+                exclude?: string | RegExp | (string | RegExp)[] | undefined;
+            };
+        };
+    }>;
+    transform?: import("rollup").ObjectHook<(this: import("rollup").TransformPluginContext, code: string, id: string, options?: {
+        ssr?: boolean | undefined;
+    }) => Promise<import("rollup").TransformResult> | import("rollup").TransformResult, {
+        filter?: {
+            id?: string | RegExp | (string | RegExp)[] | {
+                include?: string | RegExp | (string | RegExp)[] | undefined;
+                exclude?: string | RegExp | (string | RegExp)[] | undefined;
+            };
+            code?: string | RegExp | (string | RegExp)[] | {
+                include?: string | RegExp | (string | RegExp)[] | undefined;
+                exclude?: string | RegExp | (string | RegExp)[] | undefined;
+            };
+        };
+    }>;
+    sharedDuringBuild?: boolean;
+    perEnvironmentStartEndDuringDev?: boolean;
+    perEnvironmentWatchChangeDuringDev?: boolean;
+    enforce?: "pre" | "post";
+    apply?: "serve" | "build" | ((this: void, config: import("vite").UserConfig, env: import("vite").ConfigEnv) => boolean);
+    applyToEnvironment?: (environment: {
+        name: string;
+        getTopLevelConfig(): ResolvedConfig;
+        config: ResolvedConfig & {
+            define?: Record<string, any>;
+            resolve: Required<import("vite").ResolveOptions>;
+            consumer: "client" | "server";
+            keepProcessEnv?: boolean;
+            optimizeDeps: import("vite").DepOptimizationOptions;
+            dev: import("vite").ResolvedDevEnvironmentOptions;
+            build: import("vite").ResolvedBuildEnvironmentOptions;
+            plugins: readonly import("vite").Plugin[];
+        };
+        logger: import("vite").Logger;
+    }) => boolean | Promise<boolean> | import("vite").PluginOption;
+    config?: import("rollup").ObjectHook<(this: import("vite").ConfigPluginContext, config: import("vite").UserConfig, env: import("vite").ConfigEnv) => Omit<import("vite").UserConfig, "plugins"> | null | void | Promise<Omit<import("vite").UserConfig, "plugins"> | null | void>>;
+    configEnvironment?: import("rollup").ObjectHook<(this: import("vite").ConfigPluginContext, name: string, config: import("vite").EnvironmentOptions, env: import("vite").ConfigEnv & {
+        isSsrTargetWebworker?: boolean;
+    }) => import("vite").EnvironmentOptions | null | void | Promise<import("vite").EnvironmentOptions | null | void>>;
+    configureServer?: import("rollup").ObjectHook<import("vite").ServerHook>;
+    configurePreviewServer?: import("rollup").ObjectHook<import("vite").PreviewServerHook>;
+    transformIndexHtml?: import("vite").IndexHtmlTransform;
+    buildApp?: import("rollup").ObjectHook<import("vite").BuildAppHook>;
+    handleHotUpdate?: import("rollup").ObjectHook<(this: import("vite").MinimalPluginContextWithoutEnvironment, ctx: import("vite").HmrContext) => Array<import("vite").ModuleNode> | void | Promise<Array<import("vite").ModuleNode> | void>>;
+    api?: any;
+    cacheKey?: string | undefined;
+    name: string;
+    version?: string | undefined;
+    renderError?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, error?: Error | undefined) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    augmentChunkHash?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, chunk: import("rollup").RenderedChunk) => string | void, {}> | undefined;
+    generateBundle?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").NormalizedOutputOptions, bundle: import("rollup").OutputBundle, isWrite: boolean) => void | Promise<void>, {}> | undefined;
+    outputOptions?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").OutputOptions) => import("rollup").OutputOptions | import("rollup").NullValue, {}> | undefined;
+    renderChunk?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, code: string, chunk: import("rollup").RenderedChunk, options: import("rollup").NormalizedOutputOptions, meta: {
+        chunks: Record<string, import("rollup").RenderedChunk>;
+    }) => string | {
+        code: string;
+        map?: import("rollup").SourceMapInput;
+    } | import("rollup").NullValue | Promise<string | {
+        code: string;
+        map?: import("rollup").SourceMapInput;
+    } | import("rollup").NullValue>, {}> | undefined;
+    renderDynamicImport?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: {
+        customResolution: string | null;
+        format: import("rollup").InternalModuleFormat;
+        moduleId: string;
+        targetModuleId: string | null;
+        chunk: import("rollup").PreRenderedChunkWithFileName;
+        targetChunk: import("rollup").PreRenderedChunkWithFileName | null;
+        getTargetChunkImports: () => import("rollup").DynamicImportTargetChunk[] | null;
+        targetModuleAttributes: Record<string, string>;
+    }) => {
+        left: string;
+        right: string;
+    } | import("rollup").NullValue, {}> | undefined;
+    renderStart?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, outputOptions: import("rollup").NormalizedOutputOptions, inputOptions: import("rollup").NormalizedInputOptions) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    resolveFileUrl?: import("rollup").ObjectHook<import("rollup").ResolveFileUrlHook, {}> | undefined;
+    resolveImportMeta?: import("rollup").ObjectHook<import("rollup").ResolveImportMetaHook, {}> | undefined;
+    writeBundle?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").NormalizedOutputOptions, bundle: import("rollup").OutputBundle) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    footer?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    banner?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    intro?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    outro?: import("rollup").ObjectHook<import("rollup").AddonHook, {}> | undefined;
+    buildEnd?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, error?: Error | undefined) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    buildStart?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: import("rollup").NormalizedInputOptions) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    closeBundle?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, error?: Error | undefined) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    closeWatcher?: import("rollup").ObjectHook<(this: import("rollup").PluginContext) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    moduleParsed?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, info: import("rollup").ModuleInfo) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+    onLog?: import("rollup").ObjectHook<(this: import("rollup").MinimalPluginContext, level: import("rollup").LogLevel, log: import("rollup").RollupLog) => boolean | import("rollup").NullValue, {}> | undefined;
+    options?: import("rollup").ObjectHook<(this: import("rollup").MinimalPluginContext, options: import("rollup").InputOptions) => import("rollup").InputOptions | import("rollup").NullValue | Promise<import("rollup").InputOptions | import("rollup").NullValue>, {}> | undefined;
+    resolveDynamicImport?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, specifier: string | import("rollup").AstNode, importer: string, options: {
+        attributes: Record<string, string>;
+        importerAttributes: Record<string, string>;
+    }) => import("rollup").ResolveIdResult | Promise<import("rollup").ResolveIdResult>, {}> | undefined;
+    shouldTransformCachedModule?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, options: {
+        ast: import("rollup").ProgramNode;
+        attributes: Record<string, string>;
+        code: string;
+        id: string;
+        meta: import("rollup").CustomPluginOptions;
+        moduleSideEffects: boolean | "no-treeshake";
+        resolvedSources: import("rollup").ResolvedIdMap;
+        syntheticNamedExports: boolean | string;
+    }) => boolean | import("rollup").NullValue | Promise<boolean | import("rollup").NullValue>, {}> | undefined;
+    watchChange?: import("rollup").ObjectHook<(this: import("rollup").PluginContext, id: string, change: {
+        event: import("rollup").ChangeEvent;
+    }) => void | Promise<void>, {
+        sequential?: boolean;
+    }> | undefined;
+};

package/dist/vite/vitePreamblePlugin.mjs

@@ -1,11 +1,21 @@
 import MagicString from "magic-string";
 import { virtualPlugin } from "./virtualPlugin.mjs";
-export const vitePreamblePlugin = () => virtualPlugin("vite-preamble", async () => {
-    const s = new MagicString(`
-import RefreshRuntime from "/@react-refresh"; RefreshRuntime.injectIntoGlobalHook(window); window.$RefreshReg$ = () => {}; window.$RefreshSig$ = () => (type) => type; window.__vite_plugin_react_preamble_installed__ = true;
+export const vitePreamblePlugin = () => {
+    let base = "/";
+    const inner = virtualPlugin("vite-preamble", async () => {
+        const refreshPath = base.replace(/\/$/, "") + "/@react-refresh";
+        const s = new MagicString(`
+import RefreshRuntime from "${refreshPath}"; RefreshRuntime.injectIntoGlobalHook(window); window.$RefreshReg$ = () => {}; window.$RefreshSig$ = () => (type) => type; window.__vite_plugin_react_preamble_installed__ = true;
     `);
+        return {
+            code: s.toString(),
+            map: s.generateMap(),
+        };
+    });
     return {
-        code: s.toString(),
-        map: s.generateMap(),
+        ...inner,
+        configResolved(config) {
+            base = config.base || "/";
+        },
     };
-});
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -176,7 +176,7 @@
     "glob": "~13.0.6",
     "ignore": "~7.0.5",
     "jsonc-parser": "~3.3.1",
-    "kysely": "~0.28.11",
+    "kysely": "~0.28.12",
     "kysely-do": "~0.0.1-rc.1",
     "lodash": "~4.17.23",
     "magic-string": "~0.30.21",