rwsdk 1.0.0-beta.5 → 1.0.0-beta.51

package/dist/runtime/requestInfo/utils.js

@@ -0,0 +1,45 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { generateNonce } from "../lib/utils";
+export const DefaultRequestInfoDocument = ({ children }) => (_jsx(_Fragment, { children: children }));
+/**
+ * Constructs a generic requestInfo that can be used as defaults.
+ * Allows for passing in overrides to initialize with defaults.
+ */
+export const constructWithDefaultRequestInfo = (overrides = {}) => {
+    const { rw: rwOverrides, ...otherRequestInfoOverrides } = overrides;
+    const defaultRequestInfo = {
+        request: new Request("http://localhost/"),
+        path: "/",
+        params: {},
+        ctx: {},
+        cf: {
+            waitUntil: () => { },
+            passThroughOnException: () => { },
+            props: {},
+        },
+        response: {
+            status: 200,
+            headers: new Headers(),
+        },
+        isAction: false,
+        rw: {
+            Document: DefaultRequestInfoDocument,
+            nonce: generateNonce(),
+            rscPayload: true,
+            ssr: true,
+            databases: new Map(),
+            scriptsToBeLoaded: new Set(),
+            entryScripts: new Set(),
+            inlineScripts: new Set(),
+            pageRouteResolved: undefined,
+        },
+    };
+    return {
+        ...defaultRequestInfo,
+        ...otherRequestInfoOverrides,
+        rw: {
+            ...defaultRequestInfo.rw,
+            ...rwOverrides,
+        },
+    };
+};

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

@@ -2,7 +2,6 @@ import { DefaultAppContext, RequestInfo } from "./types";
 type DefaultRequestInfo = RequestInfo<DefaultAppContext>;
 export declare const requestInfo: DefaultRequestInfo;
 export declare function getRequestInfo(): RequestInfo;
-export declare function waitForRequestInfo(): Promise<DefaultRequestInfo>;
 export declare function runWithRequestInfo<Result>(nextRequestInfo: DefaultRequestInfo, fn: () => Result): Result;
 export declare function runWithRequestInfoOverrides<Result>(overrides: Partial<DefaultRequestInfo>, fn: () => Result): Result;
 export {};

package/dist/runtime/requestInfo/worker.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "async_hooks";
-const requestInfoDeferred = Promise.withResolvers();
-const requestInfoStore = new AsyncLocalStorage();
+import { defineRwState } from "rwsdk/__state";
+const requestInfoStore = defineRwState("requestInfoStore", () => new AsyncLocalStorage());
 const requestInfoBase = {};
 const REQUEST_INFO_KEYS = ["request", "params", "ctx", "rw", "cf", "response"];
 REQUEST_INFO_KEYS.forEach((key) => {
@@ -17,19 +17,13 @@ export const requestInfo = Object.freeze(requestInfoBase);
 export function getRequestInfo() {
     const store = requestInfoStore.getStore();
     if (!store) {
-        throw new Error("Request context not found");
+        throw new Error("RedwoodSDK: Request context not found. getRequestInfo() can only be called within the request lifecycle (e.g., in a route handler, middleware, or server action).\n\n" +
+            "For detailed troubleshooting steps, see: https://docs.rwsdk.com/guides/troubleshooting#request-context-errors");
     }
     return store;
 }
-export function waitForRequestInfo() {
-    return requestInfoDeferred.promise;
-}
 export function runWithRequestInfo(nextRequestInfo, fn) {
-    const runWithRequestInfoFn = () => {
-        requestInfoDeferred.resolve(nextRequestInfo);
-        return fn();
-    };
-    return requestInfoStore.run(nextRequestInfo, runWithRequestInfoFn);
+    return requestInfoStore.run(nextRequestInfo, fn);
 }
 export function runWithRequestInfoOverrides(overrides, fn) {
     const requestInfo = requestInfoStore.getStore();

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/server.d.ts

@@ -0,0 +1,52 @@
+type Interruptor<TArgs extends any[] = any[], TResult = any> = (context: {
+    request: Request;
+    ctx: Record<string, any>;
+    args: TArgs;
+}) => Promise<Response | void | TResult> | Response | void | TResult;
+type ServerFunction<TArgs extends any[] = any[], TResult = any> = (...args: TArgs) => Promise<TResult>;
+type ServerFunctionOptions = {
+    method?: "GET" | "POST";
+};
+type WrappedServerFunction<TArgs extends any[] = any[], TResult = any> = {
+    (...args: TArgs): Promise<TResult>;
+    method?: "GET" | "POST";
+};
+/**
+ * Wrap a function to be used as a server query.
+ *
+ * - **Method**: Defaults to `GET`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it returns data-only and does **not** rehydrate or re-render the React page.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `queries.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // getters.ts
+ * "use server"
+ *
+ * export const getUser = serverQuery(async (id: string) => {
+ *   return db.user.findUnique({ where: { id } })
+ * })
+ * ```
+ */
+export declare function serverQuery<TArgs extends any[] = any[], TResult = any>(fnsOrFn: ServerFunction<TArgs, TResult> | [...Interruptor<TArgs, TResult>[], ServerFunction<TArgs, TResult>], options?: ServerFunctionOptions): WrappedServerFunction<TArgs, TResult>;
+/**
+ * Wrap a function to be used as a server action.
+ *
+ * - **Method**: Defaults to `POST`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it **will** rehydrate and re-render the React page with the new server state.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `actions.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // actions.ts
+ * "use server"
+ *
+ * export const updateUser = serverAction(async (id: string, data: any) => {
+ *   return db.user.update({ where: { id }, data })
+ * })
+ * ```
+ */
+export declare function serverAction<TArgs extends any[] = any[], TResult = any>(fnsOrFn: ServerFunction<TArgs, TResult> | [...Interruptor<TArgs, TResult>[], ServerFunction<TArgs, TResult>], options?: ServerFunctionOptions): WrappedServerFunction<TArgs, TResult>;
+export {};

package/dist/runtime/server.js

@@ -0,0 +1,88 @@
+import { requestInfo } from "./requestInfo/worker";
+function createServerFunction(fns, mainFn, options) {
+    const wrapped = async (...args) => {
+        const { request, ctx } = requestInfo;
+        // Execute interruptors
+        for (const fn of fns) {
+            const result = await fn({ request, ctx, args });
+            if (result instanceof Response) {
+                // We can't easily return a Response from a server action function
+                // because the return type is expected to be TResult.
+                // However, if the interruptor returns a Response, it usually means "stop and return this HTTP response".
+                // In the RSC context, throwing a Response is a common pattern to short-circuit.
+                throw result;
+            }
+        }
+        return mainFn(...args);
+    };
+    wrapped.method = options?.method ?? "POST"; // Default to POST if not specified, though user said serverQuery defaults to GET?
+    // User said: "export const getProject = serverQuery(...) // Defaults to GET"
+    // So serverQuery defaults to GET, serverAction defaults to POST?
+    return wrapped;
+}
+/**
+ * Wrap a function to be used as a server query.
+ *
+ * - **Method**: Defaults to `GET`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it returns data-only and does **not** rehydrate or re-render the React page.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `queries.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // getters.ts
+ * "use server"
+ *
+ * export const getUser = serverQuery(async (id: string) => {
+ *   return db.user.findUnique({ where: { id } })
+ * })
+ * ```
+ */
+export function serverQuery(fnsOrFn, options) {
+    let fns = [];
+    let mainFn;
+    if (Array.isArray(fnsOrFn)) {
+        fns = fnsOrFn.slice(0, -1);
+        mainFn = fnsOrFn[fnsOrFn.length - 1];
+    }
+    else {
+        mainFn = fnsOrFn;
+    }
+    const method = options?.method ?? "GET"; // Default to GET for query
+    const wrapped = createServerFunction(fns, mainFn, { ...options, method });
+    wrapped.method = method;
+    return wrapped;
+}
+/**
+ * Wrap a function to be used as a server action.
+ *
+ * - **Method**: Defaults to `POST`. can be changed via `options`.
+ * - **Behavior**: When called from the client, it **will** rehydrate and re-render the React page with the new server state.
+ * - **Location**: Must be defined in a file with `"use server"`. We recommend `actions.ts` colocated with components.
+ * - **Middleware**: You can pass an array of functions as the first argument to act as interruptors (e.g. for auth).
+ *
+ * @example
+ * ```ts
+ * // actions.ts
+ * "use server"
+ *
+ * export const updateUser = serverAction(async (id: string, data: any) => {
+ *   return db.user.update({ where: { id }, data })
+ * })
+ * ```
+ */
+export function serverAction(fnsOrFn, options) {
+    let fns = [];
+    let mainFn;
+    if (Array.isArray(fnsOrFn)) {
+        fns = fnsOrFn.slice(0, -1);
+        mainFn = fnsOrFn[fnsOrFn.length - 1];
+    }
+    else {
+        mainFn = fnsOrFn;
+    }
+    const method = options?.method ?? "POST"; // Default to POST for action
+    const wrapped = createServerFunction(fns, mainFn, { ...options, method });
+    wrapped.method = method;
+    return wrapped;
+}

package/dist/runtime/state.d.ts

@@ -0,0 +1,3 @@
+export declare function defineRwState<T>(key: string, initializer: () => T): T;
+export declare function getRwState<T>(key: string): T | undefined;
+export declare function setRwState<T>(key: string, value: T): void;

package/dist/runtime/state.js

@@ -0,0 +1,13 @@
+const state = {};
+export function defineRwState(key, initializer) {
+    if (!(key in state)) {
+        state[key] = initializer();
+    }
+    return state[key];
+}
+export function getRwState(key) {
+    return state[key];
+}
+export function setRwState(key, value) {
+    state[key] = value;
+}

package/dist/runtime/worker.d.ts

@@ -8,9 +8,11 @@ declare global {
         DB: D1Database;
     };
 }
-export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>>(routes: Route<T>[]) => {
+export type AppDefinition<Routes extends readonly Route<any>[], T extends RequestInfo> = {
     fetch: (request: Request, env: Env, cf: ExecutionContext) => Promise<Response>;
+    __rwRoutes: Routes;
 };
+export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>, Routes extends readonly Route<T>[] = readonly Route<T>[]>(routes: Routes) => AppDefinition<Routes, T>;
 export declare const DefaultDocument: React.FC<{
     children: React.ReactNode;
 }>;

package/dist/runtime/worker.js

@@ -11,10 +11,11 @@ import { defineRoutes } from "./lib/router";
 import { generateNonce } from "./lib/utils";
 export * from "./requestInfo/types";
 export const defineApp = (routes) => {
+    const router = defineRoutes(routes);
     return {
+        __rwRoutes: routes,
         fetch: async (request, env, cf) => {
             globalThis.__webpack_require__ = ssrWebpackRequire;
-            const router = defineRoutes(routes);
             // context(justinvdm, 5 Feb 2025): Serve assets requests using the assets service binding
             // todo(justinvdm, 5 Feb 2025): Find a way to avoid this so asset requests are served directly
             // rather than first needing to go through the worker
@@ -23,6 +24,35 @@ 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 expectedToken = import.meta.env
+                    .VITE_RWSDK_WORKER_RUN_TOKEN;
+                const requestToken = request.headers.get("x-rwsdk-worker-run-token");
+                if (!expectedToken || expectedToken !== requestToken) {
+                    return new Response("Forbidden", { status: 403 });
+                }
+                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;', {
@@ -33,6 +63,10 @@ export const defineApp = (routes) => {
             }
             try {
                 const url = new URL(request.url);
+                let path = url.pathname;
+                if (path !== "/" && !path.endsWith("/")) {
+                    path = path + "/";
+                }
                 const isRSCRequest = url.searchParams.has("__rsc") ||
                     request.headers.get("accept")?.includes("text/x-component");
                 const isAction = url.searchParams.has("__rsc_action_id");
@@ -43,6 +77,8 @@ export const defineApp = (routes) => {
                     ssr: true,
                     databases: new Map(),
                     scriptsToBeLoaded: new Set(),
+                    entryScripts: new Set(),
+                    inlineScripts: new Set(),
                     pageRouteResolved: undefined,
                 };
                 const userResponseInit = {
@@ -51,6 +87,7 @@ export const defineApp = (routes) => {
                 };
                 const outerRequestInfo = {
                     request,
+                    path,
                     cf,
                     params: {},
                     ctx: {},
@@ -80,7 +117,13 @@ export const defineApp = (routes) => {
                         });
                     }
                     const actionResult = normalizeActionResult(requestInfo.rw.actionResult);
-                    const pageElement = createPageElement(requestInfo, Page);
+                    const isDataOnly = request.headers.get("x-rsc-data-only") === "true";
+                    const pageElement = isDataOnly && actionResult !== undefined
+                        ? null
+                        : createPageElement(requestInfo, Page);
+                    if (pageElement === null) {
+                        rw.pageRouteResolved?.resolve();
+                    }
                     const { rscPayload: shouldInjectRSCPayload } = rw;
                     let rscPayloadStream = renderToRscStream({
                         input: {

package/dist/scripts/debug-sync.mjs

@@ -99,28 +99,20 @@ const findUp = async (names, startDir) => {
     return undefined;
 };
 const getMonorepoRoot = async (startDir) => {
-    try {
-        // `pnpm root` is the most reliable way to find the workspace root node_modules
-        const { stdout } = await $({
-            cwd: startDir,
-        }) `pnpm root`;
-        // pnpm root returns the node_modules path, so we go up one level
-        return path.resolve(stdout, "..");
-    }
-    catch (e) {
-        console.warn(`Could not determine pnpm root from ${startDir}. Falling back to file search.`);
-        const root = await findUp(["pnpm-workspace.yaml"], startDir);
-        if (root) {
-            return root;
-        }
-    }
-    console.warn("Could not find pnpm monorepo root. Using parent directory of target as fallback.");
-    return path.resolve(startDir, "..");
+    return await findUp(["pnpm-workspace.yaml"], startDir);
 };
 const areDependenciesEqual = (deps1, deps2) => {
     // Simple string comparison for this use case is sufficient
     return JSON.stringify(deps1 ?? {}) === JSON.stringify(deps2 ?? {});
 };
+const isPlaygroundExample = async (targetDir, monorepoRoot) => {
+    const pkgJson = JSON.parse(await fs.readFile(path.join(monorepoRoot, "package.json"), "utf-8"));
+    if (pkgJson.name === "rw-sdk-monorepo") {
+        const playgroundDir = path.join(monorepoRoot, "playground");
+        return targetDir.startsWith(playgroundDir);
+    }
+    return false;
+};
 const performFullSync = async (sdkDir, targetDir, monorepoRoot) => {
     console.log("📦 Performing full sync with tarball...");
     let tarballPath = "";
@@ -178,8 +170,14 @@ const performSync = async (sdkDir, targetDir) => {
     // Clean up vite cache in the target project
     await cleanupViteEntries(targetDir);
     const monorepoRoot = await getMonorepoRoot(targetDir);
+    const rootDir = monorepoRoot ?? targetDir;
     const projectName = path.basename(targetDir);
-    const installedSdkPackageJsonPath = path.join(monorepoRoot, "node_modules", `.rwsync_${projectName}`, "node_modules", "rwsdk", "package.json");
+    if (monorepoRoot && (await isPlaygroundExample(targetDir, monorepoRoot))) {
+        console.log("Playground example detected. Skipping file sync; workspace linking will be used.");
+        console.log("✅ Done syncing");
+        return;
+    }
+    const installedSdkPackageJsonPath = path.join(rootDir, "node_modules", `.rwsync_${projectName}`, "node_modules", "rwsdk", "package.json");
     let needsFullSync = false;
     if (!existsSync(installedSdkPackageJsonPath)) {
         console.log("No previous sync found, performing full sync.");
@@ -195,10 +193,10 @@ const performSync = async (sdkDir, targetDir) => {
         }
     }
     if (needsFullSync) {
-        await performFullSync(sdkDir, targetDir, monorepoRoot);
+        await performFullSync(sdkDir, targetDir, rootDir);
     }
     else {
-        await performFastSync(sdkDir, targetDir, monorepoRoot);
+        await performFastSync(sdkDir, targetDir, rootDir);
     }
     console.log("✅ Done syncing");
 };

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,77 @@
-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 crypto from "crypto";
+import dbg from "debug";
+import getPort from "get-port";
+import path from "path";
+import { pathToFileURL } from "url";
+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 token = crypto.randomBytes(32).toString("hex");
+    process.env.VITE_RWSDK_WORKER_RUN_TOKEN = token;
+    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 fileUrl = pathToFileURL(scriptPath).href;
+        const url = `http://localhost:${port}/__worker-run?script=${encodeURIComponent(fileUrl)}`;
+        debug("Fetching %s", url);
+        const response = await fetch(url, {
+            headers: {
+                "x-rwsdk-worker-run-token": token,
+            },
+        });
+        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();