rwsdk 1.0.0-beta.27-test.20251111115809 → 1.0.0-beta.27-test.20251115092208

package/dist/runtime/client/client.d.ts

@@ -1,5 +1,6 @@
 import "./setWebpackRequire";
 export { default as React } from "react";
+export type { Dispatch, MutableRefObject, SetStateAction } from "react";
 export { ClientOnly } from "./ClientOnly.js";
 export { initClientNavigation, navigate } from "./navigation.js";
 import type { HydrationOptions, Transport } from "./types";

package/dist/runtime/imports/__mocks__/use-client-lookup.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mock implementation of the virtual:use-client-lookup.js module for tests.
+ * This provides an empty lookup object since tests don't need to actually
+ * load client modules - they use dependency injection for React hooks.
+ */
+export declare const useClientLookup: Record<string, () => Promise<any>>;

package/dist/runtime/imports/__mocks__/use-client-lookup.js

@@ -0,0 +1,6 @@
+/**
+ * Mock implementation of the virtual:use-client-lookup.js module for tests.
+ * This provides an empty lookup object since tests don't need to actually
+ * load client modules - they use dependency injection for React hooks.
+ */
+export const useClientLookup = {};

package/dist/runtime/lib/db/typeInference/builders/alterTable.d.ts

@@ -31,14 +31,14 @@ export interface AlterTableBuilder<TName extends string, TOps extends AlterOpera
         readonly __renamedFrom: TName;
     };
     setSchema(newSchema: string): AlterTableBuilder<TName, TOps>;
-    addColumn<K extends string, T extends DataTypeExpression, TNullable extends boolean = true>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>, TNullable>): AlterTableBuilder<TName, [...TOps, AddColumnOp<K, T, TNullable>]>;
+    addColumn<K extends string, T extends DataTypeExpression>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, [...TOps, AddColumnOp<K, T>]>;
     dropColumn<K extends string>(name: K): AlterTableBuilder<TName, [...TOps, DropColumnOp<K>]>;
     renameColumn<KFrom extends string, KTo extends string>(from: KFrom, to: KTo): AlterTableBuilder<TName, [...TOps, RenameColumnOp<KFrom, KTo>]>;
     alterColumn<K extends string, const TCallback extends AlterColumnBuilderCallback>(column: K, alteration: TCallback): AlterTableBuilder<TName, [
         ...TOps,
         AlterColumnOp<K, ReturnType<TCallback>["__alteration"]>
     ]>;
-    modifyColumn<K extends string, T extends DataTypeExpression, TNullable extends boolean = true>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>, TNullable>): AlterTableBuilder<TName, [...TOps, ModifyColumnOp<K, T, TNullable>]>;
+    modifyColumn<K extends string, T extends DataTypeExpression>(column: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): AlterTableBuilder<TName, [...TOps, ModifyColumnOp<K, T>]>;
     addUniqueConstraint(constraintName: string, columns: string[], build?: (builder: UniqueConstraintBuilder) => UniqueConstraintBuilder): AlterTableBuilder<TName, TOps>;
     addPrimaryKeyConstraint(constraintName: string, columns: string[], build?: (builder: PrimaryKeyConstraintBuilder) => PrimaryKeyConstraintBuilder): AlterTableBuilder<TName, TOps>;
     addCheckConstraint(constraintName: string, checkExpression: Expression<any>, build?: (builder: CheckConstraintBuilder) => CheckConstraintBuilder): AlterTableBuilder<TName, TOps>;

package/dist/runtime/lib/db/typeInference/builders/columnDefinition.d.ts

@@ -1,25 +1,25 @@
 import { ColumnDefinitionNode, Expression, sql } from "kysely";
 type DefaultValueExpression = string | number | boolean | null | ReturnType<typeof sql>;
-export interface ColumnDefinitionBuilder<TType, TNullable extends boolean = true> {
-    autoIncrement(): ColumnDefinitionBuilder<TType, TNullable>;
-    identity(): ColumnDefinitionBuilder<TType, TNullable>;
-    primaryKey(): ColumnDefinitionBuilder<TType, false>;
-    references(ref: string): ColumnDefinitionBuilder<TType, TNullable>;
-    onDelete(onDelete: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType, TNullable>;
-    onUpdate(onUpdate: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType, TNullable>;
-    unique(): ColumnDefinitionBuilder<TType, TNullable>;
-    notNull(): ColumnDefinitionBuilder<TType, false>;
-    unsigned(): ColumnDefinitionBuilder<TType, TNullable>;
-    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder<TType, false>;
-    check(expression: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
-    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
-    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder<TType, TNullable>;
-    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder<TType, TNullable>;
-    stored(): ColumnDefinitionBuilder<TType, TNullable>;
-    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
-    nullsNotDistinct(): ColumnDefinitionBuilder<TType, TNullable>;
-    ifNotExists(): ColumnDefinitionBuilder<TType, TNullable>;
-    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder<TType, TNullable>;
+export interface ColumnDefinitionBuilder<TType> {
+    autoIncrement(): ColumnDefinitionBuilder<TType>;
+    identity(): ColumnDefinitionBuilder<TType>;
+    primaryKey(): ColumnDefinitionBuilder<TType>;
+    references(ref: string): ColumnDefinitionBuilder<TType>;
+    onDelete(onDelete: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType>;
+    onUpdate(onUpdate: "no action" | "restrict" | "cascade" | "set null" | "set default"): ColumnDefinitionBuilder<TType>;
+    unique(): ColumnDefinitionBuilder<TType>;
+    notNull(): ColumnDefinitionBuilder<TType>;
+    unsigned(): ColumnDefinitionBuilder<TType>;
+    defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder<TType>;
+    check(expression: Expression<any>): ColumnDefinitionBuilder<TType>;
+    generatedAlwaysAs(expression: Expression<any>): ColumnDefinitionBuilder<TType>;
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder<TType>;
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder<TType>;
+    stored(): ColumnDefinitionBuilder<TType>;
+    modifyFront(modifier: Expression<any>): ColumnDefinitionBuilder<TType>;
+    nullsNotDistinct(): ColumnDefinitionBuilder<TType>;
+    ifNotExists(): ColumnDefinitionBuilder<TType>;
+    modifyEnd(modifier: Expression<any>): ColumnDefinitionBuilder<TType>;
     $call<T>(func: (qb: this) => T): T;
     toOperationNode(): ColumnDefinitionNode;
 }

package/dist/runtime/lib/db/typeInference/builders/createTable.d.ts

@@ -28,8 +28,7 @@ export interface CreateTableBuilder<TName extends string, TSchema extends Record
     temporary(): CreateTableBuilder<TName, TSchema>;
     onCommit(onCommit: "preserve rows" | "delete rows" | "drop"): CreateTableBuilder<TName, TSchema>;
     ifNotExists(): CreateTableBuilder<TName, TSchema>;
-    addColumn<K extends string, T extends string>(name: K, type: T): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, SqlToTsType<T> | null>>>;
-    addColumn<K extends string, T extends string, TNullable extends boolean>(name: K, type: T, build: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>, TNullable>): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, TNullable extends true ? SqlToTsType<T> | null : SqlToTsType<T>>>>;
+    addColumn<K extends string, T extends string>(name: K, type: T, build?: (col: ColumnDefinitionBuilder<SqlToTsType<T>>) => ColumnDefinitionBuilder<SqlToTsType<T>>): CreateTableBuilder<TName, Prettify<(TSchema extends Record<string, any> ? TSchema : {}) & Record<K, SqlToTsType<T>>>>;
     addUniqueConstraint(constraintName: string, columns: (keyof TSchema)[], build?: (builder: UniqueConstraintBuilder) => UniqueConstraintBuilder): CreateTableBuilder<TName, TSchema>;
     addPrimaryKeyConstraint(constraintName: string, columns: (keyof TSchema)[], build?: (builder: PrimaryKeyConstraintBuilder) => PrimaryKeyConstraintBuilder): CreateTableBuilder<TName, TSchema>;
     addCheckConstraint(constraintName: string, checkExpression: Expression<any>, build?: (builder: CheckConstraintBuilder) => CheckConstraintBuilder): CreateTableBuilder<TName, TSchema>;

package/dist/runtime/lib/db/typeInference/typetests/alterTable.typetest.js

@@ -153,7 +153,7 @@
             up: async (db) => [
                 await db.schema
                     .createTable("users")
-                    .addColumn("id", "integer", (c) => c.primaryKey().autoIncrement())
+                    .addColumn("id", "integer")
                     .execute(),
             ],
         },
@@ -242,7 +242,7 @@
                 return [
                     await db.schema
                         .createTable("users")
-                        .addColumn("id", "integer", (col) => col.notNull())
+                        .addColumn("id", "integer")
                         .execute(),
                 ];
             },
@@ -271,7 +271,7 @@
                 return [
                     await db.schema
                         .createTable("users")
-                        .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
+                        .addColumn("id", "integer")
                         .execute(),
                 ];
             },
@@ -357,79 +357,4 @@
     };
     (_test) => { };
 };
-(_it = "alterTable addColumn with notNull") => {
-    const migrations = {
-        "0": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .createTable("users")
-                        .addColumn("id", "integer", (col) => col.primaryKey())
-                        .execute(),
-                ];
-            },
-        },
-        "1": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .alterTable("users")
-                        .addColumn("email", "text", (col) => col.notNull())
-                        .execute(),
-                ];
-            },
-        },
-    };
-    (_test) => { };
-};
-(_it = "alterTable modifyColumn with notNull") => {
-    const migrations = {
-        "0": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .createTable("products")
-                        .addColumn("price", "real")
-                        .execute(),
-                ];
-            },
-        },
-        "1": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .alterTable("products")
-                        .modifyColumn("price", "real", (col) => col.notNull())
-                        .execute(),
-                ];
-            },
-        },
-    };
-    (_test) => { };
-};
-(_it = "alterTable modifyColumn nullable to non-nullable") => {
-    const migrations = {
-        "0": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .createTable("orders")
-                        .addColumn("status", "text")
-                        .execute(),
-                ];
-            },
-        },
-        "1": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .alterTable("orders")
-                        .modifyColumn("status", "text", (col) => col.notNull().defaultTo("pending"))
-                        .execute(),
-                ];
-            },
-        },
-    };
-    (_test) => { };
-};
 export {};

package/dist/runtime/lib/db/typeInference/typetests/createTable.typetest.js

@@ -22,59 +22,9 @@ import { sql } from "kysely";
                     await db.schema
                         .createTable("users")
                         .addColumn("username", "text", (col) => col.notNull())
+                        .addColumn("age", "integer", (col) => col.defaultTo(18))
                         .addColumn("active", "boolean", (col) => col.defaultTo(true))
                         .addColumn("anotherBoolean", "boolean", (col) => col.defaultTo(sql `true`))
-                        .addColumn("email", "text", (col) => col)
-                        .addColumn("favoriteColor", "text", (col) => col.unique())
-                        .addColumn("name", "text", (col) => col.defaultTo("John Doe"))
-                        .execute(),
-                ];
-            },
-        },
-    };
-    (_test) => { };
-};
-(_it = "createTable column without callback is nullable") => {
-    const migrations = {
-        "001_init": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .createTable("posts")
-                        .addColumn("title", "text")
-                        .addColumn("body", "text")
-                        .execute(),
-                ];
-            },
-        },
-    };
-    (_test) => { };
-};
-(_it = "createTable with primaryKey is non-nullable") => {
-    const migrations = {
-        "001_init": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .createTable("users")
-                        .addColumn("id", "integer", (col) => col.primaryKey())
-                        .addColumn("email", "text", (col) => col.notNull())
-                        .execute(),
-                ];
-            },
-        },
-    };
-    (_test) => { };
-};
-(_it = "createTable with unique but no notNull is nullable") => {
-    const migrations = {
-        "001_init": {
-            async up(db) {
-                return [
-                    await db.schema
-                        .createTable("products")
-                        .addColumn("sku", "text", (col) => col.unique())
-                        .addColumn("name", "text", (col) => col)
                         .execute(),
                 ];
             },

package/dist/runtime/lib/db/typeInference/utils.d.ts

@@ -1,10 +1,9 @@
 import { sql } from "kysely";
 type DataTypeExpression = string | typeof sql;
-export type AddColumnOp<K extends string, T extends DataTypeExpression, TNullable extends boolean = true> = {
+export type AddColumnOp<K extends string, T extends DataTypeExpression> = {
     op: "addColumn";
     name: K;
     type: T;
-    nullable: TNullable;
 };
 export type DropColumnOp<K extends string> = {
     op: "dropColumn";
@@ -15,11 +14,10 @@ export type RenameColumnOp<KFrom extends string, KTo extends string> = {
     from: KFrom;
     to: KTo;
 };
-export type ModifyColumnOp<K extends string, T extends DataTypeExpression, TNullable extends boolean = true> = {
+export type ModifyColumnOp<K extends string, T extends DataTypeExpression> = {
     op: "modifyColumn";
     name: K;
     type: T;
-    nullable: TNullable;
 };
 export type Alteration = {
     kind: "setDataType";
@@ -39,7 +37,7 @@ export type AlterColumnOp<K extends string, TAlteration extends Alteration> = {
     name: K;
     alteration: TAlteration;
 };
-export type AlterOperation = AddColumnOp<any, any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, any, any>;
+export type AlterOperation = AddColumnOp<any, any> | DropColumnOp<any> | RenameColumnOp<any, any> | AlterColumnOp<any, any> | ModifyColumnOp<any, any>;
 export type SqlToTsType<T extends string | typeof sql> = T extends "text" ? string : T extends "integer" ? number : T extends "blob" ? Uint8Array : T extends "real" ? number : T extends "boolean" ? boolean : T extends typeof sql ? any : never;
 export type Prettify<T> = {
     [K in keyof T]: T[K];
@@ -59,8 +57,8 @@ export type Cast<A, B> = A extends B ? A : B;
 /**
  * Applies a single alteration operation to a schema.
  */
-type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, infer T, infer TNullable> ? Prettify<TSchema & {
-    [P in K]: TNullable extends true ? SqlToTsType<T> | null : SqlToTsType<T>;
+type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, infer T> ? Prettify<TSchema & {
+    [P in K]: SqlToTsType<T>;
 }> : THeadOp extends DropColumnOp<infer K> ? Omit<TSchema, K> : THeadOp extends RenameColumnOp<infer KFrom, infer KTo> ? KFrom extends keyof TSchema ? Prettify<Omit<TSchema, KFrom> & {
     [P in KTo]: TSchema[KFrom];
 }> : TSchema : THeadOp extends AlterColumnOp<infer K, infer TAlt> ? TAlt extends {
@@ -68,8 +66,8 @@ type ApplyOp<TSchema, THeadOp> = THeadOp extends AddColumnOp<infer K, infer T, i
     dataType: infer DT extends string;
 } ? Prettify<Omit<TSchema, K> & {
     [P in K]: SqlToTsType<DT>;
-}> : TSchema : THeadOp extends ModifyColumnOp<infer K, infer T, infer TNullable> ? Prettify<Omit<TSchema, K> & {
-    [P in K]: TNullable extends true ? SqlToTsType<T> | null : SqlToTsType<T>;
+}> : TSchema : THeadOp extends ModifyColumnOp<infer K, infer T> ? Prettify<Omit<TSchema, K> & {
+    [P in K]: SqlToTsType<T>;
 }> : TSchema;
 /**
  * Recursively processes a list of alteration operations (AST)

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

@@ -0,0 +1,20 @@
+import { RpcStub } from "capnweb";
+import { DurableObject } from "cloudflare:workers";
+export type SyncStateValue = unknown;
+type OnSetHandler = (key: string, value: SyncStateValue) => void;
+type OnGetHandler = (key: string, value: SyncStateValue | undefined) => void;
+/**
+ * Durable Object that keeps shared state for multiple clients and notifies subscribers.
+ */
+export declare class SyncStateServer 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): SyncStateValue;
+    setState(value: SyncStateValue, key: string): void;
+    subscribe(key: string, client: RpcStub<(value: SyncStateValue) => void>): void;
+    unsubscribe(key: string, client: RpcStub<(value: SyncStateValue) => void>): void;
+}
+export {};

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

@@ -0,0 +1,124 @@
+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, _SyncStateServer_keyHandler, _SyncStateServer_setStateHandler, _SyncStateServer_getStateHandler, _SyncStateServer_stateStore, _SyncStateServer_subscriptions, _SyncStateServer_subscriptionRefs, _CoordinatorApi_coordinator;
+import { RpcTarget } from "capnweb";
+import { DurableObject } from "cloudflare:workers";
+/**
+ * Durable Object that keeps shared state for multiple clients and notifies subscribers.
+ */
+export class SyncStateServer extends DurableObject {
+    constructor() {
+        super(...arguments);
+        _SyncStateServer_stateStore.set(this, new Map());
+        _SyncStateServer_subscriptions.set(this, new Map());
+        _SyncStateServer_subscriptionRefs.set(this, new Map());
+    }
+    static registerKeyHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncStateServer_keyHandler);
+    }
+    static getKeyHandler() {
+        return __classPrivateFieldGet(_a, _a, "f", _SyncStateServer_keyHandler);
+    }
+    static registerSetStateHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncStateServer_setStateHandler);
+    }
+    static registerGetStateHandler(handler) {
+        __classPrivateFieldSet(_a, _a, handler, "f", _SyncStateServer_getStateHandler);
+    }
+    getState(key) {
+        const value = __classPrivateFieldGet(this, _SyncStateServer_stateStore, "f").get(key);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncStateServer_getStateHandler)) {
+            __classPrivateFieldGet(_a, _a, "f", _SyncStateServer_getStateHandler).call(_a, key, value);
+        }
+        return value;
+    }
+    setState(value, key) {
+        __classPrivateFieldGet(this, _SyncStateServer_stateStore, "f").set(key, value);
+        if (__classPrivateFieldGet(_a, _a, "f", _SyncStateServer_setStateHandler)) {
+            __classPrivateFieldGet(_a, _a, "f", _SyncStateServer_setStateHandler).call(_a, key, value);
+        }
+        const subscribers = __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").get(key);
+        if (!subscribers) {
+            return;
+        }
+        for (const subscriber of subscribers) {
+            subscriber(value).catch(() => {
+                subscribers.delete(subscriber);
+                const refs = __classPrivateFieldGet(this, _SyncStateServer_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, _SyncStateServer_subscriptionRefs, "f").delete(key);
+                    }
+                }
+            });
+        }
+        if (subscribers.size === 0) {
+            __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").delete(key);
+        }
+    }
+    subscribe(key, client) {
+        if (!__classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").set(key, new Set());
+        }
+        if (!__classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").has(key)) {
+            __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").set(key, new Map());
+        }
+        const duplicate = client.dup();
+        __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").get(key).add(duplicate);
+        __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").get(key).set(client, duplicate);
+    }
+    unsubscribe(key, client) {
+        const duplicates = __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").get(key);
+        const duplicate = duplicates?.get(client);
+        const subscribers = __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").get(key);
+        if (duplicate && subscribers) {
+            subscribers.delete(duplicate);
+            duplicates.delete(client);
+            if (subscribers.size === 0) {
+                __classPrivateFieldGet(this, _SyncStateServer_subscriptions, "f").delete(key);
+            }
+            if (duplicates.size === 0) {
+                __classPrivateFieldGet(this, _SyncStateServer_subscriptionRefs, "f").delete(key);
+            }
+        }
+    }
+}
+_a = SyncStateServer, _SyncStateServer_stateStore = new WeakMap(), _SyncStateServer_subscriptions = new WeakMap(), _SyncStateServer_subscriptionRefs = new WeakMap();
+_SyncStateServer_keyHandler = { value: null };
+_SyncStateServer_setStateHandler = { value: null };
+_SyncStateServer_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 { SyncStateServer } from "../SyncStateServer.mjs";
+const createStub = (onInvoke) => {
+    const fn = Object.assign(async (value) => {
+        await onInvoke(value);
+    }, {
+        dup: () => fn,
+    });
+    return fn;
+};
+describe("SyncStateServer", () => {
+    it("notifies subscribers when state changes", async () => {
+        const coordinator = new SyncStateServer({}, {});
+        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 SyncStateServer({}, {});
+        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 SyncStateServer({}, {});
+        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 SyncStateServer({}, {});
+        const calls = [];
+        SyncStateServer.registerSetStateHandler((key, value) => {
+            calls.push({ key, value });
+        });
+        coordinator.setState(2, "counter");
+        expect(calls).toEqual([{ key: "counter", value: 2 }]);
+        SyncStateServer.registerSetStateHandler(null);
+    });
+    it("invokes registered onGet handler", () => {
+        const coordinator = new SyncStateServer({}, {});
+        const calls = [];
+        SyncStateServer.registerGetStateHandler((key, value) => {
+            calls.push({ key, value });
+        });
+        coordinator.setState(4, "counter");
+        expect(coordinator.getState("counter")).toBe(4);
+        expect(calls).toEqual([{ key: "counter", value: 4 }]);
+        SyncStateServer.registerGetStateHandler(null);
+    });
+    describe("registerKeyHandler", () => {
+        afterEach(() => {
+            SyncStateServer.registerKeyHandler(async (key) => key);
+        });
+        it("stores and retrieves the registered handler", async () => {
+            const handler = async (key) => `transformed:${key}`;
+            SyncStateServer.registerKeyHandler(handler);
+            const retrievedHandler = SyncStateServer.getKeyHandler();
+            expect(retrievedHandler).toBe(handler);
+        });
+        it("transforms keys using the registered handler", async () => {
+            const handler = async (key) => `user:123:${key}`;
+            SyncStateServer.registerKeyHandler(handler);
+            const result = await handler("counter");
+            expect(result).toBe("user:123:counter");
+        });
+        it("returns null when no handler is registered", () => {
+            SyncStateServer.registerKeyHandler(async (key) => key);
+            const handler = SyncStateServer.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}`;
+            };
+            SyncStateServer.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;
+            };
+            SyncStateServer.registerKeyHandler(handler);
+            await handler("myKey");
+            expect(receivedKey).toBe("myKey");
+        });
+    });
+});

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

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

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

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { setSyncStateClientForTesting } from "../client";
+import { createSyncStateHook, } 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("createSyncStateHook", () => {
+    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();
+        setSyncStateClientForTesting(client);
+        subscribeHandlers.clear();
+    });
+    afterEach(() => {
+        setSyncStateClientForTesting(null);
+    });
+    it("loads remote state and updates local value", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncStateHook({ 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 = createSyncStateHook({ 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 = createSyncStateHook({ 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 = createSyncStateHook({ 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 { setSyncStateClientForTesting, } from "../client";
+import { createSyncStateHook, } 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("createSyncStateHook", () => {
+    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();
+        setSyncStateClientForTesting(client);
+        subscribeHandlers.clear();
+    });
+    afterEach(() => {
+        setSyncStateClientForTesting(null);
+    });
+    it("loads remote state and updates local value", async () => {
+        const harness = createStateHarness();
+        const useSyncedState = createSyncStateHook({ 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 = createSyncStateHook({ 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 = createSyncStateHook({ 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 = createSyncStateHook({ 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 { SyncStateServer } from "../SyncStateServer.mjs";
+describe("SyncStateProxy", () => {
+    let mockCoordinator;
+    beforeEach(() => {
+        mockCoordinator = new SyncStateServer({}, {});
+    });
+    afterEach(() => {
+        SyncStateServer.registerKeyHandler(async (key) => key);
+    });
+    it("transforms keys before calling coordinator methods when handler is registered", async () => {
+        const handler = async (key) => `transformed:${key}`;
+        SyncStateServer.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", () => {
+        SyncStateServer.registerKeyHandler(async (key) => key);
+        const handler = SyncStateServer.getKeyHandler();
+        expect(handler).not.toBeNull();
+    });
+    it("passes through original key when handler returns it unchanged", async () => {
+        const handler = async (key) => key;
+        SyncStateServer.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}`;
+        };
+        SyncStateServer.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");
+        };
+        SyncStateServer.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}`;
+        };
+        SyncStateServer.registerKeyHandler(handler);
+        const result = await handler("data");
+        expect(result).toBe("async:data");
+    });
+});

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

@@ -0,0 +1,28 @@
+export type SyncStateClient = {
+    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>;
+};
+type InitOptions = {
+    endpoint?: string;
+};
+/**
+ * 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 initSyncStateClient: (options?: InitOptions) => SyncStateClient | null;
+/**
+ * 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 getSyncStateClient: (endpoint?: string) => SyncStateClient;
+/**
+ * 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 setSyncStateClientForTesting: (client: SyncStateClient | null, endpoint?: string) => void;
+export {};

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

@@ -0,0 +1,39 @@
+import { newWebSocketRpcSession } from "capnweb";
+import { DEFAULT_SYNC_STATE_PATH } from "./constants.mjs";
+let cachedClient = null;
+let cachedEndpoint = DEFAULT_SYNC_STATE_PATH;
+/**
+ * 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 initSyncStateClient = (options = {}) => {
+    cachedEndpoint = options.endpoint ?? DEFAULT_SYNC_STATE_PATH;
+    if (typeof window === "undefined") {
+        return null;
+    }
+    cachedClient = newWebSocketRpcSession(cachedEndpoint);
+    return cachedClient;
+};
+/**
+ * Returns a cached client for the provided endpoint, creating it when necessary.
+ * @param endpoint Endpoint to connect to.
+ * @returns RPC client instance.
+ */
+export const getSyncStateClient = (endpoint = cachedEndpoint) => {
+    if (cachedClient && endpoint === cachedEndpoint) {
+        return cachedClient;
+    }
+    cachedEndpoint = endpoint;
+    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 setSyncStateClientForTesting = (client, endpoint = DEFAULT_SYNC_STATE_PATH) => {
+    cachedClient = client;
+    cachedEndpoint = endpoint;
+};

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

@@ -0,0 +1 @@
+export declare const DEFAULT_SYNC_STATE_PATH = "/__sync-state";

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

@@ -0,0 +1 @@
+export const DEFAULT_SYNC_STATE_PATH = "/__sync-state";

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

@@ -0,0 +1,20 @@
+import { React } from "../runtime/client/client";
+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 CreateSyncStateHookOptions = {
+    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 createSyncStateHook: (options?: CreateSyncStateHookOptions) => <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/useSyncState.js

@@ -0,0 +1,58 @@
+import { React } from "../runtime/client/client";
+import { getSyncStateClient } from "./client";
+import { DEFAULT_SYNC_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 createSyncStateHook = (options = {}) => {
+    const resolvedUrl = options.url ?? DEFAULT_SYNC_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 = getSyncStateClient(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 = createSyncStateHook();

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

@@ -0,0 +1,20 @@
+import { React } from "../runtime/client/client";
+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 CreateSyncStateHookOptions = {
+    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 createSyncStateHook: (options?: CreateSyncStateHookOptions) => <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 "../runtime/client/client";
+import { getSyncStateClient } from "./client";
+import { DEFAULT_SYNC_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 createSyncStateHook = (options = {}) => {
+    const resolvedUrl = options.url ?? DEFAULT_SYNC_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 = getSyncStateClient(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 = createSyncStateHook();

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

@@ -0,0 +1,14 @@
+import { SyncStateServer } from "./SyncStateServer.mjs";
+export { SyncStateServer } from "./SyncStateServer.mjs";
+export type SyncStateRouteOptions = {
+    basePath?: string;
+    resetPath?: 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, reset path, and object name.
+ * @returns Router entries for the sync state API and reset endpoint.
+ */
+export declare const syncStateRoutes: (getNamespace: (env: Cloudflare.Env) => DurableObjectNamespace<SyncStateServer>, options?: SyncStateRouteOptions) => import("../runtime/lib/router.js").RouteDefinition<import("../runtime/worker.js").RequestInfo<any, import("../runtime/worker.js").DefaultAppContext>>[];

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

@@ -0,0 +1,73 @@
+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 _SyncStateProxy_stub, _SyncStateProxy_keyHandler;
+import { RpcTarget, newWorkersRpcResponse } from "capnweb";
+import { env } from "cloudflare:workers";
+import { route } from "../runtime/entries/router";
+import { SyncStateServer } from "./SyncStateServer.mjs";
+import { DEFAULT_SYNC_STATE_PATH } from "./constants.mjs";
+export { SyncStateServer } from "./SyncStateServer.mjs";
+const DEFAULT_SYNC_STATE_NAME = "syncedState";
+class SyncStateProxy extends RpcTarget {
+    constructor(stub, keyHandler) {
+        super();
+        _SyncStateProxy_stub.set(this, void 0);
+        _SyncStateProxy_keyHandler.set(this, void 0);
+        __classPrivateFieldSet(this, _SyncStateProxy_stub, stub, "f");
+        __classPrivateFieldSet(this, _SyncStateProxy_keyHandler, keyHandler, "f");
+    }
+    async getState(key) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").getState(transformedKey);
+    }
+    async setState(value, key) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").setState(value, transformedKey);
+    }
+    async subscribe(key, client) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").subscribe(transformedKey, client);
+    }
+    async unsubscribe(key, client) {
+        const transformedKey = __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f") ? await __classPrivateFieldGet(this, _SyncStateProxy_keyHandler, "f").call(this, key) : key;
+        return __classPrivateFieldGet(this, _SyncStateProxy_stub, "f").unsubscribe(transformedKey, client);
+    }
+}
+_SyncStateProxy_stub = new WeakMap(), _SyncStateProxy_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, reset path, and object name.
+ * @returns Router entries for the sync state API and reset endpoint.
+ */
+export const syncStateRoutes = (getNamespace, options = {}) => {
+    const basePath = options.basePath ?? DEFAULT_SYNC_STATE_PATH;
+    const resetPath = options.resetPath ?? `${basePath}/reset`;
+    const durableObjectName = options.durableObjectName ?? DEFAULT_SYNC_STATE_NAME;
+    const forwardRequest = async (request) => {
+        const keyHandler = SyncStateServer.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 SyncStateProxy(coordinator, keyHandler);
+        return newWorkersRpcResponse(request, proxy);
+    };
+    return [
+        route(basePath, ({ request }) => forwardRequest(request)),
+        route(resetPath, ({ request }) => forwardRequest(request)),
+    ];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "1.0.0-beta.27-test.20251111115809",
+  "version": "1.0.0-beta.27-test.20251115092208",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {
@@ -104,6 +104,14 @@
     "./realtime/durableObject": {
       "types": "./dist/runtime/lib/realtime/durableObject.d.ts",
       "default": "./dist/runtime/lib/realtime/durableObject.js"
+    },
+    "./use-synced-state/client": {
+      "types": "./dist/use-synced-state/client.d.ts",
+      "default": "./dist/use-synced-state/client.js"
+    },
+    "./use-synced-state/worker": {
+      "types": "./dist/use-synced-state/worker.d.ts",
+      "default": "./dist/use-synced-state/worker.js"
     }
   },
   "keywords": [
@@ -144,10 +152,12 @@
     "@puppeteer/browsers": "~2.10.0",
     "@types/decompress": "~4.2.7",
     "@types/fs-extra": "~11.0.4",
+    "@types/glob": "^8.1.0",
     "@types/react": "~19.1.2",
     "@types/react-dom": "~19.1.2",
     "@types/react-is": "~19.0.0",
     "@vitejs/plugin-react": "~5.0.0",
+    "capnweb": "~0.2.0",
     "chokidar": "~4.0.0",
     "debug": "~4.4.0",
     "decompress": "~4.2.1",
@@ -173,8 +183,7 @@
     "ts-morph": "~27.0.0",
     "unique-names-generator": "~4.7.1",
     "vibe-rules": "~0.3.0",
-    "vite-tsconfig-paths": "~5.1.4",
-    "@types/glob": "^8.1.0"
+    "vite-tsconfig-paths": "~5.1.4"
   },
   "peerDependencies": {
     "@cloudflare/vite-plugin": "^1.13.10",