@mpgd/cli 0.10.1 → 0.11.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,7 +9,9 @@ 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);

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.11.0",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -50,17 +50,17 @@
     "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/adapter-devvit": "0.8.2",
+    "@mpgd/adapter-browser": "0.4.3",
     "@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/catalog": "0.4.0",
+    "@mpgd/target-config": "0.7.0",
+    "@mpgd/game-services": "0.8.2",
     "@mpgd/phaser-assets": "0.4.1",
-    "@mpgd/target-config": "0.7.0"
+    "@mpgd/platform": "0.6.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",