rwsdk 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/lib/constants.d.mts

@@ -7,5 +7,6 @@ export declare const VENDOR_CLIENT_BARREL_PATH: string;
 export declare const VENDOR_SERVER_BARREL_PATH: string;
 export declare const VENDOR_CLIENT_BARREL_EXPORT_PATH = "rwsdk/__vendor_client_barrel";
 export declare const VENDOR_SERVER_BARREL_EXPORT_PATH = "rwsdk/__vendor_server_barrel";
+export declare const RW_STATE_EXPORT_PATH = "rwsdk/__state";
 export declare const INTERMEDIATE_SSR_BRIDGE_PATH: string;
 export declare const CLIENT_MANIFEST_RELATIVE_PATH: string;

package/dist/lib/constants.mjs

@@ -9,5 +9,6 @@ export const VENDOR_CLIENT_BARREL_PATH = path.resolve(INTERMEDIATES_OUTPUT_DIR,
 export const VENDOR_SERVER_BARREL_PATH = path.resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-vendor-server-barrel.js");
 export const VENDOR_CLIENT_BARREL_EXPORT_PATH = "rwsdk/__vendor_client_barrel";
 export const VENDOR_SERVER_BARREL_EXPORT_PATH = "rwsdk/__vendor_server_barrel";
+export const RW_STATE_EXPORT_PATH = "rwsdk/__state";
 export const INTERMEDIATE_SSR_BRIDGE_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "ssr", "ssr_bridge.js");
 export const CLIENT_MANIFEST_RELATIVE_PATH = resolve("dist", "client", ".vite", "manifest.json");

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

@@ -1,4 +1,5 @@
-export declare const IS_DEBUG_MODE: string | boolean;
+export declare const IS_CI: boolean;
+export declare const IS_DEBUG_MODE: boolean;
 export declare const SETUP_PLAYGROUND_ENV_TIMEOUT: number;
 export declare const DEPLOYMENT_TIMEOUT: number;
 export declare const DEPLOYMENT_MIN_TRIES: number;

package/dist/lib/e2e/constants.mjs

@@ -1,6 +1,13 @@
+export const IS_CI = !!((process.env.CI && !process.env.NOT_CI) ||
+    process.env.GITHUB_ACTIONS ||
+    process.env.GITLAB_CI ||
+    process.env.CIRCLECI ||
+    process.env.TRAVIS ||
+    process.env.JENKINS_URL ||
+    process.env.NETLIFY);
 export const IS_DEBUG_MODE = process.env.RWSDK_E2E_DEBUG
-    ? process.env.RWSDK_E2E_DEBUG
-    : !process.env.CI;
+    ? process.env.RWSDK_E2E_DEBUG === "true"
+    : !IS_CI;
 export const SETUP_PLAYGROUND_ENV_TIMEOUT = process.env
     .RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT
     ? parseInt(process.env.RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT, 10)

package/dist/lib/e2e/dev.mjs

@@ -109,7 +109,6 @@ export async function runDevServer(packageManager = "pnpm", cwd) {
         // Listen for all output to get the URL
         const handleOutput = (data, source) => {
             const output = data.toString();
-            console.log(output);
             allOutput += output; // Accumulate all output
             log("Received output from %s: %s", source, output.replace(/\n/g, "\\n"));
             if (!url) {

package/dist/lib/e2e/environment.mjs

@@ -1,3 +1,4 @@
+import { createHash } from "crypto";
 import debug from "debug";
 import { copy, pathExists } from "fs-extra";
 import ignore from "ignore";
@@ -8,12 +9,25 @@ import { basename, join, relative, resolve } from "path";
 import tmp from "tmp-promise";
 import { $ } from "../../lib/$.mjs";
 import { ROOT_DIR } from "../constants.mjs";
-import { INSTALL_DEPENDENCIES_RETRIES } from "./constants.mjs";
+import { INSTALL_DEPENDENCIES_RETRIES, IS_CI } from "./constants.mjs";
 import { retry } from "./retry.mjs";
 const log = debug("rwsdk:e2e:environment");
+const IS_CACHE_ENABLED = process.env.RWSDK_E2E_CACHE
+    ? process.env.RWSDK_E2E_CACHE === "1"
+    : !IS_CI;
+if (IS_CACHE_ENABLED) {
+    log("E2E test caching is enabled.");
+}
 const getTempDir = async () => {
     return tmp.dir({ unsafeCleanup: true });
 };
+function slugify(str) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/--+/g, "-")
+        .replace(/^-|-$/g, "");
+}
 const createSdkTarball = async () => {
     const existingTarballPath = process.env.RWSKD_SMOKE_TEST_TARBALL_PATH;
     if (existingTarballPath) {
@@ -28,15 +42,27 @@ const createSdkTarball = async () => {
             }, // No-op cleanup
         };
     }
-    const packResult = await $({ cwd: ROOT_DIR, stdio: "pipe" }) `npm pack`;
-    const tarballName = packResult.stdout?.trim();
-    const tarballPath = path.join(ROOT_DIR, tarballName);
-    log(`📦 Created tarball: ${tarballPath}`);
+    // Create a temporary directory to receive the tarball, ensuring a stable path.
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rwsdk-tarball-"));
+    await $({
+        cwd: ROOT_DIR,
+        stdio: "pipe",
+    }) `npm pack --pack-destination=${tempDir}`;
+    // We need to determine the tarball's name, as it's version-dependent.
+    // Running `npm pack --dry-run` gives us the filename without creating a file.
+    const packDryRun = await $({
+        cwd: ROOT_DIR,
+        stdio: "pipe",
+    }) `npm pack --dry-run`;
+    const tarballName = packDryRun.stdout?.trim();
+    const tarballPath = path.join(tempDir, tarballName);
+    if (!fs.existsSync(tarballPath)) {
+        throw new Error(`Tarball was not created in the expected location: ${tarballPath}`);
+    }
+    log(`📦 Created tarball in stable temp location: ${tarballPath}`);
     const cleanupTarball = async () => {
-        if (fs.existsSync(tarballPath)) {
-            log(`🧹 Cleaning up tarball: ${tarballPath}`);
-            await fs.promises.rm(tarballPath, { force: true });
-        }
+        log(`🧹 Cleaning up tarball directory: ${tempDir}`);
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
     };
     return { tarballPath, cleanupTarball };
 };
@@ -59,7 +85,7 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         const sourceDir = monorepoRoot || projectDir;
         // Create unique project directory name
         const originalDirName = basename(sourceDir);
-        const workerName = `${originalDirName}-test-${resourceUniqueKey}`;
+        const workerName = `${slugify(originalDirName)}-test-${resourceUniqueKey}`;
         const tempCopyRoot = resolve(tempDir.path, workerName);
         // If it's a monorepo, the targetDir for commands is a subdirectory
         const targetDir = monorepoRoot
@@ -115,7 +141,9 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
                 const workspaces = rwsdkWs.workspaces;
                 if (packageManager === "pnpm") {
                     const pnpmWsPath = join(tempCopyRoot, "pnpm-workspace.yaml");
-                    const pnpmWsConfig = `packages:\n${workspaces.map((w) => `  - '${w}'`).join("\n")}\n`;
+                    const pnpmWsConfig = `packages:\n${workspaces
+                        .map((w) => `  - '${w}'`)
+                        .join("\n")}\n`;
                     await fs.promises.writeFile(pnpmWsPath, pnpmWsConfig);
                     log("Created pnpm-workspace.yaml");
                 }
@@ -157,7 +185,7 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         await setTarballDependency(targetDir, tarballFilename);
         // Install dependencies in the target directory
         const installDir = monorepoRoot ? tempCopyRoot : targetDir;
-        await retry(() => installDependencies(installDir, packageManager), {
+        await retry(() => installDependencies(installDir, packageManager, projectDir, monorepoRoot), {
             retries: INSTALL_DEPENDENCIES_RETRIES,
             delay: 1000,
         });
@@ -168,7 +196,42 @@ export async function copyProjectToTempDir(projectDir, resourceUniqueKey, packag
         await cleanupTarball();
     }
 }
-async function installDependencies(targetDir, packageManager = "pnpm") {
+async function installDependencies(targetDir, packageManager = "pnpm", projectDir, monorepoRoot) {
+    if (IS_CACHE_ENABLED) {
+        // Generate a checksum of the SDK's dist directory to factor into the cache key
+        const { stdout: sdkDistChecksum } = await $("find . -type f | sort | md5sum", {
+            shell: true,
+            cwd: path.join(ROOT_DIR, "dist"),
+        });
+        const projectIdentifier = monorepoRoot
+            ? `${monorepoRoot}-${projectDir}`
+            : projectDir;
+        const projectHash = createHash("md5")
+            .update(`${projectIdentifier}-${sdkDistChecksum}`)
+            .digest("hex")
+            .substring(0, 8);
+        const cacheDirName = monorepoRoot
+            ? basename(monorepoRoot)
+            : basename(projectDir);
+        const cacheRoot = path.join(os.tmpdir(), "rwsdk-e2e-cache", `${cacheDirName}-${projectHash}`);
+        const nodeModulesCachePath = path.join(cacheRoot, "node_modules");
+        if (await pathExists(nodeModulesCachePath)) {
+            console.log(`✅ CACHE HIT for source "${projectIdentifier}": Found cached node_modules. Hard-linking from ${nodeModulesCachePath}`);
+            try {
+                // Use cp -al for a fast, hardlink-based copy
+                await $("cp", ["-al", nodeModulesCachePath, join(targetDir, "node_modules")], { stdio: "pipe" });
+                console.log(`✅ Hardlink copy created successfully.`);
+            }
+            catch (e) {
+                console.warn(`⚠️ Hardlink copy failed, falling back to full copy. Error: ${e.message}`);
+                // Fallback to a regular copy if hardlinking fails (e.g., cross-device)
+                await copy(nodeModulesCachePath, join(targetDir, "node_modules"));
+                console.log(`✅ Full copy created successfully.`);
+            }
+            return;
+        }
+        console.log(`ℹ️ CACHE MISS for source "${projectIdentifier}": No cached node_modules found at ${nodeModulesCachePath}. Proceeding with installation.`);
+    }
     console.log(`📦 Installing project dependencies in ${targetDir} using ${packageManager}...`);
     try {
         // Clean up any pre-existing node_modules and lockfiles
@@ -220,6 +283,33 @@ async function installDependencies(targetDir, packageManager = "pnpm") {
             },
         });
         console.log("✅ Dependencies installed successfully");
+        // After successful install, populate the cache if enabled
+        if (IS_CACHE_ENABLED) {
+            // Re-calculate cache path to be safe
+            const { stdout: sdkDistChecksum } = await $("find . -type f | sort | md5sum", {
+                shell: true,
+                cwd: path.join(ROOT_DIR, "dist"),
+            });
+            const projectIdentifier = monorepoRoot
+                ? `${monorepoRoot}-${projectDir}`
+                : projectDir;
+            const projectHash = createHash("md5")
+                .update(`${projectIdentifier}-${sdkDistChecksum}`)
+                .digest("hex")
+                .substring(0, 8);
+            const cacheDirName = monorepoRoot
+                ? basename(monorepoRoot)
+                : basename(projectDir);
+            const cacheRoot = path.join(os.tmpdir(), "rwsdk-e2e-cache", `${cacheDirName}-${projectHash}`);
+            const nodeModulesCachePath = path.join(cacheRoot, "node_modules");
+            console.log(`Caching node_modules to ${nodeModulesCachePath} for future runs...`);
+            // Ensure parent directory exists
+            await fs.promises.mkdir(path.dirname(nodeModulesCachePath), {
+                recursive: true,
+            });
+            await copy(join(targetDir, "node_modules"), nodeModulesCachePath);
+            console.log(`✅ node_modules cached successfully.`);
+        }
         // Log installation details at debug level
         if (result.stdout) {
             log(`${packageManager} install output: %s`, result.stdout);

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

@@ -4,5 +4,5 @@ export interface PollOptions {
     minTries: number;
     onRetry?: (error: unknown, tries: number) => void;
 }
-export declare function poll(fn: () => Promise<boolean>, options?: Partial<PollOptions>): Promise<void>;
+export declare function poll(fn: () => boolean | Promise<boolean>, options?: Partial<PollOptions>): Promise<void>;
 export declare function pollValue<T>(fn: () => Promise<T>, options?: Partial<PollOptions>): Promise<T>;

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

@@ -37,6 +37,11 @@ export interface SetupPlaygroundEnvironmentOptions {
      * @default true
      */
     deploy?: boolean;
+    /**
+     * Whether to automatically start the dev server.
+     * @default true
+     */
+    autoStartDevServer?: boolean;
 }
 /**
  * A Vitest hook that sets up a playground environment for a test file.
@@ -77,8 +82,6 @@ export declare function createDeployment(): {
  */
 export declare function runTestWithRetries(name: string, attemptFn: () => Promise<void>): Promise<void>;
 type SDKRunner = (name: string, testLogic: (context: {
-    createDevServer: () => Promise<DevServerInstance>;
-    createDeployment: () => Promise<DeploymentInstance>;
     browser: Browser;
     page: Page;
     projectDir: string;

package/dist/lib/e2e/testHarness.mjs

@@ -85,7 +85,9 @@ function getPlaygroundDirFromImportMeta(importMetaUrl) {
  * This ensures that tests run in a clean, isolated environment.
  */
 export function setupPlaygroundEnvironment(options) {
-    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, } = typeof options === "string" ? { sourceProjectDir: options } : options;
+    const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, autoStartDevServer = true, } = typeof options === "string"
+        ? { sourceProjectDir: options, autoStartDevServer: true }
+        : options;
     ensureHooksRegistered();
     beforeAll(async () => {
         let projectDir;
@@ -111,14 +113,16 @@ export function setupPlaygroundEnvironment(options) {
                 projectDir: devEnv.targetDir,
                 cleanup: devEnv.cleanup,
             };
-            const devControl = createDevServer();
-            globalDevInstancePromise = devControl.start().then((instance) => {
-                globalDevInstance = instance;
-                return instance;
-            });
-            // Prevent unhandled promise rejections. The error will be handled inside
-            // the test's beforeEach hook where this promise is awaited.
-            globalDevInstancePromise.catch(() => { });
+            if (autoStartDevServer) {
+                const devControl = createDevServer();
+                globalDevInstancePromise = devControl.start().then((instance) => {
+                    globalDevInstance = instance;
+                    return instance;
+                });
+                // Prevent unhandled promise rejections. The error will be handled inside
+                // the test's beforeEach hook where this promise is awaited.
+                globalDevInstancePromise.catch(() => { });
+            }
         }
         else {
             globalDevPlaygroundEnv = null;

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

@@ -6,10 +6,23 @@ type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Ma
 type MaybePromise<T> = T | Promise<T>;
 type RouteComponent<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
 type RouteHandler<T extends RequestInfo = RequestInfo> = RouteFunction<T> | RouteComponent<T> | [...RouteMiddleware<T>[], RouteFunction<T> | RouteComponent<T>];
+declare const METHOD_VERBS: readonly ["delete", "get", "head", "patch", "post", "put"];
+export type MethodVerb = (typeof METHOD_VERBS)[number];
+export type MethodHandlers<T extends RequestInfo = RequestInfo> = {
+    [K in MethodVerb]?: RouteHandler<T>;
+} & {
+    config?: {
+        disable405?: true;
+        disableOptions?: true;
+    };
+    custom?: {
+        [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> = {
     path: string;
-    handler: RouteHandler<T>;
+    handler: RouteHandler<T> | MethodHandlers<T>;
     layouts?: React.FC<LayoutProps<T>>[];
 };
 export declare function matchPath<T extends RequestInfo = RequestInfo>(routePath: string, requestPath: string): T["params"] | null;
@@ -24,7 +37,7 @@ export declare function defineRoutes<T extends RequestInfo = RequestInfo>(routes
         rscActionHandler: (request: Request) => Promise<unknown>;
     }) => Response | Promise<Response>;
 };
-export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T>): RouteDefinition<T>;
+export declare function route<T extends RequestInfo = RequestInfo>(path: string, handler: RouteHandler<T> | MethodHandlers<T>): RouteDefinition<T>;
 export declare function index<T extends RequestInfo = RequestInfo>(handler: RouteHandler<T>): RouteDefinition<T>;
 export declare function prefix<T extends RequestInfo = RequestInfo>(prefixPath: string, routes: Route<T>[]): Route<T>[];
 export declare const wrapHandlerToThrowResponses: <T extends RequestInfo = RequestInfo>(handler: RouteFunction<T> | RouteComponent<T>) => RouteHandler<T>;

package/dist/runtime/lib/router.js

@@ -1,5 +1,6 @@
 import React from "react";
 import { isValidElementType } from "react-is";
+const METHOD_VERBS = ["delete", "get", "head", "patch", "post", "put"];
 export function matchPath(routePath, requestPath) {
     // Check for invalid pattern: multiple colons in a segment (e.g., /:param1:param2/)
     if (routePath.includes(":")) {
@@ -60,6 +61,38 @@ function flattenRoutes(routes) {
         return [...acc, route];
     }, []);
 }
+function isMethodHandlers(handler) {
+    return (typeof handler === "object" && handler !== null && !Array.isArray(handler));
+}
+function handleOptionsRequest(methodHandlers) {
+    const methods = new Set([
+        ...(methodHandlers.config?.disableOptions ? [] : ["OPTIONS"]),
+        ...METHOD_VERBS.filter((verb) => methodHandlers[verb]).map((verb) => verb.toUpperCase()),
+        ...Object.keys(methodHandlers.custom ?? {}).map((method) => method.toUpperCase()),
+    ]);
+    return new Response(null, {
+        status: 204,
+        headers: {
+            Allow: Array.from(methods).sort().join(", "),
+        },
+    });
+}
+function handleMethodNotAllowed(methodHandlers) {
+    const optionsResponse = handleOptionsRequest(methodHandlers);
+    return new Response("Method Not Allowed", {
+        status: 405,
+        headers: optionsResponse.headers,
+    });
+}
+function getHandlerForMethod(methodHandlers, method) {
+    const lowerMethod = method.toLowerCase();
+    // Check standard method verbs
+    if (METHOD_VERBS.includes(lowerMethod)) {
+        return methodHandlers[lowerMethod];
+    }
+    // Check custom methods (already normalized to lowercase)
+    return methodHandlers.custom?.[lowerMethod];
+}
 export function defineRoutes(routes) {
     const flattenedRoutes = flattenRoutes(routes);
     return {
@@ -125,9 +158,32 @@ export function defineRoutes(routes) {
                 if (!params) {
                     continue; // Not a match, keep going.
                 }
+                // Resolve handler if method-based routing
+                let handler;
+                if (isMethodHandlers(route.handler)) {
+                    const requestMethod = request.method;
+                    // Handle OPTIONS request
+                    if (requestMethod === "OPTIONS" &&
+                        !route.handler.config?.disableOptions) {
+                        return handleOptionsRequest(route.handler);
+                    }
+                    // Try to find handler for the request method
+                    handler = getHandlerForMethod(route.handler, requestMethod);
+                    if (!handler) {
+                        // Method not supported for this route
+                        if (!route.handler.config?.disable405) {
+                            return handleMethodNotAllowed(route.handler);
+                        }
+                        // If 405 is disabled, continue to next route
+                        continue;
+                    }
+                }
+                else {
+                    handler = route.handler;
+                }
                 // Found a match: run route-specific middlewares, then the final component, then stop.
                 return await runWithRequestInfoOverrides({ params }, async () => {
-                    const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
+                    const { routeMiddlewares, componentHandler } = parseHandlers(handler);
                     // Route-specific middlewares
                     for (const mw of routeMiddlewares) {
                         const result = await mw(getRequestInfo());
@@ -169,6 +225,16 @@ export function route(path, handler) {
     if (!path.endsWith("/")) {
         path = path + "/";
     }
+    // Normalize custom method keys to lowercase
+    if (isMethodHandlers(handler) && handler.custom) {
+        handler = {
+            ...handler,
+            custom: Object.fromEntries(Object.entries(handler.custom).map(([method, methodHandler]) => [
+                method.toLowerCase(),
+                methodHandler,
+            ])),
+        };
+    }
     return {
         path,
         handler,

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

@@ -595,6 +595,245 @@ describe("defineRoutes - Request Handling Behavior", () => {
             expect(extractedParams).toEqual({ id: "123" });
         });
     });
+    describe("HTTP Method Routing", () => {
+        it("should route GET request to get handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("GET Response");
+        });
+        it("should route POST request to post handler", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("POST Response");
+        });
+        it("should return 405 for unsupported method with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "DELETE",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should handle OPTIONS request with Allow header", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(204);
+            expect(response.headers.get("Allow")).toBe("GET, OPTIONS, POST");
+        });
+        it("should support custom methods (case-insensitive)", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        report: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "REPORT",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should normalize custom method keys to lowercase", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    custom: {
+                        REPORT: () => new Response("REPORT Response"),
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "report",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(await response.text()).toBe("REPORT Response");
+        });
+        it("should disable 405 when config.disable405 is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    config: {
+                        disable405: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "POST",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(404);
+            expect(await response.text()).toBe("Not Found");
+        });
+        it("should disable OPTIONS when config.disableOptions is true", async () => {
+            const router = defineRoutes([
+                route("/test/", {
+                    get: () => new Response("GET Response"),
+                    post: () => new Response("POST Response"),
+                    config: {
+                        disableOptions: true,
+                    },
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "OPTIONS",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(response.status).toBe(405);
+            expect(await response.text()).toBe("Method Not Allowed");
+            expect(response.headers.get("Allow")).toBe("GET, POST");
+        });
+        it("should support middleware arrays in method handlers", async () => {
+            const executionOrder = [];
+            const authMiddleware = () => {
+                executionOrder.push("authMiddleware");
+            };
+            const getHandler = () => {
+                executionOrder.push("getHandler");
+                return new Response("GET Response");
+            };
+            const router = defineRoutes([
+                route("/test/", {
+                    get: [authMiddleware, getHandler],
+                }),
+            ]);
+            const deps = createMockDependencies();
+            deps.mockRequestInfo.request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const request = new Request("http://localhost:3000/test/", {
+                method: "GET",
+            });
+            const response = await router.handle({
+                request,
+                renderPage: deps.mockRenderPage,
+                getRequestInfo: deps.getRequestInfo,
+                onError: deps.onError,
+                runWithRequestInfoOverrides: deps.mockRunWithRequestInfoOverrides,
+                rscActionHandler: deps.mockRscActionHandler,
+            });
+            expect(executionOrder).toEqual(["authMiddleware", "getHandler"]);
+            expect(await response.text()).toBe("GET Response");
+        });
+    });
     describe("Edge Cases", () => {
         it("should handle middleware-only apps with RSC actions", async () => {
             const executionOrder = [];