rwsdk 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/lib/e2e/testHarness.mjs

@@ -4,44 +4,12 @@ import path, { basename, dirname, join as pathJoin } from "path";
 import puppeteer from "puppeteer-core";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, test, } from "vitest";
 import { launchBrowser } from "./browser.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";
-const SETUP_PLAYGROUND_ENV_TIMEOUT = process.env
-    .RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT
-    ? parseInt(process.env.RWSDK_SETUP_PLAYGROUND_ENV_TIMEOUT, 10)
-    : 15 * 60 * 1000;
-const DEPLOYMENT_TIMEOUT = process.env.RWSDK_DEPLOYMENT_TIMEOUT
-    ? parseInt(process.env.RWSDK_DEPLOYMENT_TIMEOUT, 10)
-    : 5 * 60 * 1000;
-const DEPLOYMENT_MIN_TRIES = process.env.RWSDK_DEPLOYMENT_MIN_TRIES
-    ? parseInt(process.env.RWSDK_DEPLOYMENT_MIN_TRIES, 10)
-    : 5;
-const DEPLOYMENT_CHECK_TIMEOUT = process.env.RWSDK_DEPLOYMENT_CHECK_TIMEOUT
-    ? parseInt(process.env.RWSDK_DEPLOYMENT_CHECK_TIMEOUT, 10)
-    : 5 * 60 * 1000;
-const PUPPETEER_TIMEOUT = process.env.RWSDK_PUPPETEER_TIMEOUT
-    ? parseInt(process.env.RWSDK_PUPPETEER_TIMEOUT, 10)
-    : 60 * 1000 * 2;
-const HYDRATION_TIMEOUT = process.env.RWSDK_HYDRATION_TIMEOUT
-    ? parseInt(process.env.RWSDK_HYDRATION_TIMEOUT, 10)
-    : 5000;
-const DEV_SERVER_TIMEOUT = process.env.RWSDK_DEV_SERVER_TIMEOUT
-    ? parseInt(process.env.RWSDK_DEV_SERVER_TIMEOUT, 10)
-    : 5 * 60 * 1000;
-const DEV_SERVER_MIN_TRIES = process.env.RWSDK_DEV_SERVER_MIN_TRIES
-    ? parseInt(process.env.RWSDK_DEV_SERVER_MIN_TRIES, 10)
-    : 5;
-const SETUP_WAIT_TIMEOUT = process.env.RWSDK_SETUP_WAIT_TIMEOUT
-    ? parseInt(process.env.RWSDK_SETUP_WAIT_TIMEOUT, 10)
-    : 10 * 60 * 1000;
-const TEST_MAX_RETRIES = process.env.RWSDK_TEST_MAX_RETRIES
-    ? parseInt(process.env.RWSDK_TEST_MAX_RETRIES, 10)
-    : 10;
-const TEST_MAX_RETRIES_PER_CODE = process.env.RWSDK_TEST_MAX_RETRIES_PER_CODE
-    ? parseInt(process.env.RWSDK_TEST_MAX_RETRIES_PER_CODE, 10)
-    : 6;
+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";
 const SKIP_DEPLOYMENT_TESTS = process.env.RWSDK_SKIP_DEPLOY === "1";
@@ -52,6 +20,8 @@ let globalDevInstancePromise = null;
 let globalDeploymentInstancePromise = null;
 let globalDevInstance = null;
 let globalDeploymentInstance = null;
+const devInstances = [];
+const deploymentInstances = [];
 let hooksRegistered = false;
 /**
  * Registers global cleanup hooks automatically
@@ -62,11 +32,11 @@ function ensureHooksRegistered() {
     // Register global afterAll to clean up the playground environment
     afterAll(async () => {
         const cleanupPromises = [];
-        if (globalDevInstance) {
-            cleanupPromises.push(globalDevInstance.stopDev());
+        for (const instance of devInstances) {
+            cleanupPromises.push(instance.stopDev());
         }
-        if (globalDeploymentInstance) {
-            cleanupPromises.push(globalDeploymentInstance.cleanup());
+        for (const instance of deploymentInstances) {
+            cleanupPromises.push(instance.cleanup());
         }
         if (globalDevPlaygroundEnv) {
             cleanupPromises.push(globalDevPlaygroundEnv.cleanup());
@@ -75,8 +45,8 @@ function ensureHooksRegistered() {
             cleanupPromises.push(globalDeployPlaygroundEnv.cleanup());
         }
         await Promise.all(cleanupPromises);
-        globalDevInstance = null;
-        globalDeploymentInstance = null;
+        devInstances.length = 0;
+        deploymentInstances.length = 0;
         globalDevPlaygroundEnv = null;
         globalDeployPlaygroundEnv = null;
     });
@@ -114,7 +84,7 @@ function getPlaygroundDirFromImportMeta(importMetaUrl) {
  * and installs dependencies using a tarball of the SDK.
  * This ensures that tests run in a clean, isolated environment.
  */
-export function setupPlaygroundEnvironment(options = {}) {
+export function setupPlaygroundEnvironment(options) {
     const { sourceProjectDir, monorepoRoot, dev = true, deploy = true, } = typeof options === "string" ? { sourceProjectDir: options } : options;
     ensureHooksRegistered();
     beforeAll(async () => {
@@ -141,7 +111,8 @@ export function setupPlaygroundEnvironment(options = {}) {
                 projectDir: devEnv.targetDir,
                 cleanup: devEnv.cleanup,
             };
-            globalDevInstancePromise = createDevServer(devEnv.targetDir).then((instance) => {
+            const devControl = createDevServer();
+            globalDevInstancePromise = devControl.start().then((instance) => {
                 globalDevInstance = instance;
                 return instance;
             });
@@ -150,7 +121,7 @@ export function setupPlaygroundEnvironment(options = {}) {
             globalDevInstancePromise.catch(() => { });
         }
         else {
-            globalDevInstancePromise = Promise.resolve(null);
+            globalDevPlaygroundEnv = null;
         }
         if (deploy) {
             const deployEnv = await setupTarballEnvironment({
@@ -162,7 +133,10 @@ export function setupPlaygroundEnvironment(options = {}) {
                 projectDir: deployEnv.targetDir,
                 cleanup: deployEnv.cleanup,
             };
-            globalDeploymentInstancePromise = createDeployment(deployEnv.targetDir).then((instance) => {
+            const deployControl = createDeployment();
+            globalDeploymentInstancePromise = deployControl
+                .start()
+                .then((instance) => {
                 globalDeploymentInstance = instance;
                 return instance;
             });
@@ -170,7 +144,7 @@ export function setupPlaygroundEnvironment(options = {}) {
             globalDeploymentInstancePromise.catch(() => { });
         }
         else {
-            globalDeploymentInstancePromise = Promise.resolve(null);
+            globalDeployPlaygroundEnv = null;
         }
     }, SETUP_PLAYGROUND_ENV_TIMEOUT);
 }
@@ -178,82 +152,106 @@ export function setupPlaygroundEnvironment(options = {}) {
  * Creates a dev server instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export async function createDevServer(projectDir) {
-    if (SKIP_DEV_SERVER_TESTS) {
-        throw new Error("Dev server tests are skipped via RWSDK_SKIP_DEV=1");
+export function createDevServer() {
+    ensureHooksRegistered();
+    if (!globalDevPlaygroundEnv) {
+        throw new Error("Dev playground environment not initialized. Enable `dev: true` in setupPlaygroundEnvironment.");
     }
+    const { projectDir } = globalDevPlaygroundEnv;
     const packageManager = process.env.PACKAGE_MANAGER || "pnpm";
-    const devResult = await pollValue(() => runDevServer(packageManager, projectDir), {
-        timeout: DEV_SERVER_TIMEOUT,
-        minTries: DEV_SERVER_MIN_TRIES,
-        onRetry: (error, tries) => {
-            console.log(`Retrying dev server creation (attempt ${tries})... Error: ${error.message}`);
-        },
-    });
+    let instance = null;
     return {
-        url: devResult.url,
-        stopDev: devResult.stopDev,
+        projectDir,
+        start: async () => {
+            if (instance)
+                return instance;
+            if (SKIP_DEV_SERVER_TESTS) {
+                throw new Error("Dev server tests are skipped via RWSDK_SKIP_DEV=1");
+            }
+            const devResult = await pollValue(() => runDevServer(packageManager, projectDir), {
+                timeout: DEV_SERVER_TIMEOUT,
+                minTries: DEV_SERVER_MIN_TRIES,
+                onRetry: (error, tries) => {
+                    console.log(`Retrying dev server creation (attempt ${tries})... Error: ${error.message}`);
+                },
+            });
+            instance = {
+                url: devResult.url,
+                projectDir,
+                stopDev: devResult.stopDev,
+            };
+            devInstances.push(instance);
+            return instance;
+        },
     };
 }
 /**
  * Creates a deployment instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export async function createDeployment(projectDir) {
-    if (SKIP_DEPLOYMENT_TESTS) {
-        throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
+export function createDeployment() {
+    ensureHooksRegistered();
+    if (!globalDeployPlaygroundEnv) {
+        throw new Error("Deploy playground environment not initialized. Enable `deploy: true` in setupPlaygroundEnvironment.");
     }
-    return await pollValue(async () => {
-        // Extract the unique key from the project directory name instead of generating a new one
-        // The directory name format is: {projectName}-e2e-test-{randomId}
-        const dirName = basename(projectDir);
-        const match = dirName.match(/-e2e-test-([a-f0-9]+)$/);
-        const resourceUniqueKey = match
-            ? match[1]
-            : Math.random().toString(36).substring(2, 15);
-        const deployResult = await runRelease(projectDir, projectDir, resourceUniqueKey);
-        // Poll the URL to ensure it's live before proceeding
-        await poll(async () => {
-            try {
-                const response = await fetch(deployResult.url);
-                // We consider any response (even 4xx or 5xx) as success,
-                // as it means the worker is routable.
-                return response.status > 0;
-            }
-            catch (e) {
-                return false;
+    const { projectDir } = globalDeployPlaygroundEnv;
+    let instance = null;
+    return {
+        projectDir,
+        start: async () => {
+            if (instance)
+                return instance;
+            if (SKIP_DEPLOYMENT_TESTS) {
+                throw new Error("Deployment tests are skipped via RWSDK_SKIP_DEPLOY=1");
             }
-        }, {
-            timeout: DEPLOYMENT_CHECK_TIMEOUT,
-        });
-        const cleanup = async () => {
-            // Run deployment cleanup in background without blocking
-            const performCleanup = async () => {
-                if (isRelatedToTest(deployResult.workerName, resourceUniqueKey)) {
-                    await deleteWorker(deployResult.workerName, projectDir, resourceUniqueKey);
-                }
-                await deleteD1Database(resourceUniqueKey, projectDir, resourceUniqueKey);
-            };
-            // Start cleanup in background and return immediately
-            performCleanup().catch((error) => {
-                console.warn(`Warning: Background deployment cleanup failed: ${error.message}`);
+            const newInstance = await pollValue(async () => {
+                const dirName = basename(projectDir);
+                const match = dirName.match(/-e2e-test-([a-f0-9]+)$/);
+                const resourceUniqueKey = match
+                    ? match[1]
+                    : Math.random().toString(36).substring(2, 15);
+                const deployResult = await runRelease(projectDir, projectDir, resourceUniqueKey);
+                await poll(async () => {
+                    try {
+                        const response = await fetch(deployResult.url);
+                        return response.status > 0;
+                    }
+                    catch (e) {
+                        return false;
+                    }
+                }, {
+                    timeout: DEPLOYMENT_CHECK_TIMEOUT,
+                });
+                const cleanup = async () => {
+                    const performCleanup = async () => {
+                        if (isRelatedToTest(deployResult.workerName, resourceUniqueKey)) {
+                            await deleteWorker(deployResult.workerName, projectDir, resourceUniqueKey);
+                        }
+                        await deleteD1Database(resourceUniqueKey, projectDir, resourceUniqueKey);
+                    };
+                    performCleanup().catch((error) => {
+                        console.warn(`Warning: Background deployment cleanup failed: ${error.message}`);
+                    });
+                    return Promise.resolve();
+                };
+                return {
+                    url: deployResult.url,
+                    workerName: deployResult.workerName,
+                    resourceUniqueKey,
+                    projectDir: projectDir,
+                    cleanup,
+                };
+            }, {
+                timeout: DEPLOYMENT_TIMEOUT,
+                minTries: DEPLOYMENT_MIN_TRIES,
+                onRetry: (error, tries) => {
+                    console.log(`Retrying deployment creation (attempt ${tries})... Error: ${error.message}`);
+                },
             });
-            return Promise.resolve();
-        };
-        return {
-            url: deployResult.url,
-            workerName: deployResult.workerName,
-            resourceUniqueKey,
-            projectDir: projectDir,
-            cleanup,
-        };
-    }, {
-        timeout: DEPLOYMENT_TIMEOUT,
-        minTries: DEPLOYMENT_MIN_TRIES,
-        onRetry: (error, tries) => {
-            console.log(`Retrying deployment creation (attempt ${tries})... Error: ${error.message}`);
+            deploymentInstances.push(newInstance);
+            return newInstance;
         },
-    });
+    };
 }
 /**
  * Executes a test function with a retry mechanism for specific error codes.
@@ -302,7 +300,7 @@ function createTestRunner(testFn, envType) {
     return (name, testLogic) => {
         if ((envType === "dev" && SKIP_DEV_SERVER_TESTS) ||
             (envType === "deploy" && SKIP_DEPLOYMENT_TESTS)) {
-            test.skip(name, () => { });
+            test.skip(`${name} (${envType})`, () => { });
             return;
         }
         describe.concurrent(name, () => {
@@ -364,12 +362,86 @@ function createTestRunner(testFn, envType) {
                         browser: browser,
                         page: page,
                         url: instance.url,
+                        projectDir: instance
+                            .projectDir,
                     });
                 });
             });
         });
     };
 }
+/**
+ * Creates a low-level test runner that provides utilities for creating
+ * tests that need to perform setup actions before the server starts.
+ */
+function createSDKTestRunner() {
+    const internalRunner = (testFn) => {
+        return (name, testLogic) => {
+            describe.concurrent(name, () => {
+                let page;
+                let browser;
+                beforeAll(async () => {
+                    const tempDir = path.join(os.tmpdir(), "rwsdk-e2e-tests");
+                    const wsEndpointFile = path.join(tempDir, "wsEndpoint");
+                    try {
+                        const wsEndpoint = await fs.readFile(wsEndpointFile, "utf-8");
+                        browser = await puppeteer.connect({
+                            browserWSEndpoint: wsEndpoint,
+                        });
+                    }
+                    catch (error) {
+                        console.warn("Failed to connect to existing browser instance. " +
+                            "This might happen if you are running a single test file. " +
+                            "Launching a new browser instance instead.");
+                        browser = await launchBrowser();
+                    }
+                }, SETUP_WAIT_TIMEOUT);
+                afterAll(async () => {
+                    if (browser) {
+                        await browser.disconnect();
+                    }
+                });
+                beforeEach(async () => {
+                    if (!globalDevPlaygroundEnv && !globalDeployPlaygroundEnv) {
+                        throw new Error("Test environment not initialized. Call setupPlaygroundEnvironment() in your test file.");
+                    }
+                    page = await browser.newPage();
+                    page.setDefaultTimeout(PUPPETEER_TIMEOUT);
+                }, SETUP_WAIT_TIMEOUT);
+                afterEach(async () => {
+                    if (page) {
+                        try {
+                            await page.close();
+                        }
+                        catch (error) {
+                            console.warn(`Suppressing error during page.close() in test "${name}":`, error);
+                        }
+                    }
+                });
+                testFn(">", async () => {
+                    if (!browser) {
+                        throw new Error("Test environment not ready.");
+                    }
+                    await runTestWithRetries(name, async () => {
+                        await testLogic({
+                            browser: browser,
+                            page: page,
+                            projectDir: globalDevPlaygroundEnv?.projectDir ||
+                                globalDeployPlaygroundEnv?.projectDir ||
+                                "",
+                        });
+                    });
+                });
+            });
+        };
+    };
+    const main = internalRunner(test);
+    return Object.assign(main, {
+        only: internalRunner(test.only),
+        skip: test.skip,
+    });
+}
+export const testSDK = createSDKTestRunner();
 /**
  * High-level test wrapper for dev server tests.
  * Automatically skips if RWSDK_SKIP_DEV=1

package/dist/runtime/client/client.d.ts

@@ -1,6 +1,7 @@
 import "./setWebpackRequire";
 export { default as React } from "react";
 export { ClientOnly } from "./ClientOnly.js";
+export { initClientNavigation, navigate } from "./navigation.js";
 import type { HydrationOptions, Transport } from "./types";
 export declare const fetchTransport: Transport;
 export declare const initClient: ({ transport, hydrateRootOptions, handleResponse, }?: {

package/dist/runtime/client/client.js

@@ -4,6 +4,7 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 // context(justinvdm, 14 Aug 2025): `react-server-dom-webpack` uses this global
 // to load modules, so we need to define it here before importing
 // "react-server-dom-webpack."
+// prettier-ignore
 import "./setWebpackRequire";
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
@@ -11,6 +12,7 @@ import { createFromFetch, createFromReadableStream, encodeReply, } from "react-s
 import { rscStream } from "rsc-html-stream/client";
 export { default as React } from "react";
 export { ClientOnly } from "./ClientOnly.js";
+export { initClientNavigation, navigate } from "./navigation.js";
 export const fetchTransport = (transportContext) => {
     const fetchCallServer = async (id, args) => {
         const url = new URL(window.location.href);

package/dist/runtime/client/navigation.d.ts

@@ -4,6 +4,14 @@ export interface ClientNavigationOptions {
     scrollBehavior?: "auto" | "smooth" | "instant";
 }
 export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
+export interface NavigateOptions {
+    history?: "push" | "replace";
+    info?: {
+        scrollToTop?: boolean;
+        scrollBehavior?: "auto" | "smooth" | "instant";
+    };
+}
+export declare function navigate(href: string, options?: NavigateOptions): Promise<void>;
 export declare function initClientNavigation(opts?: ClientNavigationOptions): {
     handleResponse: (response: Response) => boolean;
 };

package/dist/runtime/client/navigation.js

@@ -1,10 +1,3 @@
-function saveScrollPosition(x, y) {
-    window.history.replaceState({
-        ...window.history.state,
-        scrollX: x,
-        scrollY: y,
-    }, "", window.location.href);
-}
 export function validateClickEvent(event, target) {
     // should this only work for left click?
     if (event.button !== 0) {
@@ -37,19 +30,44 @@ export function validateClickEvent(event, target) {
     }
     return true;
 }
+let IS_CLIENT_NAVIGATION = false;
+export async function navigate(href, options = { history: "push" }) {
+    if (!IS_CLIENT_NAVIGATION) {
+        window.location.href = href;
+        return;
+    }
+    saveScrollPosition(window.scrollX, window.scrollY);
+    const url = window.location.origin + href;
+    if (options.history === "push") {
+        window.history.pushState({ path: href }, "", url);
+    }
+    else {
+        window.history.replaceState({ path: href }, "", url);
+    }
+    // @ts-expect-error
+    await globalThis.__rsc_callServer();
+    const scrollToTop = options.info?.scrollToTop ?? true;
+    const scrollBehavior = options.info?.scrollBehavior ?? "instant";
+    if (scrollToTop && history.scrollRestoration === "auto") {
+        window.scrollTo({
+            top: 0,
+            left: 0,
+            behavior: scrollBehavior,
+        });
+        saveScrollPosition(0, 0);
+    }
+}
+function saveScrollPosition(x, y) {
+    window.history.replaceState({
+        ...window.history.state,
+        scrollX: x,
+        scrollY: y,
+    }, "", window.location.href);
+}
 export function initClientNavigation(opts = {}) {
-    const options = {
-        onNavigate: async function onNavigate() {
-            // @ts-expect-error
-            await globalThis.__rsc_callServer();
-        },
-        scrollToTop: true,
-        scrollBehavior: "instant",
-        ...opts,
-    };
+    IS_CLIENT_NAVIGATION = true;
     history.scrollRestoration = "auto";
     document.addEventListener("click", async function handleClickEvent(event) {
-        // Prevent default navigation
         if (!validateClickEvent(event, event.target)) {
             return;
         }
@@ -57,28 +75,18 @@ export function initClientNavigation(opts = {}) {
         const el = event.target;
         const a = el.closest("a");
         const href = a?.getAttribute("href");
-        saveScrollPosition(window.scrollX, window.scrollY);
-        window.history.pushState({ path: href }, "", window.location.origin + href);
-        await options.onNavigate();
-        if (options.scrollToTop && history.scrollRestoration === "auto") {
-            window.scrollTo({
-                top: 0,
-                left: 0,
-                behavior: options.scrollBehavior,
-            });
-            saveScrollPosition(0, 0);
-        }
-        history.scrollRestoration = "auto";
+        navigate(href);
     }, true);
     window.addEventListener("popstate", async function handlePopState() {
-        saveScrollPosition(window.scrollX, window.scrollY);
-        await options.onNavigate();
+        // @ts-expect-error
+        await globalThis.__rsc_callServer();
     });
     // Return a handleResponse function for use with initClient
     return {
         handleResponse: function handleResponse(response) {
             if (!response.ok) {
                 // Redirect to the current page (window.location) to show the error
+                // This means the page that produced the error is called twice.
                 window.location.href = window.location.href;
                 return false;
             }

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

@@ -1,2 +1,3 @@
 import "./types/ssr";
 export * from "../lib/streams/consumeEventStream";
+export declare const navigate: () => void;

package/dist/runtime/entries/clientSSR.js

@@ -1,2 +1,5 @@
 import "./types/ssr";
 export * from "../lib/streams/consumeEventStream";
+export const navigate = () => {
+    /* stub */
+};

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

@@ -1,3 +1,2 @@
 import { Kysely } from "kysely";
-import { type SqliteDurableObject } from "./index.js";
-export declare function createDb<T>(durableObjectBinding: DurableObjectNamespace<SqliteDurableObject>, name?: string): Kysely<T>;
+export declare function createDb<DatabaseType>(durableObjectBinding: DurableObjectNamespace<any>, name?: string): Kysely<DatabaseType>;

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

@@ -5,6 +5,10 @@ export function createDb(durableObjectBinding, name = "main") {
         dialect: new DOWorkerDialect({
             kyselyExecuteQuery: (...args) => {
                 const durableObjectId = durableObjectBinding.idFromName(name);
+                // context(justinvdm, 2 Oct 2025): First prize would be a type parameter
+                // for the durable object and then use it for `durableObjectBinding`'s
+                // type, rather than casting like this. However, that would prevent
+                // users from being able to do createDb<InferredDbType> then though.
                 const stub = durableObjectBinding.get(durableObjectId);
                 stub.initialize();
                 return stub.kyselyExecuteQuery(...args);

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

@@ -8,4 +8,4 @@ export interface ManifestChunk {
     css?: string[];
     assets?: string[];
 }
-export declare const getManifest: () => Promise<Manifest>;
+export declare function getManifest(): Promise<Manifest>;

package/dist/runtime/lib/manifest.js

@@ -1,14 +1,17 @@
 let manifest;
-export const getManifest = async () => {
+export async function getManifest() {
     if (manifest) {
         return manifest;
     }
     if (import.meta.env.VITE_IS_DEV_SERVER) {
+        // In dev, there's no manifest, so we can use an empty object.
         manifest = {};
     }
     else {
-        const { default: prodManifest } = await import("virtual:rwsdk:manifest.js");
-        manifest = prodManifest;
+        // context(justinvdm, 2 Oct 2025): In production, the manifest is a
+        // placeholder string that will be replaced by the linker plugin with the
+        // actual manifest JSON object.
+        manifest = "__RWSDK_MANIFEST_PLACEHOLDER__";
     }
     return manifest;
-};
+}

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

@@ -1,7 +1,13 @@
-import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+// context(justinvdm, 14 Aug 2025): `react-server-dom-webpack` uses this globa ___webpack_require__ global,
+// so we need to import our client entry point (which sets it), before importing
+// prettier-ignore
 import { initClient } from "../../client/client";
-import { packMessage, unpackMessage, } from "./protocol";
+// prettier-ignore
+import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
+// prettier-ignore
 import { MESSAGE_TYPE } from "./shared";
+// prettier-ignore
+import { packMessage, unpackMessage, } from "./protocol";
 const DEFAULT_KEY = "default";
 export const initRealtimeClient = ({ key = DEFAULT_KEY, handleResponse, } = {}) => {
     const transport = realtimeTransport({ key, handleResponse });

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

@@ -1,24 +1,6 @@
-import type { Kysely } from "kysely";
 import React from "react";
 import { RequestInfo } from "../requestInfo/types";
-export type DocumentProps<T extends RequestInfo = RequestInfo> = T & {
-    children: React.ReactNode;
-};
-export type LayoutProps<T extends RequestInfo = RequestInfo> = {
-    children?: React.ReactNode;
-    requestInfo?: T;
-};
-export type RwContext = {
-    nonce: string;
-    Document: React.FC<DocumentProps<any>>;
-    rscPayload: boolean;
-    ssr: boolean;
-    layouts?: React.FC<LayoutProps<any>>[];
-    databases: Map<string, Kysely<any>>;
-    scriptsToBeLoaded: Set<string>;
-    pageRouteResolved: PromiseWithResolvers<void> | undefined;
-    actionResult?: unknown;
-};
+import type { DocumentProps, LayoutProps } from "./types.js";
 export type RouteMiddleware<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response | void>;
 type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<Response>;
 type MaybePromise<T> = T | Promise<T>;

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

@@ -71,6 +71,8 @@ describe("defineRoutes - Request Handling Behavior", () => {
                 ssr: true,
                 databases: new Map(),
                 scriptsToBeLoaded: new Set(),
+                entryScripts: new Set(),
+                inlineScripts: new Set(),
                 pageRouteResolved: undefined,
             },
             cf: {},

package/dist/runtime/lib/{rwContext.d.ts → types.d.ts}

@@ -1,4 +1,5 @@
 import { type Kysely } from "kysely";
+import React from "react";
 import { type RequestInfo } from "../requestInfo/types.js";
 export type RwContext = {
     nonce: string;

package/dist/runtime/render/renderDocumentHtmlStream.d.ts

@@ -1,4 +1,4 @@
-import { type DocumentProps } from "../lib/router.js";
+import { type DocumentProps } from "../lib/types.js";
 import { type RequestInfo } from "../requestInfo/types.js";
 export declare const renderDocumentHtmlStream: ({ rscPayloadStream, Document, requestInfo, shouldSSR, onError, }: {
     rscPayloadStream: ReadableStream;