@signe/room 2.9.4 → 3.0.0

package/dist/index.d.ts

@@ -1,176 +1,7 @@
-import { Request as Request$2, DurableObjectStorage, WebSocket, DurableObjectState, AnalyticsEngineDataset, VectorizeIndex, R2Bucket, KVNamespace } from '@cloudflare/workers-types';
+import { C as Connection, R as Request$1, a as Room$1, b as ConnectionContext, S as Server$1, c as Storage$1 } from './party-dNs-hqkq.js';
 import { z } from 'zod';
 import * as _signe_reactive from '@signe/reactive';
-
-type AssetFetcher = {
-    fetch(path: string): Promise<Response | null>;
-};
-type StandardRequest = globalThis.Request;
-interface Request$1 extends Request$2 {
-}
-type ReturnRequest = StandardRequest | Request$2;
-/** Per-party key-value storage */
-interface Storage$1 extends DurableObjectStorage {
-}
-/** Connection metadata only available when the connection is made */
-type ConnectionContext = {
-    request: Request$2;
-};
-type Stub = {
-    /** @deprecated Use `await socket()` instead */
-    connect: () => WebSocket;
-    socket(pathOrInit?: string | RequestInit): Promise<WebSocket>;
-    socket(path: string, init?: RequestInit): Promise<WebSocket>;
-    fetch(pathOrInit?: string | RequestInit | ReturnRequest): Promise<Response>;
-    fetch(path: string, init?: RequestInit | ReturnRequest): Promise<Response>;
-};
-/** Additional information about other resources in the current project */
-type Context = {
-    /** Access other parties in this project */
-    parties: Record<string, {
-        get(id: string): Stub;
-    }>;
-    /**
-     * A binding to the Cloudflare AI service.
-     */
-    ai: AI;
-    /**
-     * A binding to the Cloudflare Vectorize service.
-     */
-    vectorize: Record<string, VectorizeIndex>;
-    /**
-     * A binding to fetch static assets
-     */
-    assets: AssetFetcher;
-    /**
-     * Custom bindings
-     */
-    bindings: CustomBindings;
-};
-type AI = Record<string, never>;
-type ImmutablePrimitive = undefined | null | boolean | string | number;
-type Immutable<T> = T extends ImmutablePrimitive ? T : T extends Array<infer U> ? ImmutableArray<U> : T extends Map<infer K, infer V> ? ImmutableMap<K, V> : T extends Set<infer M> ? ImmutableSet<M> : ImmutableObject<T>;
-type ImmutableArray<T> = ReadonlyArray<Immutable<T>>;
-type ImmutableMap<K, V> = ReadonlyMap<Immutable<K>, Immutable<V>>;
-type ImmutableSet<T> = ReadonlySet<Immutable<T>>;
-type ImmutableObject<T> = {
-    readonly [K in keyof T]: Immutable<T[K]>;
-};
-type ConnectionState<T> = ImmutableObject<T> | null;
-type ConnectionSetStateFn<T> = (prevState: ConnectionState<T>) => T;
-/** A WebSocket connected to the Room */
-type Connection<TState = unknown> = WebSocket & {
-    /** Connection identifier */
-    id: string;
-    /** @deprecated You can access the socket properties directly on the connection*/
-    socket: WebSocket;
-    uri: string;
-    /**
-     * Arbitrary state associated with this connection.
-     * Read-only, use Connection.setState to update the state.
-     */
-    state: ConnectionState<TState>;
-    setState(state: TState | ConnectionSetStateFn<TState> | null): ConnectionState<TState>;
-    /** @deprecated use Connection.setState instead */
-    serializeAttachment<T = unknown>(attachment: T): void;
-    /** @deprecated use Connection.state instead */
-    deserializeAttachment<T = unknown>(): T | null;
-};
-type CustomBindings = {
-    r2: Record<string, R2Bucket>;
-    kv: Record<string, KVNamespace>;
-};
-/** Room represents a single, self-contained, long-lived session. */
-type Room$1 = {
-    /** Room ID defined in the Party URL, e.g. /parties/:name/:id */
-    id: string;
-    /** Internal ID assigned by the platform. Use Party.id instead. */
-    internalID: string;
-    /** Party name defined in the Party URL, e.g. /parties/:name/:id */
-    name: string;
-    /** Environment variables (--var, partykit.json#vars, or .env) */
-    env: Record<string, unknown>;
-    /** A per-room key-value storage */
-    storage: Storage$1;
-    /** `blockConcurrencyWhile()` ensures no requests are delivered until */
-    blockConcurrencyWhile: DurableObjectState["blockConcurrencyWhile"];
-    /** Additional information about other resources in the current project */
-    context: Context;
-    /** @deprecated Use `room.getConnections` instead */
-    connections: Map<string, Connection>;
-    /** @deprecated Use `room.context.parties` instead */
-    parties: Context["parties"];
-    /** Send a message to all connected clients, except connection ids listed `without` */
-    broadcast: (msg: string | ArrayBuffer | ArrayBufferView, without?: string[] | undefined) => void;
-    /** Get a connection by connection id */
-    getConnection<TState = unknown>(id: string): Connection<TState> | undefined;
-    /**
-     * Get all connections. Optionally, you can provide a tag to filter returned connections.
-     * Use `Party.Server#getConnectionTags` to tag the connection on connect.
-     */
-    getConnections<TState = unknown>(tag?: string): Iterable<Connection<TState>>;
-    /**
-     * Cloudflare Analytics Engine dataset. Use this to log custom events and metrics.
-     */
-    analytics: AnalyticsEngineDataset;
-};
-type Server$1 = {
-    /**
-     * You can define an `options` field to customise the Party.Server behaviour.
-     */
-    readonly options?: ServerOptions;
-    /**
-     * You can tag a connection to filter them in Party#getConnections.
-     * Each connection supports up to 9 tags, each tag max length is 256 characters.
-     */
-    getConnectionTags?(connection: Connection, context: ConnectionContext): string[] | Promise<string[]>;
-    /**
-     * Called when the server is started, before first `onConnect` or `onRequest`.
-     * Useful for loading data from storage.
-     *
-     * You can use this to load data from storage and perform other asynchronous
-     * initialization, such as retrieving data or configuration from other
-     * services or databases.
-     */
-    onStart?(): void | Promise<void>;
-    /**
-     * Called when a new incoming WebSocket connection is opened.
-     */
-    onConnect?(connection: Connection, ctx: ConnectionContext): void | Promise<void>;
-    /**
-     * Called when a WebSocket connection receives a message from a client, or another connected party.
-     */
-    onMessage?(message: string | ArrayBuffer | ArrayBufferView, sender: Connection): void | Promise<void>;
-    /**
-     * Called when a WebSocket connection is closed by the client.
-     */
-    onClose?(connection: Connection): void | Promise<void>;
-    /**
-     * Called when a WebSocket connection is closed due to a connection error.
-     */
-    onError?(connection: Connection, error: Error): void | Promise<void>;
-    /**
-     * Called when a HTTP request is made to the room URL.
-     */
-    onRequest?(req: Request$1): Response | Promise<Response>;
-    /**
-     * Called when an alarm is triggered. Use Party.storage.setAlarm to set an alarm.
-     *
-     * Alarms have access to most Party resources such as storage, but not Party.id
-     * and Party.context.parties properties. Attempting to access them will result in a
-     * runtime error.
-     */
-    onAlarm?(): void | Promise<void>;
-};
-type ServerOptions = {
-    /**
-     * Whether the PartyKit platform should remove the server from memory
-     * between HTTP requests and WebSocket messages.
-     *
-     * The default value is `false`.
-     */
-    hibernate?: boolean;
-};
+import '@cloudflare/workers-types';
 
 type GuardFn = (sender: Connection, value: any | Request$1, room: Room$1) => boolean | Promise<boolean | Response>;
 type RoomGuardFn = (conn: Connection, ctx: ConnectionContext, room: Room$1) => boolean | Promise<boolean | Response>;
@@ -211,6 +42,13 @@ declare function RoomGuard(guards: RoomGuardFn[]): (target: any) => void;
  */
 declare function Guard(guards: GuardFn[]): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
 
+type SessionData = {
+    publicId: string;
+    state?: any;
+    created?: number;
+    connected?: boolean;
+    disconnectedAt?: number;
+};
 /**
  * @class Server
  * @implements {Party.Server}
@@ -260,6 +98,21 @@ declare class Server implements Server$1 {
       */
     get isHibernate(): boolean;
     get roomStorage(): Storage$1;
+    private stateKey;
+    private sessionKey;
+    private sessionPublicKey;
+    private transferKey;
+    private isInternalStorageKey;
+    private listStorage;
+    private loadStatePath;
+    private saveStatePath;
+    private putStorageEntries;
+    private deleteStorageKeys;
+    private deleteStatePath;
+    private createStorageMetrics;
+    private getTransferExpiryTime;
+    private getPrivateId;
+    private hasActiveSessionConnection;
     send(conn: Connection, obj: any, subRoom: any): Promise<void>;
     broadcast(obj: any, subRoom: any): void;
     /**
@@ -279,6 +132,14 @@ declare class Server implements Server$1 {
     onStart(): Promise<void>;
     runGarbageCollector(): Promise<void>;
     private garbageCollector;
+    private scheduleSessionGarbageCollector;
+    private getSessionExpiryTime;
+    private shouldRunSessionGarbageCollector;
+    private shouldRunInterval;
+    private repairSessionPublicIndexes;
+    private isTransferExpired;
+    private cleanupExpiredTransfers;
+    private expireDisconnectedSession;
     /**
      * @method createRoom
      * @private
@@ -359,12 +220,12 @@ declare class Server implements Server$1 {
      * console.log(session);
      * ```
      */
-    getSession(privateId: string): Promise<{
-        publicId: string;
-        state?: any;
-        created?: number;
-        connected?: boolean;
-    } | null>;
+    getSession(privateId: string): Promise<SessionData | null>;
+    private getSessionPrivateIds;
+    private saveSessionPrivateIds;
+    private addSessionToPublicIndex;
+    private removeSessionFromPublicIndex;
+    private getSessionEntryByPublicId;
     private saveSession;
     private updateSessionConnection;
     /**
@@ -397,6 +258,7 @@ declare class Server implements Server$1 {
      * ```
      */
     onConnect(conn: Connection, ctx: ConnectionContext): Promise<void>;
+    private isAuthorizedShardRequest;
     /**
      * @method onConnectShard
      * @private
@@ -528,8 +390,6 @@ declare class Server implements Server$1 {
      * @returns {Object} An object containing the path parameters
      */
     private extractPathParams;
-    private normalizeRequestPath;
-    private pathPatternToRegex;
     /**
      * @method handleShardRequest
      * @private
@@ -553,10 +413,12 @@ declare class Server implements Server$1 {
 
 declare class Storage {
     private memory;
-    put(key: any, value: any): Promise<void>;
+    put(key: any, value?: any): Promise<void>;
     get(key: any): Promise<any>;
-    delete(key: any): Promise<void>;
-    list(): Promise<Map<any, any>>;
+    delete(key: any): Promise<number | boolean>;
+    list(options?: {
+        prefix?: string;
+    }): Promise<Map<any, any>>;
 }
 
 declare class MockPartyClient {
@@ -564,7 +426,7 @@ declare class MockPartyClient {
     private events;
     id: string;
     conn: MockConnection;
-    constructor(server: Server, id?: string);
+    constructor(server: Server, sessionId?: string);
     addEventListener(event: any, cb: any): void;
     removeEventListener(event: any, cb: any): void;
     _trigger(event: any, data: any): void;
@@ -593,15 +455,17 @@ declare class MockPartyRoom {
         headers?: Record<string, string>;
     }): Promise<MockPartyClient>;
     broadcast(data: any): void;
-    getConnection(id: string): MockPartyClient;
+    getConnection(id: string): MockConnection;
     getConnections(): MockConnection[];
     clear(): void;
+    deleteConnection(id: string, connection?: MockConnection): void;
 }
 declare class MockConnection {
     client: MockPartyClient;
     server: Server;
     id: string;
-    constructor(client: MockPartyClient);
+    sessionId: string;
+    constructor(client: MockPartyClient, sessionId: string);
     state: any;
     setState(value: any): void;
     send(data: any): void;
@@ -623,21 +487,25 @@ interface ShardOptions {
 declare class Shard {
     private room;
     ws: PartyWebSocket;
-    connectionMap: Map<string, Connection<unknown>>;
+    connectionMap: Map<string, Set<Connection<unknown>>>;
     mainServerStub: any;
     worldUrl: string | null;
     worldId: string;
     lastReportedConnections: number;
     statsInterval: number;
     statsIntervalId: any;
-    constructor(room: Room$1);
+    constructor(room: Room$1, options?: ShardOptions);
+    private getPrivateId;
+    private getEnvString;
+    private getRoomIdFromShardId;
+    private getWorldIdFromShardId;
     onStart(): Promise<void>;
     private startPeriodicStatsUpdates;
     private stopPeriodicStatsUpdates;
     onConnect(conn: Connection, ctx: ConnectionContext): void;
     onMessage(message: string | ArrayBuffer | ArrayBufferView, sender: Connection): void;
     onClose(conn: Connection): void;
-    updateWorldStats(): Promise<boolean>;
+    updateWorldStats(force?: boolean): Promise<boolean>;
     /**
      * @method onRequest
      * @async
@@ -682,6 +550,7 @@ declare class Shard {
 declare function testRoom(Room: any, options?: {
     hibernate?: boolean;
     shard?: boolean;
+    id?: string;
     env?: Record<string, string>;
     parties?: Record<string, (io: any) => any>;
     partyFn?: (io: any) => any;
@@ -851,6 +720,7 @@ declare class RoomConfig {
 declare class ShardInfo {
     id: string;
     roomId: _signe_reactive.WritableSignal<string>;
+    worldId: _signe_reactive.WritableSignal<string>;
     url: _signe_reactive.WritableSignal<string>;
     currentConnections: _signe_reactive.WritableSignal<number>;
     maxConnections: _signe_reactive.WritableSignal<number>;
@@ -867,13 +737,20 @@ declare class WorldRoom implements RoomInterceptorPacket, RoomOnJoin {
     constructor(room: Room$1);
     onJoin(user: any, conn: Connection, ctx: ConnectionContext): Promise<void>;
     interceptorPacket(_: any, obj: any, conn: Connection): any;
+    private getWorldId;
+    private scheduleInactiveShardCleanup;
     private cleanupInactiveShards;
+    private removeShard;
+    private shouldCompleteDrain;
     registerRoom(req: Request$1, res?: ServerResponse): Promise<Response>;
     updateShardStats(req: Request$1, res: ServerResponse): Promise<Response>;
     scaleRoom(req: Request$1, res: ServerResponse): Promise<Response>;
     connect(req: Request$1, res: ServerResponse): Promise<Response>;
     private findOptimalShard;
+    private getAvailableShards;
+    private canCreateShard;
     private createShard;
+    private ensureMinShards;
 }
 
 /**