rwsdk 1.0.0-beta.4 → 1.0.0-beta.40

package/dist/use-synced-state/__tests__/useSyncState.test.js

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { setSyncedStateClientForTesting, } from "../client";
+import { createSyncedStateHook, } from "../useSyncedState";
+const createStateHarness = () => {
+    let currentState;
+    const cleanups = [];
+    const useStateImpl = ((initialValue) => {
+        const resolved = typeof initialValue === "function"
+            ? initialValue()
+            : initialValue;
+        currentState = resolved;
+        const setState = (next) => {
+            currentState =
+                typeof next === "function"
+                    ? next(currentState)
+                    : next;
+        };
+        return [currentState, setState];
+    });
+    const useEffectImpl = (callback) => {
+        const cleanup = callback();
+        if (typeof cleanup === "function") {
+            cleanups.push(cleanup);
+        }
+    };
+    const useRefImpl = ((value) => ({
+        current: value,
+    }));
+    const useCallbackImpl = (fn) => fn;
+    const deps = {
+        useState: useStateImpl,
+        useEffect: useEffectImpl,
+        useRef: useRefImpl,
+        useCallback: useCallbackImpl,
+    };
+    return {
+        deps,
+        getState: () => currentState,
+        runCleanups: () => cleanups.forEach((fn) => fn()),
+    };
+};
+describe("createSyncedStateHook", () => {
+    const subscribeHandlers = new Map();
+    const client = {
+        async getState() {
+            return 5;
+        },
+        async setState(_value, _key) { },
+        async subscribe(key, handler) {
+            subscribeHandlers.set(key, handler);
+        },
+        async unsubscribe(key) {
+            subscribeHandlers.delete(key);
+        },
+    };
+    const resetClient = () => {
+        client.getState = async () => 5;
+        client.setState = async (_value, _key) => { };
+        client.subscribe = async (key, handler) => {
+            subscribeHandlers.set(key, handler);
+        };
+        client.unsubscribe = async (key) => {
+            subscribeHandlers.delete(key);
+        };
+    };
+    beforeEach(() => {
+        resetClient();
+        setSyncedStateClientForTesting(client);
+        subscribeHandlers.clear();
+    });
+    afterEach(() => {
+        setSyncedStateClientForTesting(null);
+    });
+    it("loads remote state and updates local value", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [value] = useSyncedState(0, "counter");
+        expect(value).toBe(0);
+        await Promise.resolve();
+        expect(harness.getState()).toBe(5);
+    });
+    it("sends updates through the client and applies optimistic value", async () => {
+        const harness = createStateHarness();
+        const setCalls = [];
+        client.setState = async (value, key) => {
+            setCalls.push({ key, value });
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [, setSyncValue] = useSyncedState(0, "counter");
+        setSyncValue(9);
+        expect(harness.getState()).toBe(9);
+        expect(setCalls).toEqual([{ key: "counter", value: 9 }]);
+    });
+    it("applies remote updates from the subscription handler", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        await Promise.resolve();
+        const handler = subscribeHandlers.get("counter");
+        handler?.(7);
+        expect(harness.getState()).toBe(7);
+    });
+    it("unsubscribes during cleanup", () => {
+        const harness = createStateHarness();
+        const unsubscribed = [];
+        client.unsubscribe = async (key) => {
+            unsubscribed.push({ key });
+            subscribeHandlers.delete(key);
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        harness.runCleanups();
+        expect(unsubscribed).toEqual([{ key: "counter" }]);
+    });
+});

package/dist/use-synced-state/__tests__/useSyncedState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/use-synced-state/__tests__/useSyncedState.test.js

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { setSyncedStateClientForTesting, } from "../client";
+import { createSyncedStateHook, } from "../useSyncedState";
+const createStateHarness = () => {
+    let currentState;
+    const cleanups = [];
+    const useStateImpl = ((initialValue) => {
+        const resolved = typeof initialValue === "function"
+            ? initialValue()
+            : initialValue;
+        currentState = resolved;
+        const setState = (next) => {
+            currentState =
+                typeof next === "function"
+                    ? next(currentState)
+                    : next;
+        };
+        return [currentState, setState];
+    });
+    const useEffectImpl = (callback) => {
+        const cleanup = callback();
+        if (typeof cleanup === "function") {
+            cleanups.push(cleanup);
+        }
+    };
+    const useRefImpl = ((value) => ({
+        current: value,
+    }));
+    const useCallbackImpl = (fn) => fn;
+    const deps = {
+        useState: useStateImpl,
+        useEffect: useEffectImpl,
+        useRef: useRefImpl,
+        useCallback: useCallbackImpl,
+    };
+    return {
+        deps,
+        getState: () => currentState,
+        runCleanups: () => cleanups.forEach((fn) => fn()),
+    };
+};
+describe("createSyncedStateHook", () => {
+    const subscribeHandlers = new Map();
+    const client = {
+        async getState() {
+            return 5;
+        },
+        async setState(_value, _key) { },
+        async subscribe(key, handler) {
+            subscribeHandlers.set(key, handler);
+        },
+        async unsubscribe(key) {
+            subscribeHandlers.delete(key);
+        },
+    };
+    const resetClient = () => {
+        client.getState = async () => 5;
+        client.setState = async (_value, _key) => { };
+        client.subscribe = async (key, handler) => {
+            subscribeHandlers.set(key, handler);
+        };
+        client.unsubscribe = async (key) => {
+            subscribeHandlers.delete(key);
+        };
+    };
+    beforeEach(() => {
+        resetClient();
+        setSyncedStateClientForTesting(client);
+        subscribeHandlers.clear();
+    });
+    afterEach(() => {
+        setSyncedStateClientForTesting(null);
+    });
+    it("loads remote state and updates local value", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [value] = useSyncedState(0, "counter");
+        expect(value).toBe(0);
+        await Promise.resolve();
+        expect(harness.getState()).toBe(5);
+    });
+    it("sends updates through the client and applies optimistic value", async () => {
+        const harness = createStateHarness();
+        const setCalls = [];
+        client.setState = async (value, key) => {
+            setCalls.push({ key, value });
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        const [, setSyncValue] = useSyncedState(0, "counter");
+        setSyncValue(9);
+        expect(harness.getState()).toBe(9);
+        expect(setCalls).toEqual([{ key: "counter", value: 9 }]);
+    });
+    it("applies remote updates from the subscription handler", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        await Promise.resolve();
+        const handler = subscribeHandlers.get("counter");
+        handler?.(7);
+        expect(harness.getState()).toBe(7);
+    });
+    it("unsubscribes during cleanup", () => {
+        const harness = createStateHarness();
+        const unsubscribed = [];
+        client.unsubscribe = async (key) => {
+            unsubscribed.push({ key });
+            subscribeHandlers.delete(key);
+        };
+        const useSyncedState = createSyncedStateHook({ hooks: harness.deps });
+        useSyncedState(0, "counter");
+        harness.runCleanups();
+        expect(unsubscribed).toEqual([{ key: "counter" }]);
+    });
+});

package/dist/use-synced-state/__tests__/worker.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/use-synced-state/__tests__/worker.test.mjs

@@ -0,0 +1,69 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+vi.mock("cloudflare:workers", () => {
+    class DurableObject {
+    }
+    return { DurableObject, env: {} };
+});
+vi.mock("capnweb", () => ({
+    RpcTarget: class RpcTarget {
+    },
+    newWorkersRpcResponse: vi.fn(),
+}));
+vi.mock("../runtime/entries/router", () => ({
+    route: vi.fn((path, handler) => ({ path, handler })),
+}));
+import { SyncedStateServer } from "../SyncedStateServer.mjs";
+describe("SyncedStateProxy", () => {
+    let mockCoordinator;
+    beforeEach(() => {
+        mockCoordinator = new SyncedStateServer({}, {});
+    });
+    afterEach(() => {
+        SyncedStateServer.registerKeyHandler(async (key) => key);
+    });
+    it("transforms keys before calling coordinator methods when handler is registered", async () => {
+        const handler = async (key) => `transformed:${key}`;
+        SyncedStateServer.registerKeyHandler(handler);
+        const transformedKey = await handler("counter");
+        expect(transformedKey).toBe("transformed:counter");
+        mockCoordinator.setState(5, transformedKey);
+        const value = mockCoordinator.getState(transformedKey);
+        expect(value).toBe(5);
+    });
+    it("does not transform keys when no handler is registered", () => {
+        SyncedStateServer.registerKeyHandler(async (key) => key);
+        const handler = SyncedStateServer.getKeyHandler();
+        expect(handler).not.toBeNull();
+    });
+    it("passes through original key when handler returns it unchanged", async () => {
+        const handler = async (key) => key;
+        SyncedStateServer.registerKeyHandler(handler);
+        const result = await handler("counter");
+        expect(result).toBe("counter");
+    });
+    it("handler can scope keys per user", async () => {
+        const handler = async (key) => {
+            const userId = "user123";
+            return `user:${userId}:${key}`;
+        };
+        SyncedStateServer.registerKeyHandler(handler);
+        const result = await handler("settings");
+        expect(result).toBe("user:user123:settings");
+    });
+    it("allows errors from handler to propagate", async () => {
+        const handler = async (_key) => {
+            throw new Error("Handler error");
+        };
+        SyncedStateServer.registerKeyHandler(handler);
+        await expect(handler("test")).rejects.toThrow("Handler error");
+    });
+    it("handles async operations in handler", async () => {
+        const handler = async (key) => {
+            await new Promise((resolve) => setTimeout(resolve, 5));
+            return `async:${key}`;
+        };
+        SyncedStateServer.registerKeyHandler(handler);
+        const result = await handler("data");
+        expect(result).toBe("async:data");
+    });
+});

package/dist/use-synced-state/client-core.d.ts

@@ -0,0 +1,26 @@
+export type SyncedStateClient = {
+    getState(key: string): Promise<unknown>;
+    setState(value: unknown, key: string): Promise<void>;
+    subscribe(key: string, handler: (value: unknown) => void): Promise<void>;
+    unsubscribe(key: string, handler: (value: unknown) => void): Promise<void>;
+};
+/**
+ * Returns a cached client for the provided endpoint, creating it when necessary.
+ * @param endpoint Endpoint to connect to.
+ * @returns RPC client instance.
+ */
+export declare const getSyncedStateClient: (endpoint?: string) => SyncedStateClient;
+/**
+ * Initializes and caches an RPC client instance for the sync state endpoint.
+ * @param options Optional endpoint override.
+ * @returns Cached client instance or `null` when running without `window`.
+ */
+export declare const initSyncedStateClient: (options?: {
+    endpoint?: string;
+}) => SyncedStateClient | null;
+/**
+ * Injects a client instance for tests and updates the cached endpoint.
+ * @param client Stub client instance or `null` to clear the cache.
+ * @param endpoint Endpoint associated with the injected client.
+ */
+export declare const setSyncedStateClientForTesting: (client: SyncedStateClient | null, endpoint?: string) => void;

package/dist/use-synced-state/client-core.js

@@ -0,0 +1,39 @@
+import { newWebSocketRpcSession } from "capnweb";
+import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
+let cachedClient = null;
+let cachedEndpoint = DEFAULT_SYNCED_STATE_PATH;
+/**
+ * Returns a cached client for the provided endpoint, creating it when necessary.
+ * @param endpoint Endpoint to connect to.
+ * @returns RPC client instance.
+ */
+export const getSyncedStateClient = (endpoint = cachedEndpoint) => {
+    if (cachedClient && endpoint === cachedEndpoint) {
+        return cachedClient;
+    }
+    cachedEndpoint = endpoint;
+    cachedClient = newWebSocketRpcSession(cachedEndpoint);
+    return cachedClient;
+};
+/**
+ * Initializes and caches an RPC client instance for the sync state endpoint.
+ * @param options Optional endpoint override.
+ * @returns Cached client instance or `null` when running without `window`.
+ */
+export const initSyncedStateClient = (options = {}) => {
+    cachedEndpoint = options.endpoint ?? DEFAULT_SYNCED_STATE_PATH;
+    if (typeof window === "undefined") {
+        return null;
+    }
+    cachedClient = newWebSocketRpcSession(cachedEndpoint);
+    return cachedClient;
+};
+/**
+ * Injects a client instance for tests and updates the cached endpoint.
+ * @param client Stub client instance or `null` to clear the cache.
+ * @param endpoint Endpoint associated with the injected client.
+ */
+export const setSyncedStateClientForTesting = (client, endpoint = DEFAULT_SYNCED_STATE_PATH) => {
+    cachedClient = client;
+    cachedEndpoint = endpoint;
+};

package/dist/use-synced-state/client.d.ts

@@ -0,0 +1,3 @@
+export { getSyncedStateClient, initSyncedStateClient, setSyncedStateClientForTesting, } from "./client-core.js";
+export type { SyncedStateClient } from "./client-core.js";
+export { useSyncedState } from "./useSyncedState.js";

package/dist/use-synced-state/client.js

@@ -0,0 +1,4 @@
+// Re-export everything from client-core to maintain the public API
+export { getSyncedStateClient, initSyncedStateClient, setSyncedStateClientForTesting, } from "./client-core.js";
+// Re-export useSyncedState (no circular dependency since useSyncedState imports from client-core, not client)
+export { useSyncedState } from "./useSyncedState.js";

package/dist/use-synced-state/constants.d.mts

@@ -0,0 +1 @@
+export declare const DEFAULT_SYNCED_STATE_PATH = "/__synced-state";

package/dist/use-synced-state/constants.mjs

@@ -0,0 +1 @@
+export const DEFAULT_SYNCED_STATE_PATH = "/__synced-state";

package/dist/use-synced-state/useSyncedState.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+type HookDeps = {
+    useState: typeof React.useState;
+    useEffect: typeof React.useEffect;
+    useRef: typeof React.useRef;
+    useCallback: typeof React.useCallback;
+};
+type Setter<T> = (value: T | ((previous: T) => T)) => void;
+export type CreateSyncedStateHookOptions = {
+    url?: string;
+    hooks?: HookDeps;
+};
+/**
+ * Builds a `useSyncedState` hook configured with optional endpoint and hook overrides.
+ * @param options Optional overrides for endpoint and React primitives.
+ * @returns Hook that syncs state through the sync state service.
+ */
+export declare const createSyncedStateHook: (options?: CreateSyncedStateHookOptions) => <T>(initialValue: T, key: string) => [T, Setter<T>];
+export declare const useSyncedState: <T>(initialValue: T, key: string) => [T, Setter<T>];
+export {};

package/dist/use-synced-state/useSyncedState.js

@@ -0,0 +1,58 @@
+import React from "react";
+import { getSyncedStateClient } from "./client-core.js";
+import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
+const defaultDeps = {
+    useState: React.useState,
+    useEffect: React.useEffect,
+    useRef: React.useRef,
+    useCallback: React.useCallback,
+};
+/**
+ * Builds a `useSyncedState` hook configured with optional endpoint and hook overrides.
+ * @param options Optional overrides for endpoint and React primitives.
+ * @returns Hook that syncs state through the sync state service.
+ */
+export const createSyncedStateHook = (options = {}) => {
+    const resolvedUrl = options.url ?? DEFAULT_SYNCED_STATE_PATH;
+    const deps = options.hooks ?? defaultDeps;
+    const { useState, useEffect, useRef, useCallback } = deps;
+    return function useSyncedState(initialValue, key) {
+        if (typeof window === "undefined" && !options.hooks) {
+            return [initialValue, () => { }];
+        }
+        const client = getSyncedStateClient(resolvedUrl);
+        const [value, setValue] = useState(initialValue);
+        const valueRef = useRef(value);
+        valueRef.current = value;
+        const setSyncValue = useCallback((nextValue) => {
+            const resolved = typeof nextValue === "function"
+                ? nextValue(valueRef.current)
+                : nextValue;
+            setValue(resolved);
+            valueRef.current = resolved;
+            void client.setState(resolved, key);
+        }, [client, key, setValue, valueRef]);
+        useEffect(() => {
+            let isActive = true;
+            const handleUpdate = (next) => {
+                if (isActive) {
+                    setValue(next);
+                    valueRef.current = next;
+                }
+            };
+            void client.getState(key).then((existing) => {
+                if (existing !== undefined && isActive) {
+                    setValue(existing);
+                    valueRef.current = existing;
+                }
+            });
+            void client.subscribe(key, handleUpdate);
+            return () => {
+                isActive = false;
+                void client.unsubscribe(key, handleUpdate);
+            };
+        }, [client, key, setValue, valueRef]);
+        return [value, setSyncValue];
+    };
+};
+export const useSyncedState = createSyncedStateHook();

package/dist/use-synced-state/worker.d.mts

@@ -0,0 +1,13 @@
+import { SyncedStateServer } from "./SyncedStateServer.mjs";
+export { SyncedStateServer };
+export type SyncedStateRouteOptions = {
+    basePath?: string;
+    durableObjectName?: string;
+};
+/**
+ * Registers routes that forward sync state requests to the configured Durable Object namespace.
+ * @param getNamespace Function that returns the Durable Object namespace from the Worker env.
+ * @param options Optional overrides for base path and object name.
+ * @returns Router entries for the sync state API.
+ */
+export declare const syncedStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncedStateServer>, options?: SyncedStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<`/${string}`, import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];

package/dist/use-synced-state/worker.mjs

@@ -0,0 +1,69 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SyncedStateProxy_stub, _SyncedStateProxy_keyHandler;
+import { RpcTarget, newWorkersRpcResponse } from "capnweb";
+import { env } from "cloudflare:workers";
+import { route } from "../runtime/entries/router";
+import { SyncedStateServer, } from "./SyncedStateServer.mjs";
+import { DEFAULT_SYNCED_STATE_PATH } from "./constants.mjs";
+export { SyncedStateServer };
+const DEFAULT_SYNC_STATE_NAME = "syncedState";
+class SyncedStateProxy extends RpcTarget {
+    constructor(stub, keyHandler) {
+        super();
+        _SyncedStateProxy_stub.set(this, void 0);
+        _SyncedStateProxy_keyHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _SyncedStateProxy_stub, stub, "f");
+        __classPrivateFieldSet(this, _SyncedStateProxy_keyHandler, keyHandler, "f");
+    }
+    async getState(key) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").getState(transformedKey);
+    }
+    async setState(value, key) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").setState(value, transformedKey);
+    }
+    async subscribe(key, client) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").subscribe(transformedKey, client);
+    }
+    async unsubscribe(key, client) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncedStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncedStateProxy_stub, "f").unsubscribe(transformedKey, client);
+    }
+}
+_SyncedStateProxy_stub = new WeakMap(), _SyncedStateProxy_keyHandler = new WeakMap();
+/**
+ * Registers routes that forward sync state requests to the configured Durable Object namespace.
+ * @param getNamespace Function that returns the Durable Object namespace from the Worker env.
+ * @param options Optional overrides for base path and object name.
+ * @returns Router entries for the sync state API.
+ */
+export const syncedStateRoutes = (getNamespace, options = {}) => {
+    const basePath = options.basePath ?? DEFAULT_SYNCED_STATE_PATH;
+    const durableObjectName = options.durableObjectName ?? DEFAULT_SYNC_STATE_NAME;
+    const forwardRequest = async (request) => {
+        const keyHandler = SyncedStateServer.getKeyHandler();
+        if (!keyHandler) {
+            const namespace = getNamespace(env);
+            const id = namespace.idFromName(durableObjectName);
+            return namespace.get(id).fetch(request);
+        }
+        const namespace = getNamespace(env);
+        const id = namespace.idFromName(durableObjectName);
+        const coordinator = namespace.get(id);
+        const proxy = new SyncedStateProxy(coordinator, keyHandler);
+        return newWorkersRpcResponse(request, proxy);
+    };
+    return [route(basePath, ({ request }) => forwardRequest(request))];
+};

package/dist/vite/buildApp.mjs

@@ -1,5 +1,8 @@
 import debug from "debug";
-import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { INTERMEDIATES_OUTPUT_DIR } from "../lib/constants.mjs";
 import { runDirectivesScan } from "./runDirectivesScan.mjs";
 const log = debug("rwsdk:vite:build-app");
 /**
@@ -10,7 +13,36 @@ const log = debug("rwsdk:vite:build-app");
  * @see docs/architecture/productionBuildProcess.md
  */
 export async function buildApp({ builder, clientEntryPoints, clientFiles, serverFiles, projectRootDir, workerEntryPathname, }) {
+    await rm(resolve(projectRootDir, "dist"), { recursive: true, force: true });
     const workerEnv = builder.environments.worker;
+    // Run a pre-scan build pass to allow plugins to set up and generate code
+    // before scanning.
+    console.log("Running plugin setup pass...");
+    process.env.RWSDK_BUILD_PASS = "plugin-setup";
+    const tempEntryPath = resolve(INTERMEDIATES_OUTPUT_DIR, "temp-entry.js");
+    try {
+        if (!existsSync(dirname(tempEntryPath))) {
+            await mkdir(dirname(tempEntryPath), { recursive: true });
+        }
+        await writeFile(tempEntryPath, "");
+        const originalWorkerBuildConfig = workerEnv.config.build;
+        workerEnv.config.build = {
+            ...originalWorkerBuildConfig,
+            write: false,
+            rollupOptions: {
+                ...originalWorkerBuildConfig?.rollupOptions,
+                input: {
+                    index: tempEntryPath,
+                },
+            },
+        };
+        await builder.build(workerEnv);
+        // Restore the original config
+        workerEnv.config.build = originalWorkerBuildConfig;
+    }
+    finally {
+        await rm(tempEntryPath, { force: true });
+    }
     await runDirectivesScan({
         rootConfig: builder.config,
         environments: builder.environments,
@@ -18,7 +50,7 @@ export async function buildApp({ builder, clientEntryPoints, clientFiles, server
         serverFiles,
         entries: [workerEntryPathname],
     });
-    console.log("Building worker to discover used client components...");
+    console.log("Building worker...");
     process.env.RWSDK_BUILD_PASS = "worker";
     await builder.build(workerEnv);
     log("Used client files after worker build & filtering: %O", Array.from(clientFiles));

package/dist/vite/cloudflarePreInitPlugin.d.mts

@@ -0,0 +1,11 @@
+import type { Plugin } from "vite";
+/**
+ * Plugin that performs initialization workarounds that must run before
+ * the Cloudflare plugin's `configureServer` hook executes.
+ *
+ * Cloudflare plugin v1.15.0 executes the worker entry file during
+ * `configureServer` to detect exports, which triggers SSR code evaluation
+ * before normal server initialization completes. This plugin ensures
+ * required systems are initialized beforehand.
+ */
+export declare const cloudflarePreInitPlugin: () => Plugin;

package/dist/vite/cloudflarePreInitPlugin.mjs

@@ -0,0 +1,40 @@
+/**
+ * Plugin that performs initialization workarounds that must run before
+ * the Cloudflare plugin's `configureServer` hook executes.
+ *
+ * Cloudflare plugin v1.15.0 executes the worker entry file during
+ * `configureServer` to detect exports, which triggers SSR code evaluation
+ * before normal server initialization completes. This plugin ensures
+ * required systems are initialized beforehand.
+ */
+export const cloudflarePreInitPlugin = () => {
+    return {
+        name: "rwsdk:cloudflare-pre-init",
+        // context(justinvdm, 20 Jan 2025): This plugin must run before the
+        // Cloudflare plugin's `configureServer` hook. The Cloudflare plugin
+        // executes the worker entry file during `configureServer` to detect
+        // exports, and blocks the rest of the configureServer plugins until the
+        // request is complete. We must initialize required systems (SSR dependency
+        // optimizer + our own plugins to them, as well as CSS plugin's moduleCache)
+        // before this happens to prevent errors.
+        enforce: "pre",
+        async configureServer(server) {
+            // context(justinvdm, 20 Jan 2025): Initialize SSR dependency optimizer before
+            // Cloudflare plugin triggers SSR code evaluation. This ensures dependencies
+            // in `optimizeDeps.include` (like `react-dom/server.edge`) are correctly
+            // registered before they are discovered lazily.
+            if (server.environments.ssr?.depsOptimizer) {
+                await server.environments.ssr.depsOptimizer.init();
+            }
+            // context(justinvdm, 20 Jan 2025): Initialize CSS plugin's shared moduleCache
+            // before CSS modules are processed. The Cloudflare plugin's export detection
+            // can trigger CSS module processing in the SSR environment during `configureServer`,
+            // which happens before `initServer` runs. Vite's CSS plugin uses a shared
+            // `moduleCache` that is initialized in the client environment's `buildStart` hook.
+            // By calling `buildStart` here (which is idempotent), we ensure the CSS plugin's
+            // cache is initialized before CSS modules are processed, preventing "Cannot read
+            // properties of undefined (reading 'set')" errors.
+            await server.environments.client.pluginContainer.buildStart();
+        },
+    };
+};