@pluv/types 1.0.2 → 2.0.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @pluv/types@1.0.2 build /home/runner/work/pluv/pluv/packages/types
+> @pluv/types@2.0.1 build /home/runner/work/pluv/pluv/packages/types
 > tsup src/index.ts --format esm,cjs --dts
 
 CLI Building entry: src/index.ts
@@ -8,11 +8,11 @@
 CLI Target: es6
 ESM Build start
 CJS Build start
-CJS dist/index.js 758.00 B
-CJS ⚡️ Build success in 31ms
-ESM dist/index.mjs 0 B
-ESM ⚡️ Build success in 32ms
+CJS dist/index.js 1.21 KB
+CJS ⚡️ Build success in 35ms
+ESM dist/index.mjs 197.00 B
+ESM ⚡️ Build success in 36ms
 DTS Build start
-DTS ⚡️ Build success in 718ms
-DTS dist/index.d.mts 7.48 KB
-DTS dist/index.d.ts  7.48 KB
+DTS ⚡️ Build success in 1251ms
+DTS dist/index.d.mts 14.71 KB
+DTS dist/index.d.ts  14.71 KB

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @pluv/types
 
+## 2.0.1
+
+## 2.0.0
+
+### Patch Changes
+
+- 047a1d8: Moved several internal types to `@pluv/types`.
+
 ## 1.0.2
 
 ## 1.0.1

package/dist/index.d.mts

@@ -1,3 +1,5 @@
+import { Subject } from 'wonka';
+
 type Constructable = {
     new (...args: any[]): any;
 };
@@ -40,6 +42,55 @@ type Json = JsonPrimitive | Json[] | readonly Json[] | {
 type JsonObject = Record<string, Json>;
 type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends (arg: infer I) => void ? I : never;
 
+type CrdtType<TValue extends unknown, TJson extends unknown = any> = Omit<TValue, "__pluvType"> & {
+    __pluvType: () => TJson;
+};
+type InferCrdtJson<T extends unknown> = T extends CrdtType<any, infer IJson> ? InferCrdtJson<IJson> : T extends Record<string, any> ? {
+    [P in keyof T]: InferCrdtJson<T[P]>;
+} : T extends (infer IJson)[] ? InferCrdtJson<IJson>[] : T extends readonly (infer IJson)[] ? readonly InferCrdtJson<IJson>[] : T extends Json ? T : string;
+interface DocApplyEncodedStateParams {
+    origin?: string;
+    update?: Maybe<string | Uint8Array>;
+}
+interface DocBatchApplyEncodedStateParams {
+    origin?: string;
+    updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
+}
+interface DocSubscribeCallbackParams<TStorage extends Record<string, CrdtType<any, any>>> {
+    doc: CrdtDocLike<TStorage>;
+    local: boolean;
+    origin?: string | null;
+    update: string;
+}
+interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
+    applyEncodedState(params: DocApplyEncodedStateParams): this;
+    batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
+    canRedo(): boolean;
+    canUndo(): boolean;
+    destroy(): void;
+    get(key?: undefined): TStorage;
+    get<TKey extends keyof TStorage>(key: TKey): TStorage[TKey];
+    getEncodedState(): string;
+    isEmpty(): boolean;
+    rebuildStorage(reference: TStorage): this;
+    redo(): this;
+    subscribe(listener: (params: DocSubscribeCallbackParams<TStorage>) => void): () => void;
+    toJson(): InferCrdtJson<TStorage>;
+    toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
+    track(): this;
+    transact(fn: () => void, origin?: string): this;
+    undo(): this;
+}
+
+declare const ConnectionState: {
+    readonly Closed: "Closed";
+    readonly Connecting: "Connecting";
+    readonly Open: "Open";
+    readonly Unavailable: "Unavailable";
+    readonly Untouched: "Untouched";
+};
+type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+
 type BaseUser = {
     id: string;
 };
@@ -178,5 +229,85 @@ type InferEventMessage<TEvents = EventRecord<string, any>, TEvent extends keyof
 type IOEventMessage<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = Id<{
     room: string;
 } & InferEventMessage<InferIOOutput<TIO>, TEvent> & (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends "$error" ? Partial<IOAuthorizeEventMessage<TIO>> : IOAuthorizeEventMessage<TIO>)>;
+type PluvRouterEventConfig = {
+    [P: string]: Pick<ProcedureLike<any, any>, "config">;
+};
+type MergeEvents<TClientEvents extends PluvRouterEventConfig, TServerIO extends IOLike<any, any>> = TServerIO extends IOLike<infer IAuthorize, infer IServerEvents> ? IOLike<IAuthorize, {
+    [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<infer IClientInput, infer IClientOutput> ? {
+        [K in keyof IClientOutput]: K extends keyof IServerEvents ? IServerEvents[K] : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
+    }[keyof IClientOutput] : never;
+} & IServerEvents> : never;
+
+interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
+}
+type EventNotifierSubscriptionCallback<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject> = (value: Id<UserInfo<TIO, TPresence>> | null) => void;
+interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
+    connection: Subject<Id<WebSocketState<TIO>>>;
+    "my-presence": Subject<TPresence | null>;
+    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
+    others: Subject<readonly Id<UserInfo<TIO>>[]>;
+    "storage-loaded": Subject<boolean>;
+}
+type InferSubjectValue<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
+type SubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
+interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+    connectionId: string;
+    presence: TPresence;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}
+interface WebSocketConnection {
+    /**
+     * @description How many times a connection attempt was made. This will increment upon each
+     * unsuccessful attempt, and will reset upon a successful connection.
+     * @date April 13, 2025
+     */
+    attempts: number;
+    /**
+     * @description How many times the user has connected to the room. This can be more than 1 in
+     * the case of reconnects. This is tracked because on the very first connection (i.e. when
+     * count is 0) we don't want to send the storage state as an update to the room and overwrite
+     * the upstream state.
+     * @date April 13, 2025
+     */
+    count: number;
+    id: string | null;
+    state: ConnectionState;
+}
+interface WebSocketState<TIO extends IOLike> {
+    authorization: AuthorizationState<TIO>;
+    connection: WebSocketConnection;
+    webSocket: WebSocket | null;
+}
+interface RoomLike<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig = {}> {
+    id: string;
+    storageLoaded: boolean;
+    broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>): void;
+    canRedo(): boolean;
+    canUndo(): boolean;
+    getDoc(): CrdtDocLike<TStorage>;
+    event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>): () => void;
+    getConnection(): WebSocketConnection;
+    getMyPresence(): TPresence;
+    getMyself(): Id<UserInfo<TIO, TPresence>> | null;
+    getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
+    getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
+    getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
+    getStorageJson(): InferCrdtJson<TStorage> | null;
+    getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
+    other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO, TPresence>): () => void;
+    redo(): void;
+    storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void): () => void;
+    storageRoot(fn: (value: {
+        [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+    }) => void): () => void;
+    subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
+    transact(fn: (storage: TStorage) => void, origin?: string): void;
+    undo(): void;
+    updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
+}
 
-export type { BaseClientEventRecord, BaseClientMessage, BaseIOEventRecord, BaseUser, Constructable, DeepPartial, DeepWriteable, EventMessage, EventRecord, GetEventMessage, IOAuthorize, IOAuthorizeEventMessage, IOEventMessage, IOLike, IORouterLike, Id, InferEventMessage, InferEventsInput, InferEventsOutput, InferIOAuthorize, InferIOAuthorizeUser, InferIOInput, InferIOOutput, InputZodLike, Json, JsonObject, JsonPrimitive, Maybe, MaybePromise, MaybeReadonlyArray, NonNilProps, OptionalProps, ProcedureLike, Spread, SpreadProperties, UndefinedProps };
+export { type BaseClientEventRecord, type BaseClientMessage, type BaseIOEventRecord, type BaseUser, ConnectionState, type Constructable, type CrdtDocLike, type CrdtType, type DeepPartial, type DeepWriteable, type DocApplyEncodedStateParams, type DocBatchApplyEncodedStateParams, type DocSubscribeCallbackParams, type EventMessage, type EventNotifierSubscriptionCallback, type EventRecord, type GetEventMessage, type IOAuthorize, type IOAuthorizeEventMessage, type IOEventMessage, type IOLike, type IORouterLike, type Id, type InferEventMessage, type InferEventsInput, type InferEventsOutput, type InferIOAuthorize, type InferIOAuthorizeUser, type InferIOInput, type InferIOOutput, type InputZodLike, type Json, type JsonObject, type JsonPrimitive, type Maybe, type MaybePromise, type MaybeReadonlyArray, type MergeEvents, type NonNilProps, type OptionalProps, type OtherNotifierSubscriptionCallback, type ProcedureLike, type RoomLike, type Spread, type SpreadProperties, type UndefinedProps, type UpdateMyPresenceAction, type UserInfo, type WebSocketConnection, type WebSocketState };

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { Subject } from 'wonka';
+
 type Constructable = {
     new (...args: any[]): any;
 };
@@ -40,6 +42,55 @@ type Json = JsonPrimitive | Json[] | readonly Json[] | {
 type JsonObject = Record<string, Json>;
 type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends (arg: infer I) => void ? I : never;
 
+type CrdtType<TValue extends unknown, TJson extends unknown = any> = Omit<TValue, "__pluvType"> & {
+    __pluvType: () => TJson;
+};
+type InferCrdtJson<T extends unknown> = T extends CrdtType<any, infer IJson> ? InferCrdtJson<IJson> : T extends Record<string, any> ? {
+    [P in keyof T]: InferCrdtJson<T[P]>;
+} : T extends (infer IJson)[] ? InferCrdtJson<IJson>[] : T extends readonly (infer IJson)[] ? readonly InferCrdtJson<IJson>[] : T extends Json ? T : string;
+interface DocApplyEncodedStateParams {
+    origin?: string;
+    update?: Maybe<string | Uint8Array>;
+}
+interface DocBatchApplyEncodedStateParams {
+    origin?: string;
+    updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
+}
+interface DocSubscribeCallbackParams<TStorage extends Record<string, CrdtType<any, any>>> {
+    doc: CrdtDocLike<TStorage>;
+    local: boolean;
+    origin?: string | null;
+    update: string;
+}
+interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
+    applyEncodedState(params: DocApplyEncodedStateParams): this;
+    batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
+    canRedo(): boolean;
+    canUndo(): boolean;
+    destroy(): void;
+    get(key?: undefined): TStorage;
+    get<TKey extends keyof TStorage>(key: TKey): TStorage[TKey];
+    getEncodedState(): string;
+    isEmpty(): boolean;
+    rebuildStorage(reference: TStorage): this;
+    redo(): this;
+    subscribe(listener: (params: DocSubscribeCallbackParams<TStorage>) => void): () => void;
+    toJson(): InferCrdtJson<TStorage>;
+    toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
+    track(): this;
+    transact(fn: () => void, origin?: string): this;
+    undo(): this;
+}
+
+declare const ConnectionState: {
+    readonly Closed: "Closed";
+    readonly Connecting: "Connecting";
+    readonly Open: "Open";
+    readonly Unavailable: "Unavailable";
+    readonly Untouched: "Untouched";
+};
+type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+
 type BaseUser = {
     id: string;
 };
@@ -178,5 +229,85 @@ type InferEventMessage<TEvents = EventRecord<string, any>, TEvent extends keyof
 type IOEventMessage<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = Id<{
     room: string;
 } & InferEventMessage<InferIOOutput<TIO>, TEvent> & (InferEventMessage<InferIOOutput<TIO>, TEvent>["type"] extends "$error" ? Partial<IOAuthorizeEventMessage<TIO>> : IOAuthorizeEventMessage<TIO>)>;
+type PluvRouterEventConfig = {
+    [P: string]: Pick<ProcedureLike<any, any>, "config">;
+};
+type MergeEvents<TClientEvents extends PluvRouterEventConfig, TServerIO extends IOLike<any, any>> = TServerIO extends IOLike<infer IAuthorize, infer IServerEvents> ? IOLike<IAuthorize, {
+    [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<infer IClientInput, infer IClientOutput> ? {
+        [K in keyof IClientOutput]: K extends keyof IServerEvents ? IServerEvents[K] : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
+    }[keyof IClientOutput] : never;
+} & IServerEvents> : never;
+
+interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
+}
+type EventNotifierSubscriptionCallback<TIO extends IOLike<any, any>, TEvent extends keyof InferIOOutput<TIO>> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject> = (value: Id<UserInfo<TIO, TPresence>> | null) => void;
+interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
+    connection: Subject<Id<WebSocketState<TIO>>>;
+    "my-presence": Subject<TPresence | null>;
+    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
+    others: Subject<readonly Id<UserInfo<TIO>>[]>;
+    "storage-loaded": Subject<boolean>;
+}
+type InferSubjectValue<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue> ? Id<IValue> : never;
+type SubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject, TSubject extends keyof StateNotifierSubjects<TIO, TPresence>> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+type UpdateMyPresenceAction<TPresence extends JsonObject> = Partial<TPresence> | ((oldPresence: TPresence | null) => Partial<TPresence>);
+interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+    connectionId: string;
+    presence: TPresence;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}
+interface WebSocketConnection {
+    /**
+     * @description How many times a connection attempt was made. This will increment upon each
+     * unsuccessful attempt, and will reset upon a successful connection.
+     * @date April 13, 2025
+     */
+    attempts: number;
+    /**
+     * @description How many times the user has connected to the room. This can be more than 1 in
+     * the case of reconnects. This is tracked because on the very first connection (i.e. when
+     * count is 0) we don't want to send the storage state as an update to the room and overwrite
+     * the upstream state.
+     * @date April 13, 2025
+     */
+    count: number;
+    id: string | null;
+    state: ConnectionState;
+}
+interface WebSocketState<TIO extends IOLike> {
+    authorization: AuthorizationState<TIO>;
+    connection: WebSocketConnection;
+    webSocket: WebSocket | null;
+}
+interface RoomLike<TIO extends IOLike, TPresence extends JsonObject = {}, TStorage extends Record<string, CrdtType<any, any>> = {}, TEvents extends PluvRouterEventConfig = {}> {
+    id: string;
+    storageLoaded: boolean;
+    broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(event: TEvent, data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>): void;
+    canRedo(): boolean;
+    canUndo(): boolean;
+    getDoc(): CrdtDocLike<TStorage>;
+    event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(event: TEvent, callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>): () => void;
+    getConnection(): WebSocketConnection;
+    getMyPresence(): TPresence;
+    getMyself(): Id<UserInfo<TIO, TPresence>> | null;
+    getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
+    getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
+    getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
+    getStorageJson(): InferCrdtJson<TStorage> | null;
+    getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
+    other(connectionId: string, callback: OtherNotifierSubscriptionCallback<TIO, TPresence>): () => void;
+    redo(): void;
+    storage<TKey extends keyof TStorage>(key: TKey, fn: (value: InferCrdtJson<TStorage[TKey]>) => void): () => void;
+    storageRoot(fn: (value: {
+        [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+    }) => void): () => void;
+    subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(name: TSubject, callback: SubscriptionCallback<TIO, TPresence, TSubject>): () => void;
+    transact(fn: (storage: TStorage) => void, origin?: string): void;
+    undo(): void;
+    updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
+}
 
-export type { BaseClientEventRecord, BaseClientMessage, BaseIOEventRecord, BaseUser, Constructable, DeepPartial, DeepWriteable, EventMessage, EventRecord, GetEventMessage, IOAuthorize, IOAuthorizeEventMessage, IOEventMessage, IOLike, IORouterLike, Id, InferEventMessage, InferEventsInput, InferEventsOutput, InferIOAuthorize, InferIOAuthorizeUser, InferIOInput, InferIOOutput, InputZodLike, Json, JsonObject, JsonPrimitive, Maybe, MaybePromise, MaybeReadonlyArray, NonNilProps, OptionalProps, ProcedureLike, Spread, SpreadProperties, UndefinedProps };
+export { type BaseClientEventRecord, type BaseClientMessage, type BaseIOEventRecord, type BaseUser, ConnectionState, type Constructable, type CrdtDocLike, type CrdtType, type DeepPartial, type DeepWriteable, type DocApplyEncodedStateParams, type DocBatchApplyEncodedStateParams, type DocSubscribeCallbackParams, type EventMessage, type EventNotifierSubscriptionCallback, type EventRecord, type GetEventMessage, type IOAuthorize, type IOAuthorizeEventMessage, type IOEventMessage, type IOLike, type IORouterLike, type Id, type InferEventMessage, type InferEventsInput, type InferEventsOutput, type InferIOAuthorize, type InferIOAuthorizeUser, type InferIOInput, type InferIOOutput, type InputZodLike, type Json, type JsonObject, type JsonPrimitive, type Maybe, type MaybePromise, type MaybeReadonlyArray, type MergeEvents, type NonNilProps, type OptionalProps, type OtherNotifierSubscriptionCallback, type ProcedureLike, type RoomLike, type Spread, type SpreadProperties, type UndefinedProps, type UpdateMyPresenceAction, type UserInfo, type WebSocketConnection, type WebSocketState };

package/dist/index.js

@@ -3,6 +3,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -15,4 +19,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/index.ts
 var index_exports = {};
+__export(index_exports, {
+  ConnectionState: () => ConnectionState
+});
 module.exports = __toCommonJS(index_exports);
+
+// src/pluv/enums.ts
+var ConnectionState = {
+  Closed: "Closed",
+  Connecting: "Connecting",
+  Open: "Open",
+  Unavailable: "Unavailable",
+  Untouched: "Untouched"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionState
+});

package/dist/index.mjs

@@ -0,0 +1,11 @@
+// src/pluv/enums.ts
+var ConnectionState = {
+  Closed: "Closed",
+  Connecting: "Connecting",
+  Open: "Open",
+  Unavailable: "Unavailable",
+  Untouched: "Untouched"
+};
+export {
+  ConnectionState
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pluv/types",
-  "version": "1.0.2",
+  "version": "2.0.1",
   "description": "@pluv/io shared types",
   "author": "leedavidcs",
   "license": "MIT",
@@ -19,8 +19,11 @@
     "eslint": "^9.25.1",
     "tsup": "^8.4.0",
     "typescript": "^5.8.3",
-    "@pluv/tsconfig": "^1.0.2",
-    "eslint-config-pluv": "^1.0.2"
+    "@pluv/tsconfig": "^2.0.1",
+    "eslint-config-pluv": "^2.0.1"
+  },
+  "dependencies": {
+    "wonka": "^6.3.5"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts",

package/src/index.ts

@@ -15,12 +15,19 @@ export type {
     SpreadProperties,
     UndefinedProps,
 } from "./general";
+export { ConnectionState } from "./pluv";
 export type {
     BaseClientEventRecord,
     BaseClientMessage,
     BaseIOEventRecord,
     BaseUser,
+    CrdtDocLike,
+    CrdtType,
+    DocApplyEncodedStateParams,
+    DocBatchApplyEncodedStateParams,
+    DocSubscribeCallbackParams,
     EventMessage,
+    EventNotifierSubscriptionCallback,
     EventRecord,
     GetEventMessage,
     InferEventMessage,
@@ -36,5 +43,12 @@ export type {
     IOEventMessage,
     IOLike,
     IORouterLike,
+    MergeEvents,
+    OtherNotifierSubscriptionCallback,
     ProcedureLike,
+    RoomLike,
+    UpdateMyPresenceAction,
+    UserInfo,
+    WebSocketConnection,
+    WebSocketState,
 } from "./pluv";

package/src/pluv/crdt.ts

@@ -0,0 +1,58 @@
+import type { Json, Maybe } from "../general";
+
+export type CrdtType<TValue extends unknown, TJson extends unknown = any> = Omit<
+    TValue,
+    "__pluvType"
+> & {
+    __pluvType: () => TJson;
+};
+
+export type InferCrdtJson<T extends unknown> =
+    T extends CrdtType<any, infer IJson>
+        ? InferCrdtJson<IJson>
+        : T extends Record<string, any>
+          ? { [P in keyof T]: InferCrdtJson<T[P]> }
+          : T extends (infer IJson)[]
+            ? InferCrdtJson<IJson>[]
+            : T extends readonly (infer IJson)[]
+              ? readonly InferCrdtJson<IJson>[]
+              : T extends Json
+                ? T
+                : string;
+
+export interface DocApplyEncodedStateParams {
+    origin?: string;
+    update?: Maybe<string | Uint8Array>;
+}
+
+export interface DocBatchApplyEncodedStateParams {
+    origin?: string;
+    updates?: Maybe<readonly Maybe<string | Uint8Array>[]>;
+}
+
+export interface DocSubscribeCallbackParams<TStorage extends Record<string, CrdtType<any, any>>> {
+    doc: CrdtDocLike<TStorage>;
+    local: boolean;
+    origin?: string | null;
+    update: string;
+}
+
+export interface CrdtDocLike<TStorage extends Record<string, CrdtType<any, any>>> {
+    applyEncodedState(params: DocApplyEncodedStateParams): this;
+    batchApplyEncodedState(params: DocBatchApplyEncodedStateParams): this;
+    canRedo(): boolean;
+    canUndo(): boolean;
+    destroy(): void;
+    get(key?: undefined): TStorage;
+    get<TKey extends keyof TStorage>(key: TKey): TStorage[TKey];
+    getEncodedState(): string;
+    isEmpty(): boolean;
+    rebuildStorage(reference: TStorage): this;
+    redo(): this;
+    subscribe(listener: (params: DocSubscribeCallbackParams<TStorage>) => void): () => void;
+    toJson(): InferCrdtJson<TStorage>;
+    toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
+    track(): this;
+    transact(fn: () => void, origin?: string): this;
+    undo(): this;
+}

package/src/pluv/enums.ts

@@ -0,0 +1,9 @@
+export const ConnectionState = {
+    Closed: "Closed",
+    Connecting: "Connecting",
+    Open: "Open",
+    Unavailable: "Unavailable",
+    Untouched: "Untouched",
+} as const;
+
+export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];

package/src/pluv/index.ts

@@ -0,0 +1,4 @@
+export * from "./crdt";
+export * from "./room";
+export * from "./shared";
+export * from "./enums";

package/src/pluv/room.ts

@@ -0,0 +1,156 @@
+import type { Subject } from "wonka";
+import type { ConnectionState } from "./enums";
+import type { Id, JsonObject } from "../general";
+import type { CrdtDocLike, CrdtType, InferCrdtJson } from "./crdt";
+import type {
+    InferIOAuthorize,
+    InferIOAuthorizeUser,
+    InferIOInput,
+    InferIOOutput,
+    IOEventMessage,
+    IOLike,
+    MergeEvents,
+    PluvRouterEventConfig,
+} from "./shared";
+
+export interface AuthorizationState<TIO extends IOLike> {
+    token: string | null;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>> | null;
+}
+
+export type EventNotifierSubscriptionCallback<
+    TIO extends IOLike<any, any>,
+    TEvent extends keyof InferIOOutput<TIO>,
+> = (value: Id<IOEventMessage<TIO, TEvent>>) => void;
+
+export type OtherNotifierSubscriptionCallback<TIO extends IOLike, TPresence extends JsonObject> = (
+    value: Id<UserInfo<TIO, TPresence>> | null,
+) => void;
+
+export interface StateNotifierSubjects<TIO extends IOLike, TPresence extends JsonObject> {
+    connection: Subject<Id<WebSocketState<TIO>>>;
+    "my-presence": Subject<TPresence | null>;
+    myself: Subject<Readonly<Id<UserInfo<TIO>>> | null>;
+    others: Subject<readonly Id<UserInfo<TIO>>[]>;
+    "storage-loaded": Subject<boolean>;
+}
+
+type InferSubjectValue<
+    TIO extends IOLike,
+    TPresence extends JsonObject,
+    TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
+> =
+    StateNotifierSubjects<TIO, TPresence>[TSubject] extends Subject<infer IValue>
+        ? Id<IValue>
+        : never;
+
+export type SubscriptionCallback<
+    TIO extends IOLike,
+    TPresence extends JsonObject,
+    TSubject extends keyof StateNotifierSubjects<TIO, TPresence>,
+> = (value: InferSubjectValue<TIO, TPresence, TSubject>) => void;
+
+export type UpdateMyPresenceAction<TPresence extends JsonObject> =
+    | Partial<TPresence>
+    | ((oldPresence: TPresence | null) => Partial<TPresence>);
+
+export interface UserInfo<TIO extends IOLike, TPresence extends JsonObject = {}> {
+    connectionId: string;
+    presence: TPresence;
+    user: Id<InferIOAuthorizeUser<InferIOAuthorize<TIO>>>;
+}
+
+export interface WebSocketConnection {
+    /**
+     * @description How many times a connection attempt was made. This will increment upon each
+     * unsuccessful attempt, and will reset upon a successful connection.
+     * @date April 13, 2025
+     */
+    attempts: number;
+    /**
+     * @description How many times the user has connected to the room. This can be more than 1 in
+     * the case of reconnects. This is tracked because on the very first connection (i.e. when
+     * count is 0) we don't want to send the storage state as an update to the room and overwrite
+     * the upstream state.
+     * @date April 13, 2025
+     */
+    count: number;
+    id: string | null;
+    state: ConnectionState;
+}
+
+export interface WebSocketState<TIO extends IOLike> {
+    authorization: AuthorizationState<TIO>;
+    connection: WebSocketConnection;
+    webSocket: WebSocket | null;
+}
+
+export interface RoomLike<
+    TIO extends IOLike,
+    TPresence extends JsonObject = {},
+    TStorage extends Record<string, CrdtType<any, any>> = {},
+    TEvents extends PluvRouterEventConfig = {},
+> {
+    id: string;
+    storageLoaded: boolean;
+
+    broadcast<TEvent extends keyof InferIOInput<MergeEvents<TEvents, TIO>>>(
+        event: TEvent,
+        data: Id<InferIOInput<MergeEvents<TEvents, TIO>>[TEvent]>,
+    ): void;
+
+    canRedo(): boolean;
+
+    canUndo(): boolean;
+
+    getDoc(): CrdtDocLike<TStorage>;
+
+    event<TEvent extends keyof InferIOOutput<MergeEvents<TEvents, TIO>>>(
+        event: TEvent,
+        callback: EventNotifierSubscriptionCallback<MergeEvents<TEvents, TIO>, TEvent>,
+    ): () => void;
+
+    getConnection(): WebSocketConnection;
+
+    getMyPresence(): TPresence;
+
+    getMyself(): Id<UserInfo<TIO, TPresence>> | null;
+
+    getOther(connectionId: string): Id<UserInfo<TIO, TPresence>> | null;
+
+    getOthers(): readonly Id<UserInfo<TIO, TPresence>>[];
+
+    getStorage<TKey extends keyof TStorage>(type: TKey): TStorage[TKey] | null;
+
+    getStorageJson(): InferCrdtJson<TStorage> | null;
+    getStorageJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]> | null;
+
+    other(
+        connectionId: string,
+        callback: OtherNotifierSubscriptionCallback<TIO, TPresence>,
+    ): () => void;
+
+    redo(): void;
+
+    storage<TKey extends keyof TStorage>(
+        key: TKey,
+        fn: (value: InferCrdtJson<TStorage[TKey]>) => void,
+    ): () => void;
+
+    storageRoot(
+        fn: (value: {
+            [P in keyof TStorage]: InferCrdtJson<TStorage[P]>;
+        }) => void,
+    ): () => void;
+
+    subscribe<TSubject extends keyof StateNotifierSubjects<TIO, TPresence>>(
+        name: TSubject,
+        callback: SubscriptionCallback<TIO, TPresence, TSubject>,
+    ): () => void;
+
+    transact(fn: (storage: TStorage) => void, origin?: string): void;
+
+    undo(): void;
+
+    updateMyPresence(presence: UpdateMyPresenceAction<TPresence>): void;
+}

package/src/{pluv.ts → pluv/shared.ts}

@@ -1,4 +1,4 @@
-import type { Id, JsonObject, MaybePromise, UnionToIntersection } from "./general";
+import type { Id, JsonObject, MaybePromise, UnionToIntersection } from "../general";
 
 export type BaseUser = {
     id: string;
@@ -183,3 +183,27 @@ export type IOEventMessage<
             ? Partial<IOAuthorizeEventMessage<TIO>>
             : IOAuthorizeEventMessage<TIO>)
 >;
+
+export type PluvRouterEventConfig = { [P: string]: Pick<ProcedureLike<any, any>, "config"> };
+
+export type MergeEvents<
+    TClientEvents extends PluvRouterEventConfig,
+    TServerIO extends IOLike<any, any>,
+> =
+    TServerIO extends IOLike<infer IAuthorize, infer IServerEvents>
+        ? IOLike<
+              IAuthorize,
+              {
+                  [P in keyof TClientEvents]: TClientEvents[P] extends ProcedureLike<
+                      infer IClientInput,
+                      infer IClientOutput
+                  >
+                      ? {
+                            [K in keyof IClientOutput]: K extends keyof IServerEvents
+                                ? IServerEvents[K]
+                                : ProcedureLike<IClientInput, Id<Pick<IClientOutput, K>>>;
+                        }[keyof IClientOutput]
+                      : never;
+              } & IServerEvents
+          >
+        : never;

package/tsconfig.json

@@ -1,5 +1,10 @@
 {
 	"extends": "@pluv/tsconfig/library.json",
 	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
-	"exclude": ["node_modules"]
+	"exclude": ["node_modules"],
+	"compilerOptions": {
+		"lib": ["dom", "esnext"],
+		"module": "esnext",
+		"target": "es6"
+	}
 }