@pluv/io 0.0.0-canary-20261027014949

package/dist/index.d.mts

@@ -0,0 +1,952 @@
+import { AbstractCrdtDocFactory, CrdtLibraryType, HasStorage, InferDocLike } from "@pluv/crdt";
+import { BaseUser, BaseUser as BaseUser$1, CrdtDocFactory, CrdtDocLike, CrdtDocLike as CrdtDocLike$1, EventMessage, EventRecord, EventRecord as EventRecord$1, HasRequiredProperty, IOAuthorize, IOEventMessage, IOEventMessage as IOEventMessage$1, IOLike, IOLikeDefs, IORouterLike, Id, InferEventMessage, InferEventsOutput, InferIOAuthorize, InferIOAuthorizeUser, InferIOInput, InferIOOutput, InferTreatyProcedureInput, InferTreatyUser, JsonObject, ListUsersCursor, ListUsersError, ListUsersOptions, ListUsersResult, Maybe, MaybePromise, OnGetOperator, OnGetOperator as OnGetOperator$1, OperatorUser, OperatorUser as OperatorUser$1, ParticipantKind, ParticipantKind as ParticipantKind$1, PresenceProcedureProxy, PresenceSeq, ProcedureLike, ProcedureLike as ProcedureLike$1, RoomStatsByKind, ServerOriginEvent, SessionPresence, SetKey, SetKey as SetKey$1, StandardSchemaV1, StandardSchemaV1 as StandardSchemaV1$1, TreatyLike, TreatyProcedureInputJson, TreatyProcedureLike } from "@pluv/types";
+export declare abstract class AbstractPersistence {
+  abstract addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void>;
+  abstract deleteStorageState(room: string): Promise<void>;
+  abstract deleteUser(room: string, connectionId: string): Promise<void>;
+  abstract deleteUsers(room: string): Promise<void>;
+  abstract getStorageState(room: string): Promise<string | null>;
+  abstract getUser(room: string, connectionId: string): Promise<JsonObject | null>;
+  abstract getUsers(room: string): Promise<Map<[connectionId: string][0], JsonObject | null>>;
+  abstract getUsersSize(room: string): Promise<number>;
+  abstract initialize(roomContext: any): typeof this;
+  abstract setStorageState(room: string, state: string): Promise<void>;
+}
+type IOPubSubEventMessage<TIO extends IOLike, TEvent extends keyof InferIOOutput<TIO> = keyof InferIOOutput<TIO>> = IOEventMessage$1<TIO, TEvent> & {
+  options?: SendMessageOptions;
+};
+export declare abstract class AbstractPubSub {
+  abstract publish(roomName: string, payload: IOPubSubEventMessage<any>): Promise<void>;
+  abstract subscribe(roomName: string, onMessage: (message: IOPubSubEventMessage<any>) => void): Promise<number>;
+  abstract unsubscribe(subscriptionId: number): void;
+}
+type AbstractEvent = {};
+type AbstractCloseEvent = AbstractEvent & {
+  readonly code: number;
+  readonly reason: string;
+};
+type AbstractMessageEvent<T = any> = AbstractEvent & {
+  readonly data: T;
+};
+type AbstractErrorEvent = AbstractEvent & {
+  error: unknown;
+  message?: string;
+};
+interface AbstractEventMap {
+  close: AbstractCloseEvent;
+  message: AbstractMessageEvent;
+  error: AbstractErrorEvent;
+}
+type EventType = keyof AbstractEventMap;
+interface AbstractWebSocketHandleErrorParams {
+  error: unknown;
+  message?: string;
+  room: string;
+  session?: WebSocketSession<any>;
+}
+type AbstractListener<TType extends keyof AbstractEventMap> = (event: AbstractEventMap[TType]) => MaybePromise<void>;
+type InferWebSocketSource<TAbstractWebSocket extends AbstractWebSocket> = TAbstractWebSocket extends AbstractWebSocket<infer IWebSocket> ? IWebSocket : never;
+interface AbstractWebSocketConfig {
+  persistence: AbstractPersistence;
+  platform: AbstractPlatform<any>;
+  room: string;
+}
+export declare abstract class AbstractWebSocket<TWebSocket = any> {
+  /** The connection is not yet open. */
+  readonly CONNECTING = 0;
+  /** The connection is open and ready to communicate. */
+  readonly OPEN = 1;
+  /** The connection is in the process of closing. */
+  readonly CLOSING = 2;
+  /** The connection is closed. */
+  readonly CLOSED = 3;
+  readonly persistence: AbstractPersistence;
+  readonly room: string;
+  readonly webSocket: TWebSocket;
+  protected readonly _platform: AbstractPlatform<this>;
+  abstract set presence(presence: JsonObject | null);
+  abstract get readyState(): 0 | 1 | 2 | 3;
+  abstract get session(): WebSocketSession<any>;
+  abstract get sessionId(): string;
+  abstract get state(): WebSocketSerializedState;
+  abstract set state(state: WebSocketSerializedState);
+  /**
+   * @description Authorized user for this socket. `null` until `register` (or hibernation
+   * reattach) has assigned one.
+   */
+  abstract get user(): BaseUser$1 | null;
+  abstract set user(user: BaseUser$1);
+  constructor(webSocket: TWebSocket, config: AbstractWebSocketConfig);
+  /**
+   * TODO
+   * @description Return an unsubscribe method to remove the event-listener.
+   * This is preferred over adding an explicit abstract removeEventListener
+   * method, because the implementing class might have to transform the
+   * listener, and removing the same listener might be complicated as a
+   * result.
+   * @date August 28, 2022
+   */
+  abstract addEventListener<TType extends EventType>(type: TType, handler: AbstractListener<TType>): void;
+  abstract close(code?: number, reason?: string): void;
+  abstract send(message: ArrayBuffer | ArrayBufferView | string): void;
+  abstract terminate(): void;
+  handleError(params: AbstractWebSocketHandleErrorParams): void;
+  sendMessage<TMessage extends IOEventMessage$1<any> = IOEventMessage$1<any>>(data: TMessage): void;
+}
+interface JWT<TUser extends BaseUser$1> {
+  kind: ParticipantKind$1;
+  operator: OperatorUser$1 | null;
+  room: string;
+  sub: string;
+  user: TUser;
+}
+type JWTEncodeBase<TPlatform extends AbstractPlatform<any, any>> = {
+  /**
+   * Token lifetime in milliseconds. Converted to whole seconds for JWT `exp`.
+   * @default 60_000
+   */
+  maxAge?: number;
+  room: string;
+} & InferInitContextType<TPlatform>;
+type OccupantTokenIdentity<TUser extends BaseUser$1> = {
+  kind?: "user";
+  user: TUser;
+};
+type OperatorTokenIdentity = {
+  kind: "operator";
+  operator: OperatorUser$1 & {
+    email: string;
+  };
+};
+type OperatorSessionIdentity = {
+  kind: "operator";
+  operator: OperatorUser$1;
+};
+type JwtTokenIdentity<TUser extends BaseUser$1> = OccupantTokenIdentity<TUser> | (OperatorSessionIdentity & {
+  user: TUser;
+});
+type CreateUserTokenParams<TUser extends BaseUser$1, TPlatform extends AbstractPlatform<any, any>> = JWTEncodeBase<TPlatform> & OccupantTokenIdentity<TUser>;
+type CreateOperatorTokenParams<TPlatform extends AbstractPlatform<any, any>> = JWTEncodeBase<TPlatform> & OperatorTokenIdentity;
+type CreateTokenParams<TUser extends BaseUser$1, TPlatform extends AbstractPlatform<any, any>> = CreateUserTokenParams<TUser, TPlatform> | CreateOperatorTokenParams<TPlatform>;
+type JWTEncodeParams<TUser extends BaseUser$1, TPlatform extends AbstractPlatform<any, any>> = JWTEncodeBase<TPlatform> & JwtTokenIdentity<TUser>;
+interface AuthorizeParams {
+  platform: AbstractPlatform<any, any>;
+  secret: string;
+}
+interface AuthorizeModule {
+  decode: <TUser extends BaseUser$1>(jwt: string) => Promise<JWT<TUser> | null>;
+  encode: <TUser extends BaseUser$1, TPlatform extends AbstractPlatform<any, any>>(params: JWTEncodeParams<TUser, TPlatform>) => Promise<string>;
+}
+export declare const authorize: (params: AuthorizeParams) => {
+  decode: <TUser extends BaseUser$1>(jwt: string) => Promise<JWT<TUser> | null>;
+  encode: <TUser extends BaseUser$1, TPlatform extends AbstractPlatform<any, any>>(encodeParams: JWTEncodeParams<TUser, TPlatform>) => Promise<string>;
+};
+type InferPlatformWebSocketType<TPlatform extends AbstractPlatform> = TPlatform extends AbstractPlatform<infer IAbstractWebSocket> ? IAbstractWebSocket : never;
+type InferPlatformWebSocketSource<TPlatform> = TPlatform extends AbstractPlatform<infer IAbstractWebSocket> ? InferWebSocketSource<IAbstractWebSocket> : never;
+type InferInitContextType<TPlatform extends AbstractPlatform> = TPlatform extends AbstractPlatform<any, infer IInitContext> ? IInitContext : never;
+type InferRoomContextType<TPlatform extends AbstractPlatform> = TPlatform extends AbstractPlatform<any, any, infer IRoomContext> ? IRoomContext : never;
+type AbstractPlatformConfig<TRoomContext extends Record<string, any> = {}> = {
+  persistence?: AbstractPersistence;
+  pubSub?: AbstractPubSub;
+  roomContext?: TRoomContext;
+};
+interface ConvertWebSocketConfig {
+  room: string;
+}
+export declare abstract class AbstractPlatform<TWebSocket extends AbstractWebSocket<any> = AbstractWebSocket<any>, TInitContext extends Record<string, any> = {}, TRoomContext extends Record<string, any> = {}> {
+  protected readonly _initContext: TInitContext | undefined;
+  protected readonly _roomContext: TRoomContext | undefined;
+  private _initialized;
+  private readonly _keptAlive;
+  persistence: AbstractPersistence;
+  pubSub: AbstractPubSub;
+  abstract readonly id: string;
+  readonly _createToken?: (params: JWTEncodeParams<any, any> & {
+    authorize: ResolvedPluvIOAuthorize;
+  }) => Promise<string>;
+  abstract readonly _name: string;
+  constructor(config?: AbstractPlatformConfig<TRoomContext>);
+  abstract acceptWebSocket(webSocket: AbstractWebSocket): Promise<void>;
+  abstract convertWebSocket(webSocket: InferWebSocketSource<TWebSocket>, config: ConvertWebSocketConfig): AbstractWebSocket;
+  abstract getLastPing(webSocket: AbstractWebSocket): number | null;
+  abstract getSerializedState(webSocket: InferWebSocketSource<TWebSocket>): WebSocketSerializedState | null;
+  abstract getSessionId(webSocket: InferWebSocketSource<TWebSocket>): string | null;
+  abstract getWebSockets(): readonly InferWebSocketSource<TWebSocket>[];
+  abstract initialize(config: AbstractPlatformConfig<TRoomContext>): this;
+  abstract parseData(data: string | ArrayBuffer): Record<string, any>;
+  abstract randomUUID(): string;
+  abstract setSerializedState(webSocket: AbstractWebSocket, state: WebSocketSerializedState): WebSocketSerializedState;
+  /**
+   * Retain `promise` until it settles. Cloudflare uses this to keep the isolate awake.
+   * The default holds the reference and does nothing else.
+   */
+  keepAlive(promise: Promise<unknown>): void;
+  /**
+   * Normalize register/createToken init context before authorize runs.
+   * Platforms may convert runtime-specific request types (e.g. Node `IncomingMessage`).
+   */
+  normalizeInitContext(initContext: TInitContext): TInitContext;
+  validateConfig(config: any): void;
+  protected _initialize(): typeof this;
+}
+/**
+ * Server IO snapshot. Dependent constraints (secret vs platform) are
+ * enforced on `createIO().platform().config()`, not inside this object type.
+ */
+type IODefs = IOLikeDefs & {
+  platform: AbstractPlatform<any, any, any>;
+  context: Record<string, any>;
+};
+type PatchDefs<T extends IODefs, P extends Partial<IODefs>> = Omit<T, keyof P> & P;
+type IOLikeFromDefs<T extends IODefs> = Pick<T, "treaty" | "events">;
+interface PluvProcedureConfig<T extends IODefs, TInput extends JsonObject = {}, TOutput extends EventRecord$1<string, any> = {}> {
+  broadcast?: EventResolver<"broadcast", T, TInput, Partial<TOutput>> | null;
+  input?: StandardSchemaV1$1<unknown, TInput>;
+  self?: EventResolver<"self", T, TInput, Partial<TOutput>> | null;
+}
+export declare class PluvProcedure<T extends IODefs = IODefs, TInput extends JsonObject = {}, TOutput extends EventRecord$1<string, any> = {}, TFilled extends "input" | "broadcast" | "self" | "" = ""> {
+  private _broadcast;
+  private _input;
+  private _self;
+  get config(): ProcedureLike$1<TInput, TOutput>["config"];
+  constructor(config?: PluvProcedureConfig<T, TInput, TOutput>);
+  broadcast<TResult extends EventRecord$1<string, any> = {}>(resolver: EventResolver<"broadcast", T, TInput, TResult>): Omit<PluvProcedure<T, TInput, MergeEventRecords<[TOutput, TResult]>, TFilled | "input" | "broadcast">, TFilled | "input" | "broadcast">;
+  input<TData extends JsonObject>(input: StandardSchemaV1$1<unknown, TData>): Omit<PluvProcedure<T, TData, {}, TFilled | "input">, TFilled | "input">;
+  self<TResult extends EventRecord$1<string, any> = {}>(resolver: EventResolver<"self", T, TInput, TResult>): Omit<PluvProcedure<T, TInput, MergeEventRecords<[TOutput, TResult]>, TFilled | "input" | "self">, TFilled | "input" | "self">;
+}
+type PluvRouterEventConfig<T extends IODefs = IODefs> = {
+  [P: string]: Pick<PluvProcedure<T, any, any>, "config">;
+};
+type MergedRouter<TRouters extends PluvRouter<any>[] = [], T extends IODefs = IODefs, TRoot extends Record<string, any> = {}> = TRouters extends [infer IHead extends PluvRouter<any>, ...infer ITail extends PluvRouter<any>[]] ? MergedRouter<ITail, T, TRoot & IHead["_defs"]["events"]> : PluvRouter<SetKey<T, "events", TRoot>>;
+export declare class PluvRouter<T extends IODefs = IODefs> implements IORouterLike<T["events"]> {
+  readonly _defs: {
+    events: T["events"];
+  };
+  /** Event names this router defines. */
+  readonly eventNames: ReadonlySet<string>;
+  constructor(events: T["events"]);
+  static merge<TRouters extends PluvRouter<any>[]>(...routers: TRouters): MergedRouter<TRouters>;
+}
+declare const DEFERRED_RESULT: "$u";
+/** A handler promise the queue must not wait on. The session manager settles this on a later join. */
+type DeferredResult<T> = {
+  readonly [DEFERRED_RESULT]: Promise<T>;
+};
+export declare const deferredResult: <T>(promise: Promise<T>) => DeferredResult<T>;
+export declare const isDeferredResult: <T>(value: T | DeferredResult<T>) => value is DeferredResult<T>;
+export declare const deferredResultPromise: <T>(result: DeferredResult<T>) => Promise<T>;
+export declare const isSuspended: (value: unknown) => value is Suspended;
+export declare const isErrorMessage: (value: unknown) => value is {
+  message: string;
+};
+type PluvContext<TPlatform extends AbstractPlatform, TContext extends Record<string, any>> = MaybePromise<TContext> | ((params: InferRoomContextType<TPlatform>) => MaybePromise<TContext>);
+type EventResolverKind = "broadcast" | "self";
+type EventResolver<_TKind extends EventResolverKind = EventResolverKind, T extends IODefs = IODefs, TInput extends JsonObject = {}, TOutput extends EventRecord$1<string, any> = {}> = (data: TInput, context: EventResolverContext<T>) => MaybePromise<TOutput | void>;
+type EventResolverPresence<T extends IODefs = IODefs> = T["treaty"]["presence"] extends StandardSchemaV1$1<any, infer TPresence> ? TPresence | null : JsonObject | null;
+type EventResolverDoc<T extends IODefs = IODefs> = T["treaty"]["storage"] extends AbstractCrdtDocFactory<any, any, any, any> ? InferDocLike<T["treaty"]["storage"]> : CrdtDocLike$1<any, any>;
+/**
+ * Context passed to user procedures. Session and storage protocol procedures
+ * use a wider internal context.
+ */
+interface EventResolverContext<T extends IODefs = IODefs> {
+  connectionId: string;
+  context: T["context"];
+  doc: EventResolverDoc<T>;
+  kind: ParticipantKind$1;
+  operator: OperatorUser$1 | null;
+  presence: EventResolverPresence<T>;
+  room: string;
+  time: number;
+  user: InferTreatyUser<T["treaty"]>;
+}
+type SendMessageOptions = {
+  type?: "broadcast";
+  sessionIds?: readonly string[];
+} | {
+  type: "self";
+};
+interface WebSocketSessionTimers {
+  ping: number;
+}
+type WebSocketSessionSeq = PresenceSeq;
+interface WebSocketSerializedState extends SessionPresence<JsonObject | null> {
+  quit: boolean;
+  room: string;
+  timers: WebSocketSessionTimers;
+}
+type WebSocketSession<T extends IODefs = IODefs> = WebSocketSerializedState & {
+  id: string;
+  kind: ParticipantKind$1;
+  operator: OperatorUser$1 | null;
+  user: InferTreatyUser<T["treaty"]>;
+  webSocket: AbstractWebSocket;
+};
+type MergeEventRecords<TEventRecords extends EventRecord$1<string, any>[], TRoot extends EventRecord$1<string, any> = {}> = TEventRecords extends [infer IHead extends EventRecord$1<string, any>, ...infer ITail extends EventRecord$1<string, any>[]] ? MergeEventRecords<ITail, Omit<TRoot, keyof IHead> & { [P in keyof IHead]: TRoot extends Record<P, any> ? TRoot[P] | IHead[P] : IHead[P]; }> : Id<TRoot>;
+type GetInitialStorageEvent<TContext extends Record<string, any>> = {
+  context: TContext;
+  room: string;
+};
+type GetInitialStorageFn<TContext extends Record<string, any>> = (event: GetInitialStorageEvent<TContext>) => MaybePromise<Maybe<string>>;
+type ResolvedPluvIOAuthorize<TUser extends BaseUser$1 = any> = {
+  user: StandardSchemaV1$1<unknown, TUser>;
+  secret: string;
+};
+type PluvIOSecret<TPlatform extends AbstractPlatform<any, any> = AbstractPlatform<any, any>> = string | ((context: InferInitContextType<TPlatform>) => string);
+interface PluvIOLimits {
+  /**
+   * @description Allow a maxConnections value that would otherwise be rejected.
+   */
+  dangerouslyAllowHighPresenceFanout?: boolean | null;
+  /**
+   * @description Maximum live sockets in a room. Extra registers are rejected.
+   * Must be a positive integer.
+   * @default 256
+   */
+  maxConnections?: number | null;
+  /**
+   * @description Maximum size of presence object in bytes
+   */
+  presenceMaxSize?: number | null;
+  /**
+   * @description Maximum size of storage state in bytes
+   */
+  storageMaxSize?: number | null;
+  /**
+   * @description Maximum length of user id in characters
+   */
+  userIdMaxLength?: number | null;
+  /**
+   * @description Maximum combined size, in bytes, of the objects stored for one
+   * session. User sessions measure the user object. Operator sessions measure
+   * that user object and the operator profile together. Email is not included.
+   */
+  userMaxSize?: number | null;
+}
+type BasePluvIOListeners<T extends IODefs = IODefs> = {
+  onRoomDestroyed: (event: IORoomDestroyedEvent<T>) => void;
+  onRoomMessage: (event: IORoomMessageEvent<T>) => void;
+  onStorageDestroyed: (event: IORoomListenerEvent<T>) => void;
+  /**
+   * Document changes, about once a second. This is not every update in the
+   * document. Use the snapshot for the full document, and handle gaps yourself.
+   *
+   * Storage already saved when the room opens is not reported. An update that
+   * arrives before the changes it depends on is reported only after those
+   * changes arrive. The part that already applied is saved with the room, and
+   * if the room closes first it never appears here. Updates past the document
+   * size limit can land in the document and still be left out. If this
+   * listener throws, that batch is not sent again.
+   */
+  onStorageEdits: (event: IOStorageEditsEvent<T>) => MaybePromise<void>;
+  onStorageSnapshot: (event: IOStorageSnapshotEvent<T>) => MaybePromise<void>;
+  onUserConnected: (event: IOUserConnectedEvent<T>) => void;
+  onUserDisconnected: (event: IOUserDisconnectedEvent<T>) => void;
+};
+type PluvIOListeners<T extends IODefs = IODefs> = BasePluvIOListeners<T>;
+type PluvIORouter<T extends IODefs = IODefs> = {
+  router?: PluvRouter<T>;
+};
+type IORoomListenerEvent<T extends IODefs = IODefs> = {
+  context: T["context"];
+  encodedState: string | null;
+  room: string;
+};
+type IORoomDestroyedEvent<T extends IODefs = IODefs> = {
+  context: T["context"];
+  room: string;
+};
+type IORoomMessageEvent<T extends IODefs = IODefs> = {
+  context: T["context"];
+  message: InferEventMessage<InferEventsOutput<T["events"]>, keyof InferEventsOutput<T["events"]>>;
+  kind?: ParticipantKind$1;
+  operator?: OperatorUser$1 | null;
+  room: string;
+  user?: InferTreatyUser<T["treaty"]>;
+};
+/**
+ * `user` and `operator` come from the session. `$updateStorage` supplies
+ * `procedure` from the sender. `_commitLoadedStorage` names the procedure
+ * the server ran. A write that was never reserved has all three null.
+ */
+type IOStorageEdit<T extends IODefs = IODefs> = {
+  update: string;
+  user: InferTreatyUser<T["treaty"]> | null;
+  operator: OperatorUser$1 | null;
+  procedure: string | null;
+};
+type IOStorageEditsEvent<T extends IODefs = IODefs> = {
+  changes: readonly IOStorageEdit<T>[];
+  context: T["context"];
+  room: string;
+};
+type IOStorageSnapshotEvent<T extends IODefs = IODefs> = IORoomListenerEvent<T>;
+type IOUserConnectedEvent<T extends IODefs = IODefs> = IORoomListenerEvent<T> & {
+  kind?: ParticipantKind$1;
+  operator?: OperatorUser$1 | null;
+  user?: InferTreatyUser<T["treaty"]>;
+};
+type IOUserDisconnectedEvent<T extends IODefs = IODefs> = IORoomListenerEvent<T> & {
+  kind?: ParticipantKind$1;
+  operator?: OperatorUser$1 | null;
+  user?: InferTreatyUser<T["treaty"]>;
+};
+type WebSocketType<TPlatform extends AbstractPlatform> = InferPlatformWebSocketType<TPlatform> | InferPlatformWebSocketSource<TPlatform>;
+type SnapshotFlush = "clean" | "dirty" | "closed";
+interface RoomSessionSnapshot<T extends IODefs = IODefs> {
+  id: string;
+  user: InferTreatyUser<T["treaty"]>;
+  presence: JsonObject | null;
+  kind: ParticipantKind$1;
+  operator: OperatorUser$1 | null;
+  seq: {
+    presence: number | null;
+  };
+  lastPing: number;
+  quit: boolean;
+}
+type RoomPresenceSession<T extends IODefs = IODefs> = Pick<RoomSessionSnapshot<T>, "id" | "operator" | "presence" | "user">;
+type RoomStorageActor<T extends IODefs = IODefs> = Pick<RoomSessionSnapshot<T>, "id" | "kind" | "operator" | "presence" | "user">;
+/** A storage `prepare` finished off the queue. The next turn writes this. */
+type LoadedStorage<T extends IODefs = IODefs> = {
+  actor: RoomStorageActor<T>;
+  data: unknown;
+  /** `StorageSnapshot.generation` when this write started. A commit after `seal` is dropped. */
+  generation: number;
+  name: string;
+  prepared: unknown;
+};
+type RoomJoinActor<T extends IODefs = IODefs> = Pick<RoomSessionSnapshot<T>, "id" | "kind" | "operator" | "user">;
+interface RoomEffectFrame<T extends IODefs = IODefs> {
+  type: string;
+  data: unknown;
+  user: InferTreatyUser<T["treaty"]> | null;
+  operator: OperatorUser$1 | null;
+  connectionId: string | null;
+}
+interface RoomAttachment {
+  presence: JsonObject | null;
+  seq: number | null;
+  sessionId: string;
+}
+interface RoomEffects<T extends IODefs = IODefs> {
+  attachments: RoomAttachment[];
+  broadcast: RoomEffectFrame<T>[];
+  closes: string[];
+  /** Connection that produced this turn. Null when the result has no single actor. */
+  connectionId: string | null;
+  destroy: boolean;
+  error: unknown;
+  self: RoomEffectFrame<T>[];
+  /**
+   * The in-memory document is ahead of the last snapshot, or this effect still carries a
+   * `$storageUpdated` frame. The snapshot loop delivers those frames. A hosted supervisor reads
+   * this off the call result.
+   */
+  storageDirty: boolean;
+}
+interface RoomRegisterResult<T extends IODefs = IODefs> {
+  user: InferTreatyUser<T["treaty"]> | null;
+  kind: ParticipantKind$1 | null;
+  operator: OperatorUser$1 | null;
+  encodedState: string | null;
+  error: Error | null;
+}
+/** A hosted call released the queue. The supervisor applies the effects on a later call. */
+type Suspended = {
+  readonly suspended: true;
+};
+type WebSocketRegisterConfig<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>> = {
+  token?: string | null;
+} & InferInitContextType<TPlatform>;
+/** Internal methods `RoomSessionManager` uses. */
+interface IORoomInternal<T extends IODefs = IODefs> {
+  applyPresencePatch(params: {
+    name: string;
+    data: unknown;
+    session: RoomPresenceSession<T>;
+  }): Promise<JsonObject | null | DeferredResult<JsonObject | null> | Suspended>;
+  /**
+   * The deferred value stays `LoadedStorage | RoomEffects`. A hosted delivery
+   * resolves with empty effects after the frames were sent.
+   */
+  applyStorageProcedure(params: {
+    name: string;
+    data: unknown;
+    actor: RoomStorageActor<T>;
+  }): Promise<RoomEffects<T> | DeferredResult<LoadedStorage<T> | RoomEffects<T>>>;
+  /** Writes a loaded storage procedure. `releasePending` attaches updates already waiting. */
+  commitLoadedStorage(loaded: LoadedStorage<T>, releasePending?: boolean): Promise<RoomEffects<T>>;
+  close(session: RoomSessionSnapshot<T>): Promise<RoomEffects<T>>;
+  destroy(): Promise<void>;
+  flushSnapshot(): Promise<{
+    broadcast: RoomEffectFrame<T>[];
+    status: SnapshotFlush;
+  }>;
+  initializeStorage(params: {
+    input: {
+      stateVector?: string | null;
+      update?: string | null;
+    };
+    actor: RoomJoinActor<T>;
+  }): Promise<{
+    changeKind: "unchanged" | "initialized" | "empty";
+    state: string | null;
+    storageDirty: boolean;
+  }>;
+  logDebug(...data: unknown[]): void;
+  message(session: RoomSessionSnapshot<T>, event: {
+    data: unknown;
+    type: string;
+  }): Promise<RoomEffects<T> | DeferredResult<RoomEffects<T>> | Suspended>;
+  register(...options: keyof InferInitContextType<T["platform"]> extends never ? [{
+    token?: string;
+  }?] : [WebSocketRegisterConfig<T["platform"]>]): Promise<RoomRegisterResult<T>>;
+  dropStorageUpdates(frames: readonly RoomEffectFrame<T>[]): Promise<void>;
+  queueStorageFrames(frames: readonly RoomEffectFrame<T>[]): void;
+  storageDirty(): boolean | Promise<boolean>;
+  userConnected(params: {
+    id: string;
+    encodedState: string | null;
+    kind: ParticipantKind$1;
+    operator: OperatorUser$1 | null;
+    user: InferTreatyUser<T["treaty"]>;
+  }): Promise<RoomEffects<T>>;
+  whenReady(): Promise<boolean>;
+}
+/**
+ * What `manageSessions` calls. `IORoom` implements this in-process.
+ * A hosted supervisor passes a stub of the same shape beside its own platform.
+ */
+interface SessionRoom<T extends IODefs = IODefs> {
+  readonly id: string;
+  readonly limits: PluvIOLimits | null;
+  readonly treaty: T["treaty"];
+  readonly "~": IORoomInternal<T>;
+}
+declare const resolveMaxConnections: (limits: Pick<PluvIOLimits, "maxConnections">) => number;
+declare const assertPresenceFanoutBudget: (limits: PluvIOLimits) => void;
+/**
+ * Build a router that may include `$` protocol events. Not part of the public
+ * package API — import via `__internal` or sibling modules under `@pluv/io`.
+ */
+declare const createInternalPluvRouter: <T extends IODefs = IODefs>(events: T["events"]) => PluvRouter<T>;
+declare const getMyConnectionIds: (sessions: readonly WebSocketSession<any>[], requester: WebSocketSession<any> | null) => string[];
+declare const getRoomStatsFromSessions: (sessions: readonly WebSocketSession<any>[]) => RoomStatsByKind;
+type GroupedRoomUser = {
+  connectionIds: string[];
+  data: JsonObject;
+  key: string;
+  kind: ParticipantKind$1;
+  operator: OperatorUser$1 | null;
+  presence: JsonObject | null;
+};
+/**
+ * Group live sockets by `(kind, user id)`. Extra tabs of the same kind share
+ * one row. The socket with the newest `seq.presence` supplies `presence`,
+ * `data`, and `operator`. `excludeSessionId` drops that person's whole row.
+ * `key` is `user.id`.
+ */
+declare const groupLiveUsers: (sessions: readonly WebSocketSession<any>[], options?: {
+  excludeSessionId?: string;
+  kinds?: readonly ParticipantKind$1[];
+}) => GroupedRoomUser[];
+declare const listLiveUsers: (sessions: readonly WebSocketSession<any>[], options: {
+  cursor?: ListUsersCursor | null;
+  kinds?: readonly ParticipantKind$1[];
+  limit: number;
+}) => {
+  pageInfo: {
+    endCursor: ListUsersCursor | null;
+    hasNextPage: boolean;
+  };
+  users: {
+    data: JsonObject;
+    kind: ParticipantKind$1;
+    operator: OperatorUser$1 | null;
+  }[];
+};
+declare const pageLiveUsers: (sessions: readonly WebSocketSession<any>[], options?: ListUsersOptions) => ListUsersResult<any>;
+export declare function parsePluvSchema<TData extends JsonObject>(schema: StandardSchemaV1$1<unknown, TData>, data: unknown): TData;
+declare const resolveListUsersLimit: (limit?: number | null) => {
+  success: true;
+  limit: number;
+} | {
+  success: false;
+  error: ListUsersError;
+};
+type Throttle = {
+  cancel: () => void;
+  schedule: () => void;
+};
+declare const throttle: (fn: () => void | Promise<void>, options: {
+  wait: number;
+}) => Throttle;
+/**
+ * Orders one commit after another.
+ * `idle` means the latest reserved turn has already finished.
+ * `reserve` takes the next turn. `previous` settles when the earlier turn
+ * finishes. `finish` runs once, when this turn's commit has ended.
+ */
+export declare class CommitGate {
+  #private;
+  get idle(): boolean;
+  reserve(): {
+    previous: Promise<void>;
+    finish: () => void;
+  };
+}
+export declare const DEFAULT_MAX_CONNECTIONS = 256;
+export declare const LIST_USERS_DEFAULT_LIMIT = 50;
+export declare const LIST_USERS_MAX_LIMIT = 100;
+declare const isServerOriginEvent: (type: string) => type is ServerOriginEvent;
+/**
+ * @experimental
+ * @description Connection the host treaty procedure invoke runs as. Breaking changes may ship
+ * without a major version bump.
+ */
+type HostTreatyProcedureActor = {
+  senderId: string;
+};
+/**
+ * @experimental
+ * @description Bound host invoke for treaty storage procedures (async). Client
+ * `StorageProcedureProxy` methods return `void`; host invokes are async. Breaking changes may ship
+ * without a major version bump.
+ */
+type HostStorageProcedureProxy<TProcedures extends Record<string, TreatyProcedureLike<"storage">> = {}> = (<TName extends Extract<keyof TProcedures, string>>(name: TName, data: InferTreatyProcedureInput<TProcedures[TName]>) => Promise<void>) & { [TName in Extract<keyof TProcedures, string>]: (data: InferTreatyProcedureInput<TProcedures[TName]>) => Promise<void>; };
+/**
+ * @experimental
+ * @description Binds a live connection id and returns the client-shaped presence procedure proxy.
+ * Breaking changes may ship without a major version bump.
+ */
+type HostPresenceInvoke<TIO extends IORoom<any>> = (actor: HostTreatyProcedureActor) => PresenceProcedureProxy<TIO["_defs"]["treaty"]["_defs"]["procedures"]["presence"]>;
+/**
+ * @experimental
+ * @description Binds a live connection id and returns {@link HostStorageProcedureProxy}. Breaking
+ * changes may ship without a major version bump.
+ */
+type HostStorageInvoke<TIO extends IORoom<any>> = (actor: HostTreatyProcedureActor) => HostStorageProcedureProxy<TIO["_defs"]["treaty"]["_defs"]["procedures"]["storage"]>;
+interface IORoomListeners<T extends IODefs = IODefs> {
+  onRoomDestroyed: (event: IORoomDestroyedEvent<T>) => void;
+  onStorageDestroyed: (event: IORoomListenerEvent<T>) => void;
+  onMessage: (event: IORoomMessageEvent<T>) => void;
+  onStorageEdits?: (event: IOStorageEditsEvent<T>) => MaybePromise<void>;
+  onStorageSnapshot: (event: IOStorageSnapshotEvent<T>) => MaybePromise<void>;
+  onUserConnected: (event: IOUserConnectedEvent<T>) => void;
+  onUserDisconnected: (event: IOUserDisconnectedEvent<T>) => void;
+}
+type IORoomConfig<T extends IODefs = IODefs> = Partial<IORoomListeners<T>> & {
+  context: PluvContext<T["platform"], T["context"]>;
+  debug: boolean;
+  getInitialStorage: GetInitialStorageFn<T["context"]>;
+  limits: PluvIOLimits;
+  platform: T["platform"];
+  roomContext: InferRoomContextType<T["platform"]>;
+  router: PluvRouter<T>;
+  secret?: PluvIOSecret<T["platform"]>;
+  treaty: T["treaty"];
+};
+declare class IORoom<T extends IODefs = IODefs> implements IOLike<IOLikeFromDefs<T>>, SessionRoom<T> {
+  readonly id: string;
+  readonly limits: PluvIOLimits;
+  readonly treaty: T["treaty"];
+  readonly "~": IORoomInternal<T>;
+  private _teardown;
+  private _uninitialize;
+  private readonly _edits;
+  private readonly _snapshot;
+  private readonly _context;
+  private readonly _debug;
+  private readonly _listeners;
+  private readonly _platform;
+  private readonly _roomContext;
+  private readonly _router;
+  private readonly _secret?;
+  private readonly _storage;
+  /**
+   * @ignore
+   * @readonly
+   * @deprecated Internal use only. Changes to this will never be marked as breaking.
+   */
+  get _defs(): {
+    context: T["context"];
+    events: T["events"];
+    platform: T["platform"];
+    treaty: T["treaty"];
+  };
+  constructor(id: string, config: IORoomConfig<T>);
+  /**
+   * @internal Opens the stored document and applies a treaty presence procedure.
+   */
+  private _applyPresencePatch;
+  private _applyStorageProcedure;
+  private _commitLoadedStorage;
+  private _close;
+  private _destroyRoom;
+  private get _doc();
+  private _emitDisconnected;
+  private _getAuthorizedUser;
+  /** User context for session procedures. `.config({ context })` runs here. */
+  private _getContext;
+  private _getProcedure;
+  private _initialize;
+  private get _initialized();
+  private _initializeStorage;
+  private _logDebug;
+  private _message;
+  private _register;
+  private _resolverContext;
+  private _dropStorageUpdates;
+  /** Keeps frames from a failed send on the pending list. Ones already queued stay once. */
+  private _queueStorageFrames;
+  private _releaseStorage;
+  private _userConnected;
+  private _userContext;
+}
+type InferIORoom<TServer extends PluvServer<any>> = TServer extends PluvServer<infer IDefs extends IODefs> ? IORoom<IDefs> : never;
+type PluvServerConfig<T extends IODefs = IODefs> = Partial<PluvIOListeners<T>> & {
+  context?: PluvContext<T["platform"], T["context"]>;
+  debug?: boolean;
+  limits: PluvIOLimits;
+  io: PluvIO<SetKey$1<T, "events", {}>>;
+  onGetOperator?: OnGetOperator$1<InferTreatyUser<T["treaty"]>>;
+  platform: () => T["platform"];
+  router?: PluvRouter<T>;
+  secret: PluvIOSecret<T["platform"]>;
+  treaty: T["treaty"];
+} & (HasStorage<T["treaty"]["storage"]> extends true ? {
+  getInitialStorage: GetInitialStorageFn<T["context"]>;
+} : {
+  getInitialStorage?: "[ERROR]: Must specify storage on treaty to use getInitialStorage";
+});
+type BaseCreateRoomOptions<_T extends IODefs> = {
+  debug?: boolean;
+};
+type CreateRoomOptions<T extends IODefs = IODefs> = keyof Omit<InferRoomContextType<T["platform"]>, "meta"> extends never ? [BaseCreateRoomOptions<T>] | [] : [Id<BaseCreateRoomOptions<T> & InferRoomContextType<T["platform"]>>];
+export declare class PluvServer<T extends IODefs = IODefs> implements IOLike<IOLikeFromDefs<T>> {
+  readonly version: string;
+  private readonly _config;
+  private readonly _docFactory;
+  private readonly _listeners;
+  private readonly _onGetOperator;
+  private readonly _onStorageEdits;
+  /**
+   * @description The `createIO()` instance this server was built from.
+   */
+  get io(): PluvIO<SetKey$1<T, "events", {}>>;
+  /**
+   * @ignore
+   * @readonly
+   * @deprecated Internal use only. Changes to this will never be marked as breaking.
+   */
+  get _defs(): T;
+  /**
+   * `_router` fills `_defs` with the session slice, the storage slice, and the
+   * user's router. `createRoom` receives `_docRouter`: storage events plus the
+   * user's router. `manageSessions` dispatches session events.
+   */
+  private get _baseRouter();
+  private get _router();
+  private get _docRouter();
+  constructor(options: PluvServerConfig<T>);
+  createRoom(room: string, ...options: CreateRoomOptions<T>): IORoom<T>;
+  createToken(params: CreateTokenParams<InferTreatyUser<T["treaty"]>, T["platform"]>): Promise<string>;
+  private _getInitialStorage;
+  private _logDebug;
+}
+type PluvIOConfig<T extends IODefs = IODefs> = {
+  context?: PluvContext<T["platform"], T["context"]>;
+  debug?: boolean;
+  limits?: PluvIOLimits;
+  platform: () => T["platform"];
+  secret: PluvIOSecret<T["platform"]>;
+  treaty: T["treaty"];
+};
+type ResolvedServerConfig<T extends IODefs = IODefs> = Partial<PluvIOListeners<T>> & PluvIORouter<T> & {
+  onGetOperator?: OnGetOperator$1<InferTreatyUser<T["treaty"]>>;
+} & (HasStorage<T["treaty"]["storage"]> extends true ? {
+  getInitialStorage: GetInitialStorageFn<T["context"]>;
+} : {
+  getInitialStorage?: "[ERROR]: Must specify storage on treaty to use getInitialStorage";
+});
+type BaseServerConfig<T extends IODefs = IODefs> = { [P in keyof ResolvedServerConfig<T> as ResolvedServerConfig<T>[P] extends undefined ? never : P]: ResolvedServerConfig<T>[P]; };
+type ServerConfig<T extends IODefs = IODefs> = HasRequiredProperty<BaseServerConfig<T>> extends true ? [BaseServerConfig<T>] : [BaseServerConfig<T>?];
+export declare class PluvIO<T extends IODefs = IODefs> {
+  readonly version: string;
+  private readonly _context;
+  private readonly _debug;
+  private readonly _limits;
+  private readonly _platform;
+  private readonly _secret;
+  private readonly _treaty;
+  get procedure(): PluvProcedure<T, {}, {}>;
+  constructor(options: PluvIOConfig<T>);
+  createToken(params: CreateUserTokenParams<InferTreatyUser<T["treaty"]>, T["platform"]>): Promise<string>;
+  createToken(params: CreateTokenParams<InferTreatyUser<T["treaty"]>, T["platform"]>, options: {
+    onGetOperator?: OnGetOperator$1<InferTreatyUser<T["treaty"]>> | null;
+  }): Promise<string>;
+  private _resolveEncodeParams;
+  private _assertIdLength;
+  private _assertUserLimits;
+  mergeRouters<TRouters extends PluvRouter<SetKey<T, "events", any>>[]>(...routers: TRouters): MergedRouter<TRouters, T>;
+  router<TEvents extends PluvRouterEventConfig<T>>(events: TEvents): PluvRouter<SetKey<T, "events", TEvents>>;
+  server<TEvents extends PluvRouterEventConfig<T> = {}>(...config: ServerConfig<SetKey<T, "events", TEvents>>): PluvServer<SetKey<T, "events", TEvents>>;
+}
+type IOConfigParams<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>, TTreaty extends TreatyLike = TreatyLike, TContext extends Record<string, any> = {}> = {
+  context?: PluvContext<TPlatform, TContext>;
+  debug?: boolean;
+  limits?: PluvIOLimits;
+  secret: PluvIOSecret<TPlatform>;
+  treaty: TTreaty;
+};
+type IOPlatformFactory<TPlatform extends AbstractPlatform<any> = AbstractPlatform<any>> = () => TPlatform;
+type ConfiguredIODefs<TPlatform extends AbstractPlatform<any>, TTreaty extends TreatyLike, TContext extends Record<string, any>> = {
+  platform: TPlatform;
+  treaty: TTreaty;
+  context: TContext;
+  events: {};
+};
+interface IOConfigBuilder<TPlatform extends AbstractPlatform<any>> {
+  config: <TTreaty extends TreatyLike, TContext extends Record<string, any> = {}>(params: IOConfigParams<TPlatform, TTreaty, TContext>) => PluvIO<ConfiguredIODefs<TPlatform, TTreaty, TContext>>;
+}
+interface IOPlatformBuilder {
+  platform: <TPlatform extends AbstractPlatform<any>>(platform: IOPlatformFactory<TPlatform>) => IOConfigBuilder<TPlatform>;
+}
+export declare const createIO: () => IOPlatformBuilder;
+type CreateBaseRouterParams<T extends IODefs = IODefs> = {
+  limits: Pick<PluvIOLimits, "presenceMaxSize" | "storageMaxSize">;
+  logDebug?: (...data: any[]) => void;
+  onStorageSnapshot: (event: IOStorageSnapshotEvent<T>) => void;
+};
+type BaseRouter<T extends IODefs> = PluvRouter<SetKey$1<T, "events", {}>>;
+/**
+ * Built-in `$` protocol events. Kept separate from `PluvServer` so the protocol
+ * can be constructed/tested without a full server instance. This merge only
+ * fills `_defs`. `manageSessions` dispatches the session slice. The room
+ * dispatches storage events plus the user's router.
+ */
+declare const createBaseRouter: <T extends IODefs = IODefs>(params: CreateBaseRouterParams<T>) => BaseRouter<T>;
+/**
+ * Maintainer / test-only surface. Not part of the public API — shape and
+ * contents may change without a semver bump. Prefer public exports for apps.
+ */
+export declare const __internal: {
+  assertPresenceFanoutBudget: typeof assertPresenceFanoutBudget;
+  createBaseRouter: typeof createBaseRouter;
+  createInternalPluvRouter: typeof createInternalPluvRouter;
+  getMyConnectionIds: typeof getMyConnectionIds;
+  getRoomStatsFromSessions: typeof getRoomStatsFromSessions;
+  groupLiveUsers: typeof groupLiveUsers;
+  isServerOriginEvent: typeof isServerOriginEvent;
+  listLiveUsers: typeof listLiveUsers;
+  pageLiveUsers: typeof pageLiveUsers;
+  resolveListUsersLimit: typeof resolveListUsersLimit;
+  resolveMaxConnections: typeof resolveMaxConnections;
+  ROOM_STATS_THROTTLE_MS: number;
+  SERVER_ORIGIN_EVENTS: readonly ["$error", "$roomStats", "$syncStateReceived"];
+  throttle: typeof throttle;
+};
+type TreatyDomainSchema = {
+  schema: unknown;
+  procedures: Record<string, TreatyProcedureInputJson>;
+};
+type TreatySchemaJson = {
+  user: unknown;
+  presence: TreatyDomainSchema | null;
+  storage: TreatyDomainSchema | null;
+};
+type BroadcastProxy<TIO extends IORoom<any>> = (<TEvent extends keyof InferIOInput<TIO>>(event: TEvent, data: Id<InferIOInput<TIO>[TEvent]>, senderId: string) => Promise<void>) & { [event in keyof InferIOInput<TIO>]: (data: Id<InferIOInput<TIO>>[event], senderId: string) => Promise<void>; };
+/**
+ * Session manager for one room. `createRoom` returns the room.
+ * `manageSessions` attaches the sockets.
+ */
+declare class RoomSessionManager<T extends IODefs = IODefs> {
+  private readonly _room;
+  readonly broadcast: BroadcastProxy<IORoom<T>>;
+  readonly __experimental_presence: HostPresenceInvoke<IORoom<T>>;
+  readonly __experimental_storage: HostStorageInvoke<IORoom<T>>;
+  private readonly _platform;
+  private readonly _sessions;
+  private readonly _sessionRouter;
+  private readonly _roomStats;
+  private readonly _queue;
+  private readonly _limits;
+  private _closing;
+  private _connecting;
+  private _registering;
+  private _storageSnapshotRun;
+  private readonly _commitGate;
+  private _retry;
+  private _lastGarbageCollectMs;
+  /** Procedure frames whose delivery failed. This isolate outlives the facet. */
+  private _unsent;
+  private _unsentId;
+  private _treatySchema?;
+  constructor(_room: SessionRoom<T>, platform: T["platform"]);
+  get id(): string;
+  getTreatySchema(): TreatySchemaJson;
+  register(webSocket: InferPlatformWebSocketSource<T["platform"]>, ...options: keyof InferInitContextType<T["platform"]> extends never ? [{
+    token?: string;
+  }?] : [WebSocketRegisterConfig<T["platform"]>]): Promise<void>;
+  applyFrames(effects: RoomEffects<T>, senderId: string): Promise<void>;
+  /** Writes sockets only. The facet drops storage after `deliverFrames` returns. */
+  writeFrames(effects: RoomEffects<T>, senderId: string): Promise<void>;
+  applyPresence(params: {
+    name: string;
+    patch: JsonObject | null;
+    senderId: string;
+  }): Promise<void>;
+  onMessage(webSocket: WebSocketType<T["platform"]>): (event: AbstractMessageEvent) => Promise<void>;
+  onClose(webSocket: WebSocketType<T["platform"]>): (event: AbstractCloseEvent) => Promise<void>;
+  onError(webSocket: WebSocketType<T["platform"]>): (event: AbstractErrorEvent) => Promise<void>;
+  garbageCollect(): Promise<void>;
+  evict(sessionId: string): Promise<void>;
+  evictAll(): Promise<void>;
+  getSize(): number;
+  noteStorageDirty(): void;
+  retryUnsent(effects: RoomEffects<T>): void;
+  listUsers(options?: ListUsersOptions): ListUsersResult<IORoom<T>>;
+  private _socket;
+  private _applyEffects;
+  private _collectPong;
+  private _createBroadcast;
+  private _createPresence;
+  private _createStorage;
+  private _deliverRecord;
+  private _destroyEmptyRoom;
+  private _destroyIdleRoom;
+  private _disconnect;
+  private _emitRoomStats;
+  private _emitSyncState;
+  private _evictSockets;
+  private _hydrate;
+  private _isLiveSocket;
+  private _noteStorage;
+  /** A failed send leaves the queued update for the snapshot loop. */
+  private _retainStorage;
+  private _onPublished;
+  private _onSocketMessage;
+  private _openSession;
+  private _parseMessage;
+  private _publish;
+  private _readInputs;
+  private _removeSocket;
+  private _runSessionProcedure;
+  /** Sends procedure frames that `deliverFrames` did not. A failed send stays in this promise and retries after the snapshot interval. */
+  private _deliverUnsent;
+  /** One promise. Wait, ask the room for a snapshot, and repeat until that snapshot is current. */
+  private _snapshotUntilClean;
+  private _sessionContext;
+  private _toSnapshot;
+  /**
+   * Removes each socket on the queue, then runs `onUserDisconnected` after that
+   * join so the listener can await the session manager. `$exit` is written on
+   * a later join. Destroy waits until every unregister in progress has sent `$exit`.
+   */
+  private _unregisterSockets;
+  private _writeFrames;
+}
+export declare function manageSessions<T extends IODefs = IODefs>(room: IORoom<T>): RoomSessionManager<T>;
+export declare function manageSessions<T extends IODefs = IODefs>(room: SessionRoom<T>, platform: T["platform"]): RoomSessionManager<T>;
+export type { AbstractCloseEvent, AbstractErrorEvent, AbstractEvent, AbstractEventMap, AbstractListener, AbstractMessageEvent, AbstractPlatformConfig, AbstractWebSocketConfig, AbstractWebSocketHandleErrorParams, AuthorizeModule, AuthorizeParams, BaseUser, ConvertWebSocketConfig, CrdtDocFactory, CrdtDocLike, CrdtLibraryType, CreateRoomOptions, CreateTokenParams, DeferredResult, EventMessage, EventRecord, GetInitialStorageFn, HostPresenceInvoke, HostStorageInvoke, HostStorageProcedureProxy, HostTreatyProcedureActor, IOAuthorize, IOConfigBuilder, IOConfigParams, IODefs, IOEventMessage, IOLikeFromDefs, IOPlatformBuilder, IOPlatformFactory, IOPubSubEventMessage, IORoom, IORoomDestroyedEvent, IORoomInternal, IORoomListenerEvent, IORoomMessageEvent, IOStorageEdit, IOStorageEditsEvent, IOStorageSnapshotEvent, IOUserConnectedEvent, IOUserDisconnectedEvent, InferIOAuthorize, InferIOAuthorizeUser, InferIORoom, InferInitContextType, InferPlatformWebSocketType, InferRoomContextType, JWT, JWTEncodeParams, LoadedStorage, MergedRouter, OnGetOperator, OperatorUser, ParticipantKind, PatchDefs, PluvContext, PluvIOConfig, PluvIOLimits, PluvIOListeners, PluvIOSecret, PluvProcedureConfig, PluvRouterEventConfig, PluvServerConfig, ProcedureLike, RoomEffects, RoomJoinActor, RoomPresenceSession, RoomRegisterResult, RoomSessionManager, RoomStorageActor, ServerConfig, SessionRoom, StandardSchemaV1, Suspended, TreatyDomainSchema, TreatySchemaJson, WebSocketSerializedState, WebSocketSession, WebSocketSessionSeq };
+//# sourceMappingURL=index.d.mts.map