@mpgd/cli 0.9.0 → 0.10.1

package/dist/index.js

@@ -7,7 +7,9 @@ import i18n, { defineI18n } from '@gunshi/plugin-i18n';
 import resources from '@gunshi/resources';
 import { cli } from 'gunshi';
 import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, } from './game-acceptance.js';
-export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, } from './game-acceptance.js';
+import { resolveGameplayE2EReportFile } from './gameplay-e2e.js';
+export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, maximumGameplayE2EReportBytes, } from './game-acceptance.js';
+export { collectGameplayE2EPathEvidence, defaultGameplayE2EReportFile, maximumGameplayE2EStates, parseGameplayE2EPlan, readGameplayE2EPlan, renderGameplayE2EMarkdown, resolveGameplayE2EReportFile, runGameplayE2E, } from './gameplay-e2e.js';
 export { assertProductionTargetReadiness, } from './production-target-readiness.js';
 const sourceDir = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolvePackageRoot(sourceDir);
@@ -61,6 +63,7 @@ const acceptanceStepIds = {
     playtest: 'playtest',
     targetBuild: 'target-build',
     targetSmoke: 'target-smoke',
+    gameplayE2E: 'gameplay-e2e',
 };
 export async function runMpgdCli(args) {
     await cli([...args], entryCommand, {
@@ -227,8 +230,8 @@ const gameCommand = defineI18n({
             name: 'accept',
             description: 'Run the reusable game handoff acceptance workflow.',
             resource: commandResource({
-                en: 'Run check, test, build, graph, playtest, and target acceptance with handoff reports.',
-                ko: 'check, test, build, graph, playtest, 타깃 인수 검증과 인계 리포트를 실행합니다.',
+                en: 'Run check, test, build, graph, playtest, target, and gameplay acceptance with handoff reports.',
+                ko: 'check, test, build, graph, playtest, 타깃 및 gameplay 인수 검증과 인계 리포트를 실행합니다.',
             }, {
                 game: {
                     en: 'Game root containing package.json and mpgd.targets.json.',
@@ -246,6 +249,10 @@ const gameCommand = defineI18n({
                     en: 'Optional game-owned package script used for automated playtesting.',
                     ko: '자동 플레이테스트에 사용할 선택적 게임 소유 패키지 스크립트.',
                 },
+                'gameplay-script': {
+                    en: 'Optional game-owned package script used for target gameplay E2E.',
+                    ko: '타깃 gameplay E2E에 사용할 선택적 게임 소유 패키지 스크립트.',
+                },
                 'report-dir': {
                     en: 'JSON and Markdown handoff report directory.',
                     ko: 'JSON 및 Markdown 인계 리포트 디렉터리.',
@@ -296,6 +303,12 @@ const gameCommand = defineI18n({
                     default: 'playtest',
                     description: 'Game-owned package script used for automated playtesting.',
                 },
+                'gameplay-script': {
+                    type: 'string',
+                    required: false,
+                    default: 'gameplay:e2e',
+                    description: 'Game-owned package script used for target gameplay E2E.',
+                },
                 'report-dir': {
                     type: 'string',
                     required: false,
@@ -327,6 +340,11 @@ const gameCommand = defineI18n({
                     required: false,
                     description: 'Skip the game-owned playtest package script.',
                 },
+                'skip-gameplay-e2e': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Skip the game-owned target gameplay E2E package script.',
+                },
                 'skip-target-build': {
                     type: 'boolean',
                     required: false,
@@ -353,12 +371,14 @@ const gameCommand = defineI18n({
                     aitVariant: readOptionalString(ctx.values['ait-variant']) ?? 'wrapper',
                     ...(iosVariant === undefined ? {} : { iosVariant }),
                     playtestScript: readOptionalString(ctx.values['playtest-script']) ?? 'playtest',
+                    gameplayScript: readOptionalString(ctx.values['gameplay-script']) ?? 'gameplay:e2e',
                     ...(reportDir === undefined ? {} : { reportDir }),
                     ...(kitPath === undefined ? {} : { kitPath }),
                     timeoutMs,
                     skipTest: ctx.values['skip-test'] === true,
                     skipGraph: ctx.values['skip-graph'] === true,
                     skipPlaytest: ctx.values['skip-playtest'] === true,
+                    skipGameplayE2E: ctx.values['skip-gameplay-e2e'] === true,
                     skipTargetBuild: ctx.values['skip-target-build'] === true,
                     skipTargetSmoke: ctx.values['skip-target-smoke'] === true,
                 });
@@ -445,6 +465,14 @@ function acceptGame(input) {
         ...(input.kitPath === undefined ? {} : { 'kit-path': input.kitPath }),
     });
     const packageManager = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
+    const gameplayE2EEnabled = !input.skipGameplayE2E
+        && gamePackage.scripts?.[input.gameplayScript] !== undefined;
+    const gameplayE2ETargets = gameplayE2EEnabled
+        ? parseTargetList(input.targets, {
+            ...process.env,
+            MPGD_PLATFORM_TARGETS_FILE: targetsFile,
+        })
+        : [];
     const steps = [
         packageScriptAcceptanceStep({
             id: acceptanceStepIds.check,
@@ -519,24 +547,45 @@ function acceptGame(input) {
             ...(input.iosVariant === undefined ? {} : { iosVariant: input.iosVariant }),
             skipped: input.skipTargetSmoke,
         }),
+        packageScriptAcceptanceStep({
+            id: acceptanceStepIds.gameplayE2E,
+            label: 'Target gameplay E2E',
+            script: input.gameplayScript,
+            gameRoot,
+            packageManager,
+            scripts: gamePackage.scripts,
+            required: false,
+            skipped: input.skipGameplayE2E,
+        }),
     ];
     const reportDir = path.resolve(gameRoot, input.reportDir ?? 'artifacts/acceptance');
     const releaseManifestFile = resolveGameAcceptanceReleaseManifestFile(gameRoot);
+    const gameplayE2EReportFile = resolveGameplayE2EReportFile(gameRoot);
     const result = runGameAcceptance({
         gameRoot,
         reportDir,
         ...(input.skipTargetBuild
             ? {}
             : { releaseManifestFile }),
+        ...(gameplayE2EEnabled
+            ? {
+                gameplayE2EReportFile,
+                requireGameplayE2EReport: true,
+                gameplayE2EStepId: acceptanceStepIds.gameplayE2E,
+                gameplayE2ETargets,
+            }
+            : {}),
         options: {
             targets: input.targets,
             profile: input.profile,
             aitVariant: input.aitVariant,
             iosVariant: input.iosVariant ?? null,
             playtestScript: input.playtestScript,
+            gameplayScript: input.gameplayScript,
             skipTest: input.skipTest,
             skipGraph: input.skipGraph,
             skipPlaytest: input.skipPlaytest,
+            skipGameplayE2E: input.skipGameplayE2E,
             skipTargetBuild: input.skipTargetBuild,
             skipTargetSmoke: input.skipTargetSmoke,
             timeoutMs: String(input.timeoutMs),
@@ -546,7 +595,12 @@ function acceptGame(input) {
         env: {
             ...process.env,
             MPGD_KIT_PATH: kitPath,
+            MPGD_ACCEPTANCE_TARGETS: gameplayE2EEnabled
+                ? gameplayE2ETargets.join(',')
+                : input.targets,
+            MPGD_ACCEPTANCE_PROFILE: input.profile,
             MPGD_RELEASE_MANIFEST_FILE: releaseManifestFile,
+            MPGD_GAMEPLAY_E2E_REPORT_FILE: gameplayE2EReportFile,
         },
     });
     if (result.report.status === 'failed') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.9.0",
+  "version": "0.10.1",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -49,18 +49,18 @@
     "@types/node": "^24.0.0",
     "ttsc": "0.18.4",
     "typescript": "7.0.2",
-    "@mpgd/adapter-ait": "0.4.2",
-    "@mpgd/adapter-browser": "0.4.2",
-    "@mpgd/analytics": "0.3.5",
-    "@mpgd/adapter-capacitor": "0.4.2",
-    "@mpgd/adapter-devvit": "0.7.0",
+    "@mpgd/adapter-ait": "0.4.3",
+    "@mpgd/adapter-browser": "0.4.3",
+    "@mpgd/adapter-capacitor": "0.4.3",
+    "@mpgd/adapter-devvit": "0.8.1",
+    "@mpgd/analytics": "0.3.6",
     "@mpgd/bridge": "0.6.0",
-    "@mpgd/catalog": "0.3.5",
-    "@mpgd/game-services": "0.7.0",
+    "@mpgd/catalog": "0.4.0",
+    "@mpgd/game-services": "0.8.1",
+    "@mpgd/platform": "0.6.0",
+    "@mpgd/i18n": "0.5.2",
     "@mpgd/phaser-assets": "0.4.1",
-    "@mpgd/i18n": "0.5.1",
-    "@mpgd/platform": "0.5.1",
-    "@mpgd/target-config": "0.6.1"
+    "@mpgd/target-config": "0.7.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/templates/phaser-game/README.md

@@ -82,11 +82,15 @@ pnpm accept
 ```
 
 The command runs `check`, an optional `test` script, `build`, the kit's ttsc
-graph preflight, an optional game-owned `playtest` script, and the configured
-target build/smoke matrix. Results are written as JSON and Markdown under
-`artifacts/acceptance`. Add a non-interactive `playtest` package script when the
-game has an automated browser scenario; interactive platform playtests remain
-separate operator workflows.
+graph preflight, an optional game-owned browser `playtest` script, the configured
+target build/smoke matrix, and an optional target `gameplay:e2e` script. Results
+are written as JSON and Markdown under `artifacts/acceptance`. Add a
+non-interactive `playtest` script for a browser scenario. Add `gameplay:e2e` only
+after this game has a real target automation and state-inspection driver; the
+manifest plan in `mpgd.game.json` is reusable, but the driver remains
+game-owned. The kit validates and attaches its hashed artifact, release
+manifest, screenshots, and pause/resume session evidence. See
+`docs/GAMEPLAY_E2E.md` in the mpgd-kit repository for the driver contract.
 Each command has a 30-minute timeout by default. Pass `--timeout-ms` to the
 underlying `mpgd game accept` command when a target matrix needs a different
 per-step limit.
@@ -173,11 +177,12 @@ The generated `devvit.json` app name is a Devvit-safe slug derived from the game
 directory name; edit it before `devvit:init` if you need a different Reddit app
 name.
 
-The default post entry builds a lightweight inline preview without importing
-Phaser. Its Play button requests the separate `game` entrypoint, whose
+The default post entry builds a lightweight inline mode launch screen without
+importing Phaser eagerly. Play here loads gameplay inside the post only after a
+user click; Open expanded mode requests the separate `game` entrypoint, whose
 `game.html` document starts the Phaser bundle directly. Keep these physical
-entries separate when customizing the preview so Reddit cards do not pay the
-game runtime cost before expansion.
+entries separate so feed cards meet Devvit's inline mode performance and
+gesture requirements while still supporting playable posts.
 
 First-time Devvit setup:
 

package/templates/phaser-game/agent/acceptance.md

@@ -8,11 +8,15 @@ pnpm icons:verify
 pnpm accept
 ```
 
-`pnpm accept` runs the configured game check, optional test and playtest scripts,
-game build, kit TypeScript graph preflight, and the reusable target build/smoke
-matrix. It writes `artifacts/acceptance/acceptance-report.json` and
-`acceptance-report.md` for handoff. Missing optional `test` or `playtest` scripts
-are recorded as skipped; check and build remain required.
+`pnpm accept` runs the configured game check, optional test and browser playtest
+scripts, game build, kit TypeScript graph preflight, the reusable target
+build/smoke matrix, and an optional `gameplay:e2e` target script. It writes
+`artifacts/acceptance/acceptance-report.json` and `acceptance-report.md` for
+handoff. Missing optional `test`, `playtest`, or `gameplay:e2e` scripts are
+recorded as skipped; check and build remain required. When `gameplay:e2e`
+exists, it must execute the `mpgd.game.json` acceptance states through a
+game-owned driver and write the standard hashed report requested by
+`MPGD_GAMEPLAY_E2E_REPORT_FILE`.
 
 For Apps in Toss changes, use the apps-in-toss MCP before implementation and
 keep SDK calls inside adapters or target wrappers.
@@ -23,8 +27,10 @@ For Reddit Devvit changes, keep Devvit SDK calls inside the adapter or target wr
 continue to expose game-facing behavior through `PlatformGateway`. The Devvit
 app root is game-owned in `apps/target-devvit`; run `pnpm devvit:init` once
 after login before upload or playtest.
-Verify the default post entry renders only the lightweight inline preview and
-the `game` entry opens the separate expanded Phaser document.
+Verify the default post entry renders a lightweight inline mode launch screen,
+Play here starts gameplay inside the post, and the `game` entry opens the
+separate expanded mode Phaser document. Inline gameplay must remain tap/click
+only and must not trap feed scrolling.
 
 For Microsoft Store changes, keep the first pass as a PWA/web target that uses
 the browser adapter. Add a dedicated Store commerce adapter only when wiring

package/templates/phaser-game/agent/game-manifest.json

@@ -38,7 +38,7 @@
       "owner": "apps/target-devvit"
     },
     {
-      "id": "platform.devvit.surface-split",
+      "id": "platform.devvit.view-modes",
       "owner": "src/platform/devvitEntrypoint.ts"
     },
     {

package/templates/phaser-game/apps/target-devvit/README.md

@@ -41,10 +41,18 @@ replace the `devvit.json` scheduler endpoint and should not use process-local
 memory when delivery must cross instances. The generated target exposes only
 the oRPC bridge route; the former JSON compatibility route is not generated.
 
-The default post entry uses `index.html` for a lightweight inline preview. Its
-Play button requests the `game` entrypoint, which loads the separate
-`game.html` Phaser document. Keep inline UI free of game runtime imports so the
-card remains lightweight before expansion.
+The default post entry uses `index.html` for a lightweight inline mode launch
+screen. Play here loads Phaser inside the post after a user click. Open expanded
+mode requests the `game` entrypoint, which loads the separate `game.html`
+document. Keep launch UI free of eager game runtime imports, and keep inline
+gameplay tap/click only so the post does not trap feed scrolling.
+
+The generated bridge does not advertise or accept a generic platform
+leaderboard. Devvit ranking should be owned by a server completion handler that
+validates the game-specific attempt, records it through the verified leaderboard
+provider from `@mpgd/adapter-devvit/server`, and exposes only an authenticated
+game-scoped snapshot route. Do not enable `nativeLeaderboard` or trust a raw
+client score submission for that flow.
 
 `devvit playtest` runs the official unified Vite build in watch mode, so a
 separate client/server watcher or staging prebuild is not required.
@@ -66,6 +74,12 @@ explicit recovery endpoint or scheduler calls `reconcile`, which requires an exa
 match of the full canonical envelope. A missing match from a bounded listing
 remains unresolved rather than restoring submit permission.
 
+The generated Redis wrapper implements `DevvitIndexedDurableOperationStore`.
+Use `listPending()` with a small limit and its scope-bound continuation cursor to
+discover prepared, attempted, and terminal work without scanning Redis keys.
+Listing is read-only; prepared work still requires an explicit `execute` decision,
+attempted work must use `reconcile`, and terminal ambiguity remains fail-closed.
+
 Keep operation definitions and `@devvit/web/server` imports inside this target
 app. The canonical `{ mpgd, launch, payload }` envelope is public and untrusted;
 keep private content and authoritative records in server-side storage. Exercise

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

@@ -13,15 +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_048_576;
-const leaderboardUpdateMaxAttempts = 3;
-const leaderboardBackoffBaseMs = 25;
-const leaderboardLockTtlMs = 2_000;
-const leaderboardLockTtlSeconds = Math.ceil(leaderboardLockTtlMs / 1_000);
-const leaderboardLockRetryBudgetMs = leaderboardLockTtlSeconds * 1_000;
 const gameName = '__GAME_NAME__';
 const gameTitle = __GAME_TITLE_TS_LITERAL__;
 const bridgeRpcHandler = createBridgeRpcNodeHandler(
@@ -143,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,
@@ -246,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);
@@ -263,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();
 
@@ -393,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);
 }

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/src/main.ts

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