rwsdk 0.1.6 → 0.1.7-test.20250702144348

package/bin/rwsync

@@ -0,0 +1,2 @@
+#!/bin/sh
+DIR=$PWD && (cd "${@:-SDK_REPO}/sdk" && pnpm debug-sync $DIR)

package/dist/runtime/client.js

@@ -59,7 +59,12 @@ export const initClient = async ({ transport = fetchTransport, hydrateRootOption
         transportContext.setRscPayload = (v) => startTransition(() => setStreamData(v));
         return _jsx(_Fragment, { children: React.use(streamData).node });
     }
-    hydrateRoot(rootEl, _jsx(Content, {}), hydrateRootOptions);
+    hydrateRoot(rootEl, _jsx(Content, {}), {
+        onUncaughtError: (error, { componentStack }) => {
+            console.error("Uncaught error: %O\n\nComponent stack:%s", error, componentStack);
+        },
+        ...hydrateRootOptions,
+    });
     if (import.meta.hot) {
         import.meta.hot.on("rsc:update", (e) => {
             console.log("[rwsdk] hot update", e.file);

package/dist/runtime/clientNavigation.d.ts

@@ -1,3 +1,4 @@
+export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
 export declare function initClientNavigation(opts?: {
     onNavigate: () => void;
 }): void;

package/dist/runtime/clientNavigation.js

@@ -1,3 +1,32 @@
+export function validateClickEvent(event, target) {
+    // should this only work for left click?
+    if (event.button !== 0) {
+        return false;
+    }
+    if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
+        return false;
+    }
+    const link = target.closest("a");
+    if (!link) {
+        return false;
+    }
+    const href = link.getAttribute("href");
+    if (!href) {
+        return false;
+    }
+    // Skip if target="_blank" or similar
+    if (link.target && link.target !== "_self") {
+        return false;
+    }
+    if (href.startsWith("http")) {
+        return false;
+    }
+    // Skip if download attribute
+    if (link.hasAttribute("download")) {
+        return false;
+    }
+    return true;
+}
 export function initClientNavigation(opts = {
     onNavigate: async function onNavigate() {
         // @ts-expect-error
@@ -6,33 +35,14 @@ export function initClientNavigation(opts = {
 }) {
     // Intercept all anchor tag clicks
     document.addEventListener("click", async function handleClickEvent(event) {
-        // should this only work for left click?
-        if (event.button !== 0) {
-            return;
-        }
-        if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
-            return;
-        }
-        const target = event.target;
-        const link = target.closest("a");
-        if (!link) {
-            return;
-        }
-        const href = link.getAttribute("href");
-        if (!href) {
-            return;
-        }
-        // Skip if target="_blank" or similar
-        if (link.target && link.target !== "_self") {
-            return;
-        }
-        // Skip if download attribute
-        if (link.hasAttribute("download")) {
+        // Prevent default navigation
+        if (!validateClickEvent(event, event.target)) {
             return;
         }
-        // Prevent default navigation
         event.preventDefault();
-        // push this to the history stack.
+        const el = event.target;
+        const a = el.closest("a");
+        const href = a?.getAttribute("href");
         window.history.pushState({ path: href }, "", window.location.origin + href);
         await opts.onNavigate();
     }, true);

package/dist/runtime/clientNavigation.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "vitest";
+import { validateClickEvent } from "./clientNavigation";
+describe("clientNavigation", () => {
+    let mockEvent = {
+        button: 0, // right click
+        metaKey: false,
+        altKey: false,
+        shiftKey: false,
+        ctrlKey: false,
+    };
+    let mockTarget = {
+        closest: () => {
+            return {
+                getAttribute: () => "/test",
+                hasAttribute: () => false,
+            };
+        },
+    };
+    it("should return true", () => {
+        expect(validateClickEvent(mockEvent, mockTarget)).toBe(true);
+    });
+    it("should return false if the event is not a left click", () => {
+        expect(validateClickEvent({ ...mockEvent, button: 1 }, mockTarget)).toBe(false);
+    });
+    it("none of the modifier keys are pressed", () => {
+        expect(validateClickEvent({ ...mockEvent, metaKey: true }, mockTarget)).toBe(false);
+    });
+    it("the target is not an anchor tag", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => undefined,
+        })).toBe(false);
+    });
+    it("should have an href attribute", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => ({ getAttribute: () => undefined }),
+        })).toBe(false);
+    });
+    it("should not have a target attribute", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => ({
+                target: "_blank",
+                getAttribute: () => "/test",
+                hasAttribute: () => false,
+            }),
+        })).toBe(false);
+    });
+    it("should be a relative link", () => {
+        expect(validateClickEvent(mockEvent, {
+            closest: () => ({
+                getAttribute: () => "/test",
+                hasAttribute: () => false,
+            }),
+        })).toBe(true);
+    });
+});

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

@@ -82,12 +82,18 @@ export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) =
         try {
             const socket = ensureWs();
             const { encodeReply } = await import("react-server-dom-webpack/client.browser");
+            // Note(peterp, 2025-07-02): We need to send the "current URL" per message,
+            // in case the user has enabled client side navigation.
+            const clientUrl = new URL(window.location.href);
+            clientUrl.protocol = "";
+            clientUrl.host = "";
             const encodedArgs = args != null ? await encodeReply(args) : null;
             const requestId = crypto.randomUUID();
             const messageData = JSON.stringify({
                 id,
                 args: encodedArgs,
                 requestId,
+                clientUrl,
             });
             const encoder = new TextEncoder();
             const messageBytes = encoder.encode(messageData);

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

@@ -56,9 +56,9 @@ export class RealtimeDurableObject extends DurableObject {
         if (messageType === MESSAGE_TYPE.ACTION_REQUEST) {
             const decoder = new TextDecoder();
             const jsonData = decoder.decode(message.slice(1));
-            const { id, args, requestId } = JSON.parse(jsonData);
+            const { id, args, requestId, clientUrl } = JSON.parse(jsonData);
             try {
-                await this.handleAction(ws, id, args, clientInfo, requestId);
+                await this.handleAction(ws, id, args, clientInfo, requestId, clientUrl);
             }
             catch (error) {
                 const encoder = new TextEncoder();
@@ -100,10 +100,12 @@ export class RealtimeDurableObject extends DurableObject {
             reader.releaseLock();
         }
     }
-    async handleAction(ws, id, args, clientInfo, requestId) {
-        const url = new URL(clientInfo.url);
-        url.searchParams.set("__rsc", "true");
-        url.searchParams.set("__rsc_action_id", id);
+    async handleAction(ws, id, args, clientInfo, requestId, clientUrl) {
+        const url = new URL(clientUrl);
+        url.searchParams.set("__rsc", "");
+        if (id != null) {
+            url.searchParams.set("__rsc_action_id", id);
+        }
         const response = await fetch(url.toString(), {
             method: "POST",
             body: args,

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

@@ -1,11 +1,9 @@
 import { route } from "../../entries/router";
 import { validateUpgradeRequest } from "./validateUpgradeRequest";
 import { DEFAULT_REALTIME_KEY } from "./constants";
-import { requestInfo } from "../../requestInfo/worker";
 import { env } from "cloudflare:workers";
 export { renderRealtimeClients } from "./renderRealtimeClients";
-export const realtimeRoute = (getDurableObjectNamespace) => route("/__realtime", async function () {
-    const { request } = requestInfo;
+export const realtimeRoute = (getDurableObjectNamespace) => route("/__realtime", async function ({ request }) {
     const validation = validateUpgradeRequest(request);
     if (!validation.valid) {
         return validation.response;

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

@@ -1,8 +1,9 @@
 import { type DocumentProps } from "../lib/router";
 import { type RequestInfo } from "../requestInfo/types";
-export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, shouldSSR, }: {
+export declare const renderRscThenableToHtmlStream: ({ thenable, Document, requestInfo, shouldSSR, onError, }: {
     thenable: any;
     Document: React.FC<DocumentProps>;
     requestInfo: RequestInfo;
     shouldSSR: boolean;
+    onError: (error: unknown) => void;
 }) => Promise<import("react-dom/server").ReactDOMServerReadableStream>;

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { use } from "react";
 import { renderToReadableStream } from "react-dom/server.edge";
-export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, shouldSSR, }) => {
+export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, shouldSSR, onError, }) => {
     const Component = () => {
         const node = use(thenable).node;
         // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
@@ -21,5 +21,26 @@ export const renderRscThenableToHtmlStream = async ({ thenable, Document, reques
     };
     return await renderToReadableStream(_jsx(Component, {}), {
         nonce: requestInfo.rw.nonce,
+        onError(error, { componentStack }) {
+            try {
+                const message = error
+                    ? (error.stack ?? error.message ?? error)
+                    : error;
+                const wrappedMessage = `Error rendering RSC to HTML stream: ${message}\n\nComponent stack:\n${componentStack}`;
+                if (error instanceof Error) {
+                    const wrappedError = new Error(wrappedMessage);
+                    wrappedError.stack = error.stack;
+                    error = wrappedError;
+                }
+                else {
+                    error = new Error(wrappedMessage);
+                    error.stack = componentStack;
+                }
+                onError(error);
+            }
+            catch {
+                onError(error);
+            }
+        },
     });
 };

package/dist/runtime/render/renderToStream.js

@@ -4,7 +4,7 @@ import { transformRscToHtmlStream } from "./transformRscToHtmlStream";
 import { requestInfo } from "../requestInfo/worker";
 import { injectRSCPayload } from "rsc-html-stream/server";
 export const IdentityDocument = ({ children }) => (_jsx(_Fragment, { children: children }));
-export const renderToStream = async (element, { Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = false, onError, } = {}) => {
+export const renderToStream = async (element, { Document = IdentityDocument, injectRSCPayload: shouldInjectRSCPayload = false, onError = () => { }, } = {}) => {
     let rscStream = renderToRscStream({
         node: element,
         actionResult: null,
@@ -21,6 +21,7 @@ export const renderToStream = async (element, { Document = IdentityDocument, inj
         stream: rscStream,
         Document,
         requestInfo,
+        onError,
     });
     return htmlStream;
 };

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

@@ -1,7 +1,8 @@
 import { DocumentProps } from "../lib/router";
 import { RequestInfo } from "../requestInfo/types";
-export declare const transformRscToHtmlStream: ({ stream, Document, requestInfo, }: {
+export declare const transformRscToHtmlStream: ({ stream, Document, requestInfo, onError, }: {
     stream: ReadableStream;
     Document: React.FC<DocumentProps>;
     requestInfo: RequestInfo;
+    onError: (error: unknown) => void;
 }) => Promise<import("react-dom/server.js").ReactDOMServerReadableStream>;

package/dist/runtime/render/transformRscToHtmlStream.js

@@ -2,7 +2,7 @@ import { createModuleMap } from "./createModuleMap.js";
 import ReactServerDom from "react-server-dom-webpack/client.edge";
 import { renderRscThenableToHtmlStream } from "rwsdk/__ssr_bridge";
 const { createFromReadableStream } = ReactServerDom;
-export const transformRscToHtmlStream = ({ stream, Document, requestInfo, }) => {
+export const transformRscToHtmlStream = ({ stream, Document, requestInfo, onError, }) => {
     const thenable = createFromReadableStream(stream, {
         serverConsumerManifest: {
             moduleMap: createModuleMap(),
@@ -14,5 +14,6 @@ export const transformRscToHtmlStream = ({ stream, Document, requestInfo, }) =>
         Document,
         requestInfo,
         shouldSSR: requestInfo.rw.ssr,
+        onError,
     });
 };

package/dist/runtime/worker.js

@@ -114,6 +114,7 @@ export const defineApp = (routes) => {
                         stream: rscPayloadStream,
                         Document: rw.Document,
                         requestInfo: requestInfo,
+                        onError,
                     });
                     if (injectRSCPayloadStream) {
                         html = html.pipeThrough(injectRSCPayloadStream);

package/dist/scripts/debug-sync.d.mts

@@ -1,5 +1,6 @@
 export interface DebugSyncOptions {
     targetDir: string;
+    sdkDir?: string;
     dev?: boolean;
     watch?: boolean;
     build?: boolean;

package/dist/scripts/debug-sync.mjs

@@ -1,20 +1,78 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { $ } from "../lib/$.mjs";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const getPackageManagerInfo = (targetDir) => {
+    if (existsSync(path.join(targetDir, "yarn.lock"))) {
+        return { name: "yarn", lockFile: "yarn.lock", command: "add" };
+    }
+    if (existsSync(path.join(targetDir, "pnpm-lock.yaml"))) {
+        return { name: "pnpm", lockFile: "pnpm-lock.yaml", command: "add" };
+    }
+    return { name: "npm", lockFile: "package-lock.json", command: "install" };
+};
+const performSync = async (sdkDir, targetDir) => {
+    console.log("🏗️  rebuilding sdk...");
+    await $({ cwd: sdkDir, stdio: "inherit", shell: true }) `pnpm build`;
+    console.log("📦 packing sdk...");
+    const packResult = await $({ cwd: sdkDir, shell: true }) `npm pack`;
+    const tarballName = packResult.stdout?.trim() ?? "";
+    const tarballPath = path.resolve(sdkDir, tarballName);
+    console.log(` installing ${tarballName} in ${targetDir}...`);
+    const pm = getPackageManagerInfo(targetDir);
+    const packageJsonPath = path.join(targetDir, "package.json");
+    const lockfilePath = path.join(targetDir, pm.lockFile);
+    const originalPackageJson = await fs
+        .readFile(packageJsonPath, "utf-8")
+        .catch(() => null);
+    const originalLockfile = await fs
+        .readFile(lockfilePath, "utf-8")
+        .catch(() => null);
+    try {
+        let installCommand = `${pm.name} ${pm.command} ${tarballPath}`;
+        if (pm.name === "yarn") {
+            installCommand = `yarn add file:${tarballPath}`;
+        }
+        await $({
+            cwd: targetDir,
+            stdio: "inherit",
+            shell: true,
+        }) `${installCommand}`;
+    }
+    finally {
+        if (originalPackageJson) {
+            console.log("Restoring package.json...");
+            await fs.writeFile(packageJsonPath, originalPackageJson);
+        }
+        if (originalLockfile) {
+            console.log(`Restoring ${pm.lockFile}...`);
+            await fs.writeFile(lockfilePath, originalLockfile);
+        }
+        await fs.unlink(tarballPath).catch(() => {
+            // ignore if deletion fails
+        });
+    }
+    console.log("✅ done syncing");
+};
 export const debugSync = async (opts) => {
-    const { targetDir, dev, watch, build } = opts;
+    const { targetDir, sdkDir = process.cwd(), dev, watch, build } = opts;
     if (!targetDir) {
         console.error("❌ Please provide a target directory as an argument.");
         process.exit(1);
     }
-    const syncCommand = `echo 🏗️ rebuilding... && pnpm build && rm -rf ${targetDir}/node_modules/rwsdk/dist ${targetDir}/node_modules/rwsdk/package.json && echo 📁 syncing sdk from ${process.cwd()} to ${targetDir}/node_modules/rwsdk/... && cp -r package.json dist ${targetDir}/node_modules/rwsdk/ && echo ✅ done syncing`;
+    const thisScriptPath = fileURLToPath(import.meta.url);
+    const syncCommand = `tsx ${thisScriptPath} --_sync ${sdkDir} ${targetDir}`;
     // Run initial sync
-    await $({ stdio: "inherit", shell: true }) `${syncCommand}`;
+    await performSync(sdkDir, targetDir);
     if (!process.env.NO_CLEAN_VITE) {
         console.log("🧹 Cleaning Vite cache...");
         await $({
             stdio: "inherit",
             shell: true,
             cwd: targetDir,
-        }) `rm -rf node_modules/.vite`;
+        }) `rm -rf ${targetDir}/node_modules/.vite*`;
     }
     // If dev flag is present, clean vite cache and start dev server
     if (dev) {
@@ -40,12 +98,22 @@ export const debugSync = async (opts) => {
 };
 if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
     const args = process.argv.slice(2);
-    const targetDir = args[0];
-    const flags = new Set(args.slice(1));
-    debugSync({
-        targetDir,
-        dev: flags.has("--dev"),
-        watch: flags.has("--watch"),
-        build: flags.has("--build"),
-    });
+    const flags = new Set(args.filter((arg) => arg.startsWith("--")));
+    const positionalArgs = args.filter((arg) => !arg.startsWith("--"));
+    if (flags.has("--_sync")) {
+        const [sdkDir, targetDir] = positionalArgs;
+        await performSync(sdkDir, targetDir);
+    }
+    else {
+        const targetDir = positionalArgs[0] ?? process.cwd();
+        debugSync({
+            targetDir,
+            sdkDir: process.env.SDK_REPO
+                ? path.resolve(__dirname, process.env.SDK_REPO, "sdk")
+                : path.resolve(__dirname, "..", ".."),
+            dev: flags.has("--dev"),
+            watch: flags.has("--watch"),
+            build: flags.has("--build"),
+        });
+    }
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "rwsdk",
-  "version": "0.1.6",
+  "version": "0.1.7-test.20250702144348",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
-    "rw-scripts": "./bin/rw-scripts.mjs"
+    "rw-scripts": "./bin/rw-scripts.mjs",
+    "rwsync": "./bin/rwsync"
   },
   "files": [
     "./README.md",

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

@@ -1,8 +0,0 @@
-/**
- * Creates the smoke test components in the target project directory
- */
-export declare function createSmokeTestComponents(targetDir: string, skipClient?: boolean): Promise<void>;
-/**
- * Modifies the worker.tsx and wrangler.jsonc files to add realtime support
- */
-export declare function modifyAppForRealtime(targetDir: string): Promise<void>;

package/dist/lib/smokeTests/components.mjs

@@ -1,194 +0,0 @@
-import { join } from "path";
-import * as fs from "fs/promises";
-import { log } from "./constants.mjs";
-import { getSmokeTestFunctionsTemplate } from "./templates/smokeTestFunctions.template";
-import { getSmokeTestTemplate } from "./templates/SmokeTest.template";
-import { getSmokeTestClientTemplate } from "./templates/SmokeTestClient.template";
-import MagicString from "magic-string";
-import { parse as parseJsonc } from "jsonc-parser";
-/**
- * Creates the smoke test components in the target project directory
- */
-export async function createSmokeTestComponents(targetDir, skipClient = false) {
-    console.log("Creating smoke test components in project...");
-    // Create directories if they don't exist
-    const componentsDir = join(targetDir, "src", "app", "components");
-    log("Creating components directory: %s", componentsDir);
-    await fs.mkdir(componentsDir, { recursive: true });
-    // Create __smokeTestFunctions.ts
-    const smokeTestFunctionsPath = join(componentsDir, "__smokeTestFunctions.ts");
-    log("Creating __smokeTestFunctions.ts at: %s", smokeTestFunctionsPath);
-    const smokeTestFunctionsContent = getSmokeTestFunctionsTemplate();
-    // Create SmokeTest.tsx with conditional client component import
-    const smokeTestPath = join(componentsDir, "__SmokeTest.tsx");
-    log("Creating __SmokeTest.tsx at: %s", smokeTestPath);
-    const smokeTestContent = getSmokeTestTemplate(skipClient);
-    // Write the server files
-    log("Writing SmokeTestFunctions file");
-    await fs.writeFile(smokeTestFunctionsPath, smokeTestFunctionsContent);
-    log("Writing SmokeTest component file");
-    await fs.writeFile(smokeTestPath, smokeTestContent);
-    // Only create client component if not skipping client-side tests
-    if (!skipClient) {
-        // Create SmokeTestClient.tsx
-        const smokeTestClientPath = join(componentsDir, "__SmokeTestClient.tsx");
-        log("Creating __SmokeTestClient.tsx at: %s", smokeTestClientPath);
-        const smokeTestClientContent = getSmokeTestClientTemplate();
-        log("Writing SmokeTestClient component file");
-        await fs.writeFile(smokeTestClientPath, smokeTestClientContent);
-        log("Created client-side smoke test component");
-    }
-    else {
-        log("Skipping client-side smoke test component creation");
-    }
-    // Modify worker.tsx and wrangler.jsonc for realtime support
-    await modifyAppForRealtime(targetDir);
-    log("Smoke test components created successfully");
-    console.log("Created smoke test components:");
-    console.log(`- ${smokeTestFunctionsPath}`);
-    console.log(`- ${smokeTestPath}`);
-    if (!skipClient) {
-        console.log(`- ${join(componentsDir, "__SmokeTestClient.tsx")}`);
-    }
-    else {
-        console.log("- Client component skipped (--skip-client was specified)");
-    }
-}
-/**
- * Modifies the worker.tsx and wrangler.jsonc files to add realtime support
- */
-export async function modifyAppForRealtime(targetDir) {
-    log("Modifying worker.tsx and wrangler.jsonc for realtime support");
-    // Modify worker.tsx
-    const workerPath = join(targetDir, "src", "worker.tsx");
-    if (await fs
-        .access(workerPath)
-        .then(() => true)
-        .catch(() => false)) {
-        log("Found worker.tsx, checking for realtime code");
-        const workerContent = await fs.readFile(workerPath, "utf-8");
-        // Check if the realtime export line already exists
-        const hasRealtimeExport = workerContent.includes('export { RealtimeDurableObject } from "rwsdk/realtime/durableObject"');
-        const hasRealtimeRoute = workerContent.includes("realtimeRoute(");
-        if (!hasRealtimeExport || !hasRealtimeRoute) {
-            log("Need to modify worker.tsx for realtime support");
-            const s = new MagicString(workerContent);
-            // Add the export line if it doesn't exist
-            if (!hasRealtimeExport) {
-                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, 'export { RealtimeDurableObject } from "rwsdk/realtime/durableObject";\n');
-                    log("Added RealtimeDurableObject export");
-                }
-            }
-            // Add the realtimeRoute line if it doesn't exist
-            if (!hasRealtimeRoute) {
-                const defineAppMatch = workerContent.match(/export default defineApp\(\[/);
-                if (defineAppMatch && defineAppMatch.index !== undefined) {
-                    const insertPosition = defineAppMatch.index + defineAppMatch[0].length;
-                    s.appendRight(insertPosition, "\n  realtimeRoute(() => env.REALTIME_DURABLE_OBJECT),");
-                    log("Added realtimeRoute to defineApp");
-                }
-            }
-            // Import realtimeRoute if it's not already imported
-            if (!workerContent.includes("realtimeRoute")) {
-                // Find the router import to append to it
-                const routerImportMatch = workerContent.match(/import \{(.*?)\} from "rwsdk\/router";/);
-                if (routerImportMatch) {
-                    const importList = routerImportMatch[1];
-                    if (!importList.includes("realtimeRoute")) {
-                        s.replace(routerImportMatch[0], routerImportMatch[0].replace(/import \{(.*?)\} from "rwsdk\/router";/, (match, imports) => `import { ${imports}, realtimeRoute } from "rwsdk/router";`));
-                        log("Added realtimeRoute to router imports");
-                    }
-                }
-            }
-            // Write the modified file
-            await fs.writeFile(workerPath, s.toString(), "utf-8");
-            log("Successfully modified worker.tsx");
-        }
-        else {
-            log("worker.tsx already has realtime support, no changes needed");
-        }
-    }
-    else {
-        log("worker.tsx not found, skipping modification");
-    }
-    // Modify wrangler.jsonc
-    const wranglerPath = join(targetDir, "wrangler.jsonc");
-    if (await fs
-        .access(wranglerPath)
-        .then(() => true)
-        .catch(() => false)) {
-        log("Found wrangler.jsonc, checking for realtime durable objects");
-        const wranglerContent = await fs.readFile(wranglerPath, "utf-8");
-        const wranglerConfig = parseJsonc(wranglerContent);
-        let modified = false;
-        // Check if REALTIME_DURABLE_OBJECT already exists in durable_objects bindings
-        const hasDurableObjectBinding = wranglerConfig.durable_objects?.bindings?.some((binding) => binding.name === "REALTIME_DURABLE_OBJECT");
-        // Check if RealtimeDurableObject is already in migrations
-        const hasMigration = wranglerConfig.migrations?.some((migration) => migration.new_sqlite_classes?.includes("RealtimeDurableObject"));
-        if (!hasDurableObjectBinding || !hasMigration) {
-            log("Need to modify wrangler.jsonc for realtime support");
-            // Create a deep copy of the config to make modifications
-            const newConfig = JSON.parse(JSON.stringify(wranglerConfig));
-            // Add durable objects binding if needed
-            if (!hasDurableObjectBinding) {
-                if (!newConfig.durable_objects) {
-                    newConfig.durable_objects = {};
-                }
-                if (!newConfig.durable_objects.bindings) {
-                    newConfig.durable_objects.bindings = [];
-                }
-                newConfig.durable_objects.bindings.push({
-                    name: "REALTIME_DURABLE_OBJECT",
-                    class_name: "RealtimeDurableObject",
-                });
-                modified = true;
-                log("Added REALTIME_DURABLE_OBJECT to durable_objects bindings");
-            }
-            // Add migration if needed
-            if (!hasMigration) {
-                if (!newConfig.migrations) {
-                    newConfig.migrations = [
-                        {
-                            tag: "v1",
-                            new_sqlite_classes: ["RealtimeDurableObject"],
-                        },
-                    ];
-                    modified = true;
-                    log("Added new migrations with RealtimeDurableObject");
-                }
-                else if (newConfig.migrations.length > 0) {
-                    // Add RealtimeDurableObject to the first migration's sqlite classes
-                    const firstMigration = newConfig.migrations[0];
-                    if (!firstMigration.new_sqlite_classes) {
-                        firstMigration.new_sqlite_classes = ["RealtimeDurableObject"];
-                    }
-                    else if (!firstMigration.new_sqlite_classes.includes("RealtimeDurableObject")) {
-                        firstMigration.new_sqlite_classes.push("RealtimeDurableObject");
-                    }
-                    modified = true;
-                    log("Added RealtimeDurableObject to existing migration");
-                }
-            }
-            if (modified) {
-                // Write the modified config back to the file
-                await fs.writeFile(wranglerPath, JSON.stringify(newConfig, null, 2), "utf-8");
-                log("Successfully modified wrangler.jsonc");
-            }
-        }
-        else {
-            log("wrangler.jsonc already has realtime support, no changes needed");
-        }
-    }
-    else {
-        log("wrangler.jsonc not found, skipping modification");
-    }
-}