rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20-test.20250929144616

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

@@ -1,3 +1,3 @@
 import "./types/shared";
-export * from "../lib/router";
 export * from "../lib/links";
+export * from "../lib/router";

package/dist/runtime/entries/router.js

@@ -1,3 +1,3 @@
 import "./types/shared";
-export * from "../lib/router";
 export * from "../lib/links";
+export * from "../lib/router";

package/dist/runtime/entries/worker.d.ts

@@ -1,11 +1,10 @@
 import "./types/worker";
-export * from "../register/worker";
-export * from "../worker";
 export * from "../error";
-export * from "../script";
 export * from "../lib/utils";
+export * from "../register/worker";
+export * from "../render/renderToStream";
+export * from "../render/renderToString";
 export * from "../requestInfo/types";
 export * from "../requestInfo/worker";
-export * from "../render/renderToString";
-export * from "../render/renderToStream";
-export * from "../imports/resolveSSRValue";
+export * from "../script";
+export * from "../worker";

package/dist/runtime/entries/worker.js

@@ -1,11 +1,10 @@
 import "./types/worker";
-export * from "../register/worker";
-export * from "../worker";
 export * from "../error";
-export * from "../script";
 export * from "../lib/utils";
+export * from "../register/worker";
+export * from "../render/renderToStream";
+export * from "../render/renderToString";
 export * from "../requestInfo/types";
 export * from "../requestInfo/worker";
-export * from "../render/renderToString";
-export * from "../render/renderToStream";
-export * from "../imports/resolveSSRValue";
+export * from "../script";
+export * from "../worker";

package/dist/runtime/imports/worker.js

@@ -1,6 +1,6 @@
-import { requestInfo } from "../requestInfo/worker";
 import { ssrWebpackRequire as baseSsrWebpackRequire } from "rwsdk/__ssr_bridge";
 import { memoizeOnId } from "../lib/memoizeOnId";
+import { requestInfo } from "../requestInfo/worker";
 // @ts-ignore
 import { useServerLookup } from "virtual:use-server-lookup.js";
 export const loadServerModule = memoizeOnId(async (id) => {

package/dist/runtime/lib/auth/session.d.ts

@@ -35,10 +35,10 @@ export declare const defineSessionStore: <Session, SessionInputData>({ cookieNam
     unset: (sessionId: string) => Promise<void>;
 }) => {
     load: (request: Request) => Promise<Session | null>;
-    save: (headers: Headers, sessionInputData: SessionInputData, { maxAge }?: {
+    save: (responseHeaders: Headers, sessionInputData: SessionInputData, { maxAge }?: {
         maxAge?: number | true;
     }) => Promise<void>;
-    remove: (request: Request, headers: Headers) => Promise<void>;
+    remove: (request: Request, responseHeaders: Headers) => Promise<void>;
 };
 type SessionStoreFromDurableObject<SessionDurableObject> = SessionDurableObject extends DurableObjectMethods<infer Session, infer SessionInputData> ? SessionStore<Session, SessionInputData> : never;
 export declare const defineDurableSession: <SessionDurableObject extends DurableObjectMethods<any, any>>({ cookieName, createCookie, secretKey, sessionDurableObject, }: {

package/dist/runtime/lib/auth/session.js

@@ -1,5 +1,5 @@
-import { ErrorResponse } from "../../error";
 import { env } from "cloudflare:workers";
+import { ErrorResponse } from "../../error";
 const AUTH_SECRET_KEY = env.AUTH_SECRET_KEY ??
     (import.meta.env.VITE_IS_DEV_SERVER
         ? "development-secret-key-do-not-use-in-production"
@@ -89,17 +89,17 @@ export const defineSessionStore = ({ cookieName = "session_id", createCookie = c
             throw new ErrorResponse(401, "Invalid session id");
         }
     };
-    const save = async (headers, sessionInputData, { maxAge } = {}) => {
+    const save = async (responseHeaders, sessionInputData, { maxAge } = {}) => {
         const sessionId = await generateSessionId({ secretKey });
         await set(sessionId, sessionInputData);
-        headers.set("Set-Cookie", createCookie({ name: cookieName, sessionId, maxAge }));
+        responseHeaders.set("Set-Cookie", createCookie({ name: cookieName, sessionId, maxAge }));
     };
-    const remove = async (request, headers) => {
+    const remove = async (request, responseHeaders) => {
         const sessionId = getSessionIdFromCookie(request);
         if (sessionId) {
             await unset(sessionId);
         }
-        headers.set("Set-Cookie", createCookie({ name: cookieName, sessionId: "", maxAge: 0 }));
+        responseHeaders.set("Set-Cookie", createCookie({ name: cookieName, sessionId: "", maxAge: 0 }));
     };
     return {
         load,

package/dist/runtime/lib/db/DOWorkerDialect.d.ts

@@ -1,4 +1,4 @@
-import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, Driver, DatabaseConnection, QueryResult } from "kysely";
+import { DatabaseConnection, Driver, QueryResult, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
 type DOWorkerDialectConfig = {
     kyselyExecuteQuery: (compiledQuery: {
         sql: string;

package/dist/runtime/lib/db/DOWorkerDialect.js

@@ -1,5 +1,5 @@
-import debug from "../debug";
 import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, } from "kysely";
+import debug from "../debug";
 const log = debug("sdk:db:do-worker-dialect");
 export class DOWorkerDialect {
     constructor(config) {

package/dist/runtime/lib/db/SqliteDurableObject.js

@@ -1,8 +1,8 @@
-import { DODialect } from "kysely-do";
 import { DurableObject } from "cloudflare:workers";
+import { DODialect } from "kysely-do";
 import { Kysely, ParseJSONResultsPlugin, } from "kysely";
-import { createMigrator } from "./index.js";
 import debug from "../debug.js";
+import { createMigrator } from "./index.js";
 const log = debug("sdk:do-db");
 // Base class for Durable Objects that need Kysely database access
 export class SqliteDurableObject extends DurableObject {

package/dist/runtime/lib/db/index.d.ts

@@ -1,5 +1,5 @@
+export { sql } from "kysely";
+export * from "./createDb.js";
 export * from "./migrations.js";
 export * from "./SqliteDurableObject.js";
-export * from "./createDb.js";
 export type * from "./typeInference/database.js";
-export { sql } from "kysely";

package/dist/runtime/lib/db/index.js

@@ -1,4 +1,4 @@
+export { sql } from "kysely";
+export * from "./createDb.js";
 export * from "./migrations.js";
 export * from "./SqliteDurableObject.js";
-export * from "./createDb.js";
-export { sql } from "kysely";

package/dist/runtime/lib/db/migrations.d.ts

@@ -1,4 +1,4 @@
-import { Kysely, Migration, Migrator, MigrationProvider } from "kysely";
+import { Kysely, Migration, MigrationProvider, Migrator } from "kysely";
 /**
  * A custom MigrationProvider that works with in-memory migrations
  * rather than reading from files.

package/dist/runtime/lib/db/typeInference/builders/alterTable.d.ts

@@ -1,7 +1,7 @@
-import { SqlToTsType, ExecutedBuilder, AlterOperation, AddColumnOp, DropColumnOp, RenameColumnOp, AlterColumnOp, ModifyColumnOp } from "../utils";
-import { ColumnDefinitionBuilder } from "./columnDefinition";
+import { CheckConstraintNode, Expression, ForeignKeyConstraintBuilder, PrimaryKeyConstraintNode, sql, UniqueConstraintNode } from "kysely";
+import { AddColumnOp, AlterColumnOp, AlterOperation, DropColumnOp, ExecutedBuilder, ModifyColumnOp, RenameColumnOp, SqlToTsType } from "../utils";
 import { AlterColumnBuilderCallback } from "./alterColumn";
-import { ForeignKeyConstraintBuilder, Expression, CheckConstraintNode, UniqueConstraintNode, PrimaryKeyConstraintNode, sql } from "kysely";
+import { ColumnDefinitionBuilder } from "./columnDefinition";
 type DataTypeExpression = string | typeof sql;
 interface CheckConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;

package/dist/runtime/lib/db/typeInference/builders/columnDefinition.d.ts

@@ -1,4 +1,4 @@
-import { Expression, sql, ColumnDefinitionNode } from "kysely";
+import { ColumnDefinitionNode, Expression, sql } from "kysely";
 type DefaultValueExpression = string | number | boolean | null | typeof sql;
 export interface ColumnDefinitionBuilder<TType> {
     autoIncrement(): ColumnDefinitionBuilder<TType>;

package/dist/runtime/lib/db/typeInference/builders/createTable.d.ts

@@ -1,6 +1,6 @@
-import { SqlToTsType, ExecutedBuilder, Prettify } from "../utils";
+import { CheckConstraintNode, CompiledQuery, CreateTableNode, Expression, ForeignKeyConstraintBuilder, PrimaryKeyConstraintNode, UniqueConstraintNode } from "kysely";
+import { ExecutedBuilder, Prettify, SqlToTsType } from "../utils";
 import { ColumnDefinitionBuilder } from "./columnDefinition";
-import { CompiledQuery, CreateTableNode, Expression, ForeignKeyConstraintBuilder, CheckConstraintNode, UniqueConstraintNode, PrimaryKeyConstraintNode } from "kysely";
 interface CheckConstraintBuilder {
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): CheckConstraintNode;

package/dist/runtime/lib/db/typeInference/builders/createView.d.ts

@@ -1,5 +1,5 @@
+import { CompiledQuery, CreateViewNode, RawBuilder, SelectQueryBuilder } from "kysely";
 import { ExecutedBuilder } from "../utils";
-import { CreateViewNode, CompiledQuery, SelectQueryBuilder, RawBuilder } from "kysely";
 export interface CreateViewBuilder<TName extends string, TSchema extends Record<string, any> = {}, TColumns extends string[] = []> {
     readonly __viewName: TName;
     readonly __schema: TSchema;

package/dist/runtime/lib/db/typeInference/builders/dropTable.d.ts

@@ -1,5 +1,5 @@
+import { CompiledQuery, DropTableNode } from "kysely";
 import { ExecutedBuilder } from "../utils";
-import { DropTableNode, CompiledQuery } from "kysely";
 export interface DropTableBuilder<TName extends string> {
     readonly __tableName: TName;
     ifExists(): DropTableBuilder<TName>;

package/dist/runtime/lib/db/typeInference/builders/dropView.d.ts

@@ -1,5 +1,5 @@
+import { CompiledQuery, DropViewNode } from "kysely";
 import { ExecutedBuilder } from "../utils";
-import { DropViewNode, CompiledQuery } from "kysely";
 export interface DropViewBuilder<TName extends string> {
     readonly __viewName: TName;
     ifExists(): DropViewBuilder<TName>;

package/dist/runtime/lib/db/typeInference/builders/schema.d.ts

@@ -1,9 +1,9 @@
-import { CreateTableBuilder } from "./createTable";
+import { CreateIndexBuilder, CreateSchemaBuilder, CreateTypeBuilder, DropIndexBuilder, DropSchemaBuilder, DropTypeBuilder, KyselyPlugin, RefreshMaterializedViewBuilder } from "kysely";
 import { AlterTableBuilder } from "./alterTable";
-import { DropTableBuilder } from "./dropTable";
+import { CreateTableBuilder } from "./createTable";
 import { CreateViewBuilder } from "./createView";
+import { DropTableBuilder } from "./dropTable";
 import { DropViewBuilder } from "./dropView";
-import { CreateIndexBuilder, DropIndexBuilder, CreateSchemaBuilder, DropSchemaBuilder, CreateTypeBuilder, DropTypeBuilder, KyselyPlugin, RefreshMaterializedViewBuilder } from "kysely";
 export interface SchemaBuilder {
     createTable<TName extends string>(name: TName): CreateTableBuilder<TName, {}>;
     alterTable<TName extends string>(name: TName): AlterTableBuilder<TName, []>;

package/dist/runtime/lib/db/typeInference/database.d.ts

@@ -1,9 +1,9 @@
 import { Kysely } from "kysely";
-import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
-import { CreateTableBuilder } from "./builders/createTable";
 import { AlterTableBuilder } from "./builders/alterTable";
+import { CreateTableBuilder } from "./builders/createTable";
 import { DropTableBuilder } from "./builders/dropTable";
 import { SchemaBuilder } from "./builders/schema";
+import { ExecutedBuilder, Prettify, ProcessAlteredTable, UnionToTuple } from "./utils";
 export interface InferenceBuilder {
     schema: SchemaBuilder;
 }

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

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

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

@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from "vitest";
+import { memoizeOnId } from "./memoizeOnId";
+describe("memoizeOnId", () => {
+    it("should call the function only once for the same id", () => {
+        const fn = vi.fn((id) => `result-${id}`);
+        const memoizedFn = memoizeOnId(fn);
+        const result1 = memoizedFn("a");
+        const result2 = memoizedFn("a");
+        expect(result1).toBe("result-a");
+        expect(result2).toBe("result-a");
+        expect(fn).toHaveBeenCalledTimes(1);
+        expect(fn).toHaveBeenCalledWith("a");
+    });
+    it("should call the function again for a different id", () => {
+        const fn = vi.fn((id) => `result-${id}`);
+        const memoizedFn = memoizeOnId(fn);
+        const result1 = memoizedFn("a");
+        const result2 = memoizedFn("b");
+        expect(result1).toBe("result-a");
+        expect(result2).toBe("result-b");
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(fn).toHaveBeenCalledWith("a");
+        expect(fn).toHaveBeenCalledWith("b");
+    });
+    it("should return the correct cached value for multiple calls", () => {
+        const fn = vi.fn((id) => ({ id }));
+        const memoizedFn = memoizeOnId(fn);
+        const resultA1 = memoizedFn("a");
+        const resultB1 = memoizedFn("b");
+        const resultA2 = memoizedFn("a");
+        expect(resultA1).toEqual({ id: "a" });
+        expect(resultB1).toEqual({ id: "b" });
+        expect(resultA2).toBe(resultA1); // Should be the same object reference
+        expect(fn).toHaveBeenCalledTimes(2);
+    });
+    it("should handle object properties that exist on Object.prototype", () => {
+        const fn = vi.fn((id) => `result-${id}`);
+        const memoizedFn = memoizeOnId(fn);
+        const result1 = memoizedFn("constructor");
+        const result2 = memoizedFn("toString");
+        const result3 = memoizedFn("constructor");
+        expect(result1).toBe("result-constructor");
+        expect(result2).toBe("result-toString");
+        expect(result3).toBe("result-constructor");
+        expect(fn).toHaveBeenCalledTimes(2);
+        expect(fn).toHaveBeenCalledWith("constructor");
+        expect(fn).toHaveBeenCalledWith("toString");
+    });
+});

package/dist/runtime/lib/realtime/client.js

@@ -1,7 +1,7 @@
-import { initClient } from "../../client/client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
-import { MESSAGE_TYPE } from "./shared";
+import { initClient } from "../../client/client";
 import { packMessage, unpackMessage, } from "./protocol";
+import { MESSAGE_TYPE } from "./shared";
 const DEFAULT_KEY = "default";
 export const initRealtimeClient = ({ key = DEFAULT_KEY, handleResponse, } = {}) => {
     const transport = realtimeTransport({ key, handleResponse });

package/dist/runtime/lib/realtime/durableObject.js

@@ -1,7 +1,7 @@
 import { DurableObject } from "cloudflare:workers";
+import { packMessage, unpackMessage, } from "./protocol";
 import { MESSAGE_TYPE } from "./shared";
 import { validateUpgradeRequest } from "./validateUpgradeRequest";
-import { packMessage, unpackMessage, } from "./protocol";
 export class RealtimeDurableObject extends DurableObject {
     constructor(state, env) {
         super(state, env);

package/dist/runtime/lib/realtime/protocol.test.d.ts

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

package/dist/runtime/lib/realtime/protocol.test.js

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { packMessage, unpackMessage } from "./protocol";
+import { MESSAGE_TYPE } from "./shared";
+describe("Realtime Protocol pack/unpack", () => {
+    const textEncoder = new TextEncoder();
+    // Helper to generate a UUID string of the correct length
+    const generateId = () => "a".repeat(36);
+    const testMessages = [
+        {
+            type: MESSAGE_TYPE.ACTION_REQUEST,
+            id: "my-action",
+            args: { foo: "bar" },
+            requestId: generateId(),
+            clientUrl: "http://localhost:3000/",
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_START,
+            id: generateId(),
+            status: 200,
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_CHUNK,
+            id: generateId(),
+            payload: textEncoder.encode("chunk data"),
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_END,
+            id: generateId(),
+        },
+        {
+            type: MESSAGE_TYPE.ACTION_ERROR,
+            id: generateId(),
+            error: "Something went wrong",
+        },
+        {
+            type: MESSAGE_TYPE.RSC_START,
+            id: generateId(),
+            status: 200,
+        },
+        {
+            type: MESSAGE_TYPE.RSC_CHUNK,
+            id: generateId(),
+            payload: textEncoder.encode("rsc chunk"),
+        },
+        {
+            type: MESSAGE_TYPE.RSC_END,
+            id: generateId(),
+        },
+    ];
+    testMessages.forEach((message) => {
+        it(`should correctly pack and unpack a ${Object.keys(MESSAGE_TYPE).find((key) => MESSAGE_TYPE[key] === message.type) || "UNKNOWN"} message`, () => {
+            const packed = packMessage(message);
+            const unpacked = unpackMessage(packed);
+            expect(unpacked).toEqual(message);
+        });
+    });
+    describe("Error Handling", () => {
+        it("should throw an error for an unknown message type on pack", () => {
+            const invalidMessage = { type: 999 };
+            expect(() => packMessage(invalidMessage)).toThrow("Unknown message type for packing");
+        });
+        it("should throw an error for an unknown message type on unpack", () => {
+            const invalidData = new Uint8Array([99, 1, 2, 3]);
+            expect(() => unpackMessage(invalidData)).toThrow("Unknown message type for unpacking: 99");
+        });
+        it("should throw an error for an empty message on unpack", () => {
+            const emptyData = new Uint8Array([]);
+            expect(() => unpackMessage(emptyData)).toThrow("Cannot unpack empty message");
+        });
+        const invalidLengthTests = [
+            { type: MESSAGE_TYPE.ACTION_START, name: "START" },
+            { type: MESSAGE_TYPE.RSC_START, name: "START" },
+            { type: MESSAGE_TYPE.ACTION_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.RSC_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.ACTION_END, name: "END" },
+            { type: MESSAGE_TYPE.RSC_END, name: "END" },
+            { type: MESSAGE_TYPE.ACTION_ERROR, name: "ERROR" },
+        ];
+        invalidLengthTests.forEach(({ type, name }) => {
+            it(`should throw for invalid ${name} message length on unpack`, () => {
+                const invalidData = new Uint8Array([type, 1, 2, 3]); // Too short
+                expect(() => unpackMessage(invalidData)).toThrow(`Invalid ${name} message length`);
+            });
+        });
+        const invalidIdTests = [
+            { type: MESSAGE_TYPE.ACTION_START, name: "START" },
+            { type: MESSAGE_TYPE.RSC_START, name: "START" },
+            { type: MESSAGE_TYPE.ACTION_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.RSC_CHUNK, name: "CHUNK" },
+            { type: MESSAGE_TYPE.ACTION_END, name: "END" },
+            { type: MESSAGE_TYPE.RSC_END, name: "END" },
+            { type: MESSAGE_TYPE.ACTION_ERROR, name: "ERROR" },
+        ];
+        invalidIdTests.forEach(({ type, name }) => {
+            it(`should throw for invalid ID length on ${name} message pack`, () => {
+                const message = {
+                    type,
+                    id: "short-id",
+                    status: 200, // For START types
+                    payload: new Uint8Array(), // For CHUNK types
+                    error: "", // For ERROR type
+                };
+                expect(() => packMessage(message)).toThrow(`Invalid message ID length for ${name} message`);
+            });
+        });
+    });
+});

package/dist/runtime/lib/realtime/shared.test.d.ts

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

package/dist/runtime/lib/realtime/shared.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { MESSAGE_TYPE } from "./shared";
+describe("Realtime Shared Constants", () => {
+    it("MESSAGE_TYPE should match snapshot", () => {
+        expect(MESSAGE_TYPE).toMatchInlineSnapshot(`
+      {
+        "ACTION_CHUNK": 5,
+        "ACTION_END": 6,
+        "ACTION_ERROR": 7,
+        "ACTION_REQUEST": 3,
+        "ACTION_START": 4,
+        "RSC_CHUNK": 1,
+        "RSC_END": 2,
+        "RSC_START": 0,
+      }
+    `);
+    });
+});

package/dist/runtime/lib/realtime/validateUpgradeRequest.test.d.ts

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

package/dist/runtime/lib/realtime/validateUpgradeRequest.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { validateUpgradeRequest } from "./validateUpgradeRequest";
+describe("validateUpgradeRequest", () => {
+    it("should return valid for a correct WebSocket upgrade request", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(true);
+    });
+    it("should return invalid if Upgrade header is not 'websocket'", async () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "not-websocket",
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(400);
+            await expect(result.response?.text()).resolves.toBe("Expected WebSocket");
+        }
+    });
+    it("should return invalid if Upgrade header is missing", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Origin: "http://localhost:8787",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(400);
+        }
+    });
+    it("should return invalid if Origin header is missing", async () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(403);
+            await expect(result.response?.text()).resolves.toBe("Invalid origin");
+        }
+    });
+    it("should return invalid if Origin does not match request URL", () => {
+        const request = new Request("http://localhost:8787/ws", {
+            headers: {
+                Upgrade: "websocket",
+                Origin: "http://another-domain.com",
+            },
+        });
+        const result = validateUpgradeRequest(request);
+        expect(result.valid).toBe(false);
+        if (!result.valid) {
+            expect(result.response?.status).toBe(403);
+        }
+    });
+});

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("../../requestInfo/types").RequestInfo<any, import("../../requestInfo/types").DefaultAppContext>>;
+export declare const realtimeRoute: (getDurableObjectNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<RealtimeDurableObject>) => import("../router").RouteDefinition<import("../../worker").RequestInfo<any, import("../../worker").DefaultAppContext>>;

package/dist/runtime/lib/realtime/worker.js

@@ -1,7 +1,7 @@
+import { env } from "cloudflare:workers";
 import { route } from "../../entries/router";
-import { validateUpgradeRequest } from "./validateUpgradeRequest";
 import { DEFAULT_REALTIME_KEY } from "./constants";
-import { env } from "cloudflare:workers";
+import { validateUpgradeRequest } from "./validateUpgradeRequest";
 export { renderRealtimeClients } from "./renderRealtimeClients";
 export const realtimeRoute = (getDurableObjectNamespace) => route("/__realtime", async function ({ request }) {
     const validation = validateUpgradeRequest(request);

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

@@ -1,6 +1,6 @@
+import type { Kysely } from "kysely";
 import React from "react";
 import { RequestInfo } from "../requestInfo/types";
-import type { Kysely } from "kysely";
 export type DocumentProps<T extends RequestInfo = RequestInfo> = T & {
     children: React.ReactNode;
 };

package/dist/runtime/lib/router.js

@@ -97,30 +97,38 @@ export function defineRoutes(routes) {
                 return undefined;
             }
             // --- Main flow ---
-            const globalMiddlewares = flattenedRoutes.filter((route) => typeof route === "function");
-            const routeDefinitions = flattenedRoutes.filter((route) => typeof route !== "function");
-            // 1. Run global middlewares
-            for (const middleware of globalMiddlewares) {
-                const result = await middleware(getRequestInfo());
-                const handled = await handleMiddlewareResult(result);
-                if (handled) {
-                    return handled;
+            let firstRouteDefinitionEncountered = false;
+            let actionHandled = false;
+            const handleAction = async () => {
+                if (!actionHandled && url.searchParams.has("__rsc_action_id")) {
+                    getRequestInfo().rw.actionResult = await rscActionHandler(request);
+                    actionHandled = true;
+                }
+            };
+            for (const route of flattenedRoutes) {
+                if (typeof route === "function") {
+                    // This is a global middleware.
+                    const result = await route(getRequestInfo());
+                    const handled = await handleMiddlewareResult(result);
+                    if (handled) {
+                        return handled; // Short-circuit
+                    }
+                    continue;
+                }
+                // This is a RouteDefinition.
+                // The first time we see one, we handle any RSC actions.
+                if (!firstRouteDefinitionEncountered) {
+                    firstRouteDefinitionEncountered = true;
+                    await handleAction();
                 }
-            }
-            // 2. Handle RSC actions
-            if (url.searchParams.has("__rsc_action_id")) {
-                getRequestInfo().rw.actionResult = await rscActionHandler(request);
-            }
-            // 3. Match and handle routes
-            for (const route of routeDefinitions) {
                 const params = matchPath(route.path, path);
                 if (!params) {
-                    continue;
+                    continue; // Not a match, keep going.
                 }
-                // Found a match: run route-specific middlewares, then the final component
+                // Found a match: run route-specific middlewares, then the final component, then stop.
                 return await runWithRequestInfoOverrides({ params }, async () => {
                     const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
-                    // 3a. Route-specific middlewares
+                    // Route-specific middlewares
                     for (const mw of routeMiddlewares) {
                         const result = await mw(getRequestInfo());
                         const handled = await handleMiddlewareResult(result);
@@ -128,7 +136,7 @@ export function defineRoutes(routes) {
                             return handled;
                         }
                     }
-                    // 3b. Final component/handler
+                    // Final component/handler
                     if (isRouteComponent(componentHandler)) {
                         const requestInfo = getRequestInfo();
                         const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(componentHandler), route.layouts || [], requestInfo);
@@ -148,7 +156,11 @@ export function defineRoutes(routes) {
                     });
                 });
             }
-            // No route matched
+            // If we've gotten this far, no route was matched.
+            // We still need to handle a possible action if the app has no route definitions at all.
+            if (!firstRouteDefinitionEncountered) {
+                await handleAction();
+            }
             return new Response("Not Found", { status: 404 });
         },
     };
@@ -168,8 +180,14 @@ export function index(handler) {
 export function prefix(prefixPath, routes) {
     return routes.map((r) => {
         if (typeof r === "function") {
-            // Pass through middleware as-is
-            return r;
+            const middleware = (requestInfo) => {
+                const url = new URL(requestInfo.request.url);
+                if (url.pathname.startsWith(prefixPath)) {
+                    return r(requestInfo);
+                }
+                return;
+            };
+            return middleware;
         }
         if (Array.isArray(r)) {
             // Recursively process nested route arrays