rwsdk 1.0.0-beta.8 → 1.0.0-beta.9

package/dist/lib/e2e/index.d.mts

@@ -1,3 +1,4 @@
+export * from "../$.mjs";
 export * from "./browser.mjs";
 export * from "./dev.mjs";
 export * from "./environment.mjs";

package/dist/lib/e2e/index.mjs

@@ -1,3 +1,4 @@
+export * from "../$.mjs";
 export * from "./browser.mjs";
 export * from "./dev.mjs";
 export * from "./environment.mjs";

package/dist/lib/e2e/testHarness.d.mts

@@ -5,6 +5,7 @@ export type { Browser, Page } from "puppeteer-core";
 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, };
 interface DevServerInstance {
     url: string;
+    projectDir: string;
     stopDev: () => Promise<void>;
 }
 interface DeploymentInstance {
@@ -43,17 +44,29 @@ export interface SetupPlaygroundEnvironmentOptions {
  * and installs dependencies using a tarball of the SDK.
  * This ensures that tests run in a clean, isolated environment.
  */
-export declare function setupPlaygroundEnvironment(options?: string | SetupPlaygroundEnvironmentOptions): void;
+export declare function setupPlaygroundEnvironment(options: SetupPlaygroundEnvironmentOptions | string): void;
 /**
  * Creates a dev server instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export declare function createDevServer(projectDir: string): Promise<DevServerInstance>;
+export declare function createDevServer(): {
+    projectDir: string;
+    start: () => Promise<DevServerInstance>;
+};
 /**
  * Creates a deployment instance using the shared playground environment.
  * Automatically registers cleanup to run after the test.
  */
-export declare function createDeployment(projectDir: string): Promise<DeploymentInstance>;
+export declare function createDeployment(): {
+    projectDir: string;
+    start: () => Promise<{
+        url: string;
+        workerName: string;
+        resourceUniqueKey: string;
+        projectDir: string;
+        cleanup: () => Promise<void>;
+    }>;
+};
 /**
  * Executes a test function with a retry mechanism for specific error codes.
  * @param name - The name of the test, used for logging.
@@ -63,13 +76,25 @@ export declare function createDeployment(projectDir: string): Promise<Deployment
  *                     called automatically on failure.
  */
 export declare function runTestWithRetries(name: string, attemptFn: () => Promise<void>): Promise<void>;
+type SDKRunner = (name: string, testLogic: (context: {
+    createDevServer: () => Promise<DevServerInstance>;
+    createDeployment: () => Promise<DeploymentInstance>;
+    browser: Browser;
+    page: Page;
+    projectDir: string;
+}) => Promise<void>) => void;
 declare function createTestRunner(testFn: (typeof test | typeof test.only)["concurrent"], envType: "dev" | "deploy"): (name: string, testLogic: (context: {
     devServer?: DevServerInstance;
     deployment?: DeploymentInstance;
     browser: Browser;
     page: Page;
     url: string;
+    projectDir: string;
 }) => Promise<void>) => void;
+export declare const testSDK: SDKRunner & {
+    only: SDKRunner;
+    skip: typeof test.skip;
+};
 /**
  * High-level test wrapper for dev server tests.
  * Automatically skips if RWSDK_SKIP_DEV=1
@@ -83,6 +108,7 @@ export declare namespace testDev {
         browser: Browser;
         page: Page;
         url: string;
+        projectDir: string;
     }) => Promise<void>) => void;
 }
 /**
@@ -98,6 +124,7 @@ export declare namespace testDeploy {
         browser: Browser;
         page: Page;
         url: string;
+        projectDir: string;
     }) => Promise<void>) => void;
 }
 /**
@@ -110,6 +137,7 @@ export declare function testDevAndDeploy(name: string, testFn: (context: {
     browser: Browser;
     page: Page;
     url: string;
+    projectDir: string;
 }) => Promise<void>): void;
 export declare namespace testDevAndDeploy {
     var skip: (name: string, testFn?: any) => void;

package/dist/lib/e2e/testHarness.mjs

@@ -20,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
@@ -30,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());
@@ -43,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;
     });
@@ -82,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 () => {
@@ -109,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;
             });
@@ -118,7 +121,7 @@ export function setupPlaygroundEnvironment(options = {}) {
             globalDevInstancePromise.catch(() => { });
         }
         else {
-            globalDevInstancePromise = Promise.resolve(null);
+            globalDevPlaygroundEnv = null;
         }
         if (deploy) {
             const deployEnv = await setupTarballEnvironment({
@@ -130,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;
             });
@@ -138,7 +144,7 @@ export function setupPlaygroundEnvironment(options = {}) {
             globalDeploymentInstancePromise.catch(() => { });
         }
         else {
-            globalDeploymentInstancePromise = Promise.resolve(null);
+            globalDeployPlaygroundEnv = null;
         }
     }, SETUP_PLAYGROUND_ENV_TIMEOUT);
 }
@@ -146,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.
@@ -270,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, () => {
@@ -332,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/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/script.d.ts

@@ -1,5 +1,3 @@
 export declare const defineScript: (fn: ({ env }: {
     env: Env;
-}) => Promise<unknown>) => {
-    fetch: (request: Request, env: Env, cf: ExecutionContext) => Promise<Response>;
-};
+}) => Promise<unknown>) => () => Promise<unknown>;

package/dist/runtime/script.js

@@ -1,11 +1,2 @@
 import { env } from "cloudflare:workers";
-import { defineApp } from "./worker";
-export const defineScript = (fn) => {
-    const app = defineApp([
-        async () => {
-            await fn({ env: env });
-            return new Response("Done!");
-        },
-    ]);
-    return app;
-};
+export const defineScript = (fn) => () => fn({ env: env });

package/dist/runtime/worker.js

@@ -23,6 +23,29 @@ export const defineApp = (routes) => {
                 url.pathname = url.pathname.slice("/assets/".length);
                 return env.ASSETS.fetch(new Request(url.toString(), request));
             }
+            else if (import.meta.env.VITE_IS_DEV_SERVER &&
+                new URL(request.url).pathname === "/__worker-run") {
+                const url = new URL(request.url);
+                const scriptPath = url.searchParams.get("script");
+                if (!scriptPath) {
+                    return new Response("Missing 'script' query parameter", {
+                        status: 400,
+                    });
+                }
+                try {
+                    const scriptModule = await import(/* @vite-ignore */ scriptPath);
+                    if (scriptModule.default) {
+                        await scriptModule.default(request, env, cf);
+                    }
+                    return new Response("Script executed successfully");
+                }
+                catch (e) {
+                    console.error(`Error executing script: ${scriptPath}\n\n${e.stack}`);
+                    return new Response(`Error executing script: ${e.message}`, {
+                        status: 500,
+                    });
+                }
+            }
             else if (import.meta.env.VITE_IS_DEV_SERVER &&
                 request.url.includes("/__vite_preamble__")) {
                 return new Response('import RefreshRuntime from "/@react-refresh"; RefreshRuntime.injectIntoGlobalHook(window); window.$RefreshReg$ = () => {}; window.$RefreshSig$ = () => (type) => type; window.__vite_plugin_react_preamble_installed__ = true;', {

package/dist/scripts/worker-run.d.mts

@@ -1 +1 @@
-export declare const runWorkerScript: (relativeScriptPath: string) => Promise<never>;
+export {};

package/dist/scripts/worker-run.mjs

@@ -1,131 +1,68 @@
-import { Lang, parse } from "@ast-grep/napi";
-import baseDebug from "debug";
-import enhancedResolve from "enhanced-resolve";
-import { readFile, writeFile } from "fs/promises";
-import path, { resolve } from "path";
-import tmp from "tmp-promise";
-import { createServer as createViteServer } from "vite";
-import { unstable_readConfig } from "wrangler";
-import { findWranglerConfig } from "../lib/findWranglerConfig.mjs";
-import { redwood } from "../vite/index.mjs";
-const debug = baseDebug("rwsdk:worker-run");
-export const runWorkerScript = async (relativeScriptPath) => {
+import dbg from "debug";
+import getPort from "get-port";
+import path from "path";
+import * as vite from "vite";
+import { createLogger } from "vite";
+const debug = dbg("rwsdk:worker-run");
+const main = async () => {
+    process.env.RWSDK_WORKER_RUN = "1";
+    const relativeScriptPath = process.argv[2];
     if (!relativeScriptPath) {
         console.error("Error: Script path is required");
         console.log("\nUsage:");
-        console.log("  npm run worker:run <script-path>");
-        console.log("\nOptions:");
-        console.log("  RWSDK_WRANGLER_CONFIG      Environment variable for config path");
+        console.log("  rwsdk worker-run <script-path>");
         console.log("\nExamples:");
-        console.log("  npm run worker:run src/scripts/seed.ts");
-        console.log("  RWSDK_WRANGLER_CONFIG=custom.toml npm run worker:run src/scripts/seed.ts\n");
+        console.log("  rwsdk worker-run src/scripts/seed.ts\n");
         process.exit(1);
     }
-    const scriptPath = resolve(process.cwd(), relativeScriptPath);
-    debug("Running worker script: %s", scriptPath);
-    const workerConfigPath = process.env.RWSDK_WRANGLER_CONFIG
-        ? resolve(process.cwd(), process.env.RWSDK_WRANGLER_CONFIG)
-        : await findWranglerConfig(process.cwd());
-    debug("Using wrangler config: %s", workerConfigPath);
-    const workerConfig = unstable_readConfig({
-        config: workerConfigPath,
-        env: "dev",
-    });
-    const durableObjectsToExport = workerConfig.durable_objects?.bindings
-        .filter((binding) => !binding.script_name)
-        .map((binding) => binding.class_name) ?? [];
-    const workerEntryRelativePath = workerConfig.main;
-    const workerEntryPath = workerEntryRelativePath ?? path.join(process.cwd(), "src/worker.tsx");
-    const durableObjectExports = [];
-    if (durableObjectsToExport.length > 0) {
-        const resolver = enhancedResolve.create.sync({
-            extensions: [".mts", ".ts", ".tsx", ".mjs", ".js", ".jsx", ".json"],
-        });
-        const workerEntryContents = await readFile(workerEntryPath, "utf-8");
-        const workerEntryAst = parse(Lang.Tsx, workerEntryContents);
-        const exportDeclarations = [
-            ...workerEntryAst.root().findAll('export { $$$EXPORTS } from "$MODULE"'),
-            ...workerEntryAst.root().findAll("export { $$$EXPORTS } from '$MODULE'"),
-            ...workerEntryAst.root().findAll("export { $$$EXPORTS } from '$MODULE'"),
-        ];
-        for (const exportDeclaration of exportDeclarations) {
-            const moduleMatch = exportDeclaration.getMatch("MODULE");
-            const exportsMatch = exportDeclaration.getMultipleMatches("EXPORTS");
-            if (!moduleMatch || exportsMatch.length === 0) {
-                continue;
-            }
-            const modulePath = moduleMatch.text();
-            const specifiers = exportsMatch.map((m) => m.text().trim());
-            for (const specifier of specifiers) {
-                if (durableObjectsToExport.includes(specifier)) {
-                    const resolvedPath = resolver(path.dirname(workerEntryPath), modulePath);
-                    durableObjectExports.push(`export { ${specifier} } from "${resolvedPath}";`);
-                }
-            }
+    const scriptPath = path.resolve(process.cwd(), relativeScriptPath);
+    const port = await getPort();
+    let server;
+    const cleanup = async () => {
+        if (server) {
+            await server.close();
         }
-    }
-    const tmpDir = await tmp.dir({
-        prefix: "rw-worker-run-",
-        unsafeCleanup: true,
-    });
-    const relativeTmpWorkerEntryPath = "worker.tsx";
-    const tmpWorkerPath = path.join(tmpDir.path, "wrangler.json");
-    const tmpWorkerEntryPath = path.join(tmpDir.path, relativeTmpWorkerEntryPath);
-    const scriptWorkerConfig = {
-        ...workerConfig,
-        configPath: tmpWorkerPath,
-        userConfigPath: tmpWorkerPath,
-        main: relativeTmpWorkerEntryPath,
+        process.exit();
     };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
     try {
-        await writeFile(tmpWorkerPath, JSON.stringify(scriptWorkerConfig, null, 2));
-        await writeFile(tmpWorkerEntryPath, `
-${durableObjectExports.join("\n")}
-export { default } from "${scriptPath}";
-`);
-        debug("Worker config written to: %s", tmpWorkerPath);
-        debug("Worker entry written to: %s", tmpWorkerEntryPath);
-        process.env.RWSDK_WORKER_RUN = "1";
-        const server = await createViteServer({
-            configFile: false,
-            plugins: [
-                redwood({
-                    configPath: tmpWorkerPath,
-                    includeCloudflarePlugin: true,
-                    entry: {
-                        worker: tmpWorkerEntryPath,
-                    },
-                }),
-            ],
+        server = await vite.createServer({
+            logLevel: "silent",
+            build: {
+                outDir: ".rwsdk",
+            },
+            customLogger: createLogger("info", {
+                prefix: "[rwsdk]",
+                allowClearScreen: true,
+            }),
             server: {
-                port: 0,
+                port,
+                host: "localhost",
             },
         });
-        debug("Vite server created");
-        try {
-            await server.listen();
-            const address = server.httpServer?.address();
-            debug("Server listening on address: %o", address);
-            if (!address || typeof address === "string") {
-                throw new Error("Dev server address is invalid");
+        await server.listen();
+        const url = `http://localhost:${port}/__worker-run?script=${scriptPath}`;
+        debug("Fetching %s", url);
+        const response = await fetch(url);
+        debug("Response from worker: %s", response);
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`Error: worker-run script failed with status ${response.status}.`);
+            if (errorText) {
+                console.error("Response:", errorText);
             }
-            debug("Fetching worker...");
-            await fetch(`http://localhost:${address.port}/`);
-            debug("Worker fetched successfully");
-        }
-        finally {
-            debug("Closing server...");
-            server.close();
-            debug("Server closed");
+            process.exit(1);
         }
+        const responseText = await response.text();
+        debug("Response from worker: %s", responseText);
+    }
+    catch (e) {
+        console.error("rwsdk: Error running script:\n\n%s", e.message);
+        process.exit(1);
     }
     finally {
-        debug("Closing inspector servers...");
-        debug("Temporary files cleaned up");
+        await cleanup();
     }
-    // todo(justinvdm, 01 Apr 2025): Investigate what handles are remaining open
-    process.exit(0);
 };
-if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
-    runWorkerScript(process.argv[2]);
-}
+main();

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -38,7 +38,7 @@ export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRoo
     return {
         name: "rwsdk:directive-modules-dev",
         configureServer(server) {
-            if (!process.env.VITE_IS_DEV_SERVER || process.env.RWSDK_WORKER_RUN) {
+            if (!process.env.VITE_IS_DEV_SERVER) {
                 resolveScanPromise();
                 return;
             }

package/dist/vite/runDirectivesScan.mjs

@@ -254,7 +254,8 @@ export const runDirectivesScan = async ({ rootConfig, environments, clientFiles,
     }
 };
 const deferredLog = (message) => {
+    const doLog = process.env.RWSDK_WORKER_RUN ? log : console.log;
     setTimeout(() => {
-        console.log(message);
+        doLog(message);
     }, 500);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.0-beta.9",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -145,11 +145,13 @@
     "@vitejs/plugin-react": "~5.0.0",
     "chokidar": "~4.0.0",
     "debug": "~4.4.0",
+    "decompress": "~4.2.1",
     "enhanced-resolve": "~5.18.1",
     "eventsource-parser": "~3.0.0",
     "execa": "~9.6.0",
     "find-up": "~8.0.0",
     "fs-extra": "~11.3.0",
+    "get-port": "^7.1.0",
     "glob": "~11.0.1",
     "ignore": "~7.0.4",
     "jsonc-parser": "~3.3.1",
@@ -166,8 +168,7 @@
     "ts-morph": "~27.0.0",
     "unique-names-generator": "~4.7.1",
     "vibe-rules": "~0.3.0",
-    "vite-tsconfig-paths": "~5.1.4",
-    "decompress": "~4.2.1"
+    "vite-tsconfig-paths": "~5.1.4"
   },
   "peerDependencies": {
     "@cloudflare/vite-plugin": "^1.12.4",