@mpgd/adapter-devvit 0.13.3 → 0.13.5

package/dist/notifications-client.js

@@ -1,6 +1,6 @@
-import { assertBridgeNotificationsV2Result, } from '@mpgd/bridge/notifications';
+import { assertBridgeNotificationsV2Result, readBridgeNotificationsHostCode, } from '@mpgd/bridge/notifications';
 import { isNotificationErrorCode, isValidNotificationTimeZone, NotificationError, notificationsProtocol, toNotificationSubscriptionAdapter, } from '@mpgd/platform/notifications';
-import { devvitHostCodeCharacters, devvitNotificationProviderId, } from './notifications-contract.js';
+import { devvitNotificationProviderId } from './notifications-contract.js';
 /**
  * The Devvit profile's provider: reads, the opt-in request, the opt-out
  * (`revokePermission`, because the game renders the consent), and the
@@ -108,7 +108,6 @@ function defaultLocale() {
     const navigatorLike = globalThis.navigator;
     return typeof navigatorLike?.language === 'string' ? navigatorLike.language : undefined;
 }
-const hostCodePattern = new RegExp(`\\(host code (${devvitHostCodeCharacters})\\)$`, 'u');
 function toNotificationError(error) {
     if (error instanceof NotificationError) {
         return error;
@@ -119,7 +118,7 @@ function toNotificationError(error) {
     const message = typeof failure.message === 'string' ? failure.message : undefined;
     const explicit = typeof failure.retryable === 'boolean' ? { retryable: failure.retryable } : {};
     if (isNotificationErrorCode(failure.code)) {
-        const hostCode = message === undefined ? undefined : hostCodePattern.exec(message)?.[1];
+        const hostCode = message === undefined ? undefined : readBridgeNotificationsHostCode(message);
         return new NotificationError(failure.code, {
             ...(message === undefined ? {} : { message }),
             ...explicit,

package/dist/notifications-contract.d.ts

@@ -46,7 +46,9 @@ export declare const devvitNotificationsPerAppPerDay = 25000;
 export declare function devvitNotificationTextLength(text: string): number;
 /**
 * The characters of a Devvit host code. The server bridge names a host code
-* in an error message as `(host code <code>)`, and the webview reads it back.
+* in an error message as `(host code <code>)`, and the webview reads it back,
+* both through `@mpgd/bridge/notifications` (`createNotificationsV2BridgeHandler`
+* and `readBridgeNotificationsHostCode`), whose pattern this equals.
 */
 export declare const devvitHostCodeCharacters = "[A-Za-z0-9_.:-]{1,128}";
 /** A post (`t3_`) or comment (`t1_`) id, the only links `enqueue` accepts. */

package/dist/notifications-contract.js

@@ -47,7 +47,9 @@ export function devvitNotificationTextLength(text) {
 }
 /**
  * The characters of a Devvit host code. The server bridge names a host code
- * in an error message as `(host code <code>)`, and the webview reads it back.
+ * in an error message as `(host code <code>)`, and the webview reads it back,
+ * both through `@mpgd/bridge/notifications` (`createNotificationsV2BridgeHandler`
+ * and `readBridgeNotificationsHostCode`), whose pattern this equals.
  */
 export const devvitHostCodeCharacters = '[A-Za-z0-9_.:-]{1,128}';
 /** A post (`t3_`) or comment (`t1_`) id, the only links `enqueue` accepts. */

package/dist/server/commerce-bridge.d.ts

@@ -20,6 +20,12 @@ export declare const devvitCommerceV2MethodUnsupportedBridgeErrorCode: 'COMMERCE
 export declare const devvitCommerceCheckoutClientOnlyBridgeErrorCode: 'DEVVIT_COMMERCE_CHECKOUT_CLIENT_ONLY';
 /** Bridge error when the payments plugin fails; retryable. */
 export declare const devvitPaymentsUnavailableBridgeErrorCode: 'DEVVIT_PAYMENTS_UNAVAILABLE';
+/**
+* Bridge error when the paid-order scan hit its page cap with pages left.
+* Retryable. A caller must not treat orders absent from this scan as delivered:
+* the list was not finished.
+*/
+export declare const devvitOrderScanIncompleteBridgeErrorCode: 'DEVVIT_ORDER_SCAN_INCOMPLETE';
 /** `Order.status` as `@devvit/protos` encodes it (`OrderStatus` enum) or as the handler types spell it. */
 export type DevvitPaymentsOrderStatusLike = number | string;
 /** The fields of a `@devvit/payments` `Order` the handler reads. */
@@ -81,6 +87,17 @@ export interface DevvitCommerceV2BridgeHandler {
   request(input: BridgeRequest): Promise<BridgeResponse>;
 }
 /**
+* Hard cap on the pages scanned per listing. `@devvit/payments` 0.14 ignores
+* `status` and `buyer` (`GetOrdersRequest` marks both "currently does nothing";
+* an empty filter means every order), and `PaymentsClient` forwards the
+* request unchanged, so every status is scanned. Devvit serves this handler
+* inside a time-bounded HTTP request. Thirty-two serial plugin calls stay
+* inside that budget (the kit treats about 20 seconds as the practical limit
+* for a Devvit task). Hitting the cap with a next page fails the request
+* instead of returning a partial list: unseen orders are not delivered.
+*/
+export declare const maximumDevvitOrderScanPages = 32;
+/**
 * Serves `commerce.v2.*` from the payments plugin:
 *
 * - `getCapabilities` answers the Devvit profile (`createDevvitCommerceCapabilities`).
@@ -92,13 +109,10 @@ export interface DevvitCommerceV2BridgeHandler {
 *   `purchased` (the order id as `transactionId` and `token`,
 *   `devvit.order.v1` evidence whose `status` says which), bounded by
 *   `maximumDevvitAvailableOrders`. Reddit marks an order `DELIVERED` as soon
-*   as the fulfillment handler answered, so the delivered orders are the ones
-*   whose ledger entry exists; the webview provider lists only the `PAID`
-*   ones as available and reports both as events, so a session that lost its
-*   checkout result still finds the order. The scan reads pages of 64
-*   (newest first, as the Devvit docs describe) and stops after two
-*   consecutive pages without a paid or delivered order or after
-*   `maximumOrderPages`, warning when pages are left.
+*   as the fulfillment handler answered. The scan reads pages of 64 until the
+*   cursor ends, or until `maximumDevvitOrderScanPages`. A scan that still has
+*   a next page at that cap fails with `DEVVIT_ORDER_SCAN_INCOMPLETE` rather
+*   than returning a partial list: an order that was not read is not delivered.
 * - `requestPurchase` is refused with `DEVVIT_COMMERCE_CHECKOUT_CLIENT_ONLY`,
 *   `finishTransaction` with `COMMERCE_V2_METHOD_UNSUPPORTED`, and
 *   `restorePurchases` answers `{ restored: false }`: the webview provider

package/dist/server/commerce-bridge.js

@@ -22,6 +22,12 @@ export const devvitCommerceV2MethodUnsupportedBridgeErrorCode = 'COMMERCE_V2_MET
 export const devvitCommerceCheckoutClientOnlyBridgeErrorCode = 'DEVVIT_COMMERCE_CHECKOUT_CLIENT_ONLY';
 /** Bridge error when the payments plugin fails; retryable. */
 export const devvitPaymentsUnavailableBridgeErrorCode = 'DEVVIT_PAYMENTS_UNAVAILABLE';
+/**
+ * Bridge error when the paid-order scan hit its page cap with pages left.
+ * Retryable. A caller must not treat orders absent from this scan as delivered:
+ * the list was not finished.
+ */
+export const devvitOrderScanIncompleteBridgeErrorCode = 'DEVVIT_ORDER_SCAN_INCOMPLETE';
 /** `OrderStatus.ORDER_STATUS_PAID` of `@devvit/protos`, and its handler-type spelling. */
 const paidOrderStatuses = new Set([
     3,
@@ -61,17 +67,16 @@ const durableAccountingTypes = new Set([
 ]);
 const orderPageSize = maximumDevvitAvailableOrders;
 /**
- * Hard cap on the pages scanned per listing. The plugin's `status` filter
- * does nothing in `@devvit/payments` 0.14 (its proto marks it so, and the
- * `PaymentsClient` forwards it unchanged), so every status is scanned. The
- * Devvit docs describe the list as newest first ("Manage Payments", "Check
- * orders"); that is documentation, not a plugin guarantee, so the scan stops
- * early only after two consecutive pages without a paid or delivered order,
- * and warns when it stops with pages left.
+ * Hard cap on the pages scanned per listing. `@devvit/payments` 0.14 ignores
+ * `status` and `buyer` (`GetOrdersRequest` marks both "currently does nothing";
+ * an empty filter means every order), and `PaymentsClient` forwards the
+ * request unchanged, so every status is scanned. Devvit serves this handler
+ * inside a time-bounded HTTP request. Thirty-two serial plugin calls stay
+ * inside that budget (the kit treats about 20 seconds as the practical limit
+ * for a Devvit task). Hitting the cap with a next page fails the request
+ * instead of returning a partial list: unseen orders are not delivered.
  */
-const maximumOrderPages = 8;
-/** Consecutive pages without a paid or delivered order after which the scan stops early. */
-const settledPagesBeforeStop = 2;
+export const maximumDevvitOrderScanPages = 32;
 /**
  * Serves `commerce.v2.*` from the payments plugin:
  *
@@ -84,13 +89,10 @@ const settledPagesBeforeStop = 2;
  *   `purchased` (the order id as `transactionId` and `token`,
  *   `devvit.order.v1` evidence whose `status` says which), bounded by
  *   `maximumDevvitAvailableOrders`. Reddit marks an order `DELIVERED` as soon
- *   as the fulfillment handler answered, so the delivered orders are the ones
- *   whose ledger entry exists; the webview provider lists only the `PAID`
- *   ones as available and reports both as events, so a session that lost its
- *   checkout result still finds the order. The scan reads pages of 64
- *   (newest first, as the Devvit docs describe) and stops after two
- *   consecutive pages without a paid or delivered order or after
- *   `maximumOrderPages`, warning when pages are left.
+ *   as the fulfillment handler answered. The scan reads pages of 64 until the
+ *   cursor ends, or until `maximumDevvitOrderScanPages`. A scan that still has
+ *   a next page at that cap fails with `DEVVIT_ORDER_SCAN_INCOMPLETE` rather
+ *   than returning a partial list: an order that was not read is not delivered.
  * - `requestPurchase` is refused with `DEVVIT_COMMERCE_CHECKOUT_CLIENT_ONLY`,
  *   `finishTransaction` with `COMMERCE_V2_METHOD_UNSUPPORTED`, and
  *   `restorePurchases` answers `{ restored: false }`: the webview provider
@@ -113,19 +115,14 @@ export function createDevvitCommerceV2BridgeHandler(input) {
     const listPaidOrders = async () => {
         const orders = [];
         let cursor;
-        let settledPages = 0;
-        for (let page = 0; page < maximumOrderPages; page += 1) {
+        for (let page = 0; page < maximumDevvitOrderScanPages; page += 1) {
             const response = await input.payments.getOrders({
                 limit: orderPageSize,
                 ...(cursor === undefined ? {} : { cursor }),
             });
             const next = response.pageInfo;
             const hasNextPage = next !== undefined && next.hasNextPage && next.endCursor.length > 0;
-            let listableOnPage = 0;
             for (const [index, order] of response.orders.entries()) {
-                if (paidOrderStatuses.has(order.status) || deliveredOrderStatuses.has(order.status)) {
-                    listableOnPage += 1;
-                }
                 const paid = readListedOrder(order, productsBySku);
                 if (paid !== undefined) {
                     orders.push(paid);
@@ -138,21 +135,15 @@ export function createDevvitCommerceV2BridgeHandler(input) {
                 }
             }
             if (!hasNextPage || next === undefined) {
-                break;
+                return orders;
             }
-            settledPages = listableOnPage === 0 ? settledPages + 1 : 0;
-            if (settledPages >= settledPagesBeforeStop) {
-                // Newest first, as documented: the older pages left hold nothing to list.
-                warn(`Devvit order scan stopped after ${String(settledPagesBeforeStop)} pages without a `
-                    + 'paid or delivered order; older pages were not read.');
-                break;
-            }
-            if (page + 1 === maximumOrderPages) {
-                warn('Devvit order scan reached its page cap; older pages were not read.');
+            if (page + 1 === maximumDevvitOrderScanPages) {
+                // A partial list would look complete. Unseen orders are not delivered.
+                throw incompleteOrderScan();
             }
             cursor = next.endCursor;
         }
-        return orders;
+        throw incompleteOrderScan();
     };
     const serve = async (request) => {
         const { payload } = request;
@@ -343,6 +334,14 @@ function normalizeBridgeProducts(input) {
         return { productId: product.productId, sku: product.sku };
     });
 }
+function incompleteOrderScan() {
+    return new PlatformOperationError({
+        code: devvitOrderScanIncompleteBridgeErrorCode,
+        message: `Devvit order scan is incomplete: it reached ${String(maximumDevvitOrderScanPages)} `
+            + 'pages with pages left. Unseen orders were not read and are not delivered.',
+        retryable: true,
+    });
+}
 async function paymentsCall(call) {
     try {
         return await call();

package/dist/server/notifications-bridge.d.ts

@@ -1,4 +1,4 @@
-import { type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
+import type { BridgeRequest, BridgeResponse } from '@mpgd/bridge';
 import { type NotificationProvider } from '@mpgd/platform/notifications';
 /**
 * The game-rendered consent of the Devvit profile (notifications v2 RFC,
@@ -95,14 +95,17 @@ export interface DevvitNotificationsV2BridgeHandler {
 }
 /**
 * The server bridge side of notifications v2 on Devvit (RFC "Bridge and
-* versioning"): each method's payload and answer are checked with the
-* `@mpgd/bridge/notifications` validators. A payload the validator rejects
-* answers `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
+* versioning"): `createNotificationsV2BridgeHandler` from
+* `@mpgd/bridge/notifications` over the Devvit server provider. Each method's
+* payload and answer are checked with the `@mpgd/bridge/notifications`
+* validators. A payload the validator rejects answers
+* `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
 * local-notification methods) `NOTIFICATIONS_UNSUPPORTED`; `openSettings`
 * answers `unavailable`, because Devvit has no settings link; an answer the
 * contract rejects `NOTIFICATIONS_CONFIGURATION_REQUIRED`. A thrown
 * `NotificationError` crosses as `{ code, message, retryable }` with its host
-* code named in the message. Devvit has no server-to-webview event channel,
-* so the bridge carries no notifications events.
+* code named in the message, and an unexpected failure's text stays on the
+* server. Devvit has no server-to-webview event channel, so the bridge
+* carries no notifications events.
 */
 export declare function createDevvitNotificationsV2BridgeHandler(input: CreateDevvitNotificationsV2BridgeHandlerInput): DevvitNotificationsV2BridgeHandler;

package/dist/server/notifications-bridge.js

@@ -1,8 +1,6 @@
-import { createBridgeError, isBridgeNotificationsV2Method, } from '@mpgd/bridge';
-import { assertBridgeNotificationsV2Payload, assertBridgeNotificationsV2Result, } from '@mpgd/bridge/notifications';
-import { PlatformOperationError } from '@mpgd/platform';
-import { isNotificationErrorCode, NotificationError, notificationsProtocolVersion, } from '@mpgd/platform/notifications';
-import { createDevvitNotificationCapabilities, devvitHostCodeCharacters, devvitNotificationProviderId, devvitUserIdPattern, } from '../notifications-contract.js';
+import { createNotificationsV2BridgeHandler } from '@mpgd/bridge/notifications';
+import { NotificationError, } from '@mpgd/platform/notifications';
+import { createDevvitNotificationCapabilities, devvitNotificationProviderId, devvitUserIdPattern, } from '../notifications-contract.js';
 /** Host codes of the failures this provider normalizes. */
 export const devvitNotificationHostCodes = Object.freeze({
     optInRefused: 'DEVVIT_OPT_IN_REFUSED',
@@ -159,119 +157,31 @@ export function createDevvitServerNotificationProvider(input) {
 }
 /**
  * The server bridge side of notifications v2 on Devvit (RFC "Bridge and
- * versioning"): each method's payload and answer are checked with the
- * `@mpgd/bridge/notifications` validators. A payload the validator rejects
- * answers `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
+ * versioning"): `createNotificationsV2BridgeHandler` from
+ * `@mpgd/bridge/notifications` over the Devvit server provider. Each method's
+ * payload and answer are checked with the `@mpgd/bridge/notifications`
+ * validators. A payload the validator rejects answers
+ * `NOTIFICATIONS_INVALID_INPUT`; a method the profile lacks (the
  * local-notification methods) `NOTIFICATIONS_UNSUPPORTED`; `openSettings`
  * answers `unavailable`, because Devvit has no settings link; an answer the
  * contract rejects `NOTIFICATIONS_CONFIGURATION_REQUIRED`. A thrown
  * `NotificationError` crosses as `{ code, message, retryable }` with its host
- * code named in the message. Devvit has no server-to-webview event channel,
- * so the bridge carries no notifications events.
+ * code named in the message, and an unexpected failure's text stays on the
+ * server. Devvit has no server-to-webview event channel, so the bridge
+ * carries no notifications events.
  */
 export function createDevvitNotificationsV2BridgeHandler(input) {
-    const provider = createDevvitServerNotificationProvider(input);
-    const onError = input.onError ?? ((error, context) => {
-        if (error instanceof NotificationError && error.code === 'NOTIFICATIONS_UNSUPPORTED') {
-            return;
-        }
-        console.warn(`devvit notifications ${context.method} failed`, error);
-    });
-    const serve = async (method, payload) => {
-        switch (method) {
-            case 'notifications.v2.getCapabilities':
-                validPayload(method, payload);
-                return {
-                    protocolVersion: notificationsProtocolVersion,
-                    provider: provider.provider,
-                    capabilities: await provider.getCapabilities(),
-                };
-            case 'notifications.v2.getPermission':
-                return provider.getPermission(validPayload(method, payload));
-            case 'notifications.v2.requestPermission':
-                return provider.requestPermission(validPayload(method, payload));
-            case 'notifications.v2.revokePermission':
-                return provider.revokePermission
-                    .call(provider, validPayload(method, payload));
-            case 'notifications.v2.register':
-                validPayload(method, payload);
-                return { registration: (await provider.register?.()) ?? null };
-            case 'notifications.v2.openSettings':
-                validPayload(method, payload);
-                return { status: 'unavailable' };
-            case 'notifications.v2.scheduleLocal':
-            case 'notifications.v2.cancelLocal':
-            case 'notifications.v2.listLocal':
-                validPayload(method, payload);
-                throw new NotificationError('NOTIFICATIONS_UNSUPPORTED', {
-                    message: `Devvit has no local notifications (${method}).`,
-                });
-        }
-    };
-    return {
-        async request(request) {
-            if (!isBridgeNotificationsV2Method(request.method)) {
-                return createBridgeError(request.id, 'UNSUPPORTED_METHOD', `${request.method} is not a notifications v2 method.`);
-            }
-            const method = request.method;
-            try {
-                const data = await serve(method, request.payload);
-                return { id: request.id, ok: true, data: validResult(method, data) };
-            }
-            catch (error) {
-                if (!(error instanceof InvalidPayloadError)) {
-                    try {
-                        const logged = onError(error, { method });
-                        if (logged instanceof Promise) {
-                            logged.catch(() => { });
-                        }
-                    }
-                    catch {
-                        // A failing log never changes the answer.
-                    }
-                }
-                return toBridgeError(request, error);
+    const handler = createNotificationsV2BridgeHandler({
+        provider: createDevvitServerNotificationProvider(input),
+        label: 'Devvit',
+        // An unexpected failure's text stays on the server.
+        unexpectedFailureMessage: (method) => `${method} failed on the Devvit server.`,
+        onError: input.onError ?? ((error, context) => {
+            if (error instanceof NotificationError && error.code === 'NOTIFICATIONS_UNSUPPORTED') {
+                return;
             }
-        },
-    };
-}
-class InvalidPayloadError extends Error {
-    name = 'InvalidPayloadError';
-}
-function validPayload(method, payload) {
-    try {
-        return assertBridgeNotificationsV2Payload(method, payload);
-    }
-    catch (error) {
-        throw new InvalidPayloadError(`${method} payload is invalid: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-}
-function validResult(method, data) {
-    try {
-        return assertBridgeNotificationsV2Result(method, data);
-    }
-    catch (error) {
-        throw new NotificationError('NOTIFICATIONS_CONFIGURATION_REQUIRED', {
-            message: `The Devvit notifications provider answered ${method} with invalid data: ${error instanceof Error ? error.message : String(error)}`,
-            cause: error,
-        });
-    }
-}
-const hostCodeValue = new RegExp(`^${devvitHostCodeCharacters}$`, 'u');
-function toBridgeError(request, error) {
-    if (error instanceof InvalidPayloadError) {
-        return createBridgeError(request.id, 'NOTIFICATIONS_INVALID_INPUT', error.message);
-    }
-    if (error instanceof NotificationError) {
-        return createBridgeError(request.id, error.code, error.hostCode === undefined || !hostCodeValue.test(error.hostCode)
-            ? error.message
-            : `${error.message} (host code ${error.hostCode})`, error.retryable);
-    }
-    if (error instanceof PlatformOperationError) {
-        return isNotificationErrorCode(error.code)
-            ? createBridgeError(request.id, error.code, error.message, error.retryable)
-            : createBridgeError(request.id, 'NOTIFICATIONS_TEMPORARILY_UNAVAILABLE', `${request.method} failed: ${error.message}`, error.retryable);
-    }
-    // An unexpected failure's text stays on the server.
-    return createBridgeError(request.id, 'NOTIFICATIONS_TEMPORARILY_UNAVAILABLE', `${request.method} failed on the Devvit server.`, true);
+            console.warn(`devvit notifications ${context.method} failed`, error);
+        }),
+    });
+    return { request: (request) => handler.request(request) };
 }

package/dist/server/redis-verified-leaderboard.js

@@ -4,6 +4,8 @@ const defaultSnapshotLimit = 10;
 const defaultTransactionAttempts = 3;
 const maximumTransactionAttempts = 32;
 const keyPrefixPattern = /^[A-Za-z0-9:_-]{1,128}$/;
+/** The commit marker's value; its SET replies `OK`, which `@devvit/redis` always maps. */
+const commitMarkerValue = '1';
 /**
  * Durable Devvit Redis provider for modest verified leaderboards. Writes are
  * fenced with WATCH/MULTI/EXEC and keep the original idempotency response.
@@ -66,13 +68,22 @@ export function createDevvitRedisVerifiedLeaderboardService(redis, options = {})
                     await transaction.hSet(keys.attempts, {
                         [attemptMember]: serializeAttemptDecision(request.attempt, response),
                     });
+                    // `@devvit/redis` `TxClient.exec()` resolves an aborted WATCH as `[]`
+                    // and drops zero or nil replies. The marker's `OK` always maps, so a
+                    // committed EXEC answers at least that reply even when the array is
+                    // shorter than the queued commands. Only an empty, `null`, or all-nil
+                    // result is an abort. Requiring `results.length === queued` would
+                    // retry a landed score whose zero replies Devvit dropped.
+                    await transaction.set(keys.commitMarker, commitMarkerValue);
                     const results = await transaction.exec();
-                    if (results === null || (Array.isArray(results) && results.length === 0)) {
-                        continue;
-                    }
-                    if (!Array.isArray(results)) {
+                    if (results !== null && !Array.isArray(results)) {
                         throw new Error('Devvit Redis transaction returned an unsupported response.');
                     }
+                    if (results === null
+                        || results.length === 0
+                        || results.every((reply) => reply === null || reply === undefined)) {
+                        continue;
+                    }
                     return response;
                 }
                 catch (error) {
@@ -136,6 +147,7 @@ async function createBoardKeys(keyPrefix, leaderboardId) {
         attempts: `${base}:attempts`,
         entries: `${base}:entries`,
         ranking: `${base}:ranking`,
+        commitMarker: `${keyPrefix}:commit`,
     };
     return {
         ...keys,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-devvit",
-  "version": "0.13.3",
+  "version": "0.13.5",
   "description": "Reddit Devvit Web platform adapter for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -54,10 +54,10 @@
     "dist"
   ],
   "dependencies": {
-    "@devvit/web": "0.14.1",
-    "@mpgd/bridge": "0.14.2",
-    "@mpgd/platform": "0.27.0",
-    "@mpgd/game-services": "0.27.0"
+    "@devvit/web": "0.15.0",
+    "@mpgd/bridge": "0.15.0",
+    "@mpgd/game-services": "0.27.2",
+    "@mpgd/platform": "0.27.2"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",