rwsdk 0.2.0-alpha.9 → 0.3.0

package/dist/lib/constants.d.mts

@@ -1,4 +1,9 @@
 export declare const ROOT_DIR: string;
 export declare const SRC_DIR: string;
 export declare const DIST_DIR: string;
-export declare const SSR_BRIDGE_PATH: string;
+export declare const VITE_DIR: string;
+export declare const INTERMEDIATES_OUTPUT_DIR: string;
+export declare const CLIENT_BARREL_PATH: string;
+export declare const SERVER_BARREL_PATH: string;
+export declare const INTERMEDIATE_SSR_BRIDGE_PATH: string;
+export declare const CLIENT_MANIFEST_RELATIVE_PATH: string;

package/dist/lib/constants.mjs

@@ -3,4 +3,9 @@ const __dirname = new URL(".", import.meta.url).pathname;
 export const ROOT_DIR = resolve(__dirname, "..", "..");
 export const SRC_DIR = resolve(ROOT_DIR, "src");
 export const DIST_DIR = resolve(ROOT_DIR, "dist");
-export const SSR_BRIDGE_PATH = resolve(DIST_DIR, "worker", "__ssr_bridge.js");
+export const VITE_DIR = resolve(ROOT_DIR, "src", "vite");
+export const INTERMEDIATES_OUTPUT_DIR = resolve(DIST_DIR, "__intermediate_builds");
+export const CLIENT_BARREL_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-client-barrel.js");
+export const SERVER_BARREL_PATH = resolve(INTERMEDIATES_OUTPUT_DIR, "rwsdk-server-barrel.js");
+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/smokeTests/browser.mjs

@@ -316,25 +316,9 @@ export async function checkUrl(url, artifactDir, browserPath, headless = true, b
 export async function checkUrlSmoke(page, url, isRealtime, bail = false, skipClient = false, environment = "Development", timestampState, targetDir, skipHmr = false, skipStyleTests = false) {
     const phase = isRealtime ? "Post-upgrade" : "Initial";
     console.log(`🔍 Testing ${phase} smoke tests at ${url}`);
-    // Parse the base URL and path to properly handle smoke test queries
-    const parsedUrl = new URL(url);
-    log("Parsed URL: %O", {
-        origin: parsedUrl.origin,
-        pathname: parsedUrl.pathname,
-        search: parsedUrl.search,
-    });
-    // Add __smoke_test query parameter, preserving any existing query parameters
-    if (parsedUrl.searchParams.has("__smoke_test")) {
-        console.log(`URL already has __smoke_test parameter: ${url}`);
-    }
-    else {
-        parsedUrl.searchParams.append("__smoke_test", "1");
-        log("Added __smoke_test parameter to URL");
-    }
     // Navigate to smoke test page
-    const smokeUrl = parsedUrl.toString();
-    console.log(`🔍 Accessing smoke test page: ${smokeUrl}`);
-    await page.goto(smokeUrl, { waitUntil: "networkidle0" });
+    console.log(`🔍 Accessing smoke test page: ${url}`);
+    await page.goto(url, { waitUntil: "networkidle0" });
     log("Page loaded successfully");
     // Track failures to report at the end
     let hasFailures = false;
@@ -692,9 +676,9 @@ export async function checkClientSmoke(page, phase = "", environment = "Developm
         // Check if we're on a smoke test page - in which case missing the refresh button is a failure
         const currentUrl = page.url();
         log("Current URL: %s", currentUrl);
-        if (currentUrl.includes("__smoke_test")) {
-            log("ERROR: Smoke test page is missing the refresh-health button");
-            throw new Error("Smoke test page is missing the refresh-health button - this is a test failure");
+        if (!currentUrl.includes("/__smoke_test")) {
+            log("ERROR: Smoke test page is not the current URL");
+            throw new Error("Smoke test page is not the current URL - this is a test failure");
         }
         console.log("ℹ️ Basic page structure verified, continuing without client-side smoke test");
         return null;

package/dist/lib/smokeTests/codeUpdates.d.mts

@@ -6,4 +6,4 @@ export declare function createSmokeTestStylesheets(targetDir: string): Promise<v
 /**
  * Modifies the worker.tsx and wrangler.jsonc files to add realtime support
  */
-export declare function modifyAppForRealtime(targetDir: string): Promise<void>;
+export declare function modifyAppForRealtime(targetDir: string, skipClient?: boolean): Promise<void>;

package/dist/lib/smokeTests/codeUpdates.mjs

@@ -46,7 +46,7 @@ export async function createSmokeTestComponents(targetDir, skipClient = false) {
         log("Skipping client-side smoke test component creation");
     }
     // Modify worker.tsx and wrangler.jsonc for realtime support
-    await modifyAppForRealtime(targetDir);
+    await modifyAppForRealtime(targetDir, skipClient);
     log("Smoke test components created successfully");
     console.log("Created smoke test components:");
     console.log(`- ${smokeTestFunctionsPath}`);
@@ -104,7 +104,7 @@ export async function createSmokeTestStylesheets(targetDir) {
 /**
  * Modifies the worker.tsx and wrangler.jsonc files to add realtime support
  */
-export async function modifyAppForRealtime(targetDir) {
+export async function modifyAppForRealtime(targetDir, skipClient = false) {
     log("Modifying worker.tsx and wrangler.jsonc for realtime support");
     // Modify worker.tsx
     const workerPath = join(targetDir, "src", "worker.tsx");
@@ -118,8 +118,14 @@ export async function modifyAppForRealtime(targetDir) {
         const hasRealtimeExport = workerContent.includes('export { RealtimeDurableObject } from "rwsdk/realtime/durableObject"');
         const hasRealtimeRoute = workerContent.includes("realtimeRoute(");
         const hasEnvImport = workerContent.includes('import { env } from "cloudflare:workers"');
-        if (!hasRealtimeExport || !hasRealtimeRoute || !hasEnvImport) {
-            log("Need to modify worker.tsx for realtime support");
+        const hasSmokeTestImport = workerContent.includes('import { SmokeTest } from "@/app/components/__SmokeTest.tsx"');
+        const hasSmokeTestRoute = workerContent.includes('route("/__smoke_test", SmokeTest)');
+        if (!hasRealtimeExport ||
+            !hasRealtimeRoute ||
+            !hasEnvImport ||
+            !hasSmokeTestImport ||
+            !hasSmokeTestRoute) {
+            log("Need to modify worker.tsx for realtime and smoke test support");
             const s = new MagicString(workerContent);
             // Add the export line if it doesn't exist
             if (!hasRealtimeExport) {
@@ -145,6 +151,26 @@ export async function modifyAppForRealtime(targetDir) {
                     log("Added env import from cloudflare:workers");
                 }
             }
+            // Add SmokeTest import if it doesn't exist
+            if (!hasSmokeTestImport) {
+                const importRegex = /import.*?from.*?;\n/g;
+                let lastImportMatch;
+                let lastImportPosition = 0;
+                // Find the position after the last import statement
+                while ((lastImportMatch = importRegex.exec(workerContent)) !== null) {
+                    lastImportPosition =
+                        lastImportMatch.index + lastImportMatch[0].length;
+                }
+                if (lastImportPosition > 0) {
+                    s.appendRight(lastImportPosition, 'import { SmokeTest } from "@/app/components/__SmokeTest";\n');
+                    log("Added SmokeTest import");
+                }
+                else {
+                    // if no imports found, just prepend to the file
+                    s.prepend('import { SmokeTest } from "@/app/components/__SmokeTest";\n');
+                    log("Added SmokeTest import to the beginning of the file");
+                }
+            }
             // Add the realtimeRoute line if it doesn't exist
             if (!hasRealtimeRoute) {
                 const defineAppMatch = workerContent.match(/export default defineApp\(\[/);
@@ -154,6 +180,16 @@ export async function modifyAppForRealtime(targetDir) {
                     log("Added realtimeRoute to defineApp");
                 }
             }
+            // Add the smoke test route if it doesn't exist
+            if (!hasSmokeTestRoute) {
+                const defineAppRegex = /(export default defineApp\(\[)([\s\S]*)(\]\);)/m;
+                const match = workerContent.match(defineAppRegex);
+                if (match) {
+                    const insertionPoint = match.index + match[1].length + match[2].length;
+                    s.appendLeft(insertionPoint, '  render(Document, [route("/__smoke_test", SmokeTest)]),\n');
+                    log("Added smoke test route to defineApp");
+                }
+            }
             // Import realtimeRoute if it's not already imported
             if (!workerContent.includes("realtimeRoute")) {
                 // First check if we already have the import from rwsdk/realtime/worker
@@ -196,7 +232,7 @@ export async function modifyAppForRealtime(targetDir) {
             log("Successfully modified worker.tsx");
         }
         else {
-            log("worker.tsx already has realtime support, no changes needed");
+            log("worker.tsx already has realtime and smoke test support, no changes needed");
         }
     }
     else {

package/dist/lib/smokeTests/development.d.mts

@@ -8,4 +8,4 @@ export declare function runDevServer(cwd?: string): Promise<{
 /**
  * Runs tests against the development server
  */
-export declare function runDevTest(url: string, artifactDir: string, customPath?: string, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, realtime?: boolean, skipHmr?: boolean, skipStyleTests?: boolean): Promise<void>;
+export declare function runDevTest(url: string, artifactDir: string, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, realtime?: boolean, skipHmr?: boolean, skipStyleTests?: boolean): Promise<void>;

package/dist/lib/smokeTests/development.mjs

@@ -172,21 +172,15 @@ export async function runDevServer(cwd) {
 /**
  * Runs tests against the development server
  */
-export async function runDevTest(url, artifactDir, customPath = "/", browserPath, headless = true, bail = false, skipClient = false, realtime = false, skipHmr = false, skipStyleTests = false) {
-    log("Starting dev server test with path: %s", customPath || "/");
+export async function runDevTest(url, artifactDir, browserPath, headless = true, bail = false, skipClient = false, realtime = false, skipHmr = false, skipStyleTests = false) {
+    log("Starting dev server test");
     console.log("🚀 Testing local development server");
     const browser = await launchBrowser(browserPath, headless);
     const page = await browser.newPage();
     try {
+        const testUrl = new URL("/__smoke_test", url).toString();
         // DRY: check both root and custom path
-        await checkServerUp(url, customPath, RETRIES, bail);
-        // Now run the tests with the custom path
-        const testUrl = url +
-            (customPath === "/"
-                ? ""
-                : customPath.startsWith("/")
-                    ? customPath
-                    : "/" + customPath);
+        await checkServerUp(url, "/", RETRIES, bail);
         // Pass the target directory to checkUrl for HMR testing
         const targetDir = state.resources.targetDir;
         await page.goto(testUrl, { waitUntil: "networkidle0" });

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

@@ -40,7 +40,7 @@ export declare function runRelease(cwd: string, projectDir: string, resourceUniq
 /**
  * Runs tests against the production deployment
  */
-export declare function runReleaseTest(customPath: string | undefined, artifactDir: string, resources: TestResources, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, projectDir?: string, realtime?: boolean, skipHmr?: boolean, skipStyleTests?: boolean): Promise<void>;
+export declare function runReleaseTest(artifactDir: string, resources: TestResources, browserPath?: string, headless?: boolean, bail?: boolean, skipClient?: boolean, projectDir?: string, realtime?: boolean, skipHmr?: boolean, skipStyleTests?: boolean): Promise<void>;
 /**
  * Check if a resource name includes a specific resource unique key
  * This is used to identify resources created during our tests

package/dist/lib/smokeTests/release.mjs

@@ -379,8 +379,8 @@ export async function runRelease(cwd, projectDir, resourceUniqueKey) {
 /**
  * Runs tests against the production deployment
  */
-export async function runReleaseTest(customPath = "/", artifactDir, resources, browserPath, headless = true, bail = false, skipClient = false, projectDir, realtime = false, skipHmr = false, skipStyleTests = false) {
-    log("Starting release test with path: %s", customPath || "/");
+export async function runReleaseTest(artifactDir, resources, browserPath, headless = true, bail = false, skipClient = false, projectDir, realtime = false, skipHmr = false, skipStyleTests = false) {
+    log("Starting release test");
     console.log("\n🚀 Testing production deployment");
     try {
         log("Running release process");
@@ -389,14 +389,9 @@ export async function runReleaseTest(customPath = "/", artifactDir, resources, b
         log("Waiting 1s before checking server...");
         await setTimeout(1000);
         // DRY: check both root and custom path
-        await checkServerUp(url, customPath);
+        await checkServerUp(url, "/");
         // Now run the tests with the custom path
-        const testUrl = url +
-            (customPath === "/"
-                ? ""
-                : customPath.startsWith("/")
-                    ? customPath
-                    : "/" + customPath);
+        const testUrl = new URL("/__smoke_test", url).toString();
         await checkUrl(testUrl, artifactDir, browserPath, headless, bail, skipClient, "Production", realtime, resources.targetDir, // Add target directory parameter
         true, // Always skip HMR in production
         skipStyleTests);

package/dist/lib/smokeTests/runSmokeTests.mjs

@@ -57,7 +57,7 @@ export async function runSmokeTests(options = {}) {
                 resources.stopDev = stopDev;
                 state.resources.stopDev = stopDev;
                 log("Running development server tests");
-                await runDevTest(url, options.artifactDir, options.customPath, browserPath, options.headless !== false, options.bail, options.skipClient, options.realtime, options.skipHmr, options.skipStyleTests);
+                await runDevTest(url, options.artifactDir, browserPath, options.headless !== false, options.bail, options.skipClient, options.realtime, options.skipHmr, options.skipStyleTests);
                 // Mark that dev tests have run successfully
                 state.devTestsRan = true;
                 // Update the overall dev test status to PASSED
@@ -95,7 +95,7 @@ export async function runSmokeTests(options = {}) {
                 // Update status when release command runs
                 try {
                     console.log("\n🚀 Running release command smoke test");
-                    await runReleaseTest(options.customPath, options.artifactDir, resources, browserPath, options.headless !== false, options.bail, options.skipClient, options.projectDir, options.realtime, options.skipHmr, options.skipStyleTests);
+                    await runReleaseTest(options.artifactDir, resources, browserPath, options.headless !== false, options.bail, options.skipClient, options.projectDir, options.realtime, options.skipHmr, options.skipStyleTests);
                     // Update release command status to PASSED
                     updateTestStatus("production", "releaseCommand", "PASSED");
                     // Mark that release tests have run successfully

package/dist/lib/smokeTests/templates/SmokeTest.template.js

@@ -5,7 +5,7 @@ import { RequestInfo } from "rwsdk/worker";
 ${skipClient ? "" : 'import { SmokeTestClient } from "./__SmokeTestClient";'}
 import { getSmokeTestTimestamp } from "./__smokeTestFunctions";
 
-export const SmokeTestInfo: React.FC = async () => {
+export const SmokeTest = async () => {
   const currentTime = Date.now();
   let status = "error";
   let timestamp = 0;
@@ -77,5 +77,6 @@ export const SmokeTestInfo: React.FC = async () => {
       ${!skipClient ? "<SmokeTestClient/>" : ""}
     </div>
   );
-};`;
+};
+`;
 }

package/dist/lib/testUtils/stubEnvVars.d.mts

@@ -0,0 +1,2 @@
+declare const stubEnvVars: () => void;
+export default stubEnvVars;

package/dist/lib/testUtils/stubEnvVars.mjs

@@ -0,0 +1,11 @@
+import { beforeEach, afterEach } from "vitest";
+const stubEnvVars = () => {
+    let originals = {};
+    beforeEach(() => {
+        originals = { ...process.env };
+    });
+    afterEach(() => {
+        process.env = { ...originals };
+    });
+};
+export default stubEnvVars;

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

@@ -0,0 +1,10 @@
+import "./setWebpackRequire";
+export { ClientOnly } from "./ClientOnly.js";
+export { default as React } from "react";
+import type { Transport, HydrationOptions } from "./types";
+export declare const fetchTransport: Transport;
+export declare const initClient: ({ transport, hydrateRootOptions, handleResponse, }?: {
+    transport?: Transport;
+    hydrateRootOptions?: HydrationOptions;
+    handleResponse?: (response: Response) => boolean;
+}) => Promise<void>;

package/dist/runtime/{client.js → client/client.js}

@@ -1,11 +1,18 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { clientWebpackRequire } from "./imports/client";
-// NOTE: `react-server-dom-webpack` uses this global to load modules,
-// so we need to define it here before importing "react-server-dom-webpack."
-globalThis.__webpack_require__ = clientWebpackRequire;
+// note(justinvdm, 14 Aug 2025): Rendering related imports and logic go here.
+// See client.tsx for the actual client entrypoint.
+// 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."
+import "./setWebpackRequire";
+import React from "react";
+import { hydrateRoot } from "react-dom/client";
+import { createFromReadableStream, createFromFetch, encodeReply, } from "react-server-dom-webpack/client.browser";
+import { rscStream } from "rsc-html-stream/client";
+export { ClientOnly } from "./ClientOnly.js";
+export { default as React } from "react";
 export const fetchTransport = (transportContext) => {
     const fetchCallServer = async (id, args) => {
-        const { createFromFetch, encodeReply } = await import("react-server-dom-webpack/client.browser");
         const url = new URL(window.location.href);
         url.searchParams.set("__rsc", "");
         if (id != null) {
@@ -41,8 +48,6 @@ export const fetchTransport = (transportContext) => {
     return fetchCallServer;
 };
 export const initClient = async ({ transport = fetchTransport, hydrateRootOptions, handleResponse, } = {}) => {
-    const React = await import("react");
-    const { hydrateRoot } = await import("react-dom/client");
     const transportContext = {
         setRscPayload: () => { },
         handleResponse,
@@ -50,7 +55,7 @@ export const initClient = async ({ transport = fetchTransport, hydrateRootOption
     let transportCallServer = transport(transportContext);
     const callServer = (id, args) => transportCallServer(id, args);
     const upgradeToRealtime = async ({ key } = {}) => {
-        const { realtimeTransport } = await import("./lib/realtime/client");
+        const { realtimeTransport } = await import("../lib/realtime/client");
         const createRealtimeTransport = realtimeTransport({ key });
         transportCallServer = createRealtimeTransport(transportContext);
     };
@@ -67,8 +72,6 @@ export const initClient = async ({ transport = fetchTransport, hydrateRootOption
     // context(justinvdm, 18 Jun 2025): We inject the RSC payload
     // unless render(Document, [...], { rscPayload: false }) was used.
     if (globalThis.__FLIGHT_DATA) {
-        const { createFromReadableStream } = await import("react-server-dom-webpack/client.browser");
-        const { rscStream } = await import("rsc-html-stream/client");
         rscPayload = createFromReadableStream(rscStream, {
             callServer,
         });

package/dist/runtime/{clientNavigation.test.js → client/navigation.test.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { validateClickEvent } from "./clientNavigation";
+import { validateClickEvent } from "./navigation";
 describe("clientNavigation", () => {
     let mockEvent = {
         button: 0, // right click

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

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

package/dist/runtime/client/setWebpackRequire.js

@@ -0,0 +1,2 @@
+import { clientWebpackRequire } from "../imports/client";
+globalThis.__webpack_require__ = clientWebpackRequire;

package/dist/runtime/{client.d.ts → client/types.d.ts}

@@ -1,19 +1,13 @@
-import { type CallServerCallback } from "react-server-dom-webpack/client.browser";
-import { type HydrationOptions } from "react-dom/client";
+import type { CallServerCallback } from "react-server-dom-webpack/client.browser";
+export type { CallServerCallback } from "react-server-dom-webpack/client.browser";
+export type { HydrationOptions } from "react-dom/client";
 export type ActionResponse<Result> = {
     node: React.ReactNode;
     actionResult: Result;
 };
-type TransportContext = {
+export type TransportContext = {
     setRscPayload: <Result>(v: Promise<ActionResponse<Result>>) => void;
     handleResponse?: (response: Response) => boolean;
 };
 export type Transport = (context: TransportContext) => CallServerCallback;
 export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[]) => Promise<Result>;
-export declare const fetchTransport: Transport;
-export declare const initClient: ({ transport, hydrateRootOptions, handleResponse, }?: {
-    transport?: Transport;
-    hydrateRootOptions?: HydrationOptions;
-    handleResponse?: (response: Response) => boolean;
-}) => Promise<void>;
-export {};

package/dist/runtime/client/types.js

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

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

@@ -1,5 +1,5 @@
 import "./types/client";
-export * from "../client";
+export * from "../client/client";
 export * from "../register/client";
 export * from "../lib/streams/consumeEventStream";
-export * from "../clientNavigation";
+export * from "../client/navigation";

package/dist/runtime/entries/client.js

@@ -1,5 +1,5 @@
 import "./types/client";
-export * from "../client";
+export * from "../client/client";
 export * from "../register/client";
 export * from "../lib/streams/consumeEventStream";
-export * from "../clientNavigation";
+export * from "../client/navigation";

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

@@ -1,4 +1,4 @@
-export declare const loadModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
-export declare const clientWebpackRequire: ((id: string) => Promise<{
+export declare const loadModule: (id: string) => Promise<any>;
+export declare const clientWebpackRequire: (id: string) => Promise<{
     [x: string]: any;
-}>) & import("lodash").MemoizedFunction;
+}>;

package/dist/runtime/imports/client.js

@@ -1,20 +1,17 @@
 import React from "react";
-import memoize from "lodash/memoize";
-export const loadModule = memoize(async (id) => {
-    if (import.meta.env.VITE_IS_DEV_SERVER) {
-        return await import(/* @vite-ignore */ id);
-    }
-    else {
-        const { useClientLookup } = await import("virtual:use-client-lookup.js");
-        const moduleFn = useClientLookup[id];
-        if (!moduleFn) {
-            throw new Error(`(client) No module found for '${id}' in module lookup for "use client" directive`);
-        }
-        return await moduleFn();
+import { ClientOnly } from "../client/client";
+import { memoizeOnId } from "../lib/memoizeOnId";
+// @ts-ignore
+import { useClientLookup } from "virtual:use-client-lookup.js";
+export const loadModule = memoizeOnId(async (id) => {
+    const moduleFn = useClientLookup[id];
+    if (!moduleFn) {
+        throw new Error(`(client) No module found for '${id}' in module lookup for "use client" directive`);
     }
+    return await moduleFn();
 });
 // context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
-export const clientWebpackRequire = memoize(async (id) => {
+export const clientWebpackRequire = memoizeOnId(async (id) => {
     const [file, name] = id.split("#");
     const promisedModule = loadModule(file);
     const promisedComponent = promisedModule.then((module) => module[name]);
@@ -23,11 +20,10 @@ export const clientWebpackRequire = memoize(async (id) => {
         const awaitedComponent = await promisedComponent;
         return { [id]: awaitedComponent };
     }
-    const { ClientOnly } = await import("./ClientOnly");
     const promisedDefault = promisedComponent.then((Component) => ({
         default: Component,
     }));
     const Lazy = React.lazy(() => promisedDefault);
-    const Wrapped = () => React.createElement(ClientOnly, null, React.createElement(Lazy));
+    const Wrapped = (props) => React.createElement(ClientOnly, null, React.createElement(Lazy, props));
     return { [id]: Wrapped };
 });

package/dist/runtime/imports/ssr.d.ts

@@ -1,5 +1,5 @@
-export declare const ssrLoadModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const ssrLoadModule: (id: string) => Promise<any>;
 export declare const ssrGetModuleExport: (id: string) => Promise<any>;
-export declare const ssrWebpackRequire: ((id: string) => Promise<{
+export declare const ssrWebpackRequire: (id: string) => Promise<{
     [x: string]: any;
-}>) & import("lodash").MemoizedFunction;
+}>;

package/dist/runtime/imports/ssr.js

@@ -1,5 +1,5 @@
-import memoize from "lodash/memoize";
-export const ssrLoadModule = memoize(async (id) => {
+import { memoizeOnId } from "../lib/memoizeOnId";
+export const ssrLoadModule = memoizeOnId(async (id) => {
     const { useClientLookup } = await import("virtual:use-client-lookup.js");
     const moduleFn = useClientLookup[id];
     if (!moduleFn) {
@@ -13,7 +13,7 @@ export const ssrGetModuleExport = async (id) => {
     return module[name];
 };
 // context(justinvdm, 2 Dec 2024): re memoize(): React relies on the same promise instance being returned for the same id
-export const ssrWebpackRequire = memoize(async (id) => {
+export const ssrWebpackRequire = memoizeOnId(async (id) => {
     const [file, name] = id.split("#");
     const module = await ssrLoadModule(file);
     return { [id]: module[name] };

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

@@ -1,5 +1,5 @@
-export declare const loadServerModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const loadServerModule: (id: string) => Promise<any>;
 export declare const getServerModuleExport: (id: string) => Promise<any>;
-export declare const ssrWebpackRequire: ((id: string) => Promise<{
+export declare const ssrWebpackRequire: (id: string) => Promise<{
     [x: string]: any;
-}>) & import("lodash").MemoizedFunction;
+}>;

package/dist/runtime/imports/worker.js

@@ -1,8 +1,9 @@
-import memoize from "lodash/memoize";
 import { requestInfo } from "../requestInfo/worker";
 import { ssrWebpackRequire as baseSsrWebpackRequire } from "rwsdk/__ssr_bridge";
-export const loadServerModule = memoize(async (id) => {
-    const { useServerLookup } = await import("virtual:use-server-lookup.js");
+import { memoizeOnId } from "../lib/memoizeOnId";
+// @ts-ignore
+import { useServerLookup } from "virtual:use-server-lookup.js";
+export const loadServerModule = memoizeOnId(async (id) => {
     const moduleFn = useServerLookup[id];
     if (!moduleFn) {
         throw new Error(`(worker) No module found for '${id}' in module lookup for "use server" directive`);
@@ -14,7 +15,7 @@ export const getServerModuleExport = async (id) => {
     const module = await loadServerModule(file);
     return module[name];
 };
-export const ssrWebpackRequire = memoize(async (id) => {
+export const ssrWebpackRequire = memoizeOnId(async (id) => {
     if (!requestInfo.rw.ssr) {
         return { [id]: () => null };
     }

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

@@ -1,2 +1,11 @@
-import { type RequestInfo } from "../requestInfo/types";
-export declare const getManifest: (requestInfo: RequestInfo) => Promise<Record<string, any>>;
+export type Manifest = Record<string, ManifestChunk>;
+export interface ManifestChunk {
+    file: string;
+    src?: string;
+    isEntry?: boolean;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    css?: string[];
+    assets?: string[];
+}
+export declare const getManifest: () => Promise<Manifest>;

package/dist/runtime/lib/manifest.js

@@ -1,5 +1,5 @@
 let manifest;
-export const getManifest = async (requestInfo) => {
+export const getManifest = async () => {
     if (manifest) {
         return manifest;
     }

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

@@ -0,0 +1 @@
+export declare const memoizeOnId: <Result>(fn: (id: string) => Result) => (id: string) => Result;

package/dist/runtime/lib/memoizeOnId.js

@@ -0,0 +1,11 @@
+export const memoizeOnId = (fn) => {
+    const hasOwnProperty = Object.prototype.hasOwnProperty;
+    const results = {};
+    const memoizedFn = (id) => {
+        if (hasOwnProperty.call(results, id)) {
+            return results[id];
+        }
+        return (results[id] = fn(id));
+    };
+    return memoizedFn;
+};

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

@@ -1,4 +1,4 @@
-import { type Transport } from "../../client";
+import { type Transport } from "../../client/types";
 export declare const initRealtimeClient: ({ key, handleResponse, }?: {
     key?: string;
     handleResponse?: (response: Response) => boolean;

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

@@ -1,4 +1,4 @@
-import { initClient } from "../../client";
+import { initClient } from "../../client/client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
 import { MESSAGE_TYPE } from "./shared";
 import { packMessage, unpackMessage, } from "./protocol";

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

@@ -18,10 +18,10 @@ export type RwContext = {
     scriptsToBeLoaded: Set<string>;
     pageRouteResolved: PromiseWithResolvers<void> | undefined;
 };
-export type RouteMiddleware<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Response | Promise<Response> | void | Promise<void> | Promise<Response | void>;
-type RouteFunction<T extends RequestInfo = RequestInfo> = (requestInfo: T) => Response | Promise<Response>;
+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>;
-type RouteComponent<T extends RequestInfo = RequestInfo> = (requestInfo: T) => MaybePromise<React.JSX.Element | Response>;
+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>];
 export type Route<T extends RequestInfo = RequestInfo> = RouteMiddleware<T> | RouteDefinition<T> | Array<Route<T>>;
 export type RouteDefinition<T extends RequestInfo = RequestInfo> = {