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

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/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

@@ -12,6 +12,7 @@ import { generateNonce } from "./lib/utils";
 export * from "./requestInfo/types";
 export const defineApp = (routes) => {
     return {
+        __rwRoutes: routes,
         fetch: async (request, env, cf) => {
             globalThis.__webpack_require__ = ssrWebpackRequire;
             const router = defineRoutes(routes);
@@ -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;', {
@@ -43,6 +73,8 @@ export const defineApp = (routes) => {
                     ssr: true,
                     databases: new Map(),
                     scriptsToBeLoaded: new Set(),
+                    entryScripts: new Set(),
+                    inlineScripts: new Set(),
                     pageRouteResolved: undefined,
                 };
                 const userResponseInit = {

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();

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

@@ -0,0 +1,21 @@
+import { RpcStub } from "capnweb";
+import { DurableObject } from "cloudflare:workers";
+export type SyncedStateValue = unknown;
+type OnSetHandler = (key: string, value: SyncedStateValue) => void;
+type OnGetHandler = (key: string, value: SyncedStateValue | undefined) => void;
+/**
+ * Durable Object that keeps shared state for multiple clients and notifies subscribers.
+ */
+export declare class SyncedStateServer extends DurableObject {
+    #private;
+    static registerKeyHandler(handler: (key: string) => Promise<string>): void;
+    static getKeyHandler(): ((key: string) => Promise<string>) | null;
+    static registerSetStateHandler(handler: OnSetHandler | null): void;
+    static registerGetStateHandler(handler: OnGetHandler | null): void;
+    getState(key: string): SyncedStateValue;
+    setState(value: SyncedStateValue, key: string): void;
+    subscribe(key: string, client: RpcStub<(value: SyncedStateValue) => void>): void;
+    unsubscribe(key: string, client: RpcStub<(value: SyncedStateValue) => void>): void;
+    fetch(request: Request): Promise<Response>;
+}
+export {};

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

@@ -0,0 +1,128 @@
+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 _a, _SyncedStateServer_keyHandler, _SyncedStateServer_setStateHandler, _SyncedStateServer_getStateHandler, _SyncedStateServer_stateStore, _SyncedStateServer_subscriptions, _SyncedStateServer_subscriptionRefs, _CoordinatorApi_coordinator;
+import { RpcTarget, newWorkersRpcResponse } from "capnweb";
+import { DurableObject } from "cloudflare:workers";
+/**
+ * Durable Object that keeps shared state for multiple clients and notifies subscribers.
+ */
+export class SyncedStateServer extends DurableObject {
+    constructor() {
+        super(...arguments);
+        _SyncedStateServer_stateStore.set(this, new Map());
+        _SyncedStateServer_subscriptions.set(this, new Map());
+        _SyncedStateServer_subscriptionRefs.set(this, new Map());
+    }
+    static registerKeyHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_keyHandler);
+    }
+    static getKeyHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_keyHandler);
+    }
+    static registerSetStateHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_setStateHandler);
+    }
+    static registerGetStateHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncedStateServer_getStateHandler);
+    }
+    getState(key) {
+        const value = __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").get(key);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler)) {
+            __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_getStateHandler).call(_a, key, value);
+        }
+        return value;
+    }
+    setState(value, key) {
+        __classPrivateFieldGet(this, _SyncedStateServer_stateStore, "f").set(key, value);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler)) {
+            __classPrivateFieldGet(_a, _a, "f", _SyncedStateServer_setStateHandler).call(_a, key, value);
+        }
+        const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key);
+        if (!subscribers) {
+            return;
+        }
+        for (const subscriber of subscribers) {
+            subscriber(value).catch(() => {
+                subscribers.delete(subscriber);
+                const refs = __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key);
+                if (refs) {
+                    for (const [original, duplicate] of refs) {
+                        if (duplicate === subscriber) {
+                            refs.delete(original);
+                            break;
+                        }
+                    }
+                    if (refs.size === 0) {
+                        __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").delete(key);
+                    }
+                }
+            });
+        }
+        if (subscribers.size === 0) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(key);
+        }
+    }
+    subscribe(key, client) {
+        if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").set(key, new Set());
+        }
+        if (!__classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").set(key, new Map());
+        }
+        const duplicate = client.dup();
+        __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key).add(duplicate);
+        __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key).set(client, duplicate);
+    }
+    unsubscribe(key, client) {
+        const duplicates = __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").get(key);
+        const duplicate = duplicates?.get(client);
+        const subscribers = __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").get(key);
+        if (duplicate && subscribers) {
+            subscribers.delete(duplicate);
+            duplicates.delete(client);
+            if (subscribers.size === 0) {
+                __classPrivateFieldGet(this, _SyncedStateServer_subscriptions, "f").delete(key);
+            }
+            if (duplicates.size === 0) {
+                __classPrivateFieldGet(this, _SyncedStateServer_subscriptionRefs, "f").delete(key);
+            }
+        }
+    }
+    async fetch(request) {
+        const api = new CoordinatorApi(this);
+        return newWorkersRpcResponse(request, api);
+    }
+}
+_a = SyncedStateServer, _SyncedStateServer_stateStore = new WeakMap(), _SyncedStateServer_subscriptions = new WeakMap(), _SyncedStateServer_subscriptionRefs = new WeakMap();
+_SyncedStateServer_keyHandler = { value: null };
+_SyncedStateServer_setStateHandler = { value: null };
+_SyncedStateServer_getStateHandler = { value: null };
+class CoordinatorApi extends RpcTarget {
+    constructor(coordinator) {
+        super();
+        _CoordinatorApi_coordinator.set(this, void 0);
+        __classPrivateFieldSet(this, _CoordinatorApi_coordinator, coordinator, "f");
+    }
+    getState(key) {
+        return __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").getState(key);
+    }
+    setState(value, key) {
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").setState(value, key);
+    }
+    subscribe(key, client) {
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").subscribe(key, client);
+    }
+    unsubscribe(key, client) {
+        __classPrivateFieldGet(this, _CoordinatorApi_coordinator, "f").unsubscribe(key, client);
+    }
+}
+_CoordinatorApi_coordinator = new WeakMap();

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

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

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

@@ -0,0 +1,109 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+vi.mock("cloudflare:workers", () => {
+    class DurableObject {
+    }
+    return { DurableObject };
+});
+import { SyncedStateServer } from "../SyncedStateServer.mjs";
+const createStub = (onInvoke) => {
+    const fn = Object.assign(async (value) => {
+        await onInvoke(value);
+    }, {
+        dup: () => fn,
+    });
+    return fn;
+};
+describe("SyncedStateServer", () => {
+    it("notifies subscribers when state changes", async () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const received = [];
+        const stub = createStub((value) => {
+            received.push(value);
+        });
+        coordinator.subscribe("counter", stub);
+        coordinator.setState(5, "counter");
+        expect(coordinator.getState("counter")).toBe(5);
+        expect(received).toEqual([5]);
+    });
+    it("removes subscriptions on unsubscribe", () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const stub = createStub(() => { });
+        coordinator.subscribe("counter", stub);
+        coordinator.unsubscribe("counter", stub);
+        coordinator.setState(1, "counter");
+        expect(coordinator.getState("counter")).toBe(1);
+    });
+    it("drops failing subscribers", async () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const stub = createStub(async () => {
+            throw new Error("fail");
+        });
+        coordinator.subscribe("counter", stub);
+        coordinator.setState(3, "counter");
+        await Promise.resolve();
+        coordinator.setState(4, "counter");
+        expect(coordinator.getState("counter")).toBe(4);
+    });
+    it("invokes registered onSet handler", () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const calls = [];
+        SyncedStateServer.registerSetStateHandler((key, value) => {
+            calls.push({ key, value });
+        });
+        coordinator.setState(2, "counter");
+        expect(calls).toEqual([{ key: "counter", value: 2 }]);
+        SyncedStateServer.registerSetStateHandler(null);
+    });
+    it("invokes registered onGet handler", () => {
+        const coordinator = new SyncedStateServer({}, {});
+        const calls = [];
+        SyncedStateServer.registerGetStateHandler((key, value) => {
+            calls.push({ key, value });
+        });
+        coordinator.setState(4, "counter");
+        expect(coordinator.getState("counter")).toBe(4);
+        expect(calls).toEqual([{ key: "counter", value: 4 }]);
+        SyncedStateServer.registerGetStateHandler(null);
+    });
+    describe("registerKeyHandler", () => {
+        afterEach(() => {
+            SyncedStateServer.registerKeyHandler(async (key) => key);
+        });
+        it("stores and retrieves the registered handler", async () => {
+            const handler = async (key) => `transformed:${key}`;
+            SyncedStateServer.registerKeyHandler(handler);
+            const retrievedHandler = SyncedStateServer.getKeyHandler();
+            expect(retrievedHandler).toBe(handler);
+        });
+        it("transforms keys using the registered handler", async () => {
+            const handler = async (key) => `user:123:${key}`;
+            SyncedStateServer.registerKeyHandler(handler);
+            const result = await handler("counter");
+            expect(result).toBe("user:123:counter");
+        });
+        it("returns null when no handler is registered", () => {
+            SyncedStateServer.registerKeyHandler(async (key) => key);
+            const handler = SyncedStateServer.getKeyHandler();
+            expect(handler).not.toBeNull();
+        });
+        it("allows handler to be async", async () => {
+            const handler = async (key) => {
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                return `async:${key}`;
+            };
+            SyncedStateServer.registerKeyHandler(handler);
+            const result = await handler("test");
+            expect(result).toBe("async:test");
+        });
+        it("handler receives the correct key parameter", async () => {
+            let receivedKey = "";
+            const handler = async (key) => {
+                receivedKey = key;
+                return key;
+            };
+            SyncedStateServer.registerKeyHandler(handler);
+            await handler("myKey");
+            expect(receivedKey).toBe("myKey");
+        });
+    });
+});

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

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