@mpgd/cli 0.10.1 → 0.12.0

package/dist/browser-gameplay-e2e.d.ts

@@ -0,0 +1,40 @@
+import type { GameplayE2EDriver, GameplayE2EObservation, GameplayE2EState } from './gameplay-e2e.js';
+export interface BrowserGameplayE2EViewport {
+  readonly width: number;
+  readonly height: number;
+}
+export interface BrowserGameplayE2EScreenshotOptions {
+  readonly path: string;
+  readonly type: 'png';
+}
+/**
+* The minimal Playwright-compatible page surface used by the browser driver.
+* Consumers keep Playwright and browser credentials in their own test harness.
+*/
+export interface BrowserGameplayE2EPage {
+  viewportSize(): BrowserGameplayE2EViewport | null;
+  readonly mouse: {
+    click(x: number, y: number): Promise<unknown>;
+  };
+  readonly keyboard: {
+    press(key: string): Promise<unknown>;
+  };
+  waitForTimeout(durationMs: number): Promise<unknown>;
+  screenshot(options: BrowserGameplayE2EScreenshotOptions): Promise<unknown>;
+}
+export interface BrowserGameplayE2EInspectInput<TPage extends BrowserGameplayE2EPage = BrowserGameplayE2EPage> {
+  readonly page: TPage;
+  readonly state: GameplayE2EState;
+  readonly phase: 'after' | 'before' | 'resumed';
+}
+export interface CreateBrowserGameplayE2EDriverInput<TPage extends BrowserGameplayE2EPage = BrowserGameplayE2EPage> {
+  readonly page: TPage;
+  readonly pause: (page: TPage) => Promise<void>;
+  readonly resume: (page: TPage) => Promise<void>;
+  readonly inspect: (input: BrowserGameplayE2EInspectInput<TPage>) => Promise<GameplayE2EObservation>;
+}
+/**
+* Creates a browser driver for generic input and screenshot operations while
+* leaving lifecycle orchestration and game-state inspection with the game.
+*/
+export declare function createBrowserGameplayE2EDriver<TPage extends BrowserGameplayE2EPage>(input: CreateBrowserGameplayE2EDriverInput<TPage>): GameplayE2EDriver;

package/dist/browser-gameplay-e2e.js

@@ -0,0 +1,54 @@
+/**
+ * Creates a browser driver for generic input and screenshot operations while
+ * leaving lifecycle orchestration and game-state inspection with the game.
+ */
+export function createBrowserGameplayE2EDriver(input) {
+    return {
+        perform: async (action) => {
+            switch (action.type) {
+                case 'tap': {
+                    const viewport = readBrowserGameplayE2EViewport(input.page);
+                    const x = resolveBrowserGameplayE2ETapCoordinate(action.x, viewport.width, 'x');
+                    const y = resolveBrowserGameplayE2ETapCoordinate(action.y, viewport.height, 'y');
+                    await input.page.mouse.click(x, y);
+                    return;
+                }
+                case 'key':
+                    await input.page.keyboard.press(action.key);
+                    return;
+                case 'wait':
+                    await input.page.waitForTimeout(action.durationMs);
+                    return;
+                default: {
+                    const unsupportedAction = action;
+                    throw new Error(`Unsupported browser Gameplay E2E action: ${String(unsupportedAction)}`);
+                }
+            }
+        },
+        pause: () => input.pause(input.page),
+        resume: () => input.resume(input.page),
+        inspect: ({ state, phase }) => input.inspect({ page: input.page, state, phase }),
+        captureScreenshot: async ({ file }) => {
+            await input.page.screenshot({ path: file, type: 'png' });
+        },
+    };
+}
+function readBrowserGameplayE2EViewport(page) {
+    const viewport = page.viewportSize();
+    if (viewport === null) {
+        throw new Error('Browser Gameplay E2E taps require a configured page viewport.');
+    }
+    if (!Number.isSafeInteger(viewport.width)
+        || viewport.width <= 0
+        || !Number.isSafeInteger(viewport.height)
+        || viewport.height <= 0) {
+        throw new Error('Browser Gameplay E2E viewport dimensions must be positive safe integers.');
+    }
+    return viewport;
+}
+function resolveBrowserGameplayE2ETapCoordinate(coordinate, viewportSize, axis) {
+    if (!Number.isFinite(coordinate) || coordinate < 0 || coordinate > 1) {
+        throw new Error(`Browser Gameplay E2E ${axis} tap coordinates must be between 0 and 1.`);
+    }
+    return Math.min(viewportSize - 1, Math.floor(coordinate * viewportSize));
+}

package/dist/evidence-io.d.ts

@@ -0,0 +1,13 @@
+export interface EvidenceReportFilesInput {
+  readonly jsonFile: string;
+  readonly markdownFile: string;
+  readonly report: unknown;
+  readonly markdown: string;
+}
+export declare function writeEvidenceReportFiles(input: EvidenceReportFilesInput): void;
+export declare function readBoundedUtf8File(file: string, maximumBytes: number): string | null;
+export declare function relativeOrAbsolute(root: string, file: string): string;
+export declare function escapeMarkdownTable(value: string): string;
+export declare function escapeMarkdownInline(value: string): string;
+export declare function formatDuration(durationMs: number): string;
+export declare function formatError(error: unknown): string;

package/dist/evidence-io.js

@@ -0,0 +1,45 @@
+import { closeSync, openSync, readSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+export function writeEvidenceReportFiles(input) {
+    writeFileSync(input.jsonFile, `${JSON.stringify(input.report, null, 2)}\n`);
+    writeFileSync(input.markdownFile, input.markdown);
+}
+export function readBoundedUtf8File(file, maximumBytes) {
+    const buffer = Buffer.allocUnsafe(maximumBytes + 1);
+    const fileDescriptor = openSync(file, 'r');
+    let offset = 0;
+    try {
+        while (offset < buffer.length) {
+            const bytesRead = readSync(fileDescriptor, buffer, offset, buffer.length - offset, null);
+            if (bytesRead === 0) {
+                break;
+            }
+            offset += bytesRead;
+        }
+    }
+    finally {
+        closeSync(fileDescriptor);
+    }
+    return offset > maximumBytes ? null : buffer.subarray(0, offset).toString('utf8');
+}
+export function relativeOrAbsolute(root, file) {
+    const relative = path.relative(root, file);
+    return relative.startsWith('..') || path.isAbsolute(relative) ? file : relative || '.';
+}
+export function escapeMarkdownTable(value) {
+    return escapeMarkdownInline(value).replaceAll('|', '\\|');
+}
+export function escapeMarkdownInline(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replace(/([\\`*_\[\]])/gu, '\\$1')
+        .replaceAll('\n', ' ');
+}
+export function formatDuration(durationMs) {
+    return durationMs < 1000 ? `${durationMs}ms` : `${(durationMs / 1000).toFixed(1)}s`;
+}
+export function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/game-acceptance.js

@@ -1,6 +1,7 @@
 import { spawnSync } from 'node:child_process';
-import { closeSync, existsSync, mkdirSync, openSync, readSync, rmSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
 import path from 'node:path';
+import { escapeMarkdownInline, escapeMarkdownTable, formatDuration, formatError, readBoundedUtf8File, relativeOrAbsolute, writeEvidenceReportFiles, } from './evidence-io.js';
 import { collectGameplayE2EPathEvidence, maximumGameplayE2EStates, readGameplayE2EPlan, resolveGameplayE2EPathInsideGameRoot, } from './gameplay-e2e.js';
 export const defaultGameAcceptanceCommandTimeoutMs = 30 * 60 * 1000;
 const defaultGameAcceptanceReleaseManifestFile = 'artifacts/release-manifest.json';
@@ -120,8 +121,12 @@ export function runGameAcceptance(input) {
     const jsonFile = path.join(reportDir, 'acceptance-report.json');
     const markdownFile = path.join(reportDir, 'acceptance-report.md');
     mkdirSync(reportDir, { recursive: true });
-    writeFileSync(jsonFile, `${JSON.stringify(report, null, 2)}\n`);
-    writeFileSync(markdownFile, renderGameAcceptanceMarkdown(report));
+    writeEvidenceReportFiles({
+        jsonFile,
+        markdownFile,
+        report,
+        markdown: renderGameAcceptanceMarkdown(report),
+    });
     return { report, jsonFile, markdownFile };
 }
 export function renderGameAcceptanceMarkdown(report) {
@@ -505,28 +510,6 @@ function validateCurrentPathEvidence(evidence, gameRoot, label) {
         ? null
         : `Gameplay E2E ${label} hash does not match its current contents.`;
 }
-function relativeOrAbsolute(root, file) {
-    const relative = path.relative(root, file);
-    return relative.startsWith('..') || path.isAbsolute(relative) ? file : relative || '.';
-}
-function readBoundedUtf8File(file, maximumBytes) {
-    const buffer = Buffer.allocUnsafe(maximumBytes + 1);
-    const fileDescriptor = openSync(file, 'r');
-    let offset = 0;
-    try {
-        while (offset < buffer.length) {
-            const bytesRead = readSync(fileDescriptor, buffer, offset, buffer.length - offset, null);
-            if (bytesRead === 0) {
-                break;
-            }
-            offset += bytesRead;
-        }
-    }
-    finally {
-        closeSync(fileDescriptor);
-    }
-    return offset > maximumBytes ? null : buffer.subarray(0, offset).toString('utf8');
-}
 function resolveRunnableStep(step) {
     if (step.command === undefined || step.command.length === 0) {
         return { ok: false, detail: `Acceptance step ${step.id} is missing command.` };
@@ -536,23 +519,6 @@ function resolveRunnableStep(step) {
     }
     return { ok: true, command: step.command, cwd: step.cwd };
 }
-function escapeMarkdownTable(value) {
-    return escapeMarkdownInline(value).replaceAll('|', '\\|');
-}
-function escapeMarkdownInline(value) {
-    return value
-        .replaceAll('&', '&amp;')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replace(/([\\`*_[\]])/gu, '\\$1')
-        .replaceAll('\n', ' ');
-}
-function formatDuration(durationMs) {
-    return durationMs < 1000 ? `${durationMs}ms` : `${(durationMs / 1000).toFixed(1)}s`;
-}
-function formatError(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 function isTimeoutError(error) {
     return 'code' in error && error.code === 'ETIMEDOUT';
 }

package/dist/gameplay-e2e.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
-import { closeSync, existsSync, lstatSync, mkdirSync, opendirSync, openSync, readFileSync, readlinkSync, readSync, rmSync, writeFileSync, } from 'node:fs';
+import { closeSync, existsSync, lstatSync, mkdirSync, opendirSync, openSync, readFileSync, readlinkSync, readSync, rmSync, } from 'node:fs';
 import path from 'node:path';
+import { escapeMarkdownInline, escapeMarkdownTable, formatDuration, formatError as formatEvidenceError, relativeOrAbsolute, writeEvidenceReportFiles, } from './evidence-io.js';
 export const defaultGameplayE2EReportFile = 'artifacts/gameplay-e2e/gameplay-e2e-report.json';
 const gameplayStateIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const gameplayKeyControlCharacterPattern = /[\u0000-\u001f\u007f]/u;
@@ -140,8 +141,12 @@ export async function runGameplayE2E(input) {
     // Driver callbacks are untrusted and may have changed output paths while the run was active.
     const verifiedJsonFile = resolveGameplayE2EPathInsideGameRoot(gameRoot, jsonFile, 'Gameplay E2E report');
     const verifiedMarkdownFile = resolveGameplayE2EPathInsideGameRoot(gameRoot, markdownFile, 'Gameplay E2E Markdown report');
-    writeFileSync(verifiedJsonFile, `${JSON.stringify(report, null, 2)}\n`);
-    writeFileSync(verifiedMarkdownFile, renderGameplayE2EMarkdown(report));
+    writeEvidenceReportFiles({
+        jsonFile: verifiedJsonFile,
+        markdownFile: verifiedMarkdownFile,
+        report,
+        markdown: renderGameplayE2EMarkdown(report),
+    });
     return { report, jsonFile: verifiedJsonFile, markdownFile: verifiedMarkdownFile };
 }
 export function renderGameplayE2EMarkdown(report) {
@@ -647,10 +652,6 @@ function readBoundedInteger(value, source, minimum, maximum) {
     }
     return result;
 }
-function relativeOrAbsolute(root, file) {
-    const relative = path.relative(root, file);
-    return relative.startsWith('..') || path.isAbsolute(relative) ? file : relative || '.';
-}
 function replaceFileExtension(file, extension) {
     const currentExtension = path.extname(file);
     return currentExtension.length === 0
@@ -662,23 +663,9 @@ function assertGameplayE2EJsonReportFile(file) {
         throw new Error('Gameplay E2E JSON report file must not use a Markdown extension.');
     }
 }
-function escapeMarkdownTable(value) {
-    return escapeMarkdownInline(value).replaceAll('|', '\\|');
-}
-function escapeMarkdownInline(value) {
-    return value
-        .replaceAll('&', '&')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replace(/([\\`*_[\]])/gu, '\\$1')
-        .replaceAll('\n', ' ');
-}
-function formatDuration(durationMs) {
-    return durationMs < 1000 ? `${durationMs}ms` : `${(durationMs / 1000).toFixed(1)}s`;
-}
 function formatError(error) {
     if (error instanceof GameplayE2EAggregatedError) {
         return `${error.message} ${error.errors.map(formatError).join(' ')}`;
     }
-    return error instanceof Error ? error.message : String(error);
+    return formatEvidenceError(error);
 }

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, maximumGameplayE2EReportBytes, type GameAcceptanceCommandResult, type GameAcceptanceCommandRunner, type GameAcceptanceReport, type GameAcceptanceStatus, type GameAcceptanceStep, type GameAcceptanceStepResult, type GameAcceptanceStepStatus, type RunGameAcceptanceInput, type RunGameAcceptanceResult, } from './game-acceptance.js';
+export { createBrowserGameplayE2EDriver, type BrowserGameplayE2EInspectInput, type BrowserGameplayE2EPage, type BrowserGameplayE2EScreenshotOptions, type BrowserGameplayE2EViewport, type CreateBrowserGameplayE2EDriverInput, } from './browser-gameplay-e2e.js';
 export { collectGameplayE2EPathEvidence, defaultGameplayE2EReportFile, maximumGameplayE2EStates, parseGameplayE2EPlan, readGameplayE2EPlan, renderGameplayE2EMarkdown, resolveGameplayE2EReportFile, runGameplayE2E, type GameplayE2EAction, type GameplayE2EActionResult, type GameplayE2EDriver, type GameplayE2EHashLimits, type GameplayE2EInputAction, type GameplayE2EObservation, type GameplayE2EPauseResumeAction, type GameplayE2EPathEvidence, type GameplayE2EPlan, type GameplayE2EReport, type GameplayE2EResultStatus, type GameplayE2EState, type GameplayE2EStateResult, type GameplayE2EStatus, type RunGameplayE2EInput, type RunGameplayE2EResult, } from './gameplay-e2e.js';
+export { assertMicrosoftStorePwaCacheTransition, assertMicrosoftStorePwaPrecacheUrl, assertMicrosoftStorePwaReleaseEvidence, inspectMicrosoftStorePwaBrowserCacheTransition, microsoftStorePwaCacheSchema, readMicrosoftStorePwaBrowserReleaseEvidence, requestMicrosoftStorePwaBrowserUpdate, resolveMicrosoftStorePwaScopedCacheName, type AssertMicrosoftStorePwaCacheTransitionInput, type InspectMicrosoftStorePwaCacheTransitionInput, type MicrosoftStorePwaBrowserPage, type MicrosoftStorePwaCachedIndexObservation, type MicrosoftStorePwaCacheTransitionEvidence, type MicrosoftStorePwaCacheTransitionObservation, type MicrosoftStorePwaReleaseEvidence, } from './microsoft-store-pwa-e2e.js';
 export { assertProductionTargetReadiness, type ProductionTargetReadinessInput, } from './production-target-readiness.js';
 export declare function runMpgdCli(args: readonly string[]): Promise<void>;
 export declare function runCreateGameCli(args: readonly string[]): Promise<void>;

package/dist/index.js

@@ -9,20 +9,27 @@ import { cli } from 'gunshi';
 import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, } from './game-acceptance.js';
 import { resolveGameplayE2EReportFile } from './gameplay-e2e.js';
 export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, defaultGameAcceptanceCommandTimeoutMs, maximumGameplayE2EReportBytes, } from './game-acceptance.js';
+export { createBrowserGameplayE2EDriver, } from './browser-gameplay-e2e.js';
 export { collectGameplayE2EPathEvidence, defaultGameplayE2EReportFile, maximumGameplayE2EStates, parseGameplayE2EPlan, readGameplayE2EPlan, renderGameplayE2EMarkdown, resolveGameplayE2EReportFile, runGameplayE2E, } from './gameplay-e2e.js';
+export { assertMicrosoftStorePwaCacheTransition, assertMicrosoftStorePwaPrecacheUrl, assertMicrosoftStorePwaReleaseEvidence, inspectMicrosoftStorePwaBrowserCacheTransition, microsoftStorePwaCacheSchema, readMicrosoftStorePwaBrowserReleaseEvidence, requestMicrosoftStorePwaBrowserUpdate, resolveMicrosoftStorePwaScopedCacheName, } from './microsoft-store-pwa-e2e.js';
 export { assertProductionTargetReadiness, } from './production-target-readiness.js';
 const sourceDir = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolvePackageRoot(sourceDir);
 const detectedKitRoot = resolveDefaultKitRoot();
 const gameTemplateDir = path.resolve(packageRoot, 'templates/phaser-game');
 const cliVersion = readPackageVersion(packageRoot);
-const recommendedMatrixTargets = 'web,microsoft-store,ait,reddit';
+const recommendedMatrixTargets = 'web,microsoft-store,verse8,ait,reddit';
 const defaultDependencyVersion = `^${cliVersion}`;
+const standaloneTemplateDependencyVersionFallbacks = {
+    // Initial-published independently from the CLI release line; package metadata wins once concrete.
+    '@mpgd/adapter-verse8': '^0.1.0',
+};
 const mpgdTemplateDependencyPackages = [
     { name: '@mpgd/adapter-ait', packageDir: 'adapters/ait' },
     { name: '@mpgd/adapter-browser', packageDir: 'adapters/browser' },
     { name: '@mpgd/adapter-capacitor', packageDir: 'adapters/capacitor' },
     { name: '@mpgd/adapter-devvit', packageDir: 'adapters/devvit' },
+    { name: '@mpgd/adapter-verse8', packageDir: 'adapters/verse8' },
     { name: '@mpgd/analytics', packageDir: 'packages/analytics' },
     { name: '@mpgd/bridge', packageDir: 'packages/bridge' },
     { name: '@mpgd/catalog', packageDir: 'packages/catalog' },
@@ -33,10 +40,17 @@ const mpgdTemplateDependencyPackages = [
     { name: '@mpgd/platform', packageDir: 'packages/platform' },
     { name: '@mpgd/target-config', packageDir: 'packages/target-config' },
 ];
-const recommendedMatrixTargetOrder = ['web-preview', 'microsoft-store', 'ait', 'reddit'];
+const recommendedMatrixTargetOrder = [
+    'web-preview',
+    'microsoft-store',
+    'verse8',
+    'ait',
+    'reddit',
+];
 const allMatrixTargetOrder = [
     'web-preview',
     'microsoft-store',
+    'verse8',
     'android',
     'ios',
     'ait',
@@ -48,6 +62,7 @@ const supportedBuildTargets = [
     'web-preview',
     'microsoft-store',
     'msstore',
+    'verse8',
     'android',
     'ios',
     'ait',
@@ -1254,6 +1269,7 @@ function resolveMpgdDependencyVersionReplacements(input) {
             ?? (input.workspace ? 'workspace:*' : undefined)
             ?? resolvePublishedTemplateDependencyVersion(dependency.name, packageJson)
             ?? resolveWorkspaceTemplateDependencyVersion(kitRoot, dependency.packageDir)
+            ?? standaloneTemplateDependencyVersionFallbacks[dependency.name]
             ?? defaultDependencyVersion;
         return {
             placeholder: mpgdDependencyVersionPlaceholder(dependency.name),

package/dist/microsoft-store-pwa-e2e.d.ts

@@ -0,0 +1,68 @@
+export declare const microsoftStorePwaCacheSchema: 'microsoft-store-offline-v1';
+export interface MicrosoftStorePwaReleaseEvidence {
+  readonly schemaVersion: 1;
+  readonly cacheSchema: typeof microsoftStorePwaCacheSchema;
+  readonly pwaId: string;
+  readonly appVersion: string;
+  readonly buildId: string;
+  readonly sourceGitSha: string;
+  readonly kitGitSha: string;
+  readonly configTarget: 'microsoft-store';
+  readonly revision: string;
+  readonly cachePrefix: string;
+  readonly cacheNamePattern: string;
+  readonly precacheUrls: readonly string[];
+}
+/**
+* The minimal Playwright-compatible page surface used by the PWA helpers.
+* Consumers keep Playwright and browser credentials in their own harness.
+*/
+export interface MicrosoftStorePwaBrowserPage {
+  evaluate<TResult>(pageFunction: () => TResult | Promise<TResult>): Promise<TResult>;
+  evaluate<TResult, TArgument>(pageFunction: (argument: TArgument) => TResult | Promise<TResult>, argument: TArgument): Promise<TResult>;
+}
+export interface MicrosoftStorePwaCachedIndexObservation {
+  readonly referencesReleaseA: boolean;
+  readonly referencesReleaseB: boolean;
+}
+export interface MicrosoftStorePwaCacheTransitionObservation {
+  readonly registrationScope: string;
+  readonly scopedCacheNames: {
+    readonly a: string;
+    readonly b: string;
+  };
+  readonly cacheNames: readonly string[];
+  readonly cachedReleaseBIndex: MicrosoftStorePwaCachedIndexObservation;
+}
+export interface InspectMicrosoftStorePwaCacheTransitionInput<TPage extends MicrosoftStorePwaBrowserPage = MicrosoftStorePwaBrowserPage> {
+  readonly page: TPage;
+  readonly releaseA: MicrosoftStorePwaReleaseEvidence;
+  readonly releaseB: MicrosoftStorePwaReleaseEvidence;
+  readonly releaseAIndexMarker: string;
+  readonly releaseBIndexMarker: string;
+  readonly releaseBIndexRequestCount: number;
+  readonly preservedCacheNames?: readonly string[];
+}
+export interface AssertMicrosoftStorePwaCacheTransitionInput extends MicrosoftStorePwaCacheTransitionObservation {
+  readonly releaseA: MicrosoftStorePwaReleaseEvidence;
+  readonly releaseB: MicrosoftStorePwaReleaseEvidence;
+  readonly releaseBIndexRequestCount: number;
+  readonly preservedCacheNames?: readonly string[];
+}
+export interface MicrosoftStorePwaCacheTransitionEvidence extends MicrosoftStorePwaCacheTransitionObservation {
+  readonly checks: {
+    readonly releaseBActivated: true;
+    readonly releaseACacheRemoved: true;
+    readonly preservedCachesRetained: true;
+    readonly releaseBIndexCached: true;
+    readonly staleReleaseAIndexExcluded: true;
+    readonly releaseBInstallBypassedHttpCache: true;
+  };
+}
+export declare function readMicrosoftStorePwaBrowserReleaseEvidence<TPage extends MicrosoftStorePwaBrowserPage>(page: TPage, releaseUrl?: string): Promise<MicrosoftStorePwaReleaseEvidence>;
+export declare function requestMicrosoftStorePwaBrowserUpdate<TPage extends MicrosoftStorePwaBrowserPage>(page: TPage): Promise<void>;
+export declare function inspectMicrosoftStorePwaBrowserCacheTransition<TPage extends MicrosoftStorePwaBrowserPage>(input: InspectMicrosoftStorePwaCacheTransitionInput<TPage>): Promise<MicrosoftStorePwaCacheTransitionEvidence>;
+export declare function assertMicrosoftStorePwaCacheTransition(input: AssertMicrosoftStorePwaCacheTransitionInput): MicrosoftStorePwaCacheTransitionEvidence;
+export declare function resolveMicrosoftStorePwaScopedCacheName(evidenceInput: MicrosoftStorePwaReleaseEvidence, registrationScopeInput: string): string;
+export declare function assertMicrosoftStorePwaReleaseEvidence(input: unknown): MicrosoftStorePwaReleaseEvidence;
+export declare function assertMicrosoftStorePwaPrecacheUrl(input: unknown): string;

package/dist/microsoft-store-pwa-e2e.js

@@ -0,0 +1,257 @@
+import { createHash } from 'node:crypto';
+export const microsoftStorePwaCacheSchema = 'microsoft-store-offline-v1';
+export async function readMicrosoftStorePwaBrowserReleaseEvidence(page, releaseUrl) {
+    const explicitReleaseUrl = releaseUrl === undefined
+        ? undefined
+        : requireNonEmptyString(releaseUrl, 'PWA release evidence URL');
+    const input = await page.evaluate(async (browserInput) => {
+        let requestedUrl = browserInput.releaseUrl;
+        if (requestedUrl === undefined) {
+            const browser = globalThis;
+            const registration = await browser.navigator.serviceWorker.getRegistration();
+            if (registration === undefined) {
+                throw new Error('Missing service worker registration before reading release evidence.');
+            }
+            requestedUrl = new URL('./pwa-release.json', registration.scope).href;
+        }
+        const response = await fetch(requestedUrl);
+        if (!response.ok) {
+            throw new Error(`Failed to read PWA release evidence: ${String(response.status)}.`);
+        }
+        return response.json();
+    }, { releaseUrl: explicitReleaseUrl });
+    return assertMicrosoftStorePwaReleaseEvidence(input);
+}
+export async function requestMicrosoftStorePwaBrowserUpdate(page) {
+    await page.evaluate(async () => {
+        const browser = globalThis;
+        const registration = await browser.navigator.serviceWorker.getRegistration();
+        if (registration === undefined) {
+            throw new Error('Missing service worker registration before update.');
+        }
+        await registration.update();
+    });
+}
+export async function inspectMicrosoftStorePwaBrowserCacheTransition(input) {
+    const releaseA = assertMicrosoftStorePwaReleaseEvidence(input.releaseA);
+    const releaseB = assertMicrosoftStorePwaReleaseEvidence(input.releaseB);
+    const releaseAIndexMarker = requireNonEmptyString(input.releaseAIndexMarker, 'release A index marker');
+    const releaseBIndexMarker = requireNonEmptyString(input.releaseBIndexMarker, 'release B index marker');
+    const observation = await input.page.evaluate(async (browserInput) => {
+        const browser = globalThis;
+        const registration = await browser.navigator.serviceWorker.ready;
+        const encodedScope = encodeURIComponent(registration.scope);
+        const scopedCacheNames = {
+            a: browserInput.releaseACacheNamePattern.replace('{scope}', encodedScope),
+            b: browserInput.releaseBCacheNamePattern.replace('{scope}', encodedScope),
+        };
+        const cacheNames = await browser.caches.keys();
+        const releaseBCache = await browser.caches.open(scopedCacheNames.b);
+        const cachedIndexUrl = new URL('./index.html', registration.scope).href;
+        const cachedIndexResponse = await releaseBCache.match(cachedIndexUrl);
+        if (cachedIndexResponse === undefined) {
+            throw new Error('Release B cache is missing index.html.');
+        }
+        const cachedIndex = await cachedIndexResponse.text();
+        return {
+            registrationScope: registration.scope,
+            scopedCacheNames,
+            cacheNames,
+            cachedReleaseBIndex: {
+                referencesReleaseA: cachedIndex.includes(browserInput.releaseAIndexMarker),
+                referencesReleaseB: cachedIndex.includes(browserInput.releaseBIndexMarker),
+            },
+        };
+    }, {
+        releaseACacheNamePattern: releaseA.cacheNamePattern,
+        releaseBCacheNamePattern: releaseB.cacheNamePattern,
+        releaseAIndexMarker,
+        releaseBIndexMarker,
+    });
+    return assertMicrosoftStorePwaCacheTransition({
+        releaseA,
+        releaseB,
+        releaseBIndexRequestCount: input.releaseBIndexRequestCount,
+        ...(input.preservedCacheNames === undefined
+            ? {}
+            : { preservedCacheNames: input.preservedCacheNames }),
+        ...observation,
+    });
+}
+export function assertMicrosoftStorePwaCacheTransition(input) {
+    const releaseA = assertMicrosoftStorePwaReleaseEvidence(input.releaseA);
+    const releaseB = assertMicrosoftStorePwaReleaseEvidence(input.releaseB);
+    const expectedCacheNames = {
+        a: resolveMicrosoftStorePwaScopedCacheName(releaseA, input.registrationScope),
+        b: resolveMicrosoftStorePwaScopedCacheName(releaseB, input.registrationScope),
+    };
+    if (releaseA.pwaId !== releaseB.pwaId || releaseA.cachePrefix !== releaseB.cachePrefix) {
+        throw new Error('PWA cache transition releases must identify the same application.');
+    }
+    if (releaseA.buildId === releaseB.buildId || releaseA.revision === releaseB.revision) {
+        throw new Error('PWA cache transition releases must use distinct builds and revisions.');
+    }
+    if (input.scopedCacheNames.a !== expectedCacheNames.a
+        || input.scopedCacheNames.b !== expectedCacheNames.b) {
+        throw new Error('Observed PWA cache names do not match the registration scope.');
+    }
+    if (!input.cacheNames.includes(expectedCacheNames.b)) {
+        throw new Error('Release B cache must exist after activation.');
+    }
+    if (input.cacheNames.includes(expectedCacheNames.a)) {
+        throw new Error('Release A cache must be deleted after release B activates.');
+    }
+    for (const cacheName of input.preservedCacheNames ?? []) {
+        if (!input.cacheNames.includes(requireNonEmptyString(cacheName, 'preserved cache name'))) {
+            throw new Error(`Activating release B removed unrelated cache ${cacheName}.`);
+        }
+    }
+    if (!input.cachedReleaseBIndex.referencesReleaseB) {
+        throw new Error('Release B cache must contain release B index.html.');
+    }
+    if (input.cachedReleaseBIndex.referencesReleaseA) {
+        throw new Error('Release B cache must not contain release A index.html.');
+    }
+    if (!Number.isSafeInteger(input.releaseBIndexRequestCount) || input.releaseBIndexRequestCount <= 0) {
+        throw new Error('Release B install must request index.html while bypassing the HTTP cache.');
+    }
+    return {
+        registrationScope: requireRegistrationScope(input.registrationScope),
+        scopedCacheNames: expectedCacheNames,
+        cacheNames: [...input.cacheNames],
+        cachedReleaseBIndex: { ...input.cachedReleaseBIndex },
+        checks: {
+            releaseBActivated: true,
+            releaseACacheRemoved: true,
+            preservedCachesRetained: true,
+            releaseBIndexCached: true,
+            staleReleaseAIndexExcluded: true,
+            releaseBInstallBypassedHttpCache: true,
+        },
+    };
+}
+export function resolveMicrosoftStorePwaScopedCacheName(evidenceInput, registrationScopeInput) {
+    const evidence = assertMicrosoftStorePwaReleaseEvidence(evidenceInput);
+    const registrationScope = requireRegistrationScope(registrationScopeInput);
+    return evidence.cacheNamePattern.replace('{scope}', encodeURIComponent(registrationScope));
+}
+export function assertMicrosoftStorePwaReleaseEvidence(input) {
+    assertRecord(input, 'PWA release evidence');
+    if (input.schemaVersion !== 1 || input.cacheSchema !== microsoftStorePwaCacheSchema) {
+        throw new Error('Unsupported Microsoft Store PWA release evidence schema.');
+    }
+    if (input.configTarget !== 'microsoft-store') {
+        throw new Error('PWA release evidence must target microsoft-store.');
+    }
+    if (!Array.isArray(input.precacheUrls)) {
+        throw new Error('PWA release evidence precacheUrls must be an array.');
+    }
+    const pwaId = requireGameSpecificPwaId(input.pwaId);
+    const revision = requireRevision(input.revision);
+    const expectedCachePrefix = `mpgd-pwa-${createHash('sha256')
+        .update(pwaId)
+        .digest('hex')
+        .slice(0, 12)}-`;
+    const cachePrefix = requireNonEmptyString(input.cachePrefix, 'PWA cache prefix');
+    const cacheNamePattern = requireNonEmptyString(input.cacheNamePattern, 'PWA cache name pattern');
+    const precacheUrls = input.precacheUrls.map(assertMicrosoftStorePwaPrecacheUrl);
+    if (cachePrefix !== expectedCachePrefix) {
+        throw new Error('PWA cache prefix is inconsistent with its application ID.');
+    }
+    if (cacheNamePattern !== `${cachePrefix}{scope}-${revision}`) {
+        throw new Error('PWA cache name pattern is inconsistent.');
+    }
+    if (precacheUrls.length !== new Set(precacheUrls).size
+        || precacheUrls.some((url, index) => index > 0 && compareCodeUnits(precacheUrls[index - 1] ?? '', url) > 0)) {
+        throw new Error('PWA precache URLs must be unique and sorted.');
+    }
+    return {
+        schemaVersion: 1,
+        cacheSchema: microsoftStorePwaCacheSchema,
+        pwaId,
+        appVersion: requireNonEmptyString(input.appVersion, 'PWA app version'),
+        buildId: requireNonEmptyString(input.buildId, 'PWA build ID'),
+        sourceGitSha: requireGitSha(input.sourceGitSha, 'PWA source Git SHA'),
+        kitGitSha: requireGitSha(input.kitGitSha, 'PWA kit Git SHA'),
+        configTarget: 'microsoft-store',
+        revision,
+        cachePrefix,
+        cacheNamePattern,
+        precacheUrls,
+    };
+}
+export function assertMicrosoftStorePwaPrecacheUrl(input) {
+    const url = requireNonEmptyString(input, 'PWA precache URL');
+    if (!url.startsWith('./')
+        || url.includes('\\')
+        || url.includes('?')
+        || url.includes('#')
+        || hasDotSegment(url)) {
+        throw new Error(`Unsafe PWA precache URL: ${url}`);
+    }
+    return url;
+}
+function hasDotSegment(url) {
+    for (const segment of url.slice(2).split('/')) {
+        let decoded;
+        try {
+            decoded = decodeURIComponent(segment);
+        }
+        catch {
+            return true;
+        }
+        if (decoded === '.' || decoded === '..') {
+            return true;
+        }
+    }
+    return false;
+}
+function requireGameSpecificPwaId(input) {
+    const pwaId = requireNonEmptyString(input, 'PWA ID');
+    if (pwaId === '.' || pwaId === './' || pwaId === '/') {
+        throw new Error('Microsoft Store PWA manifest id must be game-specific.');
+    }
+    return pwaId;
+}
+function requireRegistrationScope(input) {
+    const scope = requireNonEmptyString(input, 'service worker registration scope');
+    let parsed;
+    try {
+        parsed = new URL(scope);
+    }
+    catch {
+        throw new Error('Service worker registration scope must be an absolute URL.');
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error('Service worker registration scope must use HTTP or HTTPS.');
+    }
+    return scope;
+}
+function requireRevision(input) {
+    const revision = requireNonEmptyString(input, 'PWA revision');
+    if (!/^[0-9a-f]{16}$/u.test(revision)) {
+        throw new Error('PWA revision must be a 16-character hexadecimal digest.');
+    }
+    return revision;
+}
+function requireGitSha(input, label) {
+    const value = requireNonEmptyString(input, label);
+    if (!/^[0-9a-f]{40}$/u.test(value)) {
+        throw new Error(`${label} must be a full 40-character lowercase Git SHA.`);
+    }
+    return value;
+}
+function requireNonEmptyString(input, label) {
+    if (typeof input !== 'string' || input.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return input.trim();
+}
+function assertRecord(input, label) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new Error(`${label} must be an object.`);
+    }
+}
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -49,18 +49,19 @@
     "@types/node": "^24.0.0",
     "ttsc": "0.18.4",
     "typescript": "7.0.2",
-    "@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.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/target-config": "0.7.0"
+    "@mpgd/adapter-browser": "0.5.0",
+    "@mpgd/adapter-capacitor": "0.4.4",
+    "@mpgd/adapter-devvit": "0.8.3",
+    "@mpgd/adapter-verse8": "0.2.0",
+    "@mpgd/adapter-ait": "0.4.4",
+    "@mpgd/bridge": "0.6.1",
+    "@mpgd/catalog": "0.5.0",
+    "@mpgd/analytics": "0.3.7",
+    "@mpgd/game-services": "0.9.0",
+    "@mpgd/i18n": "0.5.3",
+    "@mpgd/target-config": "0.8.0",
+    "@mpgd/platform": "0.7.0",
+    "@mpgd/phaser-assets": "0.4.1"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/templates/phaser-game/README.md

@@ -31,17 +31,17 @@ platform-specific artifacts. Keep an `mpgd-kit` checkout nearby and pass it with
 pnpm exec mpgd target build-all \
   --targets-file ./mpgd.targets.json \
   --kit-path ../mpgd-kit \
-  --targets web,microsoft-store,ait,reddit \
+  --targets web,microsoft-store,verse8,ait,reddit \
   --profile staging \
   --ait-variant wrapper
 pnpm exec mpgd target smoke-all \
   --targets-file ./mpgd.targets.json \
   --kit-path ../mpgd-kit \
-  --targets web,microsoft-store,ait,reddit
+  --targets web,microsoft-store,verse8,ait,reddit
 pnpm exec mpgd target doctor \
   --targets-file ./mpgd.targets.json \
   --kit-path ../mpgd-kit \
-  --targets web,microsoft-store,ait,reddit
+  --targets web,microsoft-store,verse8,ait,reddit
 ```
 
 When developing the kit itself, the same commands work through the repository
@@ -51,7 +51,7 @@ script:
 pnpm --dir ../mpgd-kit mpgd target build-all \
   --targets-file "$PWD/mpgd.targets.json" \
   --kit-path ../mpgd-kit \
-  --targets web,microsoft-store,ait,reddit \
+  --targets web,microsoft-store,verse8,ait,reddit \
   --profile staging \
   --ait-variant wrapper
 ```
@@ -285,7 +285,26 @@ submission.
   app; do not force activation with `skipWaiting()`. Keep the web manifest `id`
   game-specific because the cache namespace uses it to isolate apps sharing an
   origin.
-- Reddit Devvit is game-owned in `apps/target-devvit`.
+- Verse8 is a game-owned iframe web target that writes to `artifacts/verse8`.
+  The adapter verifies the host-provided auth credential and distinguishes
+  Verse8-signed accounts from self-signed guest accounts. Ads are available
+  only when placement mappings are present. VXShop stays capability-disabled
+  until the gateway receives the literal `purchaseEventAuthority:
+  'agent8-server'`, catalog product mappings, and an authenticated Agent8
+  entitlement reader. The client purchase result is always `pending`; grants
+  belong only in the reserved Agent8 `$onItemPurchased` event. Do not use
+  `VXShop.onClose`, client metadata, or a client-created transaction ID as
+  purchase evidence. Keep `@agent8/gameserver-node` in the separate Agent8
+  server project and use `@mpgd/adapter-verse8/agent8` there for the locked,
+  consume-once catalog grant. Authenticated-encrypted Agent8 cloud state is
+  available only after the gateway receives a game-owned remote storage client;
+  the starter does not install the React browser SDK, configure that client, or
+  ship server persistence secrets. Agent8 verified
+  leaderboards stay server-only and require a game-specific completion
+  verifier, so the generic platform leaderboard capability remains disabled.
+- Reddit Devvit is game-owned in `apps/target-devvit`. Its Redis-backed storage
+  bridge fails closed on identity, provider, serialization, and quota errors;
+  it never switches progress to browser `localStorage`.
 - Apps in Toss currently uses the kit reference wrapper at
   `${MPGD_KIT_PATH}/apps/target-ait` for smoke packaging. Before a real Toss
   submission, create a game-owned wrapper/config so the app name, CLI state, and

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

@@ -36,5 +36,19 @@ 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
 Digital Goods API and Payment Request through backend ledger verification.
 
+## Verse8 Agent8 Structured Server
+
+Keep the Agent8 server in a separate game-owned project. Its acceptance flow
+must call `createVerse8Agent8LeaderboardBoundary` with an authenticated sender
+account and a game-specific completion verifier, then cover rejected malformed
+submissions, verified recording, and account-scoped snapshot reads.
+
+Inject endpoints, persistence secrets, encryption keys, and authentication at
+runtime. Do not commit personal MCP configuration, `.env` files, credentials,
+tokens, or Agent8 authentication state to this generated game. The kit command
+`pnpm smoke:verse8-agent8-acceptance` validates the generic structured-server
+contract and generated Verse8 target surface; it does not validate a deployed
+game server or replace game-owned production evidence.
+
 Verify the first screen reports the viewport orientation policy, and treat
 locked orientation modes as soft prompts instead of unsafe WebView hard locks.

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

@@ -20,7 +20,7 @@ pnpm check
 pnpm build
 pnpm icons:generate
 pnpm icons:verify
-pnpm exec mpgd target build-all --targets-file ./mpgd.targets.json --kit-path ../mpgd-kit --targets web,microsoft-store,ait,reddit --profile staging --ait-variant wrapper
+pnpm exec mpgd target build-all --targets-file ./mpgd.targets.json --kit-path ../mpgd-kit --targets web,microsoft-store,verse8,ait,reddit --profile staging --ait-variant wrapper
 pnpm devvit:login
 pnpm devvit:init
 pnpm devvit:playtest

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

@@ -5,7 +5,7 @@
     "title": "__GAME_TITLE__",
     "engine": "phaser-4"
   },
-  "targets": ["web-preview", "microsoft-store", "android", "ios", "ait", "reddit"],
+  "targets": ["web-preview", "microsoft-store", "verse8", "android", "ios", "ait", "reddit"],
   "futureTargets": ["telegram", "tauri"],
   "platformBoundary": "PlatformGateway",
   "mcpRequirements": {

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

@@ -3,9 +3,11 @@ 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 {
+  bridgeStorageLoadProtocol,
   createBridgeError,
   type BridgeRequest,
   type BridgeResponse,
+  type BridgeStorageLoadData,
 } from '@mpgd/bridge';
 import {
   createBridgeRpcRouter,
@@ -15,6 +17,7 @@ import { createBridgeRpcNodeHandler } from '@mpgd/bridge/orpc/node';
 
 const maxStorageKeyLength = 128;
 const maxEncodedStorageKeyLength = 384;
+const maxStorageValueBytes = 262_144;
 const maxRequestBodySize = 1_048_576;
 const gameName = '__GAME_NAME__';
 const gameTitle = __GAME_TITLE_TS_LITERAL__;
@@ -263,7 +266,11 @@ async function loadStorage(input: BridgeRequest): Promise<BridgeResponse> {
   const playerId = currentPlayerId();
 
   if (playerId === undefined) {
-    return ok(input, null);
+    return createBridgeError(
+      input.id,
+      'DEVVIT_STORAGE_IDENTITY_REQUIRED',
+      'A current Reddit player is required to load storage.',
+    );
   }
 
   const key = storageKey(input, playerId);
@@ -272,14 +279,36 @@ async function loadStorage(input: BridgeRequest): Promise<BridgeResponse> {
     return key;
   }
 
-  const stored = await redis.get(key);
+  let stored: string | null | undefined;
+
+  try {
+    stored = await redis.get(key);
+  } catch (error) {
+    console.warn(`devvit storage load failed: ${errorMessage(error)}`);
+    return createBridgeError(
+      input.id,
+      'DEVVIT_STORAGE_LOAD_FAILED',
+      'Devvit storage could not be loaded.',
+      true,
+    );
+  }
 
   if (stored === undefined || stored === null) {
-    return ok(input, null);
+    return ok(input, {
+      __mpgdBridgeProtocol: bridgeStorageLoadProtocol,
+      found: false,
+    } satisfies BridgeStorageLoadData);
   }
 
   try {
-    return ok(input, JSON.parse(stored));
+    return ok(
+      input,
+      {
+        __mpgdBridgeProtocol: bridgeStorageLoadProtocol,
+        found: true,
+        value: JSON.parse(stored),
+      } satisfies BridgeStorageLoadData,
+    );
   } catch {
     return createBridgeError(input.id, 'CORRUPTED_STORAGE_VALUE', 'Stored data is not valid JSON.');
   }
@@ -289,9 +318,11 @@ async function saveStorage(input: BridgeRequest): Promise<BridgeResponse> {
   const playerId = currentPlayerId();
 
   if (playerId === undefined) {
-    return ok(input, {
-      saved: false,
-    });
+    return createBridgeError(
+      input.id,
+      'DEVVIT_STORAGE_IDENTITY_REQUIRED',
+      'A current Reddit player is required to save storage.',
+    );
   }
 
   const key = storageKey(input, playerId);
@@ -301,16 +332,42 @@ async function saveStorage(input: BridgeRequest): Promise<BridgeResponse> {
   }
 
   const payload = optionalObjectPayload(input.payload) as { readonly value?: unknown };
+  let serialized: string;
 
   try {
-    await redis.set(key, JSON.stringify(payload.value ?? null));
-  } catch (error) {
-    console.warn(`devvit storage save was not persisted for key ${key}: ${errorMessage(error)}`);
+    const candidate = JSON.stringify(payload.value);
 
-    return ok(input, {
-      saved: false,
-      playerId,
-    });
+    if (typeof candidate !== 'string') {
+      throw new Error('JSON serialization did not produce a string.');
+    }
+
+    serialized = candidate;
+  } catch {
+    return createBridgeError(
+      input.id,
+      'INVALID_STORAGE_VALUE',
+      'Storage values must be JSON serializable.',
+    );
+  }
+
+  if (new TextEncoder().encode(serialized).length > maxStorageValueBytes) {
+    return createBridgeError(
+      input.id,
+      'DEVVIT_STORAGE_QUOTA_EXCEEDED',
+      `Storage values must not exceed ${String(maxStorageValueBytes)} UTF-8 bytes.`,
+    );
+  }
+
+  try {
+    await redis.set(key, serialized);
+  } catch (error) {
+    console.warn(`devvit storage save was not persisted: ${errorMessage(error)}`);
+    return createBridgeError(
+      input.id,
+      'DEVVIT_STORAGE_SAVE_FAILED',
+      'Devvit storage could not be saved.',
+      true,
+    );
   }
 
   return ok(input, {

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

@@ -14,6 +14,13 @@
       "icon": { "profile": "microsoft-pwa" },
       "output": "artifacts/microsoft-store"
     },
+    "verse8": {
+      "kind": "web",
+      "gameApp": ".",
+      "adapter": "verse8",
+      "icon": { "profile": "web-preview" },
+      "output": "artifacts/verse8"
+    },
     "android": {
       "kind": "capacitor-android",
       "gameApp": ".",

package/templates/phaser-game/package.json

@@ -30,6 +30,8 @@
     "ait:console:deploy": "aitcc app deploy",
     "build:microsoft-store": "pnpm exec mpgd target build microsoft-store production --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
     "smoke:microsoft-store": "pnpm exec mpgd target smoke microsoft-store --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "build:verse8": "pnpm exec mpgd target build verse8 production --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
+    "smoke:verse8": "pnpm exec mpgd target smoke verse8 --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
     "build:devvit": "pnpm exec mpgd target build reddit production --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
     "build:devvit:staging": "pnpm exec mpgd target build reddit staging --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
     "smoke:devvit": "pnpm exec mpgd target smoke reddit --targets-file ./mpgd.targets.json --kit-path ${MPGD_KIT_PATH:-__DEFAULT_KIT_PATH__}",
@@ -59,6 +61,7 @@
     "@mpgd/adapter-browser": "__MPGD_DEPENDENCY_VERSION_ADAPTER_BROWSER__",
     "@mpgd/adapter-capacitor": "__MPGD_DEPENDENCY_VERSION_ADAPTER_CAPACITOR__",
     "@mpgd/adapter-devvit": "__MPGD_DEPENDENCY_VERSION_ADAPTER_DEVVIT__",
+    "@mpgd/adapter-verse8": "__MPGD_DEPENDENCY_VERSION_ADAPTER_VERSE8__",
     "@mpgd/analytics": "__MPGD_DEPENDENCY_VERSION_ANALYTICS__",
     "@mpgd/bridge": "__MPGD_DEPENDENCY_VERSION_BRIDGE__",
     "@mpgd/catalog": "__MPGD_DEPENDENCY_VERSION_CATALOG__",

package/templates/phaser-game/src/platform/buildGateways/verse8.ts

@@ -0,0 +1,25 @@
+import { createVerse8PlatformGateway } from '@mpgd/adapter-verse8';
+import type { AdPlacements } from '@mpgd/catalog';
+import adPlacementsJson from '@mpgd/catalog/placements.json';
+import type { PlatformGateway } from '@mpgd/platform';
+
+import type { RuntimeConfig } from '../runtimeDetector';
+
+export async function createBuildGateway(_runtime: RuntimeConfig): Promise<PlatformGateway> {
+  const adPlacements = adPlacementsJson as AdPlacements;
+  const placementIds = new Map(
+    adPlacements.placements.flatMap((placement) => {
+      const platformPlacementId = placement.platformPlacementIds.verse8;
+
+      return platformPlacementId === undefined
+        ? []
+        : [[placement.id, platformPlacementId] as const];
+    }),
+  );
+
+  return createVerse8PlatformGateway({
+    resolveAdPlacementId(placementId) {
+      return placementIds.get(placementId);
+    },
+  });
+}

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

@@ -5,6 +5,7 @@ const validTargets = new Set<string>([
   'ios',
   'ait',
   'reddit',
+  'verse8',
   'telegram',
   'tauri',
 ] satisfies readonly PlatformTarget[]);

package/templates/phaser-game/vite.shared.ts

@@ -88,6 +88,8 @@ export function resolveBuildGatewayModule(input: {
       return input.debug && input.buildId === devvitSandboxBuildId
         ? 'src/platform/buildGateways/redditSandbox.ts'
         : 'src/platform/buildGateways/reddit.ts';
+    case 'verse8':
+      return 'src/platform/buildGateways/verse8.ts';
     default:
       return 'src/platform/buildGateways/browser.ts';
   }