@mpgd/cli 0.8.0 → 0.10.0

package/templates/phaser-game/apps/target-devvit/src/server/index.ts

@@ -3,7 +3,6 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { createServer, context, getServerPort, reddit, redis } from '@devvit/web/server';
 import type { UiResponse } from '@devvit/web/shared';
 import {
-  assertBridgeRequest,
   createBridgeError,
   type BridgeRequest,
   type BridgeResponse,
@@ -14,16 +13,9 @@ import {
 } from '@mpgd/bridge/orpc';
 import { createBridgeRpcNodeHandler } from '@mpgd/bridge/orpc/node';
 
-const redisKeyComponentPattern = /^[A-Za-z0-9:_-]{1,128}$/;
 const maxStorageKeyLength = 128;
 const maxEncodedStorageKeyLength = 384;
-const maxRequestBodySize = 1_000_000;
-const legacyBridgeEndpoint = '/api/mpgd/bridge';
-const leaderboardUpdateMaxAttempts = 3;
-const leaderboardBackoffBaseMs = 25;
-const leaderboardLockTtlMs = 2_000;
-const leaderboardLockTtlSeconds = Math.ceil(leaderboardLockTtlMs / 1_000);
-const leaderboardLockRetryBudgetMs = leaderboardLockTtlSeconds * 1_000;
+const maxRequestBodySize = 1_048_576;
 const gameName = '__GAME_NAME__';
 const gameTitle = __GAME_TITLE_TS_LITERAL__;
 const bridgeRpcHandler = createBridgeRpcNodeHandler(
@@ -59,11 +51,6 @@ async function handleHttpRequest(
     return;
   }
 
-  if (request.method === 'POST' && requestPathname(request) === legacyBridgeEndpoint) {
-    await handleLegacyBridgeRequest(request, response);
-    return;
-  }
-
   if (await bridgeRpcHandler(request, response)) {
     return;
   }
@@ -73,73 +60,6 @@ async function handleHttpRequest(
   });
 }
 
-async function handleLegacyBridgeRequest(
-  request: IncomingMessage,
-  response: ServerResponse,
-): Promise<void> {
-  let body: unknown;
-
-  try {
-    body = await readJsonRequestBody(request, maxRequestBodySize);
-  } catch (error) {
-    const responseError = describeLegacyBridgeBodyError(error);
-
-    if (error instanceof RequestBodyTooLargeError) {
-      discardOversizedRequestBody(request, response);
-    }
-
-    if (responseError.retryable) {
-      console.error(`devvit legacy bridge body read failed: ${errorMessage(error)}`, error);
-    }
-
-    sendJson(
-      response,
-      responseError.status,
-      createBridgeError(
-        'unknown',
-        responseError.code,
-        responseError.message,
-        responseError.retryable,
-      ),
-    );
-    return;
-  }
-
-  let bridgeRequest: BridgeRequest;
-
-  try {
-    bridgeRequest = assertBridgeRequest(body);
-  } catch (error) {
-    console.warn(`devvit legacy bridge validation failed: ${errorMessage(error)}`);
-    sendJson(
-      response,
-      400,
-      createBridgeError(
-        requestIdFromBody(body),
-        'INVALID_BRIDGE_REQUEST',
-        'Invalid bridge request.',
-      ),
-    );
-    return;
-  }
-
-  try {
-    sendJson(response, 200, await handleBridgeRequest(bridgeRequest));
-  } catch (error) {
-    console.error(`devvit legacy bridge request failed: ${errorMessage(error)}`, error);
-    sendJson(
-      response,
-      500,
-      createBridgeError(
-        bridgeRequest.id,
-        'DEVVIT_BRIDGE_INTERNAL_ERROR',
-        'Devvit bridge request failed.',
-        true,
-      ),
-    );
-  }
-}
-
 async function handleCreatePostMenu(response: ServerResponse): Promise<void> {
   const subredditName = currentSubredditName();
 
@@ -217,7 +137,7 @@ async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse
         nativeAds: false,
         rewardedAds: false,
         interstitialAds: false,
-        nativeLeaderboard: true,
+        nativeLeaderboard: false,
         achievements: false,
         cloudSave: true,
         socialShare: false,
@@ -320,7 +240,9 @@ async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse
       });
 
     case 'leaderboard.submitScore':
-      return submitLeaderboardScore(input);
+      return ok(input, {
+        submitted: false,
+      });
 
     case 'storage.load':
       return loadStorage(input);
@@ -337,48 +259,6 @@ async function handleBridgeRequest(input: BridgeRequest): Promise<BridgeResponse
   }
 }
 
-async function submitLeaderboardScore(input: BridgeRequest): Promise<BridgeResponse> {
-  const payload = optionalObjectPayload(input.payload) as {
-    readonly leaderboardId?: unknown;
-    readonly score?: unknown;
-  };
-  const leaderboardId = leaderboardIdFromPayload(input, payload.leaderboardId);
-  const playerId = currentPlayerId();
-
-  if (typeof leaderboardId !== 'string') {
-    return leaderboardId;
-  }
-
-  if (typeof payload.score !== 'number' || !Number.isFinite(payload.score)) {
-    return createBridgeError(
-      input.id,
-      'INVALID_LEADERBOARD_SCORE',
-      'Finite leaderboard score is required.',
-    );
-  }
-
-  if (playerId === undefined) {
-    return ok(input, {
-      submitted: false,
-    });
-  }
-
-  const redisKey = leaderboardKey(leaderboardId);
-  let scoreUpdate: 'updated' | 'unchanged' | 'failed';
-
-  try {
-    scoreUpdate = await submitMaxLeaderboardScore(redisKey, playerId, payload.score);
-  } catch (error) {
-    console.warn(`devvit leaderboard score submission failed: ${errorMessage(error)}`);
-    scoreUpdate = 'failed';
-  }
-
-  return ok(input, {
-    submitted: scoreUpdate !== 'failed',
-    highScoreUpdated: scoreUpdate === 'updated',
-  });
-}
-
 async function loadStorage(input: BridgeRequest): Promise<BridgeResponse> {
   const playerId = currentPlayerId();
 
@@ -467,179 +347,6 @@ function storageKey(input: BridgeRequest, playerId: string): string | BridgeResp
   return `${gameName}:save:${encodeURIComponent(playerId)}:${encodedKey}`;
 }
 
-function leaderboardIdFromPayload(
-  input: BridgeRequest,
-  value: unknown,
-): string | BridgeResponse {
-  if (value === undefined) {
-    return 'default';
-  }
-
-  if (typeof value !== 'string' || !isValidRedisKeyComponent(value)) {
-    return createBridgeError(
-      input.id,
-      'INVALID_LEADERBOARD_ID',
-      'Leaderboard id format is invalid.',
-    );
-  }
-
-  return value;
-}
-
-function leaderboardKey(leaderboardId: string): string {
-  return `${gameName}:leaderboard:${encodeURIComponent(leaderboardId)}`;
-}
-
-async function submitMaxLeaderboardScore(
-  redisKey: string,
-  playerId: string,
-  score: number,
-): Promise<'updated' | 'unchanged' | 'failed'> {
-  const lockKey = leaderboardLockKey(redisKey, playerId);
-  const startedAt = Date.now();
-  let attempt = 0;
-
-  while (Date.now() - startedAt <= leaderboardLockRetryBudgetMs) {
-    const lockToken = createLockToken();
-    const acquiredLock = await acquireLeaderboardLock(lockKey, lockToken);
-
-    if (!acquiredLock) {
-      await delay(nextLeaderboardRetryDelay(attempt, startedAt));
-      attempt += 1;
-      continue;
-    }
-
-    try {
-      const currentScore = await redis.zScore(redisKey, playerId);
-
-      if (currentScore !== undefined && score <= currentScore) {
-        return 'unchanged';
-      }
-
-      if (await writeLeaderboardScoreIfLockHeld(lockKey, lockToken, redisKey, playerId, score)) {
-        return 'updated';
-      }
-
-      await delay(nextLeaderboardRetryDelay(attempt, startedAt));
-      attempt += 1;
-    } finally {
-      try {
-        await releaseLeaderboardLock(lockKey, lockToken);
-      } catch (error) {
-        console.warn(`devvit leaderboard lock release failed: ${errorMessage(error)}`);
-      }
-    }
-  }
-
-  console.warn(`devvit leaderboard lock contention exceeded retry budget for key: ${lockKey}`);
-
-  return 'failed';
-}
-
-function leaderboardLockKey(redisKey: string, playerId: string): string {
-  return `${redisKey}:lock:${encodeURIComponent(playerId)}`;
-}
-
-function createLockToken(): string {
-  const cryptoImpl = globalThis.crypto;
-
-  if (typeof cryptoImpl?.randomUUID === 'function') {
-    return cryptoImpl.randomUUID();
-  }
-
-  if (typeof cryptoImpl?.getRandomValues === 'function') {
-    const values = new Uint32Array(4);
-    cryptoImpl.getRandomValues(values);
-
-    return Array.from(values, (value) => value.toString(36).padStart(7, '0')).join('');
-  }
-
-  throw new Error('Web Crypto is required to create a Devvit leaderboard lock token.');
-}
-
-async function acquireLeaderboardLock(lockKey: string, lockToken: string): Promise<boolean> {
-  const result = await redis.set(lockKey, lockToken, {
-    nx: true,
-    expiration: leaderboardLockExpirationDate(),
-  });
-
-  return result === 'OK';
-}
-
-function leaderboardLockExpirationDate(): Date {
-  // Devvit Redis SetOptions expects a Date and converts it to Redis EX seconds internally.
-  return new Date(Date.now() + leaderboardLockTtlMs);
-}
-
-async function writeLeaderboardScoreIfLockHeld(
-  lockKey: string,
-  lockToken: string,
-  redisKey: string,
-  playerId: string,
-  score: number,
-): Promise<boolean> {
-  const transaction = await redis.watch(lockKey);
-  const currentToken = await redis.get(lockKey);
-
-  if (currentToken !== lockToken) {
-    await transaction.unwatch();
-    return false;
-  }
-
-  await transaction.multi();
-  await transaction.zAdd(redisKey, {
-    member: playerId,
-    score,
-  });
-
-  const results = await transaction.exec();
-
-  return Array.isArray(results) && results.length > 0;
-}
-
-async function releaseLeaderboardLock(lockKey: string, lockToken: string): Promise<void> {
-  for (let attempt = 0; attempt < leaderboardUpdateMaxAttempts; attempt += 1) {
-    const transaction = await redis.watch(lockKey);
-    const currentToken = await redis.get(lockKey);
-
-    if (currentToken !== lockToken) {
-      await transaction.unwatch();
-      return;
-    }
-
-    await transaction.multi();
-    await transaction.del(lockKey);
-
-    const results = await transaction.exec();
-
-    if (Array.isArray(results) && results.length > 0) {
-      return;
-    }
-
-    await delay(leaderboardBackoffBaseMs * (attempt + 1));
-  }
-
-  console.warn(`devvit leaderboard lock release exhausted retries for key: ${lockKey}`);
-}
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-function nextLeaderboardRetryDelay(attempt: number, startedAt: number): number {
-  const elapsed = Date.now() - startedAt;
-  const remaining = Math.max(0, leaderboardLockRetryBudgetMs - elapsed);
-  const backoff = leaderboardBackoffBaseMs * (attempt + 1);
-
-  return Math.min(backoff, remaining);
-}
-
-function isValidRedisKeyComponent(value: string): boolean {
-  return redisKeyComponentPattern.test(value);
-}
-
 function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
@@ -690,38 +397,6 @@ function requestPathname(request: IncomingMessage): string {
 
 class RequestBodyTooLargeError extends Error {}
 
-function describeLegacyBridgeBodyError(error: unknown): {
-  readonly status: number;
-  readonly code: string;
-  readonly message: string;
-  readonly retryable: boolean;
-} {
-  if (error instanceof RequestBodyTooLargeError) {
-    return {
-      status: 413,
-      code: 'BRIDGE_REQUEST_TOO_LARGE',
-      message: 'Bridge request body is too large.',
-      retryable: false,
-    };
-  }
-
-  if (error instanceof SyntaxError) {
-    return {
-      status: 400,
-      code: 'INVALID_BRIDGE_REQUEST',
-      message: 'Bridge request body is not valid JSON.',
-      retryable: false,
-    };
-  }
-
-  return {
-    status: 500,
-    code: 'DEVVIT_BRIDGE_INTERNAL_ERROR',
-    message: 'Bridge request body could not be read.',
-    retryable: true,
-  };
-}
-
 async function* readRequestBodyChunks(
   request: IncomingMessage,
   maxBodySize: number,
@@ -751,19 +426,6 @@ async function drainRequestBody(
   }
 }
 
-async function readJsonRequestBody(
-  request: IncomingMessage,
-  maxBodySize: number,
-): Promise<unknown> {
-  const chunks: Buffer[] = [];
-
-  for await (const chunk of readRequestBodyChunks(request, maxBodySize)) {
-    chunks.push(chunk);
-  }
-
-  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-}
-
 function assertContentLengthWithinLimit(
   request: IncomingMessage,
   maxBodySize: number,
@@ -787,15 +449,6 @@ function discardOversizedRequestBody(
   request.resume();
 }
 
-function requestIdFromBody(input: unknown): string {
-  if (typeof input !== 'object' || input === null || !('id' in input)) {
-    return 'unknown';
-  }
-
-  const id = (input as { readonly id?: unknown }).id;
-  return typeof id === 'string' && id.length > 0 ? id : 'unknown';
-}
-
 function setResponseSecurityHeaders(response: ServerResponse): void {
   response.setHeader('cache-control', 'no-store');
   response.setHeader('content-security-policy', "default-src 'none'; frame-ancestors 'none'");

package/templates/phaser-game/apps/target-devvit/src/server/postOperationStore.ts

@@ -1,9 +1,9 @@
 import { redis } from '@devvit/web/server';
 import {
   createDevvitRedisPostOperationStore,
-  type DevvitDurableOperationStore,
+  type DevvitIndexedDurableOperationStore,
 } from '@mpgd/adapter-devvit/server';
 
-export function createPostOperationStore(): DevvitDurableOperationStore {
+export function createPostOperationStore(): DevvitIndexedDurableOperationStore {
   return createDevvitRedisPostOperationStore(redis);
 }

package/templates/phaser-game/mpgd.game.json

@@ -4,5 +4,47 @@
       "source": "public/icon.svg",
       "backgroundColor": "#0f172a"
     }
+  },
+  "acceptance": {
+    "gameplay": {
+      "schemaVersion": 1,
+      "states": [
+        {
+          "id": "launch-ready",
+          "label": "Launch ready",
+          "expectation": "The lobby is rendered and ready for primary input.",
+          "actions": [
+            {
+              "type": "wait",
+              "durationMs": 500
+            }
+          ]
+        },
+        {
+          "id": "primary-input",
+          "label": "Primary input",
+          "expectation": "The game enters its playable state after primary input.",
+          "actions": [
+            {
+              "type": "tap",
+              "x": 0.5,
+              "y": 0.72
+            }
+          ]
+        },
+        {
+          "id": "resume-session",
+          "label": "Resume session",
+          "expectation": "The active game session remains healthy after pause and resume.",
+          "actions": [
+            {
+              "type": "pause-resume",
+              "backgroundMs": 1000,
+              "expectSameSession": true
+            }
+          ]
+        }
+      ]
+    }
   }
 }

package/templates/phaser-game/mpgd.targets.json

@@ -43,7 +43,6 @@
     },
     "reddit": {
       "kind": "devvit-web",
-      "buildStrategy": "devvit-vite",
       "gameApp": ".",
       "wrapperApp": "apps/target-devvit",
       "adapter": "devvit",

package/templates/phaser-game/src/main.ts

@@ -76,6 +76,8 @@ async function bootstrap(): Promise<void> {
 
     createStarterGame({
       mountId: 'game',
+      preserveBrowserTouchGestures:
+        document.body.dataset.mpgdPreserveBrowserTouchGestures === 'true',
       context: {
         platform,
         runtime,

package/templates/phaser-game/src/platform/devvitEntrypoint.ts

@@ -1,57 +1,132 @@
 import {
   requestDevvitExpandedMode,
-  startDevvitWebSurface,
+  startDevvitWebView,
+  type DevvitInlineModeContext,
 } from '@mpgd/adapter-devvit/web';
 
-await startDevvitWebSurface({
-  async mountInlinePreview() {
-    await import('./devvitInlinePreview.css');
-    renderInlinePreview();
+await startDevvitWebView({
+  async mountInlineMode(context) {
+    await import('./devvitInlineMode.css');
+    renderInlineLaunchScreen(context);
   },
-  async loadExpandedGame() {
+  async loadGameplay() {
     await import('../main');
   },
   onModeUnavailable(error) {
     if (!(error instanceof ReferenceError)) {
-      console.warn('[devvit] web view mode unavailable; loading the game surface.', error);
+      console.warn('[devvit] web view mode unavailable; loading gameplay.', error);
     }
   },
 });
 
-function renderInlinePreview(): void {
-  const preview = document.createElement('main');
-  preview.className = 'devvit-preview';
+function renderInlineLaunchScreen(
+  context: DevvitInlineModeContext,
+  errorMessage?: string,
+): void {
+  const launchScreen = document.createElement('main');
+  launchScreen.className = 'devvit-launch-screen';
 
   const eyebrow = document.createElement('p');
-  eyebrow.className = 'devvit-preview__eyebrow';
-  eyebrow.textContent = 'Ready to play';
+  eyebrow.className = 'devvit-launch-screen__eyebrow';
+  eyebrow.textContent = 'Inline mode';
 
   const title = document.createElement('h1');
   title.textContent = '__GAME_TITLE__';
 
   const description = document.createElement('p');
-  description.className = 'devvit-preview__description';
-  description.textContent = 'Open the expanded view to start the game.';
-
-  const button = document.createElement('button');
-  button.className = 'devvit-preview__button';
-  button.type = 'button';
-  button.textContent = 'Play';
-  button.addEventListener('click', async (event) => {
-    try {
-      await requestDevvitExpandedMode(event, 'game');
-    } catch (error) {
-      console.error('[devvit] expanded game surface request failed.', error);
-    }
+  description.className = 'devvit-launch-screen__description';
+  description.textContent = 'Play directly in the post or open expanded mode.';
+
+  const actions = document.createElement('div');
+  actions.className = 'devvit-launch-screen__actions';
+
+  const playInlineButton = document.createElement('button');
+  playInlineButton.className = 'devvit-launch-screen__button';
+  playInlineButton.type = 'button';
+  playInlineButton.textContent = 'Play here';
+
+  const expandButton = document.createElement('button');
+  expandButton.className =
+    'devvit-launch-screen__button devvit-launch-screen__button--secondary';
+  expandButton.type = 'button';
+  expandButton.textContent = 'Open expanded mode';
+
+  const status = document.createElement('p');
+  status.className = 'devvit-launch-screen__status';
+  status.setAttribute('aria-live', 'polite');
+  status.textContent = errorMessage ?? '';
+
+  playInlineButton.addEventListener('click', () => {
+    setBusy(true, 'Loading gameplay…');
+    const loading = mountGameplayDocument();
+
+    void context.startGameplay()
+      .then(() => {
+        loading.remove();
+      })
+      .catch((error: unknown) => {
+        console.error('[devvit] inline mode gameplay failed to load.', error);
+        renderInlineLaunchScreen(context, 'Gameplay could not start. Try again.');
+      });
   });
+  expandButton.addEventListener('click', (event) => {
+    setBusy(true, 'Opening expanded mode…');
+
+    void requestDevvitExpandedMode(event, 'game')
+      .then(() => {
+        setBusy(false, '');
+      })
+      .catch((error: unknown) => {
+        console.error('[devvit] expanded mode request failed.', error);
+        setBusy(false, 'Expanded mode is unavailable. Try again.');
+      });
+  });
+
+  actions.append(playInlineButton, expandButton);
+  launchScreen.append(eyebrow, title, description, actions, status);
+  const body = requireDocumentBody();
+
+  body.classList.remove('devvit-inline-mode-gameplay');
+  body.classList.add('devvit-inline-mode-host');
+  delete body.dataset.mpgdPreserveBrowserTouchGestures;
+  body.replaceChildren(launchScreen);
+
+  function setBusy(busy: boolean, message: string): void {
+    playInlineButton.disabled = busy;
+    expandButton.disabled = busy;
+    status.textContent = message;
+  }
+}
+
+function mountGameplayDocument(): HTMLElement {
+  const body = requireDocumentBody();
+  const app = document.createElement('main');
+  const game = document.createElement('div');
+  const loading = document.createElement('p');
+
+  app.id = 'app';
+  game.id = 'game';
+  loading.className = 'devvit-inline-gameplay-loading';
+  loading.setAttribute('aria-live', 'polite');
+  loading.setAttribute('role', 'status');
+  loading.textContent = 'Loading gameplay…';
+  game.append(loading);
+  app.append(game);
+
+  body.classList.remove('devvit-inline-mode-host');
+  body.classList.add('devvit-inline-mode-gameplay');
+  body.dataset.mpgdPreserveBrowserTouchGestures = 'true';
+  body.replaceChildren(app);
+
+  return loading;
+}
 
-  preview.append(eyebrow, title, description, button);
+function requireDocumentBody(): HTMLElement {
   const body = document.body;
 
   if (body === null) {
-    throw new Error('Devvit inline preview requires a document body.');
+    throw new Error('Devvit inline mode requires a document body.');
   }
 
-  body.classList.add('devvit-preview-host');
-  body.replaceChildren(preview);
+  return body;
 }