rwsdk 1.0.0-beta.28 → 1.0.0-beta.29

package/dist/lib/e2e/environment.mjs

@@ -144,8 +144,13 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         // Determine the source directory to copy from
         const sourceDir = monorepoRoot || projectDir;
         // Create unique project directory name
+        // Format: {projectName}-t-{hash} (kept under 54 chars for Cloudflare limit)
         const originalDirName = basename(sourceDir);
-        const workerName = `${slugify(originalDirName)}-test-${resourceUniqueKey}`;
+        const slugified = slugify(originalDirName);
+        // Truncate project name to leave room for "-t-" (3 chars) + hash (8 chars) = 11 chars
+        // Max project name: 54 - 11 = 43 chars
+        const truncatedProjectName = slugified.substring(0, 43);
+        const workerName = `${truncatedProjectName}-t-${resourceUniqueKey}`;
         const tempCopyRoot = resolve(tempDir.path, workerName);
         // If it's a monorepo, the targetDir for commands is a subdirectory
         const targetDir = monorepoRoot

package/dist/lib/e2e/release.d.mts

@@ -39,6 +39,7 @@ export declare function runRelease(cwd: string, projectDir: string, resourceUniq
 /**
  * Check if a resource name includes a specific resource unique key
  * This is used to identify resources created during our tests
+ * Handles both full format (adjective-animal-hash) and hash-only format
  */
 export declare function isRelatedToTest(resourceName: string, resourceUniqueKey: string): boolean;
 /**

package/dist/lib/e2e/release.mjs

@@ -245,9 +245,15 @@ export async function runRelease(cwd, projectDir, resourceUniqueKey) {
         await ensureCloudflareAccountId(cwd, projectDir);
         // Extract worker name from directory name to ensure consistency
         const dirName = cwd ? basename(cwd) : "unknown-worker";
+        // Extract hash part from resourceUniqueKey for matching
+        // resourceUniqueKey format is typically "adjective-animal-hash" or just "hash"
+        const hashPart = resourceUniqueKey.includes("-")
+            ? resourceUniqueKey.split("-").pop() || resourceUniqueKey.substring(0, 8)
+            : resourceUniqueKey.substring(0, 8);
+        const uniqueKeyForMatching = hashPart.substring(0, 8);
         // Ensure resource unique key is included in worker name for tracking
-        if (resourceUniqueKey && !dirName.includes(resourceUniqueKey)) {
-            log(`Worker name doesn't contain our unique key, this is unexpected: ${dirName}, key: ${resourceUniqueKey}`);
+        if (resourceUniqueKey && !dirName.includes(uniqueKeyForMatching)) {
+            log(`Worker name doesn't contain our unique key, this is unexpected: ${dirName}, key: ${uniqueKeyForMatching}`);
             console.log(`⚠️ Worker name doesn't contain our unique key. This might cause cleanup issues.`);
         }
         // Ensure the worker name in wrangler.jsonc matches our unique name
@@ -376,9 +382,16 @@ export async function runRelease(cwd, projectDir, resourceUniqueKey) {
 /**
  * Check if a resource name includes a specific resource unique key
  * This is used to identify resources created during our tests
+ * Handles both full format (adjective-animal-hash) and hash-only format
  */
 export function isRelatedToTest(resourceName, resourceUniqueKey) {
-    return resourceName.includes(resourceUniqueKey);
+    // Extract hash part if resourceUniqueKey contains dashes (full format)
+    // Otherwise use as-is (hash-only format)
+    const hashPart = resourceUniqueKey.includes("-")
+        ? resourceUniqueKey.split("-").pop() || resourceUniqueKey.substring(0, 8)
+        : resourceUniqueKey;
+    const uniqueKeyForMatching = hashPart.substring(0, 8);
+    return resourceName.includes(uniqueKeyForMatching);
 }
 /**
  * Delete the worker using wrangler

package/dist/lib/e2e/tarball.mjs

@@ -2,9 +2,8 @@ import { createHash } from "crypto";
 import { $ } from "execa";
 import fs from "node:fs";
 import path from "node:path";
-import { adjectives, animals, uniqueNamesGenerator, } from "unique-names-generator";
 import { ROOT_DIR } from "../constants.mjs";
-import { copyProjectToTempDir, } from "./environment.mjs";
+import { copyProjectToTempDir } from "./environment.mjs";
 const log = (message) => console.log(message);
 /**
  * Copies wrangler cache from monorepo to temp directory for deployment tests
@@ -66,18 +65,12 @@ async function copyWranglerCache(targetDir, sdkRoot) {
 export async function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager = "pnpm", }) {
     log(`🚀 Setting up tarball environment for ${projectDir}`);
     // Generate a resource unique key for this test run
-    const uniqueNameSuffix = uniqueNamesGenerator({
-        dictionaries: [adjectives, animals],
-        separator: "-",
-        length: 2,
-        style: "lowerCase",
-    });
-    // Create a short unique hash based on the timestamp
+    // Use just the hash to keep worker names short (under Cloudflare's 54 char limit)
     const hash = createHash("md5")
         .update(Date.now().toString())
         .digest("hex")
         .substring(0, 8);
-    const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
+    const resourceUniqueKey = hash;
     try {
         const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot);
         // Copy wrangler cache to improve deployment performance

package/dist/lib/e2e/testHarness.mjs

@@ -1,15 +1,15 @@
 import fs from "fs-extra";
 import path, { basename, dirname, join as pathJoin } from "path";
 import puppeteer from "puppeteer-core";
+import { fileURLToPath } from "url";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, test, } from "vitest";
 import { launchBrowser } from "./browser.mjs";
-import { ensureTmpDir } from "./utils.mjs";
 import { DEPLOYMENT_CHECK_TIMEOUT, DEPLOYMENT_MIN_TRIES, DEPLOYMENT_TIMEOUT, DEV_SERVER_MIN_TRIES, DEV_SERVER_TIMEOUT, HYDRATION_TIMEOUT, INSTALL_DEPENDENCIES_RETRIES, PUPPETEER_TIMEOUT, SETUP_PLAYGROUND_ENV_TIMEOUT, SETUP_WAIT_TIMEOUT, TEST_MAX_RETRIES, TEST_MAX_RETRIES_PER_CODE, } from "./constants.mjs";
 import { runDevServer } from "./dev.mjs";
 import { poll, pollValue } from "./poll.mjs";
 import { deleteD1Database, deleteWorker, isRelatedToTest, runRelease, } from "./release.mjs";
 import { setupTarballEnvironment } from "./tarball.mjs";
-import { fileURLToPath } from "url";
+import { ensureTmpDir } from "./utils.mjs";
 export { DEPLOYMENT_CHECK_TIMEOUT, DEPLOYMENT_MIN_TRIES, DEPLOYMENT_TIMEOUT, DEV_SERVER_MIN_TRIES, DEV_SERVER_TIMEOUT, HYDRATION_TIMEOUT, INSTALL_DEPENDENCIES_RETRIES, PUPPETEER_TIMEOUT, SETUP_PLAYGROUND_ENV_TIMEOUT, SETUP_WAIT_TIMEOUT, TEST_MAX_RETRIES, TEST_MAX_RETRIES_PER_CODE, };
 // Environment variable flags for skipping tests
 const SKIP_DEV_SERVER_TESTS = process.env.RWSDK_SKIP_DEV === "1";
@@ -223,7 +223,10 @@ export function createDeployment() {
             }
             const newInstance = await pollValue(async () => {
                 const dirName = basename(projectDir);
-                const match = dirName.match(/-e2e-test-([a-f0-9]+)$/);
+                // Match formats: {projectName}-t-{hash}, {projectName}-test-{hash}, or {projectName}-e2e-test-{hash}
+                const match = dirName.match(/-t-([a-f0-9]+)$/) ||
+                    dirName.match(/-test-([a-f0-9]+)$/) ||
+                    dirName.match(/-e2e-test-([a-f0-9]+)$/);
                 const resourceUniqueKey = match
                     ? match[1]
                     : Math.random().toString(36).substring(2, 15);

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

@@ -1,32 +1,25 @@
-type ParseRoute<T extends string> = T extends `${infer Start}:${infer Param}/${infer Rest}` ? {
+import type { RouteDefinition, RouteMiddleware } from "./router";
+type PathParams<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? {
     [K in Param]: string;
-} & ParseRoute<Rest> : T extends `${infer Start}:${infer Param}` ? {
+} & PathParams<Rest> : Path extends `${string}:${infer Param}` ? {
     [K in Param]: string;
-} : T extends `${infer Start}*${infer Rest}` ? {
+} : Path extends `${string}*${infer Rest}` ? {
     $0: string;
-} & ParseRoute<Rest> : T extends `${infer Start}*` ? {
+} & PathParams<Rest> : Path extends `${string}*` ? {
     $0: string;
 } : {};
-type LinkFunction<T extends readonly string[]> = {
-    <Path extends T[number]>(path: Path, params?: ParseRoute<Path> extends Record<string, never> ? undefined : ParseRoute<Path>): string;
+type ParamsForPath<Path extends string> = PathParams<Path> extends Record<string, never> ? undefined : PathParams<Path>;
+export type LinkFunction<Paths extends string> = {
+    <Path extends Paths>(path: Path, params?: ParamsForPath<Path>): string;
 };
-/**
- * Creates a type-safe link generation function from route patterns.
- *
- * @example
- * // Define your routes
- * const link = defineLinks([
- *   "/",
- *   "/about",
- *   "/users/:id",
- *   "/files/*",
- * ] as const)
- *
- * // Generate links with type checking
- * link("/")                                  // "/"
- * link("/about")                             // "/about"
- * link("/users/:id", { id: "123" })          // "/users/123"
- * link("/files/*", { $0: "docs/guide.pdf" }) // "/files/docs/guide.pdf"
- */
-export declare function defineLinks<const T extends readonly string[]>(routes: T): LinkFunction<T>;
+type RoutePaths<Value> = Value extends RouteDefinition<infer Path, any> ? Path : Value extends readonly (infer Item)[] ? RouteArrayPaths<Value> : Value extends RouteMiddleware<any> ? never : never;
+type RouteArrayPaths<Routes extends readonly any[]> = number extends Routes["length"] ? RoutePaths<Routes[number]> : Routes extends readonly [infer Head, ...infer Tail] ? RoutePaths<Head> | RouteArrayPaths<Tail> : never;
+type AppRoutes<App> = App extends {
+    __rwRoutes: infer Routes;
+} ? Routes : never;
+export type AppRoutePaths<App> = RoutePaths<AppRoutes<App>>;
+export type AppLink<App> = LinkFunction<AppRoutePaths<App>>;
+export declare function linkFor<App>(): AppLink<App>;
+export declare function createLinks<App>(_app?: App): AppLink<App>;
+export declare function defineLinks<const T extends readonly string[]>(routes: T): LinkFunction<T[number]>;
 export {};

package/dist/runtime/lib/links.js

@@ -1,56 +1,84 @@
-/**
- * Creates a type-safe link generation function from route patterns.
- *
- * @example
- * // Define your routes
- * const link = defineLinks([
- *   "/",
- *   "/about",
- *   "/users/:id",
- *   "/files/*",
- * ] as const)
- *
- * // Generate links with type checking
- * link("/")                                  // "/"
- * link("/about")                             // "/about"
- * link("/users/:id", { id: "123" })          // "/users/123"
- * link("/files/*", { $0: "docs/guide.pdf" }) // "/files/docs/guide.pdf"
- */
+export function linkFor() {
+    return createLinkFunction();
+}
+export function createLinks(_app) {
+    return linkFor();
+}
 export function defineLinks(routes) {
-    // Validate routes at runtime
     routes.forEach((route) => {
         if (typeof route !== "string") {
             throw new Error(`Invalid route: ${route}. Routes must be strings.`);
         }
     });
-    return (path, params) => {
+    const link = createLinkFunction();
+    return ((path, params) => {
         if (!routes.includes(path)) {
             throw new Error(`Invalid route: ${path}`);
         }
-        if (!params)
+        return link(path, params);
+    });
+}
+const TOKEN_REGEX = /:([a-zA-Z0-9_]+)|\*/g;
+function createLinkFunction() {
+    return ((path, params) => {
+        const expectsParams = hasRouteParameters(path);
+        if (!params || Object.keys(params).length === 0) {
+            if (expectsParams) {
+                throw new Error(`Route ${path} requires an object of parameters`);
+            }
             return path;
-        let result = path;
-        // Replace named parameters
-        for (const [key, value] of Object.entries(params)) {
-            if (key.startsWith("$")) {
-                // Replace each star with its corresponding $ parameter
-                const starIndex = parseInt(key.slice(1));
-                const stars = result.match(/\*/g) || [];
-                if (starIndex >= stars.length) {
-                    throw new Error(`Parameter ${key} has no corresponding * in route`);
-                }
-                // Replace the nth star with the value
-                let count = 0;
-                result = result.replace(/\*/g, (match) => count++ === starIndex ? value : match);
+        }
+        return interpolate(path, params);
+    });
+}
+function hasRouteParameters(path) {
+    TOKEN_REGEX.lastIndex = 0;
+    const result = TOKEN_REGEX.test(path);
+    TOKEN_REGEX.lastIndex = 0;
+    return result;
+}
+function interpolate(template, params) {
+    let result = "";
+    let lastIndex = 0;
+    let wildcardIndex = 0;
+    const consumed = new Set();
+    TOKEN_REGEX.lastIndex = 0;
+    let match;
+    while ((match = TOKEN_REGEX.exec(template)) !== null) {
+        result += template.slice(lastIndex, match.index);
+        if (match[1]) {
+            const name = match[1];
+            const value = params[name];
+            if (value === undefined) {
+                throw new Error(`Missing parameter "${name}" for route ${template}`);
             }
-            else {
-                // Handle named parameters
-                if (typeof value !== "string") {
-                    throw new Error(`Parameter ${key} must be a string`);
-                }
-                result = result.replace(`:${key}`, value);
+            result += encodeURIComponent(value);
+            consumed.add(name);
+        }
+        else {
+            const key = `$${wildcardIndex}`;
+            const value = params[key];
+            if (value === undefined) {
+                throw new Error(`Missing parameter "${key}" for route ${template}`);
             }
+            result += encodeWildcardValue(value);
+            consumed.add(key);
+            wildcardIndex += 1;
+        }
+        lastIndex = TOKEN_REGEX.lastIndex;
+    }
+    result += template.slice(lastIndex);
+    for (const key of Object.keys(params)) {
+        if (!consumed.has(key)) {
+            throw new Error(`Parameter "${key}" is not used by route ${template}`);
         }
-        return result;
-    };
+    }
+    TOKEN_REGEX.lastIndex = 0;
+    return result;
+}
+function encodeWildcardValue(value) {
+    return value
+        .split("/")
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
 }

package/dist/runtime/lib/links.test.d.ts

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

package/dist/runtime/lib/links.test.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { defineLinks } from "./links";
+const link = defineLinks(["/", "/users/:id", "/files/*"]);
+describe("link helpers", () => {
+    it("returns static routes without parameters", () => {
+        expect(link("/")).toBe("/");
+    });
+    it("replaces named parameters with encoded values", () => {
+        expect(link("/users/:id", { id: "user id" })).toBe("/users/user%20id");
+    });
+    it("replaces wildcard parameters preserving path segments", () => {
+        expect(link("/files/*", { $0: "docs/Guide Document.md" })).toBe("/files/docs/Guide%20Document.md");
+    });
+    it("throws when parameters are missing", () => {
+        expect(() => link("/users/:id")).toThrowError(/requires an object of parameters/i);
+    });
+    it("throws when extra parameters are supplied", () => {
+        expect(() => link("/users/:id", { id: "123", extra: "value" })).toThrowError(/is not used by route/i);
+    });
+});

package/dist/runtime/lib/realtime/worker.d.ts

@@ -1,3 +1,3 @@
 import type { RealtimeDurableObject } from "./durableObject";
 export { renderRealtimeClients } from "./renderRealtimeClients";
-export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<import("../../worker").RequestInfo<any, import("../../worker").DefaultAppContext>>;
+export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<"/__realtime", import("../../worker").RequestInfo<any, import("../../worker").DefaultAppContext>>;

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

@@ -19,14 +19,27 @@ export type MethodHandlers<T extends RequestInfo = RequestInfo> = {
         [method: string]: RouteHandler<T>;
     };
 };
-export type Route<T extends RequestInfo = RequestInfo> = RouteMiddleware<T> | RouteDefinition<T> | Array<Route<T>>;
-export type RouteDefinition<T extends RequestInfo = RequestInfo> = {
+export type Route<T extends RequestInfo = RequestInfo> = RouteMiddleware<T> | RouteDefinition<string, T> | readonly Route<T>[];
+type NormalizedRouteDefinition<T extends RequestInfo = RequestInfo> = {
     path: string;
     handler: RouteHandler<T> | MethodHandlers<T>;
     layouts?: React.FC<LayoutProps<T>>[];
 };
+export type RouteDefinition<Path extends string = string, T extends RequestInfo = RequestInfo> = NormalizedRouteDefinition<T> & {
+    readonly __rwPath?: Path;
+};
+type TrimTrailingSlash<S extends string> = S extends `${infer Head}/` ? TrimTrailingSlash<Head> : S;
+type TrimLeadingSlash<S extends string> = S extends `/${infer Rest}` ? TrimLeadingSlash<Rest> : S;
+type NormalizePrefix<Prefix extends string> = TrimTrailingSlash<TrimLeadingSlash<Prefix>> extends "" ? "" : `/${TrimTrailingSlash<TrimLeadingSlash<Prefix>>}`;
+type NormalizePath<Path extends string> = TrimTrailingSlash<Path> extends "/" ? "/" : `/${TrimTrailingSlash<TrimLeadingSlash<Path>>}`;
+type JoinPaths<Prefix extends string, Path extends string> = NormalizePrefix<Prefix> extends "" ? NormalizePath<Path> : Path extends "/" ? NormalizePrefix<Prefix> : `${NormalizePrefix<Prefix>}${NormalizePath<Path>}`;
+type PrefixedRouteValue<Prefix extends string, Value> = Value extends RouteDefinition<infer Path, infer Req> ? RouteDefinition<JoinPaths<Prefix, Path>, Req> : Value extends readonly Route<any>[] ? PrefixedRouteArray<Prefix, Value> : Value;
+type PrefixedRouteArray<Prefix extends string, Routes extends readonly Route<any>[]> = Routes extends readonly [] ? [] : Routes extends readonly [infer Head, ...infer Tail] ? readonly [
+    PrefixedRouteValue<Prefix, Head>,
+    ...PrefixedRouteArray<Prefix, Tail extends readonly Route<any>[] ? Tail : []>
+] : ReadonlyArray<PrefixedRouteValue<Prefix, Routes[number]>>;
 export declare function matchPath<T extends RequestInfo = RequestInfo>(routePath: string, requestPath: string): T["params"] | null;
-export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes: Route<T>[]): {
+export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes: readonly Route<T>[]): {
     routes: Route<T>[];
     handle: ({ request, renderPage, getRequestInfo, onError, runWithRequestInfoOverrides, rscActionHandler, }: {
         request: Request;
@@ -74,7 +87,7 @@ export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes
  * // Route with middleware array
  * route("/admin", [isAuthenticated, isAdmin, () => <AdminDashboard />])
  */
-export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T> | MethodHandlers<T>): RouteDefinition<T>;
+export declare function route<Path extends string, T extends RequestInfo = RequestInfo>(path: Path, handler: RouteHandler<T> | MethodHandlers<T>): RouteDefinition<NormalizePath<Path>, T>;
 /**
  * Defines a route handler for the root path "/".
  *
@@ -86,7 +99,7 @@ export declare function route<T extends RequestInfo = RequestInfo>(path: string,
  * // With middleware
  * index([logRequest, () => <HomePage />])
  */
-export declare function index<T extends RequestInfo = RequestInfo>(handler: RouteHandler<T>): RouteDefinition<T>;
+export declare function index<T extends RequestInfo = RequestInfo>(handler: RouteHandler<T>): RouteDefinition<"/", T>;
 /**
  * Prefixes a group of routes with a path.
  *
@@ -106,7 +119,7 @@ export declare function index<T extends RequestInfo = RequestInfo>(handler: Rout
  *   ]),
  * ])
  */
-export declare function prefix<T extends RequestInfo = RequestInfo>(prefixPath: string, routes: Route<T>[]): Route<T>[];
+export declare function prefix<Prefix extends string, T extends RequestInfo = RequestInfo, Routes extends readonly Route<T>[] = readonly Route<T>[]>(prefixPath: Prefix, routes: Routes): PrefixedRouteArray<Prefix, Routes>;
 export declare const wrapHandlerToThrowResponses: <T extends RequestInfo = RequestInfo>(handler: RouteFunction<T> | RouteComponent<T>) => RouteHandler<T>;
 /**
  * Wraps routes with a layout component.
@@ -128,7 +141,7 @@ export declare const wrapHandlerToThrowResponses: <T extends RequestInfo = Reque
  *   route("/post/:id", ({ params }) => <BlogPost id={params.id} />),
  * ])
  */
-export declare function layout<T extends RequestInfo = RequestInfo>(LayoutComponent: React.FC<LayoutProps<T>>, routes: Route<T>[]): Route<T>[];
+export declare function layout<T extends RequestInfo = RequestInfo, Routes extends readonly Route<T>[] = readonly Route<T>[]>(LayoutComponent: React.FC<LayoutProps<T>>, routes: Routes): Routes;
 /**
  * Wraps routes with a Document component and configures rendering options.
  *
@@ -153,9 +166,10 @@ export declare function layout<T extends RequestInfo = RequestInfo>(LayoutCompon
  *   ssr: true,
  * })
  */
-export declare function render<T extends RequestInfo = RequestInfo>(Document: React.FC<DocumentProps<T>>, routes: Route<T>[], options?: {
+type RenderedRoutes<T extends RequestInfo, Routes extends readonly Route<T>[]> = readonly [RouteMiddleware<T>, ...Routes];
+export declare function render<T extends RequestInfo = RequestInfo, Routes extends readonly Route<T>[] = readonly Route<T>[]>(Document: React.FC<DocumentProps<T>>, routes: Routes, options?: {
     rscPayload?: boolean;
     ssr?: boolean;
-}): Route<T>[];
+}): RenderedRoutes<T, Routes>;
 export declare const isClientReference: (value: any) => boolean;
 export {};

package/dist/runtime/lib/router.js

@@ -259,8 +259,9 @@ export function defineRoutes(routes) {
  * route("/admin", [isAuthenticated, isAdmin, () => <AdminDashboard />])
  */
 export function route(path, handler) {
-    if (!path.endsWith("/")) {
-        path = path + "/";
+    let normalizedPath = path;
+    if (!normalizedPath.endsWith("/")) {
+        normalizedPath = normalizedPath + "/";
     }
     // Normalize custom method keys to lowercase
     if (isMethodHandlers(handler) && handler.custom) {
@@ -273,8 +274,9 @@ export function route(path, handler) {
         };
     }
     return {
-        path,
+        path: normalizedPath,
         handler,
+        __rwPath: normalizedPath,
     };
 }
 /**
@@ -311,7 +313,7 @@ export function index(handler) {
  * ])
  */
 export function prefix(prefixPath, routes) {
-    return routes.map((r) => {
+    const prefixed = routes.map((r) => {
         if (typeof r === "function") {
             const middleware = (requestInfo) => {
                 const url = new URL(requestInfo.request.url);
@@ -326,13 +328,14 @@ export function prefix(prefixPath, routes) {
             // Recursively process nested route arrays
             return prefix(prefixPath, r);
         }
-        // For RouteDefinition objects, update the path and preserve layouts
+        const routeDef = r;
         return {
-            path: prefixPath + r.path,
-            handler: r.handler,
-            ...(r.layouts && { layouts: r.layouts }),
+            path: prefixPath + routeDef.path,
+            handler: routeDef.handler,
+            ...(routeDef.layouts && { layouts: routeDef.layouts }),
         };
     });
+    return prefixed;
 }
 function wrapWithLayouts(Component, layouts = [], requestInfo) {
     if (layouts.length === 0) {
@@ -396,7 +399,6 @@ export const wrapHandlerToThrowResponses = (handler) => {
  * ])
  */
 export function layout(LayoutComponent, routes) {
-    // Attach layouts directly to route definitions
     return routes.map((route) => {
         if (typeof route === "function") {
             // Pass through middleware as-is
@@ -406,37 +408,13 @@ export function layout(LayoutComponent, routes) {
             // Recursively process nested route arrays
             return layout(LayoutComponent, route);
         }
-        // For RouteDefinition objects, prepend the layout so outer layouts come first
+        const routeDef = route;
         return {
-            ...route,
-            layouts: [LayoutComponent, ...(route.layouts || [])],
+            ...routeDef,
+            layouts: [LayoutComponent, ...(routeDef.layouts || [])],
         };
     });
 }
-/**
- * Wraps routes with a Document component and configures rendering options.
- *
- * @param options.rscPayload - Toggle the RSC payload that's appended to the Document. Disabling this will mean that interactivity no longer works.
- * @param options.ssr - Disable sever side rendering for all these routes. This only allow client side rendering, which requires `rscPayload` to be enabled.
- *
- * @example
- * // Basic usage
- * defineApp([
- *   render(Document, [
- *     route("/", () => <HomePage />),
- *     route("/about", () => <AboutPage />),
- *   ]),
- * ])
- *
- * @example
- * // With custom rendering options
- * render(Document, [
- *   route("/", () => <HomePage />),
- * ], {
- *   rscPayload: true,
- *   ssr: true,
- * })
- */
 export function render(Document, routes, options = {}) {
     options = {
         rscPayload: true,

package/dist/runtime/worker.d.ts

@@ -8,9 +8,11 @@ declare global {
         DB: D1Database;
     };
 }
-export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>>(routes: Route<T>[]) => {
+export type AppDefinition<Routes extends readonly Route<any>[], T extends RequestInfo> = {
     fetch: (request: Request, env: Env, cf: ExecutionContext) => Promise<Response>;
+    __rwRoutes: Routes;
 };
+export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>, Routes extends readonly Route<T>[] = readonly Route<T>[]>(routes: Routes) => AppDefinition<Routes, T>;
 export declare const DefaultDocument: React.FC<{
     children: React.ReactNode;
 }>;

package/dist/runtime/worker.js

@@ -12,6 +12,7 @@ import { generateNonce } from "./lib/utils";
 export * from "./requestInfo/types";
 export const defineApp = (routes) => {
     return {
+        __rwRoutes: routes,
         fetch: async (request, env, cf) => {
             globalThis.__webpack_require__ = ssrWebpackRequire;
             const router = defineRoutes(routes);

package/dist/use-synced-state/worker.d.mts

@@ -11,4 +11,4 @@ export type SyncStateRouteOptions = {
  * @param options Optional overrides for base path, reset path, and object name.
  * @returns Router entries for the sync state API and reset endpoint.
  */
-export declare const syncStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncStateServer>, options?: SyncStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];
+export declare const syncStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncStateServer>, options?: SyncStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<`/${string}`, import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];

package/dist/vite/constants.d.mts

@@ -1,2 +1,3 @@
 export declare const cloudflareBuiltInModules: string[];
 export declare const externalModules: string[];
+export declare const externalModulesSet: Set<string>;

package/dist/vite/constants.mjs

@@ -10,3 +10,4 @@ export const externalModules = [
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ];
+export const externalModulesSet = new Set(externalModules);

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,6 +1,7 @@
 import debug from "debug";
 import MagicString from "magic-string";
 import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import { externalModulesSet } from "./constants.mjs";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
 const log = debug("rwsdk:vite:ssr-bridge-plugin");
 export const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
@@ -184,6 +185,14 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                                 const normalized = site.specifier.startsWith("/@id/")
                                     ? site.specifier.slice("/@id/".length)
                                     : site.specifier;
+                                // If the import is for a known external module, we must leave it
+                                // as a bare specifier. Rewriting it with any prefix (`/@id/` or
+                                // our virtual one) will break Vite's default externalization.
+                                if (externalModulesSet.has(normalized)) {
+                                    const replacement = `import("${normalized}")`;
+                                    s.overwrite(site.start, site.end, replacement);
+                                    continue;
+                                }
                                 // context(justinvdm, 11 Aug 2025):
                                 // - We replace __vite_ssr_import__ and __vite_ssr_dynamic_import__
                                 //   with import() calls so that the module graph can be built

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.28",
+  "version": "1.0.0-beta.29",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -167,7 +167,7 @@
     "find-up": "~8.0.0",
     "fs-extra": "~11.3.0",
     "get-port": "^7.1.0",
-    "glob": "~11.0.1",
+    "glob": "~11.1.0",
     "ignore": "~7.0.4",
     "jsonc-parser": "~3.3.1",
     "kysely": "~0.28.2",