@rpgjs/client 5.0.0-beta.25 → 5.0.0-beta.27

package/src/services/loadMap.ts

@@ -1,5 +1,6 @@
 import { Context, inject } from "@signe/di";
-import { UpdateMapToken, UpdateMapService, type LightingState } from "@rpgjs/common";
+import { UpdateMapToken, UpdateMapService, type LightingState, type RpgContext, type RpgProvider } from "@rpgjs/common";
+import type { RpgClientMap } from "../Game/Map";
 
 export const LoadMapToken = 'LoadMapToken'
 
@@ -9,7 +10,7 @@ export const LoadMapToken = 'LoadMapToken'
  * 
  * @interface MapData
  */
-type MapData = {
+export type MapData = {
   /** Raw map data that will be passed to the map component */
   data: any;
   /** CanvasEngine component that will render the map */
@@ -26,6 +27,10 @@ type MapData = {
   id?: string;
   /** Optional initial lighting state for the loaded map */
   lighting?: LightingState | null;
+  /** Optional render parameters passed to the map component. */
+  params?: Record<string, unknown>;
+  /** Internal controller used by a progressive map provider. */
+  streamController?: { attach(map: RpgClientMap): void; detach(): void };
 }
 
 /**
@@ -42,14 +47,16 @@ export type LoadMapOptions = (mapId: string) => Promise<MapData> | MapData
 export class LoadMapService {
   private updateMapService: UpdateMapService;
 
-  constructor(private context: Context, private options: LoadMapOptions) {
-    if (context['side'] === 'server') {
+  constructor(private context: RpgContext, private options: LoadMapOptions) {
+    if (context.side === 'server') {
       return
     }
-    this.updateMapService = inject(context, UpdateMapToken);
   }
 
+  initialize(): void {}
+
   async load(mapId: string) {
+    this.updateMapService ??= inject(this.context as Context, UpdateMapToken);
     const map = await this.options(mapId.replace('map-', ''))
     await this.updateMapService.update(map);
     return map;
@@ -147,12 +154,12 @@ export class LoadMapService {
  * @see {@link LoadMapOptions} for callback function signature
  * @see {@link MapData} for return data structure
  */
-export function provideLoadMap(options: LoadMapOptions) {
+export function provideLoadMap(options: LoadMapOptions): RpgProvider[] {
   return [
     {
       provide: UpdateMapToken,
-      useFactory: (context: Context) => {
-        if (context['side'] === 'client') {
+      useFactory: (context: RpgContext) => {
+        if (context.side === 'client') {
           console.warn('UpdateMapToken is not overridden')
         }
         return
@@ -160,7 +167,7 @@ export function provideLoadMap(options: LoadMapOptions) {
     },
     {
       provide: LoadMapToken,
-      useFactory: (context: Context) => new LoadMapService(context, options),
+      useFactory: (context: RpgContext) => new LoadMapService(context, options),
     },
   ];
 }

package/src/services/mapStreaming.spec.ts

@@ -0,0 +1,240 @@
+import { Context, inject, injector } from "@signe/di";
+import { MAP_STREAM_EVENT, MAP_STREAM_REQUEST_EVENT, UpdateMapToken } from "@rpgjs/common";
+import { describe, expect, it, vi } from "vitest";
+import type { MapStreamChunk, MapStreamManifest } from "@rpgjs/common";
+import { LoadMapToken } from "./loadMap";
+import { WebSocketToken } from "./AbstractSocket";
+import { MapStreamClientController, provideClientMapStreaming } from "./mapStreaming";
+
+type State = { keys: Set<string> };
+
+function manifest(revision: string): MapStreamManifest<Record<string, never>> {
+  return {
+    protocol: 1,
+    mapId: "demo",
+    revision,
+    width: 200,
+    height: 100,
+    chunkWidth: 100,
+    chunkHeight: 100,
+    columns: 2,
+    rows: 1,
+    renderData: {},
+  };
+}
+
+function chunk(key: string, x: number): MapStreamChunk<{ tile: number }> {
+  return {
+    key,
+    x,
+    y: 0,
+    bounds: { x: x * 100, y: 0, width: 100, height: 100 },
+    renderData: { tile: x + 1 },
+    hitboxes: [{ id: `wall-${key}`, x: x * 100, y: 0, width: 10, height: 10 }],
+  };
+}
+
+async function createStreamingLoader(socket: unknown, timeoutMs?: number) {
+  const context = new Context();
+  const update = vi.fn();
+  await injector(context, [
+    { provide: WebSocketToken, useValue: socket },
+    { provide: UpdateMapToken, useValue: { update } },
+    ...provideClientMapStreaming({
+      adapter: {
+        component: {},
+        createState: () => ({ keys: new Set<string>() }),
+        applyChunk: (state: State, value) => state.keys.add(value.key),
+        removeChunk: (state: State, key) => state.keys.delete(key),
+        getData: (state: State) => [...state.keys],
+      },
+      timeoutMs,
+    }),
+  ]);
+  return {
+    loader: inject<{ load(mapId: string): Promise<any> }>(context, LoadMapToken),
+    update,
+  };
+}
+
+describe("MapStreamClientController", () => {
+  it("keeps the active map attached when a new map revision arrives", () => {
+    const controller = new MapStreamClientController<Record<string, never>, { tile: number }, State>({
+      component: {},
+      createState: () => ({ keys: new Set() }),
+      applyChunk: (state, value) => state.keys.add(value.key),
+      removeChunk: (state, key) => state.keys.delete(key),
+      getData: (state) => [...state.keys],
+    }, manifest("one"));
+    controller.receive({
+      mapId: "demo",
+      revision: "one",
+      manifest: manifest("one"),
+      chunks: [chunk("0:0", 0)],
+      removed: [],
+    });
+
+    let current = controller.toMapData();
+    const data = Object.assign(() => current, {
+      set: vi.fn((value) => { current = value; }),
+    });
+    const map = {
+      data,
+      replaceStreamedStaticHitboxes: vi.fn(),
+      clearStreamedStaticHitboxes: vi.fn(),
+    };
+    controller.attach(map);
+
+    controller.reset(manifest("two"));
+    controller.receive({
+      mapId: "demo",
+      revision: "two",
+      manifest: manifest("two"),
+      chunks: [chunk("1:0", 1)],
+      removed: [],
+    });
+
+    expect(map.clearStreamedStaticHitboxes).toHaveBeenCalledWith("0:0");
+    expect(map.replaceStreamedStaticHitboxes).toHaveBeenCalledWith("1:0", chunk("1:0", 1).hitboxes);
+    expect(current.data).toEqual(["1:0"]);
+  });
+
+  it("removes streamed hitboxes and the prediction boundary when chunks are evicted", () => {
+    const controller = new MapStreamClientController<Record<string, never>, { tile: number }, State>({
+      component: {},
+      createState: () => ({ keys: new Set() }),
+      applyChunk: (state, value) => state.keys.add(value.key),
+      removeChunk: (state, key) => state.keys.delete(key),
+      getData: (state) => [...state.keys],
+    }, manifest("one"));
+    controller.receive({
+      mapId: "demo",
+      revision: "one",
+      manifest: manifest("one"),
+      chunks: [chunk("0:0", 0), chunk("1:0", 1)],
+      removed: [],
+    });
+
+    let current = controller.toMapData();
+    const data = Object.assign(() => current, {
+      set: vi.fn((value) => { current = value; }),
+    });
+    const map = {
+      data,
+      replaceStreamedStaticHitboxes: vi.fn(),
+      clearStreamedStaticHitboxes: vi.fn(),
+    };
+    controller.attach(map);
+    map.replaceStreamedStaticHitboxes.mockClear();
+    map.clearStreamedStaticHitboxes.mockClear();
+
+    controller.receive({
+      mapId: "demo",
+      revision: "one",
+      chunks: [],
+      removed: ["0:0"],
+    });
+    expect(current.data).toEqual(["1:0"]);
+    expect(map.clearStreamedStaticHitboxes).toHaveBeenCalledWith("0:0");
+    expect(map.replaceStreamedStaticHitboxes).toHaveBeenCalledWith("__boundary__", [
+      { x: 98, y: 0, width: 2, height: 100 },
+    ]);
+
+    map.clearStreamedStaticHitboxes.mockClear();
+    controller.receive({
+      mapId: "demo",
+      revision: "one",
+      chunks: [],
+      removed: ["1:0"],
+    });
+    expect(current.data).toEqual([]);
+    expect(map.clearStreamedStaticHitboxes.mock.calls).toEqual([
+      ["1:0"],
+      ["__boundary__"],
+    ]);
+  });
+
+  it("requests fresh streaming data when a cached map is loaded again", async () => {
+    const listeners = new Map<string, (packet: unknown) => void>();
+    const socket = {
+      on: vi.fn((event: string, callback: (packet: unknown) => void) => listeners.set(event, callback)),
+      emit: vi.fn((event: string) => {
+        if (event !== MAP_STREAM_REQUEST_EVENT) return;
+        listeners.get(MAP_STREAM_EVENT)?.({
+          mapId: "demo",
+          revision: "one",
+          manifest: manifest("one"),
+          chunks: [chunk("0:0", 0)],
+          removed: [],
+        });
+      }),
+    };
+    const { loader } = await createStreamingLoader(socket);
+
+    await loader.load("map-demo");
+    await loader.load("map-demo");
+
+    expect(socket.emit).toHaveBeenCalledTimes(2);
+    expect(socket.emit).toHaveBeenNthCalledWith(2, MAP_STREAM_REQUEST_EVENT, { mapId: "demo" });
+  });
+
+  it("shares one stream request between concurrent loads", async () => {
+    const listeners = new Map<string, (packet: unknown) => void>();
+    const socket = {
+      on: vi.fn((event: string, callback: (packet: unknown) => void) => listeners.set(event, callback)),
+      emit: vi.fn(),
+    };
+    const { loader, update } = await createStreamingLoader(socket);
+
+    const first = loader.load("map-demo");
+    const second = loader.load("demo");
+    expect(socket.emit).toHaveBeenCalledTimes(1);
+
+    listeners.get(MAP_STREAM_EVENT)?.({
+      mapId: "demo",
+      revision: "one",
+      manifest: manifest("one"),
+      chunks: [chunk("0:0", 0)],
+      removed: [],
+    });
+    const [firstMap, secondMap] = await Promise.all([first, second]);
+
+    expect(firstMap.streamController).toBe(secondMap.streamController);
+    expect(update).toHaveBeenCalledTimes(2);
+  });
+
+  it("cleans up a timed-out request so a later load can retry", async () => {
+    vi.useFakeTimers();
+    try {
+      const listeners = new Map<string, (packet: unknown) => void>();
+      let respond = false;
+      const socket = {
+        on: vi.fn((event: string, callback: (packet: unknown) => void) => listeners.set(event, callback)),
+        emit: vi.fn((event: string) => {
+          if (!respond || event !== MAP_STREAM_REQUEST_EVENT) return;
+          listeners.get(MAP_STREAM_EVENT)?.({
+            mapId: "demo",
+            revision: "one",
+            manifest: manifest("one"),
+            chunks: [chunk("0:0", 0)],
+            removed: [],
+          });
+        }),
+      };
+      const { loader } = await createStreamingLoader(socket, 20);
+
+      const rejection = expect(loader.load("demo")).rejects.toThrow(
+        "Map stream 'demo' was not received after 20ms",
+      );
+      await vi.advanceTimersByTimeAsync(20);
+      await rejection;
+
+      respond = true;
+      await expect(loader.load("demo")).resolves.toMatchObject({ id: "demo" });
+      expect(socket.emit).toHaveBeenCalledTimes(2);
+    }
+    finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/src/services/mapStreaming.ts

@@ -0,0 +1,277 @@
+import { Context, inject } from "@signe/di";
+import {
+  MAP_STREAM_EVENT,
+  MAP_STREAM_REQUEST_EVENT,
+  type MapChunkHitbox,
+  type MapStreamChunk,
+  type MapStreamManifest,
+  type MapStreamPacket,
+  type RpgContext,
+  type RpgProvider,
+} from "@rpgjs/common";
+import { AbstractWebsocket, WebSocketToken } from "./AbstractSocket";
+import { LoadMapToken, type MapData, type LoadMapOptions } from "./loadMap";
+import { UpdateMapService, UpdateMapToken } from "@rpgjs/common";
+
+export interface ClientMapStreamingAdapter<TManifestData = unknown, TChunkData = unknown, TState = unknown> {
+  /** CanvasEngine component that renders the provider-specific state. */
+  component: unknown;
+  /** Create empty client render state from public manifest data. */
+  createState(manifest: MapStreamManifest<TManifestData>): TState;
+  /** Apply one disclosed render chunk to the state. */
+  applyChunk(state: TState, chunk: MapStreamChunk<TChunkData>): void;
+  /** Remove one chunk that left the retention window. */
+  removeChunk(state: TState, key: string): void;
+  /** Return the serializable/component-ready map value exposed to CanvasEngine. */
+  getData(state: TState): unknown;
+  /** Optionally derive component parameters from the public manifest. */
+  getParams?(manifest: MapStreamManifest<TManifestData>): Record<string, unknown>;
+}
+
+export interface ClientMapStreamingOptions<TManifestData = unknown, TChunkData = unknown, TState = unknown> {
+  /** Format adapter paired with the server compiler. */
+  adapter: ClientMapStreamingAdapter<TManifestData, TChunkData, TState>;
+  /** Optional direct loader used only by standalone RPG mode. */
+  directLoad?: LoadMapOptions;
+  /** Maximum wait for the initial authoritative manifest. Defaults to 10 seconds. */
+  timeoutMs?: number;
+}
+
+type StreamingPhysicsMap = {
+  data: { (): MapData | null; set(value: MapData): void };
+  replaceStreamedStaticHitboxes(namespace: string, hitboxes: MapChunkHitbox[]): void;
+  clearStreamedStaticHitboxes(namespace: string): void;
+};
+
+type Waiter = {
+  resolve(controller: MapStreamClientController<any, any, any>): void;
+  reject(error: Error): void;
+  timer: ReturnType<typeof setTimeout>;
+};
+
+export class MapStreamClientController<TManifestData, TChunkData, TState> {
+  private state: TState;
+  private manifest: MapStreamManifest<TManifestData>;
+  private readonly chunks = new Map<string, MapStreamChunk<TChunkData>>();
+  private attachedMap?: StreamingPhysicsMap;
+
+  constructor(
+    private readonly adapter: ClientMapStreamingAdapter<TManifestData, TChunkData, TState>,
+    manifest: MapStreamManifest<TManifestData>,
+  ) {
+    this.manifest = manifest;
+    this.state = adapter.createState(manifest);
+  }
+
+  get revision(): string {
+    return this.manifest.revision;
+  }
+
+  reset(manifest: MapStreamManifest<TManifestData>): void {
+    const attachedMap = this.attachedMap;
+    this.detach();
+    this.manifest = manifest;
+    this.state = this.adapter.createState(manifest);
+    this.chunks.clear();
+    this.attachedMap = attachedMap;
+  }
+
+  receive(packet: MapStreamPacket<TManifestData, TChunkData>): void {
+    for (const key of packet.removed) {
+      this.chunks.delete(key);
+      this.adapter.removeChunk(this.state, key);
+      this.attachedMap?.clearStreamedStaticHitboxes(key);
+    }
+    for (const chunk of packet.chunks) {
+      this.chunks.set(chunk.key, chunk);
+      this.adapter.applyChunk(this.state, chunk);
+      this.attachedMap?.replaceStreamedStaticHitboxes(chunk.key, chunk.hitboxes);
+    }
+    this.publish();
+  }
+
+  toMapData(): MapData {
+    return {
+      id: this.manifest.mapId,
+      width: this.manifest.width,
+      height: this.manifest.height,
+      data: this.adapter.getData(this.state),
+      component: this.adapter.component,
+      params: this.adapter.getParams?.(this.manifest),
+      streamController: this,
+    };
+  }
+
+  attach(map: StreamingPhysicsMap): void {
+    this.attachedMap = map;
+    for (const chunk of this.chunks.values()) {
+      map.replaceStreamedStaticHitboxes(chunk.key, chunk.hitboxes);
+    }
+    this.updatePredictionBoundary();
+  }
+
+  detach(): void {
+    if (!this.attachedMap) return;
+    for (const key of this.chunks.keys()) {
+      this.attachedMap.clearStreamedStaticHitboxes(key);
+    }
+    this.attachedMap.clearStreamedStaticHitboxes("__boundary__");
+    this.attachedMap = undefined;
+  }
+
+  private publish(): void {
+    if (!this.attachedMap) return;
+    const current = this.attachedMap.data();
+    if (current) {
+      this.attachedMap.data.set({ ...current, data: this.adapter.getData(this.state) });
+    }
+    this.updatePredictionBoundary();
+  }
+
+  private updatePredictionBoundary(): void {
+    const map = this.attachedMap;
+    if (!map) return;
+    if (this.chunks.size === 0) {
+      map.clearStreamedStaticHitboxes("__boundary__");
+      return;
+    }
+    const chunks = [...this.chunks.values()];
+    const left = Math.min(...chunks.map((chunk) => chunk.bounds.x));
+    const top = Math.min(...chunks.map((chunk) => chunk.bounds.y));
+    const right = Math.max(...chunks.map((chunk) => chunk.bounds.x + chunk.bounds.width));
+    const bottom = Math.max(...chunks.map((chunk) => chunk.bounds.y + chunk.bounds.height));
+    const thickness = 2;
+    const barriers: MapChunkHitbox[] = [];
+    if (left > 0) barriers.push({ x: left - thickness, y: top, width: thickness, height: bottom - top });
+    if (top > 0) barriers.push({ x: left, y: top - thickness, width: right - left, height: thickness });
+    if (right < this.manifest.width) barriers.push({ x: right, y: top, width: thickness, height: bottom - top });
+    if (bottom < this.manifest.height) barriers.push({ x: left, y: bottom, width: right - left, height: thickness });
+    map.replaceStreamedStaticHitboxes("__boundary__", barriers);
+  }
+}
+
+class MapStreamingClientService<TManifestData, TChunkData, TState> {
+  private readonly controllers = new Map<string, MapStreamClientController<TManifestData, TChunkData, TState>>();
+  private readonly waiters = new Map<string, Waiter[]>();
+
+  constructor(
+    private readonly socket: AbstractWebsocket,
+    private readonly options: ClientMapStreamingOptions<TManifestData, TChunkData, TState>,
+  ) {
+    socket.on(MAP_STREAM_EVENT, (packet) => this.receive(packet));
+  }
+
+  async load(mapId: string): Promise<MapData> {
+    const normalizedId = mapId.replace(/^map-/, "");
+    const existing = this.controllers.get(normalizedId);
+    if (existing) {
+      this.socket.emit(MAP_STREAM_REQUEST_EVENT, { mapId: normalizedId });
+      return existing.toMapData();
+    }
+
+    const shouldRequest = !this.waiters.has(normalizedId);
+    const controllerPromise = new Promise<MapStreamClientController<TManifestData, TChunkData, TState>>((resolve, reject) => {
+      const timeoutMs = Math.max(1, this.options.timeoutMs ?? 10_000);
+      const waiter: Waiter = { resolve, reject, timer: undefined as unknown as ReturnType<typeof setTimeout> };
+      const timer = setTimeout(() => {
+        const current = this.waiters.get(normalizedId) ?? [];
+        const remaining = current.filter((entry) => entry !== waiter);
+        if (remaining.length > 0) this.waiters.set(normalizedId, remaining);
+        else this.waiters.delete(normalizedId);
+        reject(new Error(`Map stream '${normalizedId}' was not received after ${timeoutMs}ms`));
+      }, timeoutMs);
+      waiter.timer = timer;
+      const waiters = this.waiters.get(normalizedId) ?? [];
+      waiters.push(waiter);
+      this.waiters.set(normalizedId, waiters);
+    });
+    // The map-room connection is established before load() runs. Request the
+    // initial packet only after the waiter is registered so fast local and DO
+    // transports cannot deliver it before the client is ready.
+    if (shouldRequest) {
+      this.socket.emit(MAP_STREAM_REQUEST_EVENT, { mapId: normalizedId });
+    }
+    return (await controllerPromise).toMapData();
+  }
+
+  private receive(packet: MapStreamPacket<TManifestData, TChunkData>): void {
+    if (!packet || typeof packet.mapId !== "string") return;
+    const mapId = packet.mapId.replace(/^map-/, "");
+    let controller = this.controllers.get(mapId);
+    if (!controller) {
+      if (!packet.manifest) return;
+      controller = new MapStreamClientController(this.options.adapter, packet.manifest);
+      this.controllers.set(mapId, controller);
+    }
+    else if (packet.manifest && controller.revision !== packet.manifest.revision) {
+      controller.reset(packet.manifest);
+    }
+    controller.receive(packet);
+
+    const waiters = this.waiters.get(mapId) ?? [];
+    waiters.forEach((waiter) => {
+      clearTimeout(waiter.timer);
+      waiter.resolve(controller!);
+    });
+    this.waiters.delete(mapId);
+  }
+}
+
+class MapStreamingLoadMapService<TManifestData, TChunkData, TState> {
+  private socket?: AbstractWebsocket;
+  private stream?: MapStreamingClientService<TManifestData, TChunkData, TState>;
+  private updateMap?: UpdateMapService;
+
+  constructor(
+    private readonly context: RpgContext,
+    private readonly options: ClientMapStreamingOptions<TManifestData, TChunkData, TState>,
+  ) {}
+
+  initialize(): void {
+    if (this.stream) return;
+    this.socket = inject<AbstractWebsocket>(this.context as Context, WebSocketToken);
+    this.stream = new MapStreamingClientService(this.socket, this.options);
+  }
+
+  async load(mapId: string): Promise<MapData> {
+    this.initialize();
+    const map = this.socket?.mode === "standalone" && this.options.directLoad
+      ? await this.options.directLoad(mapId.replace(/^map-/, ""))
+      : await this.stream!.load(mapId);
+    this.updateMap ??= inject<UpdateMapService>(this.context as Context, UpdateMapToken);
+    await this.updateMap.update(map);
+    return map;
+  }
+}
+
+/**
+ * Provide a transport-neutral client map loader backed by authoritative chunks.
+ * Standalone mode may keep a direct loader while MMORPG mode never fetches the
+ * private source map.
+ *
+ * @param options - Client adapter, optional standalone loader, and timeout.
+ * @returns Dependency-injection providers for the RPGJS map loader.
+ *
+ * @example
+ * ```ts
+ * provideClientMapStreaming({
+ *   adapter: {
+ *     component: MyMap,
+ *     createState: (manifest) => ({ manifest, chunks: new Map() }),
+ *     applyChunk: (state, chunk) => state.chunks.set(chunk.key, chunk.renderData),
+ *     removeChunk: (state, key) => state.chunks.delete(key),
+ *     getData: (state) => state,
+ *   },
+ * })
+ * ```
+ */
+export function provideClientMapStreaming<TManifestData, TChunkData, TState>(
+  options: ClientMapStreamingOptions<TManifestData, TChunkData, TState>,
+): RpgProvider[] {
+  return [
+    {
+      provide: LoadMapToken,
+      useFactory: (context: RpgContext) => new MapStreamingLoadMapService(context, options),
+    },
+  ];
+}

package/src/services/mmorpg.ts

@@ -1,9 +1,8 @@
-import { Context } from "@signe/di";
 import { connectionRoom } from "@signe/sync/client";
 import { RpgGui } from "../Gui/Gui";
 import { RpgClientEngine } from "../RpgClientEngine";
 import { AbstractWebsocket, SocketQuery, SocketUpdateProperties, WebSocketToken } from "./AbstractSocket";
-import { UpdateMapService, UpdateMapToken } from "@rpgjs/common";
+import { UpdateMapService, UpdateMapToken, type RpgContext, type RpgProvider } from "@rpgjs/common";
 import { provideKeyboardControls } from "./keyboardControls";
 import { provideSaveClient } from "./save";
 import { isNativeSocketEvent, waitForRpgjsConnected } from "./mmorpg-connection";
@@ -14,6 +13,12 @@ export interface MmorpgOptions {
     connectionIdScope?: "local" | "session" | "ephemeral";
     query?: SocketQuery | (() => SocketQuery | undefined);
     socketOptions?: Record<string, any>;
+    /**
+     * Time allowed for a room to restore and send the RPGJS acceptance packet.
+     * Increase this for cold edge rooms or local Durable Object startup.
+     * Defaults to 10 seconds.
+     */
+    connectionAcceptanceTimeoutMs?: number;
 }
 
 export class BridgeWebsocket extends AbstractWebsocket {
@@ -25,7 +30,7 @@ export class BridgeWebsocket extends AbstractWebsocket {
   private acceptedOpenListeners = new Set<(data: any) => void>();
   private targetRoom = "lobby-1";
 
-  constructor(protected context: Context, private options: MmorpgOptions = {}) {
+  constructor(protected context: RpgContext, private options: MmorpgOptions = {}) {
     super(context);
     this.privateId = this.resolveConnectionId();
   }
@@ -89,7 +94,10 @@ export class BridgeWebsocket extends AbstractWebsocket {
     pendingOn
       .filter(({ event }) => !this.isNativeSocketEvent(event))
       .forEach(({ event, callback }) => this.attachEvent(event, callback));
-    await waitForRpgjsConnected(this.socket.conn);
+    await waitForRpgjsConnected(
+      this.socket.conn,
+      this.options.connectionAcceptanceTimeoutMs ?? 10_000,
+    );
     pendingOn
       .filter(({ event }) => this.isNativeSocketEvent(event))
       .forEach(({ event, callback }) => this.attachEvent(event, callback));
@@ -161,7 +169,11 @@ export class BridgeWebsocket extends AbstractWebsocket {
   async reconnect(_listeners?: (data: any) => void): Promise<void> {
     if (!this.socket?.conn) return;
     const conn = this.socket.conn;
-    const connected = waitForRpgjsConnected(conn, 10000, { ignoreCleanClose: true });
+    const connected = waitForRpgjsConnected(
+      conn,
+      this.options.connectionAcceptanceTimeoutMs ?? 10_000,
+      { ignoreCleanClose: true },
+    );
     conn.reconnect();
     await connected;
     this.emitAcceptedOpen();
@@ -173,7 +185,7 @@ export class BridgeWebsocket extends AbstractWebsocket {
 }
 
 class UpdateMapStandaloneService extends UpdateMapService {
-  constructor(protected context: Context, private _options: MmorpgOptions) {
+  constructor(protected context: RpgContext, private _options: MmorpgOptions) {
     super(context);
   }
 
@@ -184,15 +196,15 @@ class UpdateMapStandaloneService extends UpdateMapService {
   }
 }
 
-export function provideMmorpg(options: MmorpgOptions) {
+export function provideMmorpg(options: MmorpgOptions): RpgProvider[] {
   return [
     {
       provide: WebSocketToken,
-      useFactory: (context: Context) => new BridgeWebsocket(context, options),
+      useFactory: (context: RpgContext) => new BridgeWebsocket(context, options),
     },
     {
       provide: UpdateMapToken,
-      useFactory: (context: Context) => new UpdateMapStandaloneService(context, options),
+      useFactory: (context: RpgContext) => new UpdateMapStandaloneService(context, options),
     },
     provideKeyboardControls(),
     provideSaveClient(),