@kokimoki/app 3.1.3 → 3.1.5

package/dist/kokimoki-leaderboard.d.ts

@@ -1,175 +0,0 @@
-import { KokimokiClient } from "./kokimoki-client";
-import { Paginated } from "./types/common";
-/**
- * Kokimoki Leaderboard Service
- *
- * Provides efficient player ranking and score tracking with database indexes and optimized queries.
- * Ideal for games with large numbers of players and competitive scoring.
- *
- * **Key Features:**
- * - Efficient ranking with database indexes
- * - Support for ascending (lowest-is-best) and descending (highest-is-best) sorting
- * - Pagination for large leaderboards
- * - Public and private metadata for entries
- * - Insert (preserve all attempts) or upsert (keep latest only) modes
- *
- * **When to use Leaderboard API vs Global Store:**
- *
- * Use the **Leaderboard API** when:
- * - You have a large number of entries (hundreds to thousands of players)
- * - You need efficient ranking and sorting with database indexes
- * - You want pagination and optimized queries for top scores
- * - Memory and network efficiency are important
- *
- * Use a **Global Store** when:
- * - You have a small number of players (typically under 100)
- * - You need real-time updates and live leaderboard changes
- * - You want to combine player scores with other game state
- * - The leaderboard is temporary (session-based or reset frequently)
- *
- * Access via `kmClient.leaderboard`
- *
- * @example
- * ```typescript
- * // Submit a high score
- * const { rank } = await kmClient.leaderboard.upsertEntry(
- *   'high-scores',
- *   'desc',
- *   1500,
- *   { playerName: 'Alice' },
- *   {}
- * );
- *
- * // Get top 10
- * const { items } = await kmClient.leaderboard.listEntries('high-scores', 'desc', 0, 10);
- *
- * // Get player's best
- * const best = await kmClient.leaderboard.getBestEntry('high-scores', 'desc');
- * ```
- */
-export declare class KokimokiLeaderboard {
-    private readonly client;
-    constructor(client: KokimokiClient);
-    /**
-     * Add a new entry to a leaderboard.
-     *
-     * Creates a new entry each time it's called, preserving all attempts. Use this when you want
-     * to track every score submission (e.g., all game attempts).
-     *
-     * @param leaderboardName The name of the leaderboard to add the entry to
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param score The numeric score value
-     * @param metadata Public metadata visible to all players (e.g., player name, level)
-     * @param privateMetadata Private metadata only accessible via API calls (e.g., session ID)
-     * @returns A promise resolving to an object with the entry's rank
-     *
-     * @example
-     * ```typescript
-     * const { rank } = await kmClient.leaderboard.insertEntry(
-     *   'high-scores',
-     *   'desc',
-     *   1500,
-     *   { playerName: 'Alice', level: 10 },
-     *   { sessionId: 'abc123' }
-     * );
-     * console.log(`New rank: ${rank}`);
-     * ```
-     */
-    insertEntry<MetadataT, PrivateMetadataT>(leaderboardName: string, sortDir: "asc" | "desc", score: number, metadata: MetadataT, privateMetadata: PrivateMetadataT): Promise<{
-        rank: number;
-    }>;
-    /**
-     * Add or update the latest entry for the current client in a leaderboard.
-     *
-     * Replaces the previous entry if one exists for this client. Use this when you only want
-     * to keep the latest or best score per player (e.g., daily high score).
-     *
-     * @param leaderboardName The name of the leaderboard to upsert the entry in
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param score The numeric score value
-     * @param metadata Public metadata visible to all players (e.g., player name, completion time)
-     * @param privateMetadata Private metadata only accessible via API calls (e.g., device ID)
-     * @returns A promise resolving to an object with the entry's updated rank
-     *
-     * @example
-     * ```typescript
-     * const { rank } = await kmClient.leaderboard.upsertEntry(
-     *   'daily-scores',
-     *   'desc',
-     *   2000,
-     *   { playerName: 'Bob', completionTime: 120 },
-     *   { deviceId: 'xyz789' }
-     * );
-     * console.log(`Updated rank: ${rank}`);
-     * ```
-     */
-    upsertEntry<MetadataT, PrivateMetadataT>(leaderboardName: string, sortDir: "asc" | "desc", score: number, metadata: MetadataT, privateMetadata: PrivateMetadataT): Promise<{
-        rank: number;
-    }>;
-    /**
-     * List entries in a leaderboard with pagination.
-     *
-     * Retrieves a sorted list of leaderboard entries. Use skip and limit parameters for
-     * pagination (e.g., showing top 10, or implementing "load more" functionality).
-     *
-     * @param leaderboardName The name of the leaderboard to query
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param skip Number of entries to skip for pagination (default: 0)
-     * @param limit Maximum number of entries to return (default: 100)
-     * @returns A promise resolving to a paginated list of entries with rank, score, and metadata
-     *
-     * @example
-     * ```typescript
-     * // Get top 10 scores
-     * const { items, total } = await kmClient.leaderboard.listEntries(
-     *   'weekly-scores',
-     *   'desc',
-     *   0,
-     *   10
-     * );
-     *
-     * items.forEach(entry => {
-     *   console.log(`Rank ${entry.rank}: ${entry.metadata.playerName} - ${entry.score}`);
-     * });
-     * ```
-     */
-    listEntries<MetadataT>(leaderboardName: string, sortDir: "asc" | "desc", skip?: number, limit?: number): Promise<Paginated<{
-        rank: number;
-        score: number;
-        metadata: MetadataT;
-    }>>;
-    /**
-     * Get the best entry for a specific client in a leaderboard.
-     *
-     * Retrieves the highest-ranked entry for a client based on the sort direction.
-     * Defaults to the current client if no clientId is provided.
-     *
-     * @param leaderboardName The name of the leaderboard to query
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param clientId The client ID to get the best entry for (optional, defaults to current client)
-     * @returns A promise resolving to the best entry with rank, score, and metadata
-     *
-     * @example
-     * ```typescript
-     * // Get current client's best entry
-     * const myBest = await kmClient.leaderboard.getBestEntry('all-time-high', 'desc');
-     * console.log(`My best: Rank ${myBest.rank}, Score ${myBest.score}`);
-     *
-     * // Get another player's best entry
-     * const otherBest = await kmClient.leaderboard.getBestEntry(
-     *   'all-time-high',
-     *   'desc',
-     *   'other-client-id'
-     * );
-     * ```
-     */
-    getBestEntry<MetadataT>(leaderboardName: string, sortDir: "asc" | "desc", clientId?: string): Promise<{
-        rank: number;
-        score: number;
-        metadata: MetadataT;
-    }>;
-}

package/dist/kokimoki-leaderboard.js

@@ -1,203 +0,0 @@
-/**
- * Kokimoki Leaderboard Service
- *
- * Provides efficient player ranking and score tracking with database indexes and optimized queries.
- * Ideal for games with large numbers of players and competitive scoring.
- *
- * **Key Features:**
- * - Efficient ranking with database indexes
- * - Support for ascending (lowest-is-best) and descending (highest-is-best) sorting
- * - Pagination for large leaderboards
- * - Public and private metadata for entries
- * - Insert (preserve all attempts) or upsert (keep latest only) modes
- *
- * **When to use Leaderboard API vs Global Store:**
- *
- * Use the **Leaderboard API** when:
- * - You have a large number of entries (hundreds to thousands of players)
- * - You need efficient ranking and sorting with database indexes
- * - You want pagination and optimized queries for top scores
- * - Memory and network efficiency are important
- *
- * Use a **Global Store** when:
- * - You have a small number of players (typically under 100)
- * - You need real-time updates and live leaderboard changes
- * - You want to combine player scores with other game state
- * - The leaderboard is temporary (session-based or reset frequently)
- *
- * Access via `kmClient.leaderboard`
- *
- * @example
- * ```typescript
- * // Submit a high score
- * const { rank } = await kmClient.leaderboard.upsertEntry(
- *   'high-scores',
- *   'desc',
- *   1500,
- *   { playerName: 'Alice' },
- *   {}
- * );
- *
- * // Get top 10
- * const { items } = await kmClient.leaderboard.listEntries('high-scores', 'desc', 0, 10);
- *
- * // Get player's best
- * const best = await kmClient.leaderboard.getBestEntry('high-scores', 'desc');
- * ```
- */
-export class KokimokiLeaderboard {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Add a new entry to a leaderboard.
-     *
-     * Creates a new entry each time it's called, preserving all attempts. Use this when you want
-     * to track every score submission (e.g., all game attempts).
-     *
-     * @param leaderboardName The name of the leaderboard to add the entry to
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param score The numeric score value
-     * @param metadata Public metadata visible to all players (e.g., player name, level)
-     * @param privateMetadata Private metadata only accessible via API calls (e.g., session ID)
-     * @returns A promise resolving to an object with the entry's rank
-     *
-     * @example
-     * ```typescript
-     * const { rank } = await kmClient.leaderboard.insertEntry(
-     *   'high-scores',
-     *   'desc',
-     *   1500,
-     *   { playerName: 'Alice', level: 10 },
-     *   { sessionId: 'abc123' }
-     * );
-     * console.log(`New rank: ${rank}`);
-     * ```
-     */
-    async insertEntry(leaderboardName, sortDir, score, metadata, privateMetadata) {
-        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries`, {
-            method: "POST",
-            headers: this.client.apiHeaders,
-            body: JSON.stringify({
-                leaderboardName,
-                sortDir,
-                score,
-                metadata,
-                privateMetadata,
-                upsert: false,
-            }),
-        });
-        return await res.json();
-    }
-    /**
-     * Add or update the latest entry for the current client in a leaderboard.
-     *
-     * Replaces the previous entry if one exists for this client. Use this when you only want
-     * to keep the latest or best score per player (e.g., daily high score).
-     *
-     * @param leaderboardName The name of the leaderboard to upsert the entry in
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param score The numeric score value
-     * @param metadata Public metadata visible to all players (e.g., player name, completion time)
-     * @param privateMetadata Private metadata only accessible via API calls (e.g., device ID)
-     * @returns A promise resolving to an object with the entry's updated rank
-     *
-     * @example
-     * ```typescript
-     * const { rank } = await kmClient.leaderboard.upsertEntry(
-     *   'daily-scores',
-     *   'desc',
-     *   2000,
-     *   { playerName: 'Bob', completionTime: 120 },
-     *   { deviceId: 'xyz789' }
-     * );
-     * console.log(`Updated rank: ${rank}`);
-     * ```
-     */
-    async upsertEntry(leaderboardName, sortDir, score, metadata, privateMetadata) {
-        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries`, {
-            method: "POST",
-            headers: this.client.apiHeaders,
-            body: JSON.stringify({
-                leaderboardName,
-                sortDir,
-                score,
-                metadata,
-                privateMetadata,
-                upsert: true,
-            }),
-        });
-        return await res.json();
-    }
-    /**
-     * List entries in a leaderboard with pagination.
-     *
-     * Retrieves a sorted list of leaderboard entries. Use skip and limit parameters for
-     * pagination (e.g., showing top 10, or implementing "load more" functionality).
-     *
-     * @param leaderboardName The name of the leaderboard to query
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param skip Number of entries to skip for pagination (default: 0)
-     * @param limit Maximum number of entries to return (default: 100)
-     * @returns A promise resolving to a paginated list of entries with rank, score, and metadata
-     *
-     * @example
-     * ```typescript
-     * // Get top 10 scores
-     * const { items, total } = await kmClient.leaderboard.listEntries(
-     *   'weekly-scores',
-     *   'desc',
-     *   0,
-     *   10
-     * );
-     *
-     * items.forEach(entry => {
-     *   console.log(`Rank ${entry.rank}: ${entry.metadata.playerName} - ${entry.score}`);
-     * });
-     * ```
-     */
-    async listEntries(leaderboardName, sortDir, skip = 0, limit = 100) {
-        const encodedLeaderboardName = encodeURIComponent(leaderboardName);
-        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries?leaderboardName=${encodedLeaderboardName}&sortDir=${sortDir}&skip=${skip}&limit=${limit}`, {
-            headers: this.client.apiHeaders,
-        });
-        return await res.json();
-    }
-    /**
-     * Get the best entry for a specific client in a leaderboard.
-     *
-     * Retrieves the highest-ranked entry for a client based on the sort direction.
-     * Defaults to the current client if no clientId is provided.
-     *
-     * @param leaderboardName The name of the leaderboard to query
-     * @param sortDir Sort direction: "asc" for lowest-is-best (e.g., completion time),
-     *                "desc" for highest-is-best (e.g., points)
-     * @param clientId The client ID to get the best entry for (optional, defaults to current client)
-     * @returns A promise resolving to the best entry with rank, score, and metadata
-     *
-     * @example
-     * ```typescript
-     * // Get current client's best entry
-     * const myBest = await kmClient.leaderboard.getBestEntry('all-time-high', 'desc');
-     * console.log(`My best: Rank ${myBest.rank}, Score ${myBest.score}`);
-     *
-     * // Get another player's best entry
-     * const otherBest = await kmClient.leaderboard.getBestEntry(
-     *   'all-time-high',
-     *   'desc',
-     *   'other-client-id'
-     * );
-     * ```
-     */
-    async getBestEntry(leaderboardName, sortDir, clientId) {
-        const encodedLeaderboardName = encodeURIComponent(leaderboardName);
-        const res = await fetch(`${this.client.apiUrl}/leaderboard-entries/best?leaderboardName=${encodedLeaderboardName}&sortDir=${sortDir}&clientId=${clientId || this.client.id}`, {
-            headers: this.client.apiHeaders,
-        });
-        return await res.json();
-    }
-}

package/dist/kokimoki-local-store.d.ts

@@ -1,11 +0,0 @@
-import { KokimokiStore } from "./kokimoki-store";
-export declare class KokimokiLocalStore<T extends object> extends KokimokiStore<T> {
-    private readonly localRoomName;
-    private _stateKey?;
-    private get stateKey();
-    constructor(localRoomName: string, defaultState: T);
-    getInitialUpdate(appId: string, clientId: string): {
-        roomHash: number;
-        initialUpdate: Uint8Array | undefined;
-    };
-}

package/dist/kokimoki-local-store.js

@@ -1,40 +0,0 @@
-import { KokimokiStore } from "./kokimoki-store";
-import { RoomSubscriptionMode } from "./room-subscription-mode";
-import { fingerprint32 } from "farmhash-modern";
-import * as Y from "yjs";
-export class KokimokiLocalStore extends KokimokiStore {
-    localRoomName;
-    _stateKey;
-    get stateKey() {
-        if (!this._stateKey) {
-            throw new Error("Not initialized");
-        }
-        return this._stateKey;
-    }
-    constructor(localRoomName, defaultState) {
-        super(`/l/${localRoomName}`, defaultState, RoomSubscriptionMode.ReadWrite);
-        this.localRoomName = localRoomName;
-        // Synchronize doc changes to local storage
-        // TODO: maybe do not serialize full state every time
-        this.doc.on("update", () => {
-            const value = Y.encodeStateAsUpdate(this.doc);
-            const valueString = String.fromCharCode(...value);
-            const valueBase64 = btoa(valueString);
-            localStorage.setItem(this.stateKey, valueBase64);
-        });
-    }
-    getInitialUpdate(appId, clientId) {
-        this._stateKey = `${appId}/${clientId}/${this.localRoomName}`;
-        // get initial update from local storage
-        let initialUpdate = undefined;
-        const state = localStorage.getItem(this.stateKey);
-        if (state) {
-            const valueString = atob(state);
-            initialUpdate = Uint8Array.from(valueString, (c) => c.charCodeAt(0));
-        }
-        return {
-            roomHash: fingerprint32(this.roomName),
-            initialUpdate,
-        };
-    }
-}

package/dist/kokimoki-queue.js

@@ -1,38 +0,0 @@
-"use strict";
-// import EventEmitter from "events";
-// import { KokimokiStore } from "./kokimoki-store";
-// import { KokimokiSchema as S } from "./kokimoki-schema";
-// import type TypedEventEmitter from "typed-emitter";
-// import type { RoomSubscriptionMode } from "./room-subscription-mode";
-// export class KokimokiQueue<
-//   Req extends S.Generic<unknown>
-// > extends KokimokiStore<S.Dict<Req>> {
-//   private _emitter = new EventEmitter() as TypedEventEmitter<{
-//     messages: (
-//       messages: { id: string; payload: Req["defaultValue"] }[]
-//     ) => void;
-//   }>;
-//   public readonly on = this._emitter.on.bind(this._emitter);
-//   public readonly off = this._emitter.off.bind(this._emitter);
-//   constructor(
-//     roomName: string,
-//     public readonly payloadSchema: Req,
-//     mode: RoomSubscriptionMode
-//   ) {
-//     super(`/q/${roomName}`, S.dict(payloadSchema), mode);
-//     const emittedMessageIds = new Set<string>();
-//     this.doc.on("update", () => {
-//       const newMessages: { id: string; payload: Req["defaultValue"] }[] = [];
-//       for (const id in this.proxy) {
-//         if (emittedMessageIds.has(id)) {
-//           continue;
-//         }
-//         emittedMessageIds.add(id);
-//         newMessages.push({ id, payload: this.proxy[id] });
-//       }
-//       if (newMessages.length > 0) {
-//         this._emitter.emit("messages", newMessages);
-//       }
-//     });
-//   }
-// }

package/dist/kokimoki-req-res.js

@@ -1,198 +0,0 @@
-"use strict";
-// import type { KokimokiClient } from "./kokimoki-client";
-// import type { KokimokiQueue } from "./kokimoki-queue";
-// import { KokimokiSchema as S } from "./kokimoki-schema";
-// import { RoomSubscriptionMode } from "./room-subscription-mode";
-// export class KokimokiReqRes<
-//   Req extends S.Generic<unknown>,
-//   Res extends S.Generic<unknown>
-// > {
-//   private _reqQueueSchema;
-//   private _resQueueSchema;
-//   // Request queues are linked to client ids
-//   private _reqQueues: {
-//     [clientId: string]: KokimokiQueue<
-//       S.Struct<{ connectionId: S.String; payload: Req }>
-//     >;
-//   } = {};
-//   // Response queues are linked to specific connection ids
-//   private _resQueues: {
-//     [connectionId: string]: KokimokiQueue<
-//       S.Struct<{ reqId: S.String; error: S.Optional<S.String>; payload: Res }>
-//     >;
-//   } = {};
-//   private _reqPromises: {
-//     [reqId: string]: {
-//       resolve: (value: Res["defaultValue"]) => void;
-//       reject: (error: string) => void;
-//     };
-//   } = {};
-//   private async _getReqQueue(
-//     clientId: string,
-//     mode: RoomSubscriptionMode = RoomSubscriptionMode.Write
-//   ) {
-//     if (!this._reqQueues.hasOwnProperty(clientId)) {
-//       this._reqQueues[clientId] = this.kmClient.queue(
-//         `/r/${clientId}/req/${this.serviceName}`,
-//         this._reqQueueSchema,
-//         mode,
-//         false
-//       );
-//       await this.kmClient.join(this._reqQueues[clientId]);
-//     }
-//     return this._reqQueues[clientId];
-//   }
-//   private async _getResQueue(
-//     connectionId: string,
-//     mode: RoomSubscriptionMode = RoomSubscriptionMode.Write
-//   ) {
-//     if (!this._resQueues.hasOwnProperty(connectionId)) {
-//       this._resQueues[connectionId] = this.kmClient.queue(
-//         `/r/${connectionId}/res/${this.serviceName}`,
-//         this._resQueueSchema,
-//         mode,
-//         false
-//       );
-//       await this.kmClient.join(this._resQueues[connectionId]);
-//     }
-//     return this._resQueues[connectionId];
-//   }
-//   constructor(
-//     private kmClient: KokimokiClient,
-//     public readonly serviceName: string,
-//     public readonly reqSchema: Req,
-//     public readonly resSchema: Res,
-//     private handleRequest: (
-//       payload: Req["defaultValue"]
-//     ) => Promise<Res["defaultValue"]>
-//   ) {
-//     this._reqQueueSchema = S.struct({
-//       connectionId: S.string(),
-//       //   roomHash: S.number(),
-//       payload: reqSchema,
-//     });
-//     this._resQueueSchema = S.struct({
-//       reqId: S.string(),
-//       error: S.optional(S.string()),
-//       payload: resSchema,
-//     });
-//     // Set up queues on connect
-//     kmClient.on("connected", async () => {
-//       // Handle responses to self
-//       const resQueue = await this._getResQueue(
-//         kmClient.connectionId,
-//         RoomSubscriptionMode.ReadWrite
-//       );
-//       let handlingResponses = false;
-//       let rehandleResponses = false;
-//       resQueue.subscribe(async (messages) => {
-//         // console.log("RES", Object.keys(messages));
-//         if (handlingResponses) {
-//           rehandleResponses = true;
-//           return;
-//         }
-//         handlingResponses = true;
-//         await this.handleResponses(resQueue, messages);
-//         if (rehandleResponses) {
-//           rehandleResponses = false;
-//           await this.handleResponses(resQueue, messages);
-//         }
-//         handlingResponses = false;
-//       });
-//       // Handle requests to self
-//       const reqQueue = await this._getReqQueue(
-//         kmClient.id,
-//         RoomSubscriptionMode.ReadWrite
-//       );
-//       let handlingRequests = false;
-//       let rehandleRequests = false;
-//       reqQueue.subscribe(async (messages) => {
-//         // console.log("REQ", Object.keys(messages));
-//         if (handlingRequests) {
-//           rehandleRequests = true;
-//           return;
-//         }
-//         handlingRequests = true;
-//         await this.handleRequests(reqQueue, messages);
-//         if (rehandleRequests) {
-//           rehandleRequests = false;
-//           await this.handleRequests(reqQueue, messages);
-//         }
-//         handlingRequests = false;
-//       });
-//     });
-//   }
-//   private async handleRequests(
-//     reqQueue: KokimokiQueue<any>,
-//     messages: {
-//       [reqId: string]: { connectionId: string; payload: Req["defaultValue"] };
-//     }
-//   ) {
-//     // Send responses
-//     await this.kmClient.transact(async (t) => {
-//       for (const reqId in messages) {
-//         const { connectionId, payload } = messages[reqId];
-//         const resQueue = await this._getResQueue(connectionId);
-//         t.consumeMessage(reqQueue, reqId);
-//         try {
-//           t.queueMessage(resQueue, {
-//             reqId,
-//             error: undefined,
-//             payload: await this.handleRequest(payload),
-//           });
-//         } catch (e: any) {
-//           t.queueMessage(resQueue, {
-//             reqId,
-//             error: e.toString(),
-//             payload: null,
-//           });
-//         }
-//       }
-//     });
-//   }
-//   private async handleResponses(
-//     resQueue: KokimokiQueue<any>,
-//     messages: {
-//       [resId: string]: {
-//         reqId: string;
-//         error?: string;
-//         payload: Res["defaultValue"];
-//       };
-//     }
-//   ) {
-//     // Handle responses
-//     await this.kmClient.transact(async (t) => {
-//       for (const resId in messages) {
-//         const { reqId, error, payload } = messages[resId];
-//         const promise = this._reqPromises[reqId];
-//         t.consumeMessage(resQueue, resId);
-//         if (promise) {
-//           if (error) {
-//             promise.reject(error);
-//           } else {
-//             promise.resolve(payload);
-//           }
-//           delete this._reqPromises[reqId];
-//         }
-//       }
-//     });
-//   }
-//   async send(
-//     toClientId: string,
-//     payload: Req["defaultValue"],
-//     timeout?: number
-//   ) {
-//     const toReqQueue = await this._getReqQueue(toClientId);
-//     // Create a promise for the response
-//     return await new Promise<Res["defaultValue"]>(async (resolve, reject) => {
-//       await this.kmClient.transact((t) => {
-//         const reqId = t.queueMessage(toReqQueue, {
-//           connectionId: this.kmClient.connectionId,
-//           payload,
-//           // roomHash,
-//         });
-//         this._reqPromises[reqId] = { resolve, reject };
-//       });
-//     });
-//   }
-// }