@pluv/platform 0.0.0-stage → 5.2.3

package/dist/index.d.mts

@@ -0,0 +1,177 @@
+import { AbstractEventMap, AbstractListener, AbstractPersistence, AbstractPlatform, AbstractPlatformConfig, AbstractWebSocket, AbstractWebSocketConfig, ConvertWebSocketConfig, IODefs, RoomEffects, RoomJoinActor, RoomPresenceSession, RoomStorageActor, SessionRoom, WebSocketSerializedState, WebSocketSession } from "@pluv/io";
+import { BaseUser, JsonObject } from "@pluv/types";
+type PluvSocket = {
+  id: string;
+  lastPing: number | null;
+};
+type PluvRoomState = {
+  storage?: {
+    sql?: {
+      exec: (...args: unknown[]) => unknown;
+    };
+  };
+  waitUntil?: (promise: Promise<unknown>) => void;
+};
+type PluvRoomContext = {
+  env?: Record<string, unknown>;
+  sessions?: PluvSocket[];
+  state?: PluvRoomState;
+};
+type PlainError = {
+  message: string;
+} | null;
+/** Supervisor method the facet calls when a slow procedure produces frames. */
+type FrameDelivery = {
+  deliverFrames(effects: RoomEffects): void | Promise<void>;
+  /** Starts the snapshot loop when `storageDirty` is set. */
+  noteStorageDirty(): void | Promise<void>;
+  /** Sends procedure frames after `deliverFrames` failed. */
+  retryUnsent(effects: RoomEffects): void | Promise<void>;
+};
+/** Frame delivery for a prepared storage write. `finish` settles the host call. */
+type StorageFrameDelivery = FrameDelivery & {
+  finish(error: PlainError): void | Promise<void>;
+};
+/** Supervisor method the facet calls when a slow presence patch resolves. */
+type PresenceDelivery = {
+  deliverPresence(delivery: {
+    error: PlainError;
+    name: string;
+    patch: JsonObject | null;
+    senderId: string;
+  }): void | Promise<void>;
+};
+declare class PluvWebSocket extends AbstractWebSocket<PluvSocket> {
+  private _readyState;
+  private _sessionId;
+  private _state;
+  private _user;
+  set presence(presence: JsonObject | null);
+  get readyState(): 0 | 1 | 2 | 3;
+  get session(): WebSocketSession<any>;
+  get sessionId(): string;
+  get state(): WebSocketSerializedState;
+  set state(state: WebSocketSerializedState);
+  get user(): BaseUser | null;
+  set user(user: BaseUser);
+  constructor(webSocket: PluvSocket, config: AbstractWebSocketConfig);
+  addEventListener<TType extends keyof AbstractEventMap>(_type: TType, _handler: AbstractListener<TType>): void;
+  close(_code?: number, _reason?: string): void;
+  send(_message: ArrayBuffer | ArrayBufferView | string): void;
+  terminate(): void;
+}
+type PluvPlatformConfig = AbstractPlatformConfig<PluvRoomContext> & {
+  persistence?: AbstractPersistence;
+};
+export declare class PluvPlatform extends AbstractPlatform<PluvWebSocket, {}, PluvRoomContext> {
+  readonly id: string;
+  readonly _name = "platformPluv";
+  private readonly _persistenceProvided;
+  constructor(config?: PluvPlatformConfig);
+  acceptWebSocket(_webSocket: PluvWebSocket): Promise<void>;
+  convertWebSocket(webSocket: PluvSocket, config: ConvertWebSocketConfig): PluvWebSocket;
+  getLastPing(webSocket: PluvWebSocket): number | null;
+  getSerializedState(_webSocket: PluvSocket): WebSocketSerializedState | null;
+  getSessionId(webSocket: PluvSocket): string | null;
+  getWebSockets(): readonly PluvSocket[];
+  initialize(config: AbstractPlatformConfig<PluvRoomContext>): this;
+  parseData(data: string | ArrayBuffer): Record<string, any>;
+  randomUUID(): string;
+  setSerializedState(webSocket: PluvWebSocket, state: WebSocketSerializedState): WebSocketSerializedState;
+  keepAlive(promise: Promise<unknown>): void;
+}
+export declare const platformPluv: (config?: PluvPlatformConfig) => (() => PluvPlatform);
+type Room = SessionRoom<any>;
+type Snapshot = Parameters<Room["~"]["close"]>[0];
+type RoomFacetOptions<T extends IODefs = IODefs> = {
+  keepAlive: (promise: Promise<unknown>) => void;
+  room: SessionRoom<T>;
+};
+/**
+ * Forwards one room call and returns plain JSON. A deferred result that is still
+ * waiting becomes `{ suspended: true }`. The frames are delivered later on
+ * the `RpcTarget` the caller passed in, which this facet retains until that
+ * send finishes.
+ */
+export declare class RoomFacet<T extends IODefs = IODefs> {
+  #private;
+  constructor(options: RoomFacetOptions<T>);
+  applyPresencePatch(params: {
+    data: unknown;
+    name: string;
+    onPresence: PresenceDelivery;
+    session: RoomPresenceSession;
+  }): Promise<JsonObject | null | {
+    error?: {
+      message: string;
+    } | null;
+    suspended: true;
+  }>;
+  applyStorageProcedure(params: {
+    actor: RoomStorageActor;
+    data: unknown;
+    name: string;
+    onFrames: StorageFrameDelivery;
+  }): Promise<RoomEffects | {
+    error?: {
+      message: string;
+    } | null;
+    suspended: true;
+  }>;
+  close(session: Snapshot): Promise<RoomEffects>;
+  destroy(): Promise<null>;
+  dropStorageUpdates(frames: Readonly<RoomEffects["broadcast"]>): Promise<void>;
+  queueStorageFrames(frames: Readonly<RoomEffects["broadcast"]>): void;
+  flushSnapshot(): Promise<{
+    broadcast: unknown;
+    status: unknown;
+  }>;
+  initializeStorage(params: {
+    actor: RoomJoinActor;
+    input: {
+      stateVector?: string | null;
+      update?: string | null;
+    };
+  }): Promise<{
+    changeKind: string;
+    state: string | null;
+    storageDirty: boolean;
+  }>;
+  logDebug(...data: unknown[]): null;
+  message(params: {
+    event: {
+      data: unknown;
+      type: string;
+    };
+    onFrames: FrameDelivery;
+    session: Snapshot;
+  }): Promise<RoomEffects | {
+    error?: {
+      message: string;
+    } | null;
+    suspended: true;
+  }>;
+  register(...options: Parameters<Room["~"]["register"]>): Promise<{
+    limits: Room["limits"];
+    result: {
+      encodedState: string | null;
+      error: {
+        message: string;
+      } | null;
+      kind: string | null;
+      operator: unknown;
+      user: unknown;
+    };
+  }>;
+  storageDirty(): boolean | Promise<boolean>;
+  userConnected(params: {
+    encodedState: string | null;
+    id: string;
+    kind: string;
+    operator: unknown;
+    user: unknown;
+  }): Promise<RoomEffects>;
+  whenReady(): Promise<boolean>;
+}
+export type { FrameDelivery, PluvRoomContext, PluvSocket, PresenceDelivery, RoomFacetOptions, StorageFrameDelivery };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/PluvWebSocket.ts","../src/PluvPlatform.ts","../src/platformPluv.ts","../src/RoomFacet.ts"],"mappings":";;KAGY;EACR;EACA;;KAGQ;EACR;IACI;MACI,UAAU;;;EAGlB,aAAa,SAAS;;KAGd;EACR,MAAM;EACN,WAAW;EACX,QAAQ;;KAGA;EAAe;;;KAGf;EACR,cAAc,SAAS,qBAAqB;;EAE5C,2BAA2B;;EAE3B,YAAY,SAAS,qBAAqB;;;KAIlC,uBAAuB;EAC/B,OAAO,OAAO,oBAAoB;;;KAI1B;EACR,gBAAgB;IACZ,OAAO;IACP;IACA,OAAO;IACP;aACO;;cCnCF,sBAAsB,kBAAkB;UACzC;UACA;UACA;UACA;MAEG,SAAS,UAAU;MAInB;MAIA,WAAW;MAaX;MAQA,SAAS;MAIT,MAAM,OAAO;MAIb,QAAQ;MAIR,KAAK,MAAM;EAItB,YAAY,WAAW,YAAY,QAAQ;EAcpC,iBAAiB,oBAAoB,kBACxC,OAAO,OACP,UAAU,iBAAiB;EAGxB,MAAM,gBAAgB;EAItB,KAAK,UAAU,cAAc;EAI7B;;KC9EC,qBAAqB,uBAAuB;EACpD,cAAc;;qBAKL,qBAAqB,iBAAiB,mBAAmB;WAClD;WACA;mBAEC;EAEjB,YAAY,SAAQ;EAMb,gBAAgB,YAAY,gBAAgB;EAI5C,iBAAiB,WAAW,YAAY,QAAQ,yBAAyB;EAQzE,YAAY,WAAW;EAIvB,mBAAmB,YAAY,aAAa;EAI5C,aAAa,WAAW;EAIxB,0BAA0B;EAI1B,WAAW,QAAQ,uBAAuB;EA4B1C,UAAU,eAAe,cAAc;EAMvC;EAIA,mBACH,WAAW,eACX,OAAO,2BACR;EAMa,UAAU,SAAS;;qBCrG1B,eAAY,SAAY,8BAAiC;KCUjE,OAAO;KACP,WAAW,WAAW;KAqEf,iBAAiB,UAAU,SAAS;EAC5C,YAAY,SAAS;EACrB,MAAM,YAAY;;;;;;;;qBAST,UAAU,UAAU,SAAS;;EAKtC,YAAY,SAAS,iBAAiB;EAKzB,mBAAmB;IAC5B;IACA;IACA,YAAY;IACZ,SAAS;MACT,QAAQ;IAAsB;MAAU;;IAA0B;;EA0CzD,sBAAsB;IAC/B,OAAO;IACP;IACA;IACA,UAAU;MACV,QAAQ;IAAgB;MAAU;;IAA0B;;EA+HnD,MAAM,SAAS,WAAW,QAAQ;EAIlC,WAAW;EAMX,mBAAmB,QAAQ,SAAS,4BAA4B;EAItE,mBAAmB,QAAQ,SAAS;EAI9B,iBAAiB;IAAU;IAAoB;;EAI/C,kBAAkB;IAC3B,OAAO;IACP;MAAS;MAA6B;;MACtC;IAAU;IAAoB;IAAsB;;EAIjD,YAAY;EAMN,QAAQ;IACjB;MAAS;MAAe;;IACxB,UAAU;IACV,SAAS;MACT,QAAQ;IAAgB;MAAU;;IAA0B;;EA2DnD,YAAY,SAAS,WAAW,yBAAyB;IAClE,QAAQ;IACR;MACI;MACA;QAAS;;MACT;MACA;MACA;;;EAiBD,0BAA0B;EAIpB,cAAc;IACvB;IACA;IACA;IACA;IACA;MACA,QAAQ;EAIL,aAAa"}

package/dist/index.mjs

@@ -0,0 +1,446 @@
+import { AbstractPlatform, AbstractWebSocket, CommitGate, deferredResultPromise, isDeferredResult, isErrorMessage, isSuspended } from "@pluv/io";
+import { PersistenceCloudflareTransactionalStorage } from "@pluv/persistence-cloudflare-transactional-storage";
+// src/PluvWebSocket.ts
+var PluvWebSocket = class extends AbstractWebSocket {
+	_readyState = this.OPEN;
+	_sessionId = null;
+	_state;
+	_user = null;
+	set presence(presence) {
+		this._state.presence = presence;
+	}
+	get readyState() {
+		return this._readyState;
+	}
+	get session() {
+		const user = this._user;
+		if (!user) throw new Error("WebSocket is not authorized");
+		return {
+			...this._state,
+			id: this.sessionId,
+			user,
+			webSocket: this
+		};
+	}
+	get sessionId() {
+		if (this._sessionId) return this._sessionId;
+		this._sessionId = this.webSocket.id;
+		return this._sessionId;
+	}
+	get state() {
+		return this._state;
+	}
+	set state(state) {
+		this._state = state;
+	}
+	get user() {
+		return this._user;
+	}
+	set user(user) {
+		this._user = user;
+	}
+	constructor(webSocket, config) {
+		super(webSocket, config);
+		this._state = {
+			kind: "user",
+			operator: null,
+			presence: null,
+			quit: false,
+			room: config.room,
+			seq: { presence: null },
+			timers: { ping: webSocket.lastPing ?? Date.now() }
+		};
+	}
+	addEventListener(_type, _handler) {}
+	close(_code, _reason) {
+		throw new Error("The room facet does not accept sockets.");
+	}
+	send(_message) {
+		throw new Error("The room facet does not accept sockets.");
+	}
+	terminate() {
+		throw new Error("The room facet does not accept sockets.");
+	}
+};
+// src/PluvPlatform.ts
+const hasSql = (state) => !!state?.storage?.sql;
+var PluvPlatform = class PluvPlatform extends AbstractPlatform {
+	id = crypto.randomUUID();
+	_name = "platformPluv";
+	_persistenceProvided;
+	constructor(config = {}) {
+		super(config);
+		this._persistenceProvided = !!config.persistence;
+	}
+	acceptWebSocket(_webSocket) {
+		return Promise.reject(/* @__PURE__ */ new Error("The room facet does not accept sockets."));
+	}
+	convertWebSocket(webSocket, config) {
+		return new PluvWebSocket(webSocket, {
+			persistence: this.persistence,
+			platform: this,
+			room: config.room
+		});
+	}
+	getLastPing(webSocket) {
+		return webSocket.webSocket.lastPing;
+	}
+	getSerializedState(_webSocket) {
+		return null;
+	}
+	getSessionId(webSocket) {
+		return webSocket.id;
+	}
+	getWebSockets() {
+		return this._roomContext?.sessions ?? [];
+	}
+	initialize(config) {
+		const provided = config.roomContext;
+		const roomContext = {
+			env: provided?.env ?? {},
+			...provided?.sessions ? { sessions: provided.sessions } : {},
+			state: provided?.state ?? {}
+		};
+		if (!this._persistenceProvided && !hasSql(roomContext.state)) throw new Error("The room facet requires SQLite storage or a persistence adapter.");
+		if (!this._persistenceProvided && typeof roomContext.state?.waitUntil !== "function") throw new Error("The room facet requires waitUntil when it uses SQLite storage.");
+		const persistence = (this._persistenceProvided ? this.persistence : new PersistenceCloudflareTransactionalStorage()).initialize(roomContext);
+		return new PluvPlatform({
+			persistence,
+			pubSub: this.pubSub,
+			roomContext
+		})._initialize();
+	}
+	parseData(data) {
+		if (typeof data === "string") return JSON.parse(data);
+		return JSON.parse(new TextDecoder("utf8").decode(data));
+	}
+	randomUUID() {
+		return crypto.randomUUID();
+	}
+	setSerializedState(webSocket, state) {
+		webSocket.state = state;
+		return state;
+	}
+	keepAlive(promise) {
+		super.keepAlive(promise);
+		this._roomContext?.state?.waitUntil?.(promise);
+	}
+};
+// src/platformPluv.ts
+const platformPluv = (config = {}) => {
+	return () => new PluvPlatform(config);
+};
+// src/plain.ts
+const plain = {
+	error: (error) => {
+		if (!error) return null;
+		if (isErrorMessage(error)) return { message: error.message };
+		return { message: "Unexpected error" };
+	},
+	json: (value) => JSON.parse(JSON.stringify(value)),
+	effects: (effects) => {
+		return plain.json({
+			attachments: effects.attachments,
+			broadcast: effects.broadcast,
+			closes: effects.closes,
+			connectionId: effects.connectionId,
+			destroy: effects.destroy,
+			error: plain.error(effects.error),
+			self: effects.self,
+			storageDirty: effects.storageDirty
+		});
+	}
+};
+// src/RoomFacet.ts
+/** Broadcast, self, and `$error` still need a send. Storage stays on the pending list. */
+const procedureReplay = (effects) => {
+	const broadcast = effects.broadcast.filter((frame) => frame.type !== "$storageUpdated");
+	if (!broadcast.length && !effects.self.length && !effects.error) return null;
+	return {
+		...effects,
+		broadcast,
+		storageDirty: false
+	};
+};
+const retain = (target) => {
+	const source = target;
+	if (typeof source.dup === "function") return source.dup();
+	return source;
+};
+const yieldTurn = () => {
+	if (typeof scheduler !== "undefined") return scheduler.wait(0);
+	return new Promise((resolve) => {
+		setTimeout(resolve, 0);
+	});
+};
+const readSettled = async (deferredResult) => {
+	let settled = { status: "pending" };
+	deferredResult.then((value) => {
+		settled = {
+			status: "value",
+			value
+		};
+	}, (error) => {
+		settled = {
+			status: "error",
+			error
+		};
+	});
+	await yieldTurn();
+	return settled;
+};
+/**
+* Forwards one room call and returns plain JSON. A deferred result that is still
+* waiting becomes `{ suspended: true }`. The frames are delivered later on
+* the `RpcTarget` the caller passed in, which this facet retains until that
+* send finishes.
+*/
+var RoomFacet = class {
+	#keepAlive;
+	#room;
+	#storageTurn = new CommitGate();
+	constructor(options) {
+		this.#keepAlive = options.keepAlive;
+		this.#room = options.room;
+	}
+	async applyPresencePatch(params) {
+		const settled = await this.#room["~"].applyPresencePatch({
+			data: params.data,
+			name: params.name,
+			session: params.session
+		});
+		if (!isDeferredResult(settled)) return plain.json(settled);
+		const deferredResult = deferredResultPromise(settled);
+		const ready = await readSettled(deferredResult);
+		if (ready.status === "value") return plain.json(ready.value);
+		if (ready.status === "error") return {
+			error: plain.error(ready.error),
+			suspended: true
+		};
+		this.#deliver({
+			onReject: (sink, error) => {
+				return sink.deliverPresence({
+					error: plain.error(error),
+					name: params.name,
+					patch: null,
+					senderId: params.session.id
+				});
+			},
+			send: (sink, patch) => {
+				return sink.deliverPresence({
+					error: null,
+					name: params.name,
+					patch: plain.json(patch),
+					senderId: params.session.id
+				});
+			},
+			sink: params.onPresence,
+			deferredResult
+		});
+		return { suspended: true };
+	}
+	async applyStorageProcedure(params) {
+		const settled = await this.#room["~"].applyStorageProcedure({
+			actor: params.actor,
+			data: params.data,
+			name: params.name
+		});
+		if (!isDeferredResult(settled)) return plain.effects(settled);
+		const pending = deferredResultPromise(settled);
+		const ready = await readSettled(pending);
+		if (ready.status === "error") throw ready.error;
+		if (ready.status === "value") {
+			const value = ready.value;
+			if ("broadcast" in value) return plain.effects(value);
+			if (this.#storageTurn.idle) {
+				const turn = this.#storageTurn.reserve();
+				try {
+					return plain.effects(await this.#room["~"].commitLoadedStorage(value));
+				} finally {
+					turn.finish();
+				}
+			}
+		}
+		const turn = this.#storageTurn.reserve();
+		const loaded = ready.status === "value" ? Promise.resolve(ready.value) : pending;
+		this.#deliver({
+			onReject: async (sink, error) => {
+				try {
+					await sink.deliverFrames({
+						attachments: [],
+						broadcast: [],
+						closes: [],
+						connectionId: params.actor.id,
+						destroy: false,
+						error: null,
+						self: [],
+						storageDirty: false
+					});
+				} finally {
+					turn.finish();
+					await sink.finish(plain.error(error));
+				}
+			},
+			send: async (sink, value) => {
+				try {
+					let finished = false;
+					const finish = async (error) => {
+						if (finished) return;
+						finished = true;
+						await sink.finish(error ? plain.error(error) : null);
+					};
+					try {
+						const effects = "broadcast" in value ? value : await this.#room["~"].commitLoadedStorage(value, false);
+						const delivered = plain.effects(effects);
+						try {
+							await sink.deliverFrames(delivered);
+						} catch (error) {
+							try {
+								const replay = procedureReplay(delivered);
+								if (replay) await sink.retryUnsent(replay);
+							} finally {
+								this.#room["~"].queueStorageFrames(delivered.broadcast);
+								if (delivered.storageDirty) await sink.noteStorageDirty();
+							}
+							throw error;
+						}
+						await this.#room["~"].dropStorageUpdates(delivered.broadcast);
+						await finish(null);
+					} catch (error) {
+						console.error(error);
+						try {
+							if (await this.#room["~"].storageDirty()) await sink.noteStorageDirty();
+						} finally {
+							await finish(error);
+						}
+					}
+				} finally {
+					turn.finish();
+				}
+			},
+			sink: params.onFrames,
+			deferredResult: turn.previous.then(() => loaded, () => loaded)
+		});
+		return { suspended: true };
+	}
+	async close(session) {
+		return plain.effects(await this.#room["~"].close(session));
+	}
+	async destroy() {
+		await this.#room["~"].destroy();
+		return null;
+	}
+	async dropStorageUpdates(frames) {
+		await this.#room["~"].dropStorageUpdates(frames);
+	}
+	queueStorageFrames(frames) {
+		this.#room["~"].queueStorageFrames(frames);
+	}
+	async flushSnapshot() {
+		return plain.json(await this.#room["~"].flushSnapshot());
+	}
+	async initializeStorage(params) {
+		return plain.json(await this.#room["~"].initializeStorage(params));
+	}
+	logDebug(...data) {
+		this.#room["~"].logDebug(...data);
+		return null;
+	}
+	async message(params) {
+		const settled = await this.#room["~"].message(params.session, params.event);
+		if (isDeferredResult(settled)) {
+			const deferredResult = deferredResultPromise(settled);
+			const ready = await readSettled(deferredResult);
+			if (ready.status === "value") return plain.effects(ready.value);
+			if (ready.status === "error") return {
+				error: plain.error(ready.error),
+				suspended: true
+			};
+			this.#deliver({
+				onReject: (sink, error) => {
+					return sink.deliverFrames(plain.effects({
+						attachments: [],
+						broadcast: [],
+						closes: [],
+						connectionId: params.session.id,
+						destroy: false,
+						error,
+						self: [],
+						storageDirty: false
+					}));
+				},
+				send: async (sink, effects) => {
+					const delivered = plain.effects(effects);
+					try {
+						await sink.deliverFrames(delivered);
+					} catch (error) {
+						try {
+							const replay = procedureReplay(delivered);
+							if (replay) await sink.retryUnsent(replay);
+						} finally {
+							if (delivered.storageDirty) await sink.noteStorageDirty();
+						}
+						throw error;
+					}
+					await this.#room["~"].dropStorageUpdates(delivered.broadcast);
+				},
+				sink: params.onFrames,
+				deferredResult
+			});
+			return { suspended: true };
+		}
+		if (isSuspended(settled)) return settled;
+		return plain.effects(settled);
+	}
+	async register(...options) {
+		const result = await this.#room["~"].register(...options);
+		return {
+			limits: plain.json(this.#room.limits),
+			result: plain.json({
+				encodedState: result.encodedState,
+				error: plain.error(result.error),
+				kind: result.kind,
+				operator: result.operator,
+				user: result.user
+			})
+		};
+	}
+	storageDirty() {
+		return this.#room["~"].storageDirty();
+	}
+	async userConnected(params) {
+		return plain.effects(await this.#room["~"].userConnected(params));
+	}
+	whenReady() {
+		return this.#room["~"].whenReady();
+	}
+	#deliver(params) {
+		const { deferredResult, onReject, send, sink } = params;
+		const kept = retain(sink);
+		const delivery = deferredResult.then(async (value) => {
+			await yieldTurn();
+			try {
+				await send(kept, value);
+			} catch (error) {
+				console.error(error);
+			}
+		}, async (error) => {
+			await yieldTurn();
+			if (!onReject) {
+				console.error(error);
+				return;
+			}
+			try {
+				await onReject(kept, error);
+			} catch (reportError) {
+				console.error(reportError);
+			}
+		}).finally(() => {
+			kept[Symbol.dispose]?.();
+		});
+		this.#keepAlive(delivery);
+	}
+};
+export { PluvPlatform, RoomFacet, platformPluv };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/PluvWebSocket.ts","../src/PluvPlatform.ts","../src/platformPluv.ts","../src/plain.ts","../src/RoomFacet.ts"],"sourcesContent":["import type {\n    AbstractEventMap,\n    AbstractListener,\n    AbstractWebSocketConfig,\n    WebSocketSerializedState,\n    WebSocketSession,\n} from \"@pluv/io\";\nimport { AbstractWebSocket } from \"@pluv/io\";\nimport type { BaseUser, JsonObject } from \"@pluv/types\";\nimport type { PluvSocket } from \"./types\";\n\nexport class PluvWebSocket extends AbstractWebSocket<PluvSocket> {\n    private _readyState: 0 | 1 | 2 | 3 = this.OPEN;\n    private _sessionId: string | null = null;\n    private _state: WebSocketSerializedState;\n    private _user: BaseUser | null = null;\n\n    public set presence(presence: JsonObject | null) {\n        this._state.presence = presence;\n    }\n\n    public get readyState(): 0 | 1 | 2 | 3 {\n        return this._readyState;\n    }\n\n    public get session(): WebSocketSession<any> {\n        const user = this._user;\n\n        if (!user) throw new Error(\"WebSocket is not authorized\");\n\n        return {\n            ...this._state,\n            id: this.sessionId,\n            user,\n            webSocket: this,\n        };\n    }\n\n    public get sessionId(): string {\n        if (this._sessionId) return this._sessionId;\n\n        this._sessionId = this.webSocket.id;\n\n        return this._sessionId;\n    }\n\n    public get state(): WebSocketSerializedState {\n        return this._state;\n    }\n\n    public set state(state: WebSocketSerializedState) {\n        this._state = state;\n    }\n\n    public get user(): BaseUser | null {\n        return this._user;\n    }\n\n    public set user(user: BaseUser) {\n        this._user = user;\n    }\n\n    constructor(webSocket: PluvSocket, config: AbstractWebSocketConfig) {\n        super(webSocket, config);\n\n        this._state = {\n            kind: \"user\",\n            operator: null,\n            presence: null,\n            quit: false,\n            room: config.room,\n            seq: { presence: null },\n            timers: { ping: webSocket.lastPing ?? Date.now() },\n        };\n    }\n\n    public addEventListener<TType extends keyof AbstractEventMap>(\n        _type: TType,\n        _handler: AbstractListener<TType>,\n    ): void {}\n\n    public close(_code?: number, _reason?: string): void {\n        throw new Error(\"The room facet does not accept sockets.\");\n    }\n\n    public send(_message: ArrayBuffer | ArrayBufferView | string): void {\n        throw new Error(\"The room facet does not accept sockets.\");\n    }\n\n    public terminate(): void {\n        throw new Error(\"The room facet does not accept sockets.\");\n    }\n}\n","import type {\n    AbstractPersistence,\n    AbstractPlatformConfig,\n    ConvertWebSocketConfig,\n    WebSocketSerializedState,\n} from \"@pluv/io\";\nimport { AbstractPlatform } from \"@pluv/io\";\nimport { PersistenceCloudflareTransactionalStorage } from \"@pluv/persistence-cloudflare-transactional-storage\";\nimport { PluvWebSocket } from \"./PluvWebSocket\";\nimport type { PluvRoomContext, PluvRoomState, PluvSocket } from \"./types\";\n\nexport type PluvPlatformConfig = AbstractPlatformConfig<PluvRoomContext> & {\n    persistence?: AbstractPersistence;\n};\n\nconst hasSql = (state: PluvRoomState | undefined): boolean => !!state?.storage?.sql;\n\nexport class PluvPlatform extends AbstractPlatform<PluvWebSocket, {}, PluvRoomContext> {\n    public readonly id = crypto.randomUUID();\n    public readonly _name = \"platformPluv\";\n\n    private readonly _persistenceProvided: boolean;\n\n    constructor(config: PluvPlatformConfig = {}) {\n        super(config);\n\n        this._persistenceProvided = !!config.persistence;\n    }\n\n    public acceptWebSocket(_webSocket: PluvWebSocket): Promise<void> {\n        return Promise.reject(new Error(\"The room facet does not accept sockets.\"));\n    }\n\n    public convertWebSocket(webSocket: PluvSocket, config: ConvertWebSocketConfig): PluvWebSocket {\n        return new PluvWebSocket(webSocket, {\n            persistence: this.persistence,\n            platform: this,\n            room: config.room,\n        });\n    }\n\n    public getLastPing(webSocket: PluvWebSocket): number | null {\n        return webSocket.webSocket.lastPing;\n    }\n\n    public getSerializedState(_webSocket: PluvSocket): WebSocketSerializedState | null {\n        return null;\n    }\n\n    public getSessionId(webSocket: PluvSocket): string | null {\n        return webSocket.id;\n    }\n\n    public getWebSockets(): readonly PluvSocket[] {\n        return this._roomContext?.sessions ?? [];\n    }\n\n    public initialize(config: AbstractPlatformConfig<PluvRoomContext>): this {\n        const provided = config.roomContext;\n        const roomContext: PluvRoomContext = {\n            env: provided?.env ?? {},\n            ...(provided?.sessions ? { sessions: provided.sessions } : {}),\n            state: provided?.state ?? {},\n        };\n        if (!this._persistenceProvided && !hasSql(roomContext.state)) {\n            throw new Error(\"The room facet requires SQLite storage or a persistence adapter.\");\n        }\n\n        if (!this._persistenceProvided && typeof roomContext.state?.waitUntil !== \"function\") {\n            throw new Error(\"The room facet requires waitUntil when it uses SQLite storage.\");\n        }\n\n        const persistence = (\n            this._persistenceProvided\n                ? this.persistence\n                : new PersistenceCloudflareTransactionalStorage()\n        ).initialize(roomContext);\n\n        return new PluvPlatform({\n            persistence,\n            pubSub: this.pubSub,\n            roomContext,\n        })._initialize() as this;\n    }\n\n    public parseData(data: string | ArrayBuffer): Record<string, any> {\n        if (typeof data === \"string\") return JSON.parse(data);\n\n        return JSON.parse(new TextDecoder(\"utf8\").decode(data));\n    }\n\n    public randomUUID(): string {\n        return crypto.randomUUID();\n    }\n\n    public setSerializedState(\n        webSocket: PluvWebSocket,\n        state: WebSocketSerializedState,\n    ): WebSocketSerializedState {\n        webSocket.state = state;\n\n        return state;\n    }\n\n    public override keepAlive(promise: Promise<unknown>): void {\n        super.keepAlive(promise);\n        this._roomContext?.state?.waitUntil?.(promise);\n    }\n}\n","import type { PluvPlatformConfig } from \"./PluvPlatform\";\nimport { PluvPlatform } from \"./PluvPlatform\";\n\nexport const platformPluv = (config: PluvPlatformConfig = {}): (() => PluvPlatform) => {\n    return () => new PluvPlatform(config);\n};\n","import { isErrorMessage, type RoomEffects } from \"@pluv/io\";\nimport type { PlainError } from \"./types\";\n\nexport const plain = {\n    error: (error: unknown): PlainError => {\n        if (!error) return null;\n\n        if (isErrorMessage(error)) return { message: error.message };\n\n        return { message: \"Unexpected error\" };\n    },\n    json: <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T,\n    effects: (effects: RoomEffects): RoomEffects => {\n        return plain.json({\n            attachments: effects.attachments,\n            broadcast: effects.broadcast,\n            closes: effects.closes,\n            connectionId: effects.connectionId,\n            destroy: effects.destroy,\n            error: plain.error(effects.error),\n            self: effects.self,\n            storageDirty: effects.storageDirty,\n        });\n    },\n};\n","import type {\n    IODefs,\n    RoomEffects,\n    RoomJoinActor,\n    RoomPresenceSession,\n    RoomStorageActor,\n    SessionRoom,\n} from \"@pluv/io\";\nimport { CommitGate, deferredResultPromise, isDeferredResult, isSuspended } from \"@pluv/io\";\nimport type { JsonObject } from \"@pluv/types\";\nimport { plain } from \"./plain\";\nimport type { FrameDelivery, PresenceDelivery, StorageFrameDelivery } from \"./types\";\n\ntype Room = SessionRoom<any>;\ntype Snapshot = Parameters<Room[\"~\"][\"close\"]>[0];\n\n/** Broadcast, self, and `$error` still need a send. Storage stays on the pending list. */\nconst procedureReplay = (effects: RoomEffects): RoomEffects | null => {\n    const broadcast = effects.broadcast.filter((frame) => frame.type !== \"$storageUpdated\");\n\n    if (!broadcast.length && !effects.self.length && !effects.error) return null;\n\n    return {\n        ...effects,\n        broadcast,\n        storageDirty: false,\n    };\n};\n\n// A stub passed into an RPC is disposed when the call returns. `dup()` keeps a copy.\n// https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/#the-dup-method\ntype Retained<T extends object> = T & {\n    dup?: () => Retained<T>;\n    [Symbol.dispose]?: () => void;\n};\n\nconst retain = <T extends object>(target: T): Retained<T> => {\n    const source = target as Retained<T>;\n\n    if (typeof source.dup === \"function\") return source.dup();\n\n    return source;\n};\n\n// A turn that settles after this RPC returns still calls back into the caller.\n// Yield once so that call is not waiting on this one.\n// https://developers.cloudflare.com/workers/runtime-apis/scheduler/\nconst yieldTurn = (): Promise<void> => {\n    if (typeof scheduler !== \"undefined\") return scheduler.wait(0);\n\n    return new Promise((resolve) => {\n        setTimeout(resolve, 0);\n    });\n};\n\n// An already-settled turn belongs in this RPC result. Delivering it through the\n// caller joins the queue that is still waiting here.\nconst readSettled = async <T>(\n    deferredResult: Promise<T>,\n): Promise<\n    { status: \"value\"; value: T } | { status: \"error\"; error: unknown } | { status: \"pending\" }\n> => {\n    let settled:\n        | { status: \"value\"; value: T }\n        | { status: \"error\"; error: unknown }\n        | { status: \"pending\" } = { status: \"pending\" };\n\n    deferredResult.then(\n        (value) => {\n            settled = { status: \"value\", value };\n        },\n        (error: unknown) => {\n            settled = { status: \"error\", error };\n        },\n    );\n\n    // Microtasks already queued, including a fast async resolver, finish here.\n    // A turn still waiting on I/O stays pending.\n    await yieldTurn();\n\n    return settled;\n};\n\nexport type RoomFacetOptions<T extends IODefs = IODefs> = {\n    keepAlive: (promise: Promise<unknown>) => void;\n    room: SessionRoom<T>;\n};\n\n/**\n * Forwards one room call and returns plain JSON. A deferred result that is still\n * waiting becomes `{ suspended: true }`. The frames are delivered later on\n * the `RpcTarget` the caller passed in, which this facet retains until that\n * send finishes.\n */\nexport class RoomFacet<T extends IODefs = IODefs> {\n    readonly #keepAlive: (promise: Promise<unknown>) => void;\n    readonly #room: Room;\n    readonly #storageTurn = new CommitGate();\n\n    constructor(options: RoomFacetOptions<T>) {\n        this.#keepAlive = options.keepAlive;\n        this.#room = options.room;\n    }\n\n    public async applyPresencePatch(params: {\n        data: unknown;\n        name: string;\n        onPresence: PresenceDelivery;\n        session: RoomPresenceSession;\n    }): Promise<JsonObject | null | { error?: { message: string } | null; suspended: true }> {\n        const settled = await this.#room[\"~\"].applyPresencePatch({\n            data: params.data,\n            name: params.name,\n            session: params.session,\n        });\n\n        if (!isDeferredResult(settled)) return plain.json(settled);\n\n        const deferredResult = deferredResultPromise(settled);\n        const ready = await readSettled(deferredResult);\n\n        if (ready.status === \"value\") return plain.json(ready.value);\n\n        if (ready.status === \"error\") {\n            return { error: plain.error(ready.error), suspended: true };\n        }\n\n        this.#deliver({\n            onReject: (sink, error) => {\n                return sink.deliverPresence({\n                    error: plain.error(error),\n                    name: params.name,\n                    patch: null,\n                    senderId: params.session.id,\n                });\n            },\n            send: (sink, patch) => {\n                return sink.deliverPresence({\n                    error: null,\n                    name: params.name,\n                    patch: plain.json(patch),\n                    senderId: params.session.id,\n                });\n            },\n            sink: params.onPresence,\n            deferredResult,\n        });\n\n        return { suspended: true };\n    }\n\n    public async applyStorageProcedure(params: {\n        actor: RoomStorageActor;\n        data: unknown;\n        name: string;\n        onFrames: StorageFrameDelivery;\n    }): Promise<RoomEffects | { error?: { message: string } | null; suspended: true }> {\n        const settled = await this.#room[\"~\"].applyStorageProcedure({\n            actor: params.actor,\n            data: params.data,\n            name: params.name,\n        });\n\n        if (!isDeferredResult(settled)) return plain.effects(settled);\n\n        const pending = deferredResultPromise(settled);\n        const ready = await readSettled(pending);\n\n        // Already settled, so this RPC can reject the host call. `{ suspended: true }`\n        // would wait for a `finish` that never runs.\n        if (ready.status === \"error\") throw ready.error;\n\n        // These frames are already the commit. A loaded procedure is the other value.\n        if (ready.status === \"value\") {\n            const value = ready.value;\n\n            if (\"broadcast\" in value) return plain.effects(value);\n\n            // The earlier commit has finished, and this load has too. Commit while\n            // the caller's queue is still held.\n            if (this.#storageTurn.idle) {\n                const turn = this.#storageTurn.reserve();\n\n                try {\n                    return plain.effects(await this.#room[\"~\"].commitLoadedStorage(value));\n                } finally {\n                    turn.finish();\n                }\n            }\n        }\n\n        const turn = this.#storageTurn.reserve();\n        const loaded = ready.status === \"value\" ? Promise.resolve(ready.value) : pending;\n\n        // `{ suspended: true }` leaves the host call open until `finish`.\n        // Waiting for the previous commit here would hold the caller's queue.\n        // `send` writes after that turn, off this RPC.\n        this.#deliver({\n            onReject: async (sink, error) => {\n                // The host call rejects with this error. The caller logs it.\n                try {\n                    await sink.deliverFrames({\n                        attachments: [],\n                        broadcast: [],\n                        closes: [],\n                        connectionId: params.actor.id,\n                        destroy: false,\n                        error: null,\n                        self: [],\n                        storageDirty: false,\n                    });\n                } finally {\n                    turn.finish();\n                    await sink.finish(plain.error(error));\n                }\n            },\n            send: async (sink, value) => {\n                try {\n                    let finished = false;\n\n                    // `null` resolves the host call with empty effects. The frames\n                    // were already sent. An error rejects the call.\n                    const finish = async (error: unknown): Promise<void> => {\n                        if (finished) return;\n\n                        finished = true;\n                        await sink.finish(error ? plain.error(error) : null);\n                    };\n\n                    try {\n                        // `false` runs off the queue, so this write does not pull\n                        // updates another turn is writing.\n                        const effects =\n                            \"broadcast\" in value\n                                ? value\n                                : await this.#room[\"~\"].commitLoadedStorage(value, false);\n                        const delivered = plain.effects(effects);\n\n                        try {\n                            await sink.deliverFrames(delivered);\n                        } catch (error) {\n                            try {\n                                const replay = procedureReplay(delivered);\n\n                                if (replay) await sink.retryUnsent(replay);\n                            } finally {\n                                // The successful send never queued this frame. A failed one\n                                // still needs the snapshot loop to broadcast it.\n                                this.#room[\"~\"].queueStorageFrames(delivered.broadcast);\n\n                                if (delivered.storageDirty) await sink.noteStorageDirty();\n                            }\n\n                            // The write has already landed, and the snapshot loop still broadcasts it.\n                            // The host call rejects anyway. Falling through would `finish(null)`.\n                            throw error;\n                        }\n\n                        await this.#room[\"~\"].dropStorageUpdates(delivered.broadcast);\n                        await finish(null);\n                    } catch (error) {\n                        console.error(error);\n\n                        try {\n                            if (await this.#room[\"~\"].storageDirty()) await sink.noteStorageDirty();\n                        } finally {\n                            await finish(error);\n                        }\n                    }\n                } finally {\n                    turn.finish();\n                }\n            },\n            sink: params.onFrames,\n            deferredResult: turn.previous.then(\n                () => loaded,\n                () => loaded,\n            ),\n        });\n\n        return { suspended: true };\n    }\n\n    public async close(session: Snapshot): Promise<RoomEffects> {\n        return plain.effects(await this.#room[\"~\"].close(session));\n    }\n\n    public async destroy(): Promise<null> {\n        await this.#room[\"~\"].destroy();\n\n        return null;\n    }\n\n    public async dropStorageUpdates(frames: Readonly<RoomEffects[\"broadcast\"]>): Promise<void> {\n        await this.#room[\"~\"].dropStorageUpdates(frames);\n    }\n\n    public queueStorageFrames(frames: Readonly<RoomEffects[\"broadcast\"]>): void {\n        this.#room[\"~\"].queueStorageFrames(frames);\n    }\n\n    public async flushSnapshot(): Promise<{ broadcast: unknown; status: unknown }> {\n        return plain.json(await this.#room[\"~\"].flushSnapshot());\n    }\n\n    public async initializeStorage(params: {\n        actor: RoomJoinActor;\n        input: { stateVector?: string | null; update?: string | null };\n    }): Promise<{ changeKind: string; state: string | null; storageDirty: boolean }> {\n        return plain.json(await this.#room[\"~\"].initializeStorage(params));\n    }\n\n    public logDebug(...data: unknown[]): null {\n        this.#room[\"~\"].logDebug(...data);\n\n        return null;\n    }\n\n    public async message(params: {\n        event: { data: unknown; type: string };\n        onFrames: FrameDelivery;\n        session: Snapshot;\n    }): Promise<RoomEffects | { error?: { message: string } | null; suspended: true }> {\n        const settled = await this.#room[\"~\"].message(params.session, params.event);\n\n        if (isDeferredResult(settled)) {\n            const deferredResult = deferredResultPromise(settled);\n            const ready = await readSettled(deferredResult);\n\n            if (ready.status === \"value\") return plain.effects(ready.value);\n\n            if (ready.status === \"error\") {\n                return { error: plain.error(ready.error), suspended: true };\n            }\n\n            this.#deliver({\n                onReject: (sink, error) => {\n                    return sink.deliverFrames(\n                        plain.effects({\n                            attachments: [],\n                            broadcast: [],\n                            closes: [],\n                            connectionId: params.session.id,\n                            destroy: false,\n                            error,\n                            self: [],\n                            storageDirty: false,\n                        }),\n                    );\n                },\n                send: async (sink, effects) => {\n                    const delivered = plain.effects(effects);\n\n                    try {\n                        await sink.deliverFrames(delivered);\n                    } catch (error) {\n                        try {\n                            const replay = procedureReplay(delivered);\n\n                            if (replay) await sink.retryUnsent(replay);\n                        } finally {\n                            if (delivered.storageDirty) await sink.noteStorageDirty();\n                        }\n\n                        throw error;\n                    }\n\n                    await this.#room[\"~\"].dropStorageUpdates(delivered.broadcast);\n                },\n                sink: params.onFrames,\n                deferredResult,\n            });\n\n            return { suspended: true };\n        }\n\n        if (isSuspended(settled)) return settled;\n\n        return plain.effects(settled);\n    }\n\n    public async register(...options: Parameters<Room[\"~\"][\"register\"]>): Promise<{\n        limits: Room[\"limits\"];\n        result: {\n            encodedState: string | null;\n            error: { message: string } | null;\n            kind: string | null;\n            operator: unknown;\n            user: unknown;\n        };\n    }> {\n        const result = await this.#room[\"~\"].register(...options);\n\n        return {\n            limits: plain.json(this.#room.limits),\n            result: plain.json({\n                encodedState: result.encodedState,\n                error: plain.error(result.error),\n                kind: result.kind,\n                operator: result.operator,\n                user: result.user,\n            }),\n        };\n    }\n\n    public storageDirty(): boolean | Promise<boolean> {\n        return this.#room[\"~\"].storageDirty();\n    }\n\n    public async userConnected(params: {\n        encodedState: string | null;\n        id: string;\n        kind: string;\n        operator: unknown;\n        user: unknown;\n    }): Promise<RoomEffects> {\n        return plain.effects(await this.#room[\"~\"].userConnected(params as never));\n    }\n\n    public whenReady(): Promise<boolean> {\n        return this.#room[\"~\"].whenReady();\n    }\n\n    #deliver<TValue, TSink extends object>(params: {\n        /** Sends `$error` when the deferred result rejects. */\n        onReject?: (kept: TSink, error: unknown) => void | Promise<void>;\n        /**\n         * Sends the resolved value. A throw is logged here. Storage finishes\n         * the host call in `send` and does not rethrow.\n         */\n        send: (kept: TSink, value: TValue) => void | Promise<void>;\n        /** Supervisor stub passed into this RPC. Retained until delivery finishes. */\n        sink: TSink;\n        /** Resolves to frames or a presence patch. */\n        deferredResult: Promise<TValue>;\n    }): void {\n        const { deferredResult, onReject, send, sink } = params;\n        const kept = retain(sink);\n        const delivery = deferredResult\n            .then(\n                async (value) => {\n                    await yieldTurn();\n\n                    try {\n                        await send(kept, value);\n                    } catch (error) {\n                        console.error(error);\n                    }\n                },\n                async (error: unknown) => {\n                    await yieldTurn();\n\n                    if (!onReject) {\n                        console.error(error);\n\n                        return;\n                    }\n\n                    try {\n                        await onReject(kept, error);\n                    } catch (reportError) {\n                        console.error(reportError);\n                    }\n                },\n            )\n            .finally(() => {\n                kept[Symbol.dispose]?.();\n            });\n\n        this.#keepAlive(delivery);\n    }\n}\n"],"mappings":"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"}

package/dist/loadUserFacet.d.mts

@@ -0,0 +1,30 @@
+export type WorkerCode = {
+  compatibilityDate: string;
+  /** `null` keeps the uploaded module off the parent's fetch. */
+  globalOutbound?: Fetcher | null;
+  mainModule: string;
+  modules: Record<string, string>;
+  env?: Record<string, unknown>;
+};
+export type WorkerLoader = {
+  get: (id: string, getCode: () => WorkerCode) => {
+    getDurableObjectClass: (name: string) => unknown;
+  };
+};
+export type FacetParent = {
+  facets: {
+    get: (name: string, getStartupOptions: () => Promise<{
+      class: unknown;
+    }>) => unknown;
+  };
+};
+export type LoadUserFacetOptions = {
+  version: string;
+  code: () => WorkerCode;
+};
+/**
+ * Starts the user room facet on the first call. The id is omitted so the facet
+ * inherits the parent Durable Object id. `loader.get` is keyed by the module version.
+ */
+export declare const loadUserFacet: (ctx: FacetParent, loader: WorkerLoader, options: LoadUserFacetOptions) => unknown;
+//# sourceMappingURL=loadUserFacet.d.mts.map

package/dist/loadUserFacet.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadUserFacet.d.mts","names":[],"sources":["../src/loadUserFacet.ts"],"mappings":"A,YAAY;EACR;;EAEA,iBAAiB;EACjB;EACA,SAAS;EACT,MAAM;;YAGE;EACR,MACI,YACA,eAAe;IAEf,wBAAwB;;;YAIpB;EACR;IACI,MAAM,cAAc,yBAAyB;MAAU;;;;YAInD;EACR;EACA,YAAY;;;;;;qBAOH,gBAAa,KACjB,aAAW,QACR,cAAY,SACX"}

package/dist/loadUserFacet.mjs

@@ -0,0 +1,13 @@
+// src/loadUserFacet.ts
+/**
+* Starts the user room facet on the first call. The id is omitted so the facet
+* inherits the parent Durable Object id. `loader.get` is keyed by the module version.
+*/
+const loadUserFacet = (ctx, loader, options) => {
+	return ctx.facets.get("user", async () => {
+		return { class: loader.get(options.version, options.code).getDurableObjectClass("UserRoomFacet") };
+	});
+};
+export { loadUserFacet };
+
+//# sourceMappingURL=loadUserFacet.mjs.map

package/dist/loadUserFacet.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadUserFacet.mjs","names":[],"sources":["../src/loadUserFacet.ts"],"sourcesContent":["export type WorkerCode = {\n    compatibilityDate: string;\n    /** `null` keeps the uploaded module off the parent's fetch. */\n    globalOutbound?: Fetcher | null;\n    mainModule: string;\n    modules: Record<string, string>;\n    env?: Record<string, unknown>;\n};\n\nexport type WorkerLoader = {\n    get: (\n        id: string,\n        getCode: () => WorkerCode,\n    ) => {\n        getDurableObjectClass: (name: string) => unknown;\n    };\n};\n\nexport type FacetParent = {\n    facets: {\n        get: (name: string, getStartupOptions: () => Promise<{ class: unknown }>) => unknown;\n    };\n};\n\nexport type LoadUserFacetOptions = {\n    version: string;\n    code: () => WorkerCode;\n};\n\n/**\n * Starts the user room facet on the first call. The id is omitted so the facet\n * inherits the parent Durable Object id. `loader.get` is keyed by the module version.\n */\nexport const loadUserFacet = (\n    ctx: FacetParent,\n    loader: WorkerLoader,\n    options: LoadUserFacetOptions,\n): unknown => {\n    return ctx.facets.get(\"user\", async () => {\n        const worker = loader.get(options.version, options.code);\n\n        return { class: worker.getDurableObjectClass(\"UserRoomFacet\") };\n    });\n};\n"],"mappings":";;;;;AAiCA,MAAa,iBACT,KACA,QACA,YACU;CACV,OAAO,IAAI,OAAO,IAAI,QAAQ,YAAY;EAGtC,OAAO,EAAE,OAFM,OAAO,IAAI,QAAQ,SAAS,QAAQ,IAE9B,CAAC,CAAC,sBAAsB,eAAe,EAAE;CAClE,CAAC;AACL"}

package/package.json

@@ -1,6 +1,47 @@
 {
-  "name": "@pluv/platform",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@pluv/platform",
+    "version": "5.2.3",
+    "description": "Hosted room facet for @pluv/io",
+    "author": {
+        "email": "david@pluv.io",
+        "name": "i3dly",
+        "url": "https://github.com/i3dly"
+    },
+    "license": "MIT",
+    "homepage": "https://github.com/pluv-io/pluv",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/pluv-io/pluv.git",
+        "directory": "packages/platform"
+    },
+    "type": "module",
+    "types": "./dist/index.d.mts",
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsdown",
+        "dev": "tsdown --watch",
+        "typecheck": "tsc --noEmit",
+        "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+    },
+    "dependencies": {
+        "@pluv/io": "workspace:^",
+        "@pluv/persistence-cloudflare-transactional-storage": "workspace:^",
+        "@pluv/types": "workspace:^"
+    },
+    "devDependencies": {
+        "@cloudflare/workers-types": "^5.20261025.1",
+        "@pluv/tsconfig": "workspace:^",
+        "tsdown": "^0.23.2",
+        "typescript": "7.1.0-beta"
+    },
+    "exports": {
+        ".": "./dist/index.mjs",
+        "./load-user-facet": "./dist/loadUserFacet.mjs",
+        "./*": "./*"
+    }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.