rwsdk 0.2.0-alpha.9 → 0.3.0

package/dist/runtime/lib/router.js

@@ -71,53 +71,97 @@ export function defineRoutes(routes) {
             if (path !== "/" && !path.endsWith("/")) {
                 path = path + "/";
             }
-            // Find matching route
-            let match = null;
+            // Flow below; helpers are declared after the main flow for readability
+            // 1) Global middlewares: run any middleware functions encountered (Response short-circuits, element renders)
+            // 2) Route matching: skip non-matching route definitions; stop at first match
+            // 3) Route-specific middlewares: run middlewares attached to the matched route
+            // 4) Final component: render the matched route's final component (layouts apply only here)
             for (const route of flattenedRoutes) {
+                // 1) Global middlewares (encountered before a match)
                 if (typeof route === "function") {
-                    const r = await route(getRequestInfo());
-                    if (r instanceof Response) {
-                        return r;
+                    const result = await route(getRequestInfo());
+                    const handled = await handleMiddlewareResult(result);
+                    if (handled) {
+                        return handled;
                     }
                     continue;
                 }
+                // 2) Route matching (skip if not matched)
                 const params = matchPath(route.path, path);
-                if (params) {
-                    match = { params, handler: route.handler, layouts: route.layouts };
-                    break;
+                if (!params) {
+                    continue;
                 }
+                // Found a match: 3) route middlewares, then 4) final component, then stop
+                return await runWithRequestInfoOverrides({ params }, async () => {
+                    const { routeMiddlewares, componentHandler } = parseHandlers(route.handler);
+                    // 3) Route-specific middlewares
+                    const mwHandled = await handleRouteMiddlewares(routeMiddlewares);
+                    if (mwHandled) {
+                        return mwHandled;
+                    }
+                    // 4) Final component (always last item)
+                    return await handleRouteComponent(componentHandler, route.layouts || []);
+                });
             }
-            if (!match) {
-                // todo(peterp, 2025-01-28): Allow the user to define their own "not found" route.
-                return new Response("Not Found", { status: 404 });
-            }
-            let { params, handler, layouts } = match;
-            return runWithRequestInfoOverrides({ params }, async () => {
+            // No route matched and no middleware handled the request
+            // todo(peterp, 2025-01-28): Allow the user to define their own "not found" route.
+            return new Response("Not Found", { status: 404 });
+            // --- Helpers ---
+            function parseHandlers(handler) {
                 const handlers = Array.isArray(handler) ? handler : [handler];
-                for (const h of handlers) {
-                    if (isRouteComponent(h)) {
-                        const requestInfo = getRequestInfo();
-                        const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(h), layouts || [], requestInfo);
-                        if (!isClientReference(h)) {
-                            // context(justinvdm, 31 Jul 2025): We now know we're dealing with a page route,
-                            // so we create a deferred so that we can signal when we're done determining whether
-                            // we're returning a response or a react element
-                            requestInfo.rw.pageRouteResolved = Promise.withResolvers();
-                        }
-                        return await renderPage(requestInfo, WrappedComponent, onError);
-                    }
-                    else {
-                        const r = await h(getRequestInfo());
-                        if (r instanceof Response) {
-                            return r;
-                        }
+                const routeMiddlewares = handlers.slice(0, Math.max(handlers.length - 1, 0));
+                const componentHandler = handlers[handlers.length - 1];
+                return {
+                    routeMiddlewares: routeMiddlewares,
+                    componentHandler,
+                };
+            }
+            function renderElement(element) {
+                const requestInfo = getRequestInfo();
+                const Element = () => element;
+                return renderPage(requestInfo, Element, onError);
+            }
+            async function handleMiddlewareResult(result) {
+                if (result instanceof Response) {
+                    return result;
+                }
+                if (result && React.isValidElement(result)) {
+                    return await renderElement(result);
+                }
+                return undefined;
+            }
+            // Note: We no longer have separate global pass or match-only pass;
+            // the outer single pass above handles both behaviors correctly.
+            async function handleRouteMiddlewares(mws) {
+                for (const mw of mws) {
+                    const result = await mw(getRequestInfo());
+                    const handled = await handleMiddlewareResult(result);
+                    if (handled)
+                        return handled;
+                }
+                return undefined;
+            }
+            async function handleRouteComponent(component, layouts) {
+                if (isRouteComponent(component)) {
+                    const requestInfo = getRequestInfo();
+                    const WrappedComponent = wrapWithLayouts(wrapHandlerToThrowResponses(component), layouts, requestInfo);
+                    if (!isClientReference(component)) {
+                        // context(justinvdm, 31 Jul 2025): We now know we're dealing with a page route,
+                        // so we create a deferred so that we can signal when we're done determining whether
+                        // we're returning a response or a react element
+                        requestInfo.rw.pageRouteResolved = Promise.withResolvers();
                     }
+                    return await renderPage(requestInfo, WrappedComponent, onError);
                 }
-                // Add fallback return
+                // If the last handler is not a component, handle as middleware result (no layouts)
+                const tailResult = await component(getRequestInfo());
+                const handledTail = await handleMiddlewareResult(tailResult);
+                if (handledTail)
+                    return handledTail;
                 return new Response("Response not returned from route handler", {
                     status: 500,
                 });
-            });
+            }
         },
     };
 }

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

@@ -1,3 +1,3 @@
-export declare const loadServerModule: ((id: string) => Promise<any>) & import("lodash").MemoizedFunction;
+export declare const loadServerModule: (id: string) => Promise<any>;
 export declare const getServerModuleExport: (id: string) => Promise<any>;
 export declare const createServerReference: (id: string, name: string) => any;

package/dist/runtime/register/ssr.js

@@ -1,7 +1,8 @@
-import memoize from "lodash/memoize";
 import { createServerReference as baseCreateServerReference } from "react-server-dom-webpack/client.edge";
-export const loadServerModule = memoize(async (id) => {
-    const { useServerLookup } = await import("virtual:use-server-lookup.js");
+import { memoizeOnId } from "../lib/memoizeOnId";
+// @ts-ignore
+import { useServerLookup } from "virtual:use-server-lookup.js";
+export const loadServerModule = memoizeOnId(async (id) => {
     const moduleFn = useServerLookup[id];
     if (!moduleFn) {
         throw new Error(`(worker) No module found for '${id}' in module lookup for "use server" directive`);

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

@@ -0,0 +1,6 @@
+import type { RequestInfo } from "../requestInfo/types.js";
+import type { Manifest, ManifestChunk } from "../lib/manifest.js";
+export declare function findScriptForModule(id: string, manifest: Manifest): ManifestChunk | undefined;
+export declare const Preloads: ({ requestInfo }: {
+    requestInfo: RequestInfo;
+}) => import("react/jsx-runtime.js").JSX.Element;

package/dist/runtime/render/preloads.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { use } from "react";
+import { getManifest } from "../lib/manifest.js";
+export function findScriptForModule(id, manifest) {
+    const visited = new Set();
+    function find(id) {
+        if (visited.has(id)) {
+            return;
+        }
+        visited.add(id);
+        const manifestEntry = manifest[id];
+        if (!manifestEntry) {
+            return;
+        }
+        if (manifestEntry.isEntry || manifestEntry.isDynamicEntry) {
+            return manifestEntry;
+        }
+        if (manifestEntry.imports) {
+            for (const dep of manifestEntry.imports) {
+                const entry = find(dep);
+                if (entry) {
+                    return entry;
+                }
+            }
+        }
+        return;
+    }
+    return find(id);
+}
+export const Preloads = ({ requestInfo }) => {
+    const manifest = use(getManifest());
+    const allScripts = new Set();
+    for (const scriptId of requestInfo.rw.scriptsToBeLoaded) {
+        const script = findScriptForModule(scriptId, manifest);
+        if (script) {
+            allScripts.add(script.file);
+        }
+    }
+    return (_jsx(_Fragment, { children: Array.from(allScripts).map((href) => (_jsx("link", { rel: "modulepreload", href: href }, href))) }));
+};

package/dist/runtime/render/renderRscThenableToHtmlStream.js

@@ -1,12 +1,13 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { use } from "react";
 import { renderToReadableStream } from "react-dom/server.edge";
+import { Preloads } from "./preloads.js";
 import { Stylesheets } from "./stylesheets.js";
 export const renderRscThenableToHtmlStream = async ({ thenable, Document, requestInfo, shouldSSR, onError, }) => {
     const Component = () => {
         const RscApp = () => {
             const node = use(thenable).node;
-            return (_jsxs(_Fragment, { children: [_jsx(Stylesheets, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: node })] }));
+            return (_jsxs(_Fragment, { children: [_jsx(Stylesheets, { requestInfo: requestInfo }), _jsx(Preloads, { requestInfo: requestInfo }), _jsx("div", { id: "hydrate-root", children: node })] }));
         };
         // todo(justinvdm, 18 Jun 2025): We can build on this later to allow users
         // surface context. e.g:

package/dist/runtime/render/stylesheets.js

@@ -23,7 +23,7 @@ const findCssForModule = (scriptId, manifest) => {
     return Array.from(css);
 };
 export const Stylesheets = ({ requestInfo }) => {
-    const manifest = use(getManifest(requestInfo));
+    const manifest = use(getManifest());
     const allStylesheets = new Set();
     for (const scriptId of requestInfo.rw.scriptsToBeLoaded) {
         const css = findCssForModule(scriptId, manifest);

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

@@ -9,5 +9,7 @@ export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
     headers: Headers;
     rw: RwContext;
     cf: ExecutionContext;
-    response: ResponseInit;
+    response: ResponseInit & {
+        headers: Headers;
+    };
 }

package/dist/runtime/requestInfo/worker.js

@@ -2,7 +2,15 @@ import { AsyncLocalStorage } from "async_hooks";
 const requestInfoDeferred = Promise.withResolvers();
 const requestInfoStore = new AsyncLocalStorage();
 const requestInfoBase = {};
-const REQUEST_INFO_KEYS = ["request", "params", "ctx", "headers", "rw", "cf", "response"];
+const REQUEST_INFO_KEYS = [
+    "request",
+    "params",
+    "ctx",
+    "headers",
+    "rw",
+    "cf",
+    "response",
+];
 REQUEST_INFO_KEYS.forEach((key) => {
     Object.defineProperty(requestInfoBase, key, {
         enumerable: true,

package/dist/runtime/worker.d.ts

@@ -10,9 +10,6 @@ declare global {
 export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>>(routes: Route<T>[]) => {
     fetch: (request: Request, env: Env, cf: ExecutionContext) => Promise<Response>;
 };
-export declare const SmokeTestWrapper: React.FC<{
-    children: React.ReactNode;
-}>;
 export declare const DefaultDocument: React.FC<{
     children: React.ReactNode;
 }>;

package/dist/runtime/worker.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { transformRscToHtmlStream } from "./render/transformRscToHtmlStream";
 import { renderToRscStream } from "./render/renderToRscStream";
 import { rscActionHandler } from "./register/worker";
@@ -33,7 +33,6 @@ export const defineApp = (routes) => {
                 const url = new URL(request.url);
                 const isRSCRequest = url.searchParams.has("__rsc") ||
                     request.headers.get("accept")?.includes("text/x-component");
-                const isSmokeTest = url.searchParams.has("__smoke_test");
                 const userHeaders = new Headers();
                 const rw = {
                     Document: DefaultDocument,
@@ -67,9 +66,6 @@ export const defineApp = (routes) => {
                     else {
                         pageElement = _jsx(Page, { ...requestInfo });
                     }
-                    if (isSmokeTest) {
-                        pageElement = _jsx(SmokeTestWrapper, { children: pageElement });
-                    }
                     return pageElement;
                 };
                 const renderPage = async (requestInfo, Page, onError) => {
@@ -169,17 +165,12 @@ export const defineApp = (routes) => {
                 if (e instanceof Response) {
                     return e;
                 }
-                console.error("Unhandled error", e);
+                console.error("rwsdk: Received an unhandled error:\n\n%s", e);
                 throw e;
             }
         },
     };
 };
-export const SmokeTestWrapper = async ({ children }) => {
-    const smokeTestInfo = await Object.values(await import.meta.glob("/src/app/components/__SmokeTest.tsx"))[0]();
-    const SmokeTestInfo = smokeTestInfo.SmokeTestInfo;
-    return (_jsxs(_Fragment, { children: [_jsx(SmokeTestInfo, {}), children] }));
-};
 export const DefaultDocument = ({ children, }) => (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx("meta", { charSet: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" })] }), _jsx("body", { children: _jsx("div", { id: "root", children: children }) })] }));
 const isClientReference = (Component) => {
     return Object.prototype.hasOwnProperty.call(Component, "$$isClientReference");

package/dist/scripts/debug-sync.mjs

@@ -7,6 +7,9 @@ import chokidar from "chokidar";
 import { lock } from "proper-lockfile";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageManagerInfo = (targetDir) => {
+    if (existsSync(path.join(targetDir, "bun.lock"))) {
+        return { name: "bun", lockFile: "bun.lock", command: "add" };
+    }
     const pnpmResult = {
         name: "pnpm",
         lockFile: "pnpm-lock.yaml",
@@ -24,15 +27,48 @@ const getPackageManagerInfo = (targetDir) => {
     }
     return pnpmResult;
 };
+const cleanupViteEntries = async (targetDir) => {
+    const nodeModulesDir = path.join(targetDir, "node_modules");
+    if (!existsSync(nodeModulesDir)) {
+        return;
+    }
+    try {
+        const entries = await fs.readdir(nodeModulesDir);
+        const viteEntries = entries.filter((entry) => entry.startsWith(".vite"));
+        for (const entry of viteEntries) {
+            const entryPath = path.join(nodeModulesDir, entry);
+            try {
+                const stat = await fs.lstat(entryPath);
+                if (!stat.isSymbolicLink()) {
+                    console.log(`Removing vite cache entry: ${entry}`);
+                    await fs.rm(entryPath, { recursive: true, force: true });
+                }
+                else {
+                    console.log(`Skipping symlinked vite cache entry: ${entry}`);
+                }
+            }
+            catch {
+                // If we can't stat it, try to remove it
+                console.log(`Removing vite cache entry: ${entry}`);
+                await fs.rm(entryPath, { recursive: true, force: true });
+            }
+        }
+    }
+    catch (error) {
+        console.log(`Failed to cleanup vite cache entries: ${error}`);
+    }
+};
 const performFullSync = async (sdkDir, targetDir) => {
-    const sdkPackageJsonPath = path.join(sdkDir, "package.json");
-    let originalSdkPackageJson = null;
     let tarballPath = "";
     let tarballName = "";
+    // Clean up vite cache
+    await cleanupViteEntries(targetDir);
     try {
         console.log("📦 Packing SDK...");
-        const packResult = await $({ cwd: sdkDir }) `npm pack`;
-        tarballName = packResult.stdout?.trim() ?? "";
+        const packResult = await $({ cwd: sdkDir }) `npm pack --json`;
+        const json = JSON.parse(packResult.stdout || "[]");
+        const packInfo = Array.isArray(json) ? json[0] : undefined;
+        tarballName = (packInfo && (packInfo.filename || packInfo.name)) || "";
         if (!tarballName) {
             console.error("❌ Failed to get tarball name from npm pack.");
             return;
@@ -49,6 +85,29 @@ const performFullSync = async (sdkDir, targetDir) => {
             .readFile(lockfilePath, "utf-8")
             .catch(() => null);
         try {
+            // For bun, we need to remove the existing dependency from package.json
+            // before adding the tarball to avoid a dependency loop error.
+            if (pm.name === "bun" && originalPackageJson) {
+                try {
+                    const targetPackageJson = JSON.parse(originalPackageJson);
+                    let modified = false;
+                    if (targetPackageJson.dependencies?.rwsdk) {
+                        delete targetPackageJson.dependencies.rwsdk;
+                        modified = true;
+                    }
+                    if (targetPackageJson.devDependencies?.rwsdk) {
+                        delete targetPackageJson.devDependencies.rwsdk;
+                        modified = true;
+                    }
+                    if (modified) {
+                        console.log("Temporarily removing rwsdk from target package.json to prevent dependency loop with bun.");
+                        await fs.writeFile(packageJsonPath, JSON.stringify(targetPackageJson, null, 2));
+                    }
+                }
+                catch (e) {
+                    console.warn("Could not modify target package.json, proceeding anyway.");
+                }
+            }
             const cmd = pm.name;
             const args = [pm.command];
             if (pm.name === "yarn") {
@@ -74,10 +133,6 @@ const performFullSync = async (sdkDir, targetDir) => {
         }
     }
     finally {
-        if (originalSdkPackageJson) {
-            console.log("Restoring package.json...");
-            await fs.writeFile(sdkPackageJsonPath, originalSdkPackageJson);
-        }
         if (tarballPath) {
             console.log("Removing tarball...");
             await fs.unlink(tarballPath).catch(() => {
@@ -86,19 +141,63 @@ const performFullSync = async (sdkDir, targetDir) => {
         }
     }
 };
-const performFastSync = async (sdkDir, targetDir) => {
-    console.log("⚡️ No dependency changes, performing fast sync...");
-    const sdkPackageJson = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"));
-    const filesToSync = sdkPackageJson.files || [];
-    for (const file of filesToSync) {
-        const source = path.join(sdkDir, file);
-        const destination = path.join(targetDir, "node_modules/rwsdk", file);
-        if (existsSync(source)) {
-            await fs.cp(source, destination, { recursive: true, force: true });
+const syncFilesWithRsyncOrFs = async (sdkDir, destDir, filesEntries) => {
+    const sources = filesEntries.map((p) => path.join(sdkDir, p));
+    // Always include package.json in sync
+    const pkgJsonPath = path.join(sdkDir, "package.json");
+    sources.push(pkgJsonPath);
+    await fs.mkdir(destDir, { recursive: true });
+    // Try rsync across all sources in one shot
+    try {
+        if (sources.length > 0) {
+            const rsyncArgs = [
+                "-a",
+                "--delete",
+                "--omit-dir-times",
+                "--no-perms",
+                "--no-owner",
+                "--no-group",
+                ...sources,
+                destDir + path.sep,
+            ];
+            await $({ stdio: "inherit" })("rsync", rsyncArgs);
+            return;
+        }
+    }
+    catch {
+        // fall through to fs fallback
+    }
+    console.log("Rsync failed, falling back to fs");
+    // Fallback: destructive copy using Node fs to mirror content
+    await fs.rm(destDir, { recursive: true, force: true });
+    await fs.mkdir(destDir, { recursive: true });
+    for (const src of sources) {
+        const rel = path.relative(sdkDir, src);
+        const dst = path.join(destDir, rel);
+        await fs.mkdir(path.dirname(dst), { recursive: true });
+        try {
+            const stat = await fs.lstat(src);
+            if (stat.isDirectory()) {
+                await fs.cp(src, dst, { recursive: true, force: true });
+            }
+            else {
+                await fs.copyFile(src, dst);
+            }
+        }
+        catch {
+            await fs.cp(src, dst, { recursive: true, force: true }).catch(() => { });
         }
     }
-    // Always copy package.json
-    await fs.copyFile(path.join(sdkDir, "package.json"), path.join(targetDir, "node_modules/rwsdk/package.json"));
+};
+const performFastSync = async (sdkDir, targetDir) => {
+    console.log("⚡️ No dependency changes, performing fast sync...");
+    // Clean up vite cache
+    await cleanupViteEntries(targetDir);
+    const nodeModulesPkgDir = path.join(targetDir, "node_modules", "rwsdk");
+    // Copy directories/files declared in package.json#files (plus package.json)
+    const filesToSync = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"))
+        .files || [];
+    await syncFilesWithRsyncOrFs(sdkDir, nodeModulesPkgDir, filesToSync);
 };
 const areDependenciesEqual = (deps1, deps2) => {
     // Simple string comparison for this use case is sufficient
@@ -120,13 +219,8 @@ const performSync = async (sdkDir, targetDir) => {
     if (existsSync(installedSdkPackageJsonPath)) {
         const sdkPackageJsonContent = await fs.readFile(sdkPackageJsonPath, "utf-8");
         const installedSdkPackageJsonContent = await fs.readFile(installedSdkPackageJsonPath, "utf-8");
-        const sdkPkg = JSON.parse(sdkPackageJsonContent);
-        const installedPkg = JSON.parse(installedSdkPackageJsonContent);
-        if (areDependenciesEqual(sdkPkg.dependencies, installedPkg.dependencies) &&
-            areDependenciesEqual(sdkPkg.devDependencies, installedPkg.devDependencies) &&
-            areDependenciesEqual(sdkPkg.peerDependencies, installedPkg.peerDependencies)) {
-            packageJsonChanged = false;
-        }
+        packageJsonChanged =
+            sdkPackageJsonContent !== installedSdkPackageJsonContent;
     }
     if (packageJsonChanged) {
         console.log("📦 package.json changed, performing full sync...");
@@ -198,20 +292,19 @@ export const debugSync = async (opts) => {
         cwd: sdkDir,
     });
     let syncing = false;
-    // todo(justinvdm, 2025-07-22): Figure out wtf makes the full sync
-    // cause chokidar to find out about package.json after sync has resolved
-    let expectingFileChanges = Boolean(process.env.RWSDK_FORCE_FULL_SYNC);
-    watcher.on("all", async (_event, filePath) => {
-        if (syncing || filePath.endsWith(".tgz")) {
-            return;
-        }
-        if (expectingFileChanges && process.env.RWSDK_FORCE_FULL_SYNC) {
-            expectingFileChanges = false;
+    let pendingResync = false;
+    const triggerResync = async (reason) => {
+        if (syncing) {
+            pendingResync = true;
             return;
         }
         syncing = true;
-        expectingFileChanges = true;
-        console.log(`\nDetected change, re-syncing... (file: ${filePath})`);
+        if (reason) {
+            console.log(`\nDetected change, re-syncing... (file: ${reason})`);
+        }
+        else {
+            console.log(`\nDetected change, re-syncing...`);
+        }
         if (childProc && !childProc.killed) {
             console.log("Stopping running process...");
             childProc.kill();
@@ -220,7 +313,6 @@ export const debugSync = async (opts) => {
             });
         }
         try {
-            watcher.unwatch(filesToWatch);
             await performSync(sdkDir, targetDir);
             runWatchedCommand();
         }
@@ -230,8 +322,19 @@ export const debugSync = async (opts) => {
         }
         finally {
             syncing = false;
-            watcher.add(filesToWatch);
         }
+        if (pendingResync) {
+            pendingResync = false;
+            // Coalesce any rapid additional events into a single follow-up sync
+            await new Promise((r) => setTimeout(r, 50));
+            return triggerResync();
+        }
+    };
+    watcher.on("all", async (_event, filePath) => {
+        if (filePath.endsWith(".tgz")) {
+            return;
+        }
+        await triggerResync(filePath);
     });
     const cleanup = async () => {
         console.log("\nCleaning up...");

package/dist/scripts/smoke-test.mjs

@@ -17,7 +17,6 @@ if (fileURLToPath(import.meta.url) === process.argv[1]) {
     const ciFlag = args.includes("--ci");
     // Set initial default values (sync will be determined below)
     const options = {
-        customPath: "/", // Default path
         skipDev: false,
         skipRelease: false,
         skipClient: false,
@@ -88,7 +87,6 @@ Smoke Test Usage:
   node smoke-test.mjs [options]
 
 Options:
-  --url=PATH              Custom URL path to test (e.g., "/login")
   --skip-dev              Skip testing the local development server
   --skip-release          Skip testing the release/production deployment
   --skip-client           Skip client-side tests, only run server-side checks
@@ -114,14 +112,6 @@ Options:
         else if (arg.startsWith("--artifact-dir=")) {
             options.artifactDir = arg.substring(15);
         }
-        else if (arg.startsWith("--url=")) {
-            options.customPath = arg.substring(6);
-        }
-        else if (!arg.startsWith("--")) {
-            // For backwards compatibility, any non-flag argument is treated as the custom path
-            console.log(`Setting URL path to "${arg}" (use --url= format in the future)`);
-            options.customPath = arg;
-        }
         else {
             // Throw error for unknown options instead of just warning
             log("Unknown option: %s", arg);

package/dist/scripts/worker-run.mjs

@@ -16,13 +16,18 @@ export const runWorkerScript = async (relativeScriptPath) => {
         console.error("Error: Script path is required");
         console.log("\nUsage:");
         console.log("  npm run worker:run <script-path>");
-        console.log("\nExample:");
-        console.log("  npm run worker:run src/scripts/seed.ts\n");
+        console.log("\nOptions:");
+        console.log("  RWSDK_WRANGLER_CONFIG      Environment variable for config 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");
         process.exit(1);
     }
     const scriptPath = resolve(process.cwd(), relativeScriptPath);
     debug("Running worker script: %s", scriptPath);
-    const workerConfigPath = await findWranglerConfig(process.cwd());
+    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,

package/dist/vite/buildApp.d.mts

@@ -0,0 +1,15 @@
+import type { ViteBuilder } from "vite";
+/**
+ * The build orchestrator is responsible for running the multi-phase build
+ * process for production. It is designed to solve the circular dependency
+ * between the worker, client, and SSR builds.
+ *
+ * @see docs/architecture/productionBuildProcess.md
+ */
+export declare function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, }: {
+    builder: ViteBuilder;
+    clientEntryPoints: Set<string>;
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
+    projectRootDir: string;
+}): Promise<void>;