rwsdk 0.1.6-test.20250702140059 → 0.1.6

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

@@ -0,0 +1,8 @@
+/**
+ * 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

@@ -0,0 +1,194 @@
+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");
+    }
+}

package/dist/lib/smokeTests/templates/SmokeTestInfo.template.d.ts

@@ -0,0 +1 @@
+export declare function getSmokeTestTemplate(skipClient?: boolean): string;

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

@@ -0,0 +1,82 @@
+export function getSmokeTestTemplate(skipClient = false) {
+    return `
+import React from "react";
+import { RequestInfo } from "rwsdk/worker";
+${skipClient ? "" : 'import { SmokeTestClient } from "./__SmokeTestClient";'}
+import { smokeTestAction } from "./__smokeTestFunctions";
+
+export const SmokeTestInfo: React.FC = async () => {
+  const timestamp = Date.now();
+  let status = "error";
+  let verificationPassed = false;
+  let serverStoredTimestamp = 0;
+  let result: any = null;
+
+  try {
+    // Call the smoke test action to verify basic server functionality
+    result = await smokeTestAction(timestamp);
+    status = result.status || "error";
+    verificationPassed = result.timestamp === timestamp;
+    serverStoredTimestamp = result.serverStoredTimestamp;
+  } catch (error) {
+    console.error("Smoke test failed:", error);
+    status = "error";
+    result = { error: error instanceof Error ? error.message : String(error) };
+  }
+
+  return (
+    <div
+      id="smoke-test-container"
+      data-testid="health-status"
+      data-status={status}
+      data-timestamp={timestamp}
+      data-server-timestamp={Date.now()}
+      data-server-stored-timestamp={serverStoredTimestamp}
+      data-verified={verificationPassed ? "true" : "false"}
+      style={{
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        margin: "20px",
+        padding: "15px",
+        border: "1px solid #ddd",
+        borderRadius: "4px",
+        background: "#f9f9f9",
+      }}
+    >
+      <h2
+        style={{
+          color: status === "ok" ? "#0c9" : "#f44",
+          margin: "0 0 10px 0",
+        }}
+      >
+        Smoke Test: {status}
+      </h2>
+      <div
+        id="smoke-test-result"
+      >
+        {verificationPassed
+          ? "Timestamp verification passed ✅"
+          : "Timestamp verification failed ⚠️"}
+      </div>
+      <div id="server-stored-timestamp">
+        Server Stored Timestamp: {serverStoredTimestamp}
+      </div>
+      <details style={{ marginTop: "10px" }}>
+        <summary>Details</summary>
+        <pre
+          style={{
+            background: "#f5f5f5",
+            padding: "10px",
+            borderRadius: "4px",
+            fontSize: "12px",
+            overflow: "auto",
+          }}
+        >
+          {JSON.stringify({ timestamp, serverStoredTimestamp, result, verificationPassed }, null, 2)}
+        </pre>
+      </details>
+
+      ${!skipClient ? "<SmokeTestClient/>" : ""}
+    </div>
+  );
+};`;
+}

package/dist/runtime/client.js

@@ -59,12 +59,7 @@ 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, {}), {
-        onUncaughtError: (error, { componentStack }) => {
-            console.error("Uncaught error: %O\n\nComponent stack:%s", error, componentStack);
-        },
-        ...hydrateRootOptions,
-    });
+    hydrateRoot(rootEl, _jsx(Content, {}), 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,4 +1,3 @@
-export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
 export declare function initClientNavigation(opts?: {
     onNavigate: () => void;
 }): void;

package/dist/runtime/clientNavigation.js

@@ -1,32 +1,3 @@
-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
@@ -35,14 +6,33 @@ export function initClientNavigation(opts = {
 }) {
     // Intercept all anchor tag clicks
     document.addEventListener("click", async function handleClickEvent(event) {
-        // Prevent default navigation
-        if (!validateClickEvent(event, event.target)) {
+        // 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")) {
+            return;
+        }
+        // Prevent default navigation
         event.preventDefault();
-        const el = event.target;
-        const a = el.closest("a");
-        const href = a?.getAttribute("href");
+        // push this to the history stack.
         window.history.pushState({ path: href }, "", window.location.origin + href);
         await opts.onNavigate();
     }, true);

package/dist/runtime/components/HealthCheck.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { RequestInfo } from "../requestInfo/types";
+export declare const HealthCheckInfo: React.FC;
+/**
+ * Wrapper component that displays health check info above the original page content
+ */
+export declare const HealthCheckWrapper: React.FC<{
+    children: React.ReactNode;
+}>;
+/**
+ * Standalone health check page that conforms to the RouteComponent type
+ */
+export declare const HealthCheckPage: (requestInfo: RequestInfo) => React.JSX.Element;

package/dist/runtime/components/HealthCheck.js

@@ -0,0 +1,56 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { HealthCheckClient } from "./HealthCheckClient";
+export const HealthCheckInfo = async () => {
+    const timestamp = Date.now();
+    let status = "error";
+    let verificationPassed = false;
+    let result = null;
+    try {
+        result = await globalThis.__rw.callServer("__health", [timestamp]);
+        // Check the result
+        if (typeof result === "object" && result !== null) {
+            status = result.status || "error";
+            verificationPassed = result.timestamp === timestamp;
+        }
+        else if (result === "ok") {
+            status = "ok";
+            verificationPassed = true;
+        }
+    }
+    catch (error) {
+        console.error("Health check failed:", error);
+        status = "error";
+        result = { error: error instanceof Error ? error.message : String(error) };
+    }
+    return (_jsxs("div", { id: "health-check-container", style: {
+            fontFamily: "system-ui, -apple-system, sans-serif",
+            margin: "20px",
+            padding: "15px",
+            border: "1px solid #ddd",
+            borderRadius: "4px",
+            background: "#f9f9f9",
+        }, children: [_jsxs("h2", { style: {
+                    color: status === "ok" ? "#0c9" : "#f44",
+                    margin: "0 0 10px 0",
+                }, children: ["Health Check: ", status] }), _jsx("div", { id: "health-check-result", "data-result": status, "data-timestamp": timestamp, "data-verified": verificationPassed ? "true" : "false", children: verificationPassed
+                    ? "Timestamp verification passed ✅"
+                    : "Timestamp verification failed ⚠️" }), _jsxs("details", { style: { marginTop: "10px" }, children: [_jsx("summary", { children: "Details" }), _jsx("pre", { style: {
+                            background: "#f5f5f5",
+                            padding: "10px",
+                            borderRadius: "4px",
+                            fontSize: "12px",
+                            overflow: "auto",
+                        }, children: JSON.stringify({ timestamp, result, verificationPassed }, null, 2) })] }), _jsx(HealthCheckClient, {})] }));
+};
+/**
+ * Wrapper component that displays health check info above the original page content
+ */
+export const HealthCheckWrapper = ({ children }) => {
+    return (_jsxs(_Fragment, { children: [_jsx(HealthCheckInfo, {}), children] }));
+};
+/**
+ * Standalone health check page that conforms to the RouteComponent type
+ */
+export const HealthCheckPage = (requestInfo) => {
+    return (_jsxs("div", { style: { maxWidth: "800px", margin: "0 auto", padding: "40px 20px" }, children: [_jsx("h1", { children: "RedwoodJS SDK Health Check" }), _jsx(HealthCheckInfo, {}), _jsx("p", { style: { marginTop: "20px" }, children: "This is a dedicated health check page to verify that your RedwoodJS SDK application is functioning correctly. It tests that server-side rendering, client-side hydration, and RSC (React Server Components) actions are all working properly." }), _jsx("p", { children: "Use the button below to manually trigger a new health check at any time." })] }));
+};

package/dist/runtime/components/HealthCheckClient.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const HealthCheckClient: React.FC;

package/dist/runtime/components/HealthCheckClient.js

@@ -0,0 +1,78 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+export const HealthCheckClient = () => {
+    const [loading, setLoading] = useState(false);
+    const [lastCheck, setLastCheck] = useState(null);
+    const runHealthCheck = async () => {
+        setLoading(true);
+        try {
+            // Get current timestamp to verify round-trip
+            const timestamp = Date.now();
+            const result = await globalThis.__rw.callServer("__health", [timestamp]);
+            // Process the result
+            let status = "error";
+            let verificationPassed = false;
+            if (typeof result === "object" && result !== null) {
+                const typedResult = result;
+                status = typedResult.status || "error";
+                verificationPassed = typedResult.timestamp === timestamp;
+            }
+            else if (result === "ok") {
+                status = "ok";
+                verificationPassed = true;
+            }
+            setLastCheck({
+                status,
+                verificationPassed,
+                timestamp,
+                rawResult: result,
+            });
+        }
+        catch (error) {
+            setLastCheck({
+                status: "error",
+                verificationPassed: false,
+                timestamp: Date.now(),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    return (_jsxs("div", { className: "health-check-client", style: {
+            margin: "20px 0",
+            padding: "15px",
+            border: "1px solid #ddd",
+            borderRadius: "4px",
+            background: "#f9f9f9",
+            fontFamily: "system-ui, -apple-system, sans-serif",
+        }, children: [_jsx("h3", { children: "Manual Health Check" }), _jsx("button", { onClick: runHealthCheck, disabled: loading, style: {
+                    padding: "8px 16px",
+                    background: loading ? "#ccc" : "#0070f3",
+                    color: "white",
+                    border: "none",
+                    borderRadius: "4px",
+                    cursor: loading ? "not-allowed" : "pointer",
+                    fontWeight: "bold",
+                }, children: loading ? "Checking..." : "Run Health Check" }), lastCheck && (_jsx("div", { style: { marginTop: "15px" }, children: _jsxs("div", { style: {
+                        padding: "10px",
+                        borderRadius: "4px",
+                        background: lastCheck.status === "ok" ? "#e6f7ee" : "#ffeded",
+                        border: `1px solid ${lastCheck.status === "ok" ? "#0c9" : "#f44"}`,
+                    }, children: [_jsxs("h4", { style: {
+                                margin: "0 0 10px 0",
+                                color: lastCheck.status === "ok" ? "#0c9" : "#f44",
+                            }, children: ["Status: ", lastCheck.status] }), _jsxs("p", { children: ["Timestamp verification:", " ", lastCheck.verificationPassed ? "Passed ✅" : "Failed ⚠️"] }), lastCheck.error && (_jsxs("p", { style: { color: "#f44" }, children: ["Error: ", lastCheck.error] })), _jsxs("details", { style: { marginTop: "10px" }, children: [_jsx("summary", { children: "Raw Result" }), _jsx("pre", { style: {
+                                        background: "#f5f5f5",
+                                        padding: "10px",
+                                        borderRadius: "4px",
+                                        fontSize: "12px",
+                                        overflow: "auto",
+                                    }, children: JSON.stringify({
+                                        timestamp: lastCheck.timestamp,
+                                        result: lastCheck.rawResult,
+                                        verificationPassed: lastCheck.verificationPassed,
+                                    }, null, 2) })] })] }) }))] }));
+};

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

@@ -0,0 +1 @@
+export declare const NoSSRStub: () => import("react/jsx-runtime").JSX.Element;

package/dist/runtime/imports/NoSSRStub.js

@@ -0,0 +1,4 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ClientOnly } from "./ClientOnly";
+export const NoSSRStub = () => _jsx(ClientOnly, { children: null });

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

@@ -0,0 +1,3 @@
+import { Kysely } from "kysely";
+export declare function createDurableObjectDb<T>(durableObjectBinding: any, name?: string): Kysely<T>;
+export declare function createDb<T>(durableObjectBinding: any, name?: string): Kysely<T>;

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

@@ -0,0 +1,36 @@
+import { Kysely } from "kysely";
+import { requestInfo } from "../../requestInfo/worker.js";
+import { DOWorkerDialect } from "./SqliteDurableObject.js";
+export function createDurableObjectDb(durableObjectBinding, name = "main") {
+    const durableObjectId = durableObjectBinding.idFromName(name);
+    const stub = durableObjectBinding.get(durableObjectId);
+    return new Kysely({
+        dialect: new DOWorkerDialect({ stub }),
+    });
+}
+export function createDb(durableObjectBinding, name = "main") {
+    // Create a cache key from the binding and name
+    const cacheKey = `${durableObjectBinding}_${name}`;
+    // Return a proxy that lazily creates and caches the database instance
+    return new Proxy({}, {
+        get(target, prop, receiver) {
+            if (!requestInfo.rw.databases) {
+                requestInfo.rw.databases = new Map();
+            }
+            // Check if we have a cached instance
+            let db = requestInfo.rw.databases.get(cacheKey);
+            if (!db) {
+                // Create the database instance and cache it
+                db = createDurableObjectDb(durableObjectBinding, name);
+                requestInfo.rw.databases.set(cacheKey, db);
+            }
+            // Forward the property access to the actual database instance
+            const value = db[prop];
+            // If it's a function, bind it to the database instance
+            if (typeof value === "function") {
+                return value.bind(db);
+            }
+            return value;
+        },
+    });
+}

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

@@ -0,0 +1,2 @@
+declare const debug: (namespace: string) => (...args: any[]) => void;
+export default debug;

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

@@ -0,0 +1,41 @@
+// Simple debug function with DEBUG environment variable filtering
+// Supports patterns like: DEBUG=passkey:* or DEBUG=passkey:database,passkey:functions
+function isEnabled(namespace) {
+    const debug = process.env.DEBUG;
+    if (!debug)
+        return false;
+    // Split by comma and check each pattern
+    const patterns = debug.split(",").map((p) => p.trim());
+    for (const pattern of patterns) {
+        // Handle exclusions (patterns starting with -)
+        if (pattern.startsWith("-")) {
+            const excludePattern = pattern.slice(1);
+            if (matchesPattern(namespace, excludePattern)) {
+                return false;
+            }
+            continue;
+        }
+        // Check if namespace matches this pattern
+        if (matchesPattern(namespace, pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesPattern(namespace, pattern) {
+    // Convert pattern to regex (handle * wildcards)
+    const regex = pattern
+        .replace(/\*/g, ".*") // * becomes .*
+        .replace(/:/g, "\\:"); // escape colons
+    return new RegExp(`^${regex}$`).test(namespace);
+}
+// Factory function that creates a debugger for a given namespace
+const debug = (namespace) => {
+    return (...args) => {
+        if (isEnabled(namespace)) {
+            console.log(`[${namespace}]`, ...args);
+        }
+    };
+};
+// Export the factory function as default (like the real debug package)
+export default debug;

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -82,18 +82,12 @@ 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);