@mpgd/cli 0.21.0 → 0.22.1

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 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 { defaultOfflinePlaytestArtifactDir, defaultOfflinePlaytestMaximumBytes, defaultOfflinePlaytestOutputDir, offlinePlaytestSchemaVersion, runOfflinePlaytestPackaging, type OfflinePlaytestEvidence, type RunOfflinePlaytestPackagingInput, type RunOfflinePlaytestPackagingResult, } from './offline-playtest.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 { createMicrosoftStorePackageAcceptanceRuntime, microsoftStorePackageAcceptanceSchemaVersion, parseMicrosoftStorePackageIdentity, parseWindowsAppCertificationResult, renderMicrosoftStorePackageAcceptanceMarkdown, runMicrosoftStorePackageAcceptance, type CreateMicrosoftStorePackageAcceptanceRuntimeInput, type MicrosoftStorePackageAcceptanceEvidence, type MicrosoftStorePackageAcceptanceRuntime, type MicrosoftStorePackageIdentity, type RunMicrosoftStorePackageAcceptanceInput, } from './microsoft-store-package-acceptance.js';
 export { createMicrosoftStorePackageGenerationRuntime, microsoftStorePackageGeneratorEndpoint, microsoftStorePackageGeneratorSourceRevision, microsoftStorePackageGenerationSchemaVersion, renderMicrosoftStorePackageGenerationMarkdown, runMicrosoftStorePackageGeneration, type CreateMicrosoftStorePackageGenerationRuntimeInput, type MicrosoftStoreAddressResolver, type MicrosoftStorePackageGenerationEvidence, type MicrosoftStorePackageGenerationRuntime, type MicrosoftStoreResolvedAddress, type RunMicrosoftStorePackageGenerationInput, } from './microsoft-store-package-generation.js';
-export { microsoftStoreSubmissionSchemaVersion, parseMicrosoftStoreSubmissionConfig, renderMicrosoftStoreSubmissionMarkdown, runMicrosoftStoreSubmissionPreflight, type MicrosoftStoreSubmissionConfig, type MicrosoftStoreSubmissionEvidence, type RunMicrosoftStoreSubmissionPreflightInput, } from './microsoft-store-submission.js';
+export { microsoftStoreSubmissionSchemaVersion, parseMicrosoftStoreSubmissionConfig, renderMicrosoftStoreSubmissionMarkdown, runMicrosoftStoreSubmissionPreflight, type MicrosoftStoreSubmissionConfig, type MicrosoftStoreSubmissionCommerce, type MicrosoftStoreSubmissionCommerceProduct, type MicrosoftStoreSubmissionEvidence, type RunMicrosoftStoreSubmissionPreflightInput, } from './microsoft-store-submission.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

@@ -11,12 +11,14 @@ import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseMani
 import { resolveGameplayE2EReportFile } from './gameplay-e2e.js';
 import { createMicrosoftStorePackageAcceptanceRuntime, runMicrosoftStorePackageAcceptance, } from './microsoft-store-package-acceptance.js';
 import { runMicrosoftStorePackageGeneration } from './microsoft-store-package-generation.js';
-import { defaultMpgdKitPath, initializeMicrosoftStoreStarter, listMicrosoftStoreInitializerTemplateFiles, prepareBaseGameTemplateFile, } from './microsoft-store-starter.js';
+import { defaultMpgdKitPath, initializeMicrosoftStoreStarter, listMicrosoftStoreInitializerTemplateFiles, prepareBaseGameTemplateFile, resolveMicrosoftStoreAdapterDependencyVersion, } from './microsoft-store-starter.js';
 import { runMicrosoftStoreSubmissionPreflight } from './microsoft-store-submission.js';
+import { defaultOfflinePlaytestArtifactDir, defaultOfflinePlaytestMaximumBytes, defaultOfflinePlaytestOutputDir, runOfflinePlaytestPackaging, } from './offline-playtest.js';
 import { targetConfigExtensionsFileEnv } from './target-config-env.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 { defaultOfflinePlaytestArtifactDir, defaultOfflinePlaytestMaximumBytes, defaultOfflinePlaytestOutputDir, offlinePlaytestSchemaVersion, runOfflinePlaytestPackaging, } from './offline-playtest.js';
 export { assertMicrosoftStorePwaCacheTransition, assertMicrosoftStorePwaPrecacheUrl, assertMicrosoftStorePwaReleaseEvidence, inspectMicrosoftStorePwaBrowserCacheTransition, microsoftStorePwaCacheSchema, readMicrosoftStorePwaBrowserReleaseEvidence, requestMicrosoftStorePwaBrowserUpdate, resolveMicrosoftStorePwaScopedCacheName, } from './microsoft-store-pwa-e2e.js';
 export { createMicrosoftStorePackageAcceptanceRuntime, microsoftStorePackageAcceptanceSchemaVersion, parseMicrosoftStorePackageIdentity, parseWindowsAppCertificationResult, renderMicrosoftStorePackageAcceptanceMarkdown, runMicrosoftStorePackageAcceptance, } from './microsoft-store-package-acceptance.js';
 export { createMicrosoftStorePackageGenerationRuntime, microsoftStorePackageGeneratorEndpoint, microsoftStorePackageGeneratorSourceRevision, microsoftStorePackageGenerationSchemaVersion, renderMicrosoftStorePackageGenerationMarkdown, runMicrosoftStorePackageGeneration, } from './microsoft-store-package-generation.js';
@@ -409,6 +411,72 @@ const gameCommand = defineI18n({
                 });
             },
         }),
+        'offline-playtest': defineI18n({
+            name: 'offline-playtest',
+            description: 'Package a web preview as a test-only, direct-file offline playtest.',
+            resource: commandResource({
+                en: 'Package an existing web-preview artifact as a network-blocked, direct-file test bundle.',
+                ko: '기존 web-preview 산출물을 네트워크가 차단된 직접 실행 테스트 묶음으로 패키징합니다.',
+            }, {
+                game: {
+                    en: 'Game root containing the source artifact.',
+                    ko: '원본 산출물이 있는 게임 루트.',
+                },
+                'artifact-dir': {
+                    en: 'Existing web-preview artifact directory, relative to the game root.',
+                    ko: '게임 루트 기준 기존 web-preview 산출물 디렉터리.',
+                },
+                'output-dir': {
+                    en: 'Test-only output directory under the game artifacts directory.',
+                    ko: '게임 artifacts 디렉터리 아래의 테스트 전용 출력 디렉터리.',
+                },
+                'maximum-bytes': {
+                    en: 'Maximum size of the generated single index.html file.',
+                    ko: '생성되는 단일 index.html 파일의 최대 바이트 수.',
+                },
+            }),
+            args: {
+                game: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Game root containing the source artifact.',
+                },
+                'artifact-dir': {
+                    type: 'string',
+                    required: false,
+                    default: defaultOfflinePlaytestArtifactDir,
+                    description: 'Existing web-preview artifact directory.',
+                },
+                'output-dir': {
+                    type: 'string',
+                    required: false,
+                    default: defaultOfflinePlaytestOutputDir,
+                    description: 'Test-only output directory under game artifacts.',
+                },
+                'maximum-bytes': {
+                    type: 'string',
+                    required: false,
+                    default: String(defaultOfflinePlaytestMaximumBytes),
+                    description: 'Maximum generated index.html size in bytes.',
+                },
+            },
+            run: async (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['game', 'offline-playtest']);
+                const gameRoot = path.resolve(readRequiredPositional(positionals, 0, 'game'));
+                const artifactDir = readOptionalString(ctx.values['artifact-dir'])
+                    ?? defaultOfflinePlaytestArtifactDir;
+                const outputDir = readOptionalString(ctx.values['output-dir'])
+                    ?? defaultOfflinePlaytestOutputDir;
+                const maximumBytes = readPositiveInteger(readOptionalString(ctx.values['maximum-bytes'])
+                    ?? String(defaultOfflinePlaytestMaximumBytes), '--maximum-bytes');
+                const result = await runOfflinePlaytestPackaging({
+                    gameRoot,
+                    artifactDir,
+                    outputDir,
+                    maximumBytes,
+                });
+            },
+        }),
         icons: defineI18n({
             name: 'icons',
             description: 'Generate and verify target app icons from the game brand source.',
@@ -806,10 +874,15 @@ const targetCommand = defineI18n({
                     ? defaultMpgdKitPath
                     : toTemplatePath(path.relative(gameRoot, resolvedKitPath) || '.');
                 const dryRun = ctx.values['dry-run'] === true;
+                const adapterDependencyVersion = resolveMicrosoftStoreAdapterDependencyVersion(requireMpgdDependencyVersion(resolveMpgdDependencyVersionReplacements({
+                    workspace: false,
+                    ...(resolvedKitPath === undefined ? {} : { kitPath: resolvedKitPath }),
+                }), '@mpgd/adapter-browser'));
                 const result = initializeMicrosoftStoreStarter({
                     gameRoot,
                     templateRoot: gameTemplateDir,
                     defaultKitPath,
+                    adapterDependencyVersion,
                     dryRun,
                 });
                 for (const file of result.changedFiles) {
@@ -1599,6 +1672,7 @@ function createGameApp(input) {
                 gameRoot: appDir,
                 templateRoot: gameTemplateDir,
                 defaultKitPath: context.defaultKitPath,
+                adapterDependencyVersion: context.microsoftStoreAdapterDependencyVersion,
                 dryRun: false,
             });
         }
@@ -1650,6 +1724,13 @@ function createTemplateContext(input) {
     }
     const workspaceRoot = toTemplatePath(path.relative(input.appDir, kitPath ?? input.appDir) || '.');
     const workspacePrefix = workspaceRoot;
+    const mpgdDependencyVersionReplacements = resolveMpgdDependencyVersionReplacements({
+        ...(input.dependencyVersion === undefined
+            ? {}
+            : { overrideVersion: input.dependencyVersion }),
+        workspace: input.workspace,
+        ...(kitPath === undefined ? {} : { kitPath }),
+    });
     return {
         gameName: input.gameName,
         devvitAppName: toDevvitAppName(input.gameName),
@@ -1658,13 +1739,8 @@ function createTemplateContext(input) {
         legalLastUpdated: new Date().toISOString().slice(0, 10),
         packageName: input.packageName,
         defaultDependencyVersion: input.dependencyVersion ?? defaultDependencyVersion,
-        mpgdDependencyVersionReplacements: resolveMpgdDependencyVersionReplacements({
-            ...(input.dependencyVersion === undefined
-                ? {}
-                : { overrideVersion: input.dependencyVersion }),
-            workspace: input.workspace,
-            ...(kitPath === undefined ? {} : { kitPath }),
-        }),
+        mpgdDependencyVersionReplacements,
+        microsoftStoreAdapterDependencyVersion: resolveMicrosoftStoreAdapterDependencyVersion(requireMpgdDependencyVersion(mpgdDependencyVersionReplacements, '@mpgd/adapter-browser')),
         tsconfigExtendsLine: input.workspace
             ? `  "extends": "${workspacePrefix}/tsconfig.base.json",`
             : '',
@@ -1740,6 +1816,14 @@ function mpgdDependencyVersionPlaceholder(packageName) {
         .replaceAll('-', '_')
         .toUpperCase()}__`;
 }
+function requireMpgdDependencyVersion(replacements, packageName) {
+    const placeholder = mpgdDependencyVersionPlaceholder(packageName);
+    const replacement = replacements.find((candidate) => candidate.placeholder === placeholder);
+    if (replacement === undefined) {
+        throw new Error(`Missing template dependency version for ${packageName}.`);
+    }
+    return replacement.version;
+}
 function assertValidGameTitle(title) {
     if (title.trim().length === 0) {
         throw new Error('Game title cannot be empty.');

package/dist/microsoft-store-package-generation-contract.d.ts

@@ -80,6 +80,11 @@ export interface MicrosoftStoreSubmissionEvidenceInput {
   readonly manifestSha256: string;
   readonly manifest: Readonly<Record<string, unknown>>;
   readonly manifestIcons: readonly MicrosoftStoreManifestIconInput[];
+  readonly effectiveTarget: {
+    readonly file: string;
+    readonly snapshot: MicrosoftStoreFileSnapshot;
+  };
+  /** Comma-separated Store languages accepted by the pinned PWABuilder generator contract. */
   readonly resourceLanguage: string;
 }
 export interface MicrosoftStoreManifestIconInput {

package/dist/microsoft-store-package-generation-input.js

@@ -5,7 +5,9 @@ import { TextDecoder } from 'node:util';
 import { formatError } from './evidence-io.js';
 import { assertMicrosoftStoreSnapshotUnchanged, hashMicrosoftStoreBytes, hashMicrosoftStoreFileSnapshot, readBoundedMicrosoftStoreFileBytes, } from './microsoft-store-package-generation-integrity.js';
 import { assertMicrosoftStorePwaUrlInsideManifestScope, readHashVerifiedMicrosoftStoreManifest, } from './microsoft-store-package-generation-manifest.js';
+import { assertMicrosoftStoreEffectiveTarget, parseMicrosoftStoreSubmissionCommerce, } from './microsoft-store-submission.js';
 const maximumSubmissionEvidenceBytes = 4 * 1024 * 1024;
+const maximumEffectiveTargetBytes = 4 * 1024 * 1024;
 const maximumManifestIcons = 32;
 const maximumManifestIconBytes = 2 * 1024 * 1024;
 export function prepareMicrosoftStorePackageGenerationInput(input) {
@@ -40,6 +42,10 @@ export function prepareMicrosoftStorePackageGenerationInput(input) {
         { file: markdownFile, label: 'package generation Markdown' },
         { file: submissionEvidenceFile, label: 'submission evidence' },
         { file: submission.manifestFile, label: 'web app manifest' },
+        {
+            file: submission.effectiveTarget.file,
+            label: 'Microsoft Store effective target config',
+        },
     ];
     assertDistinctFiles(filesThatMustAlwaysBeDistinct);
     for (const [index, icon] of submission.manifestIcons.entries()) {
@@ -66,6 +72,7 @@ export function prepareMicrosoftStorePackageGenerationInput(input) {
 export function assertMicrosoftStorePackageGenerationInputUnchanged(input) {
     assertMicrosoftStoreSnapshotUnchanged(input.submissionEvidenceFile, input.submissionBefore, 'Microsoft Store submission evidence changed during package generation');
     assertMicrosoftStoreSnapshotUnchanged(input.submission.manifestFile, input.manifestBefore, 'Microsoft Store web app manifest changed during package generation');
+    assertMicrosoftStoreSnapshotUnchanged(input.submission.effectiveTarget.file, input.submission.effectiveTarget.snapshot, 'Microsoft Store effective target config changed during package generation');
     for (const [index, icon] of input.submission.manifestIcons.entries()) {
         assertMicrosoftStoreSnapshotUnchanged(icon.file, icon.snapshot, `Microsoft Store web app manifest icon[${index}] changed during package generation`);
     }
@@ -112,6 +119,19 @@ function readSubmissionEvidence(file, gameRoot, expected) {
         || manifestIconCount !== manifestIcons.length) {
         throw new Error(`Microsoft Store manifest icon evidence must contain 1-${maximumManifestIcons} entries and match iconCount.`);
     }
+    if (root.commerce === undefined) {
+        throw new Error('Microsoft Store commerce evidence is required for package generation.');
+    }
+    const commerce = requireRecord(root.commerce, 'Microsoft Store commerce evidence');
+    const commerceMode = commerce.mode;
+    if (commerceMode !== 'disabled' && commerceMode !== 'microsoft-store') {
+        throw new Error('Microsoft Store commerce evidence mode must be disabled or microsoft-store.');
+    }
+    const parsedCommerce = parseMicrosoftStoreSubmissionCommerce(commerce);
+    if (root.effectiveTarget === undefined) {
+        throw new Error('Microsoft Store effective target evidence is required for package generation.');
+    }
+    const effectiveTarget = readEffectiveTargetEvidence(root.effectiveTarget, gameRoot, parsedCommerce);
     return {
         identity: {
             packageId: requireNonEmptyString(identity.packageId, 'Microsoft Store package ID'),
@@ -140,9 +160,44 @@ function readSubmissionEvidence(file, gameRoot, expected) {
                 height: requirePositiveInteger(record.height, `Microsoft Store manifest icon evidence[${index}].height`),
             };
         }),
+        effectiveTarget,
+        // The pinned PWABuilder source accepts multiple Store languages as one comma-separated field.
         resourceLanguage: resourceLanguages.join(','),
     };
 }
+function readEffectiveTargetEvidence(input, gameRoot, commerce) {
+    const evidence = requireRecord(input, 'Microsoft Store effective target evidence for package generation');
+    const file = readCanonicalFileInside(gameRoot, path.resolve(gameRoot, requireNonEmptyString(evidence.file, 'Microsoft Store effective target evidence file')), 'Microsoft Store effective target config');
+    const snapshot = hashMicrosoftStoreFileSnapshot(file, 'Microsoft Store effective target config');
+    const expectedSha256 = requireSha256(evidence.sha256, 'Microsoft Store effective target evidence SHA-256');
+    if (snapshot.sha256 !== expectedSha256) {
+        throw new Error(`Microsoft Store effective target config SHA-256 must match submission evidence: expected ${expectedSha256}, received ${snapshot.sha256}.`);
+    }
+    const bytes = readBoundedMicrosoftStoreFileBytes(file, 'Microsoft Store effective target config', maximumEffectiveTargetBytes);
+    if (bytes === null) {
+        throw new Error('Microsoft Store effective target config is too large.');
+    }
+    if (bytes.length !== snapshot.sizeBytes || hashMicrosoftStoreBytes(bytes) !== snapshot.sha256) {
+        throw new Error(`Microsoft Store effective target config changed while it was read: ${file}`);
+    }
+    let source;
+    try {
+        source = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch (error) {
+        throw new Error(`Microsoft Store effective target config must use valid UTF-8: ${formatError(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse Microsoft Store effective target config: ${formatError(error)}`);
+    }
+    assertMicrosoftStoreEffectiveTarget(parsed, commerce);
+    assertMicrosoftStoreSnapshotUnchanged(file, snapshot, 'Microsoft Store effective target config changed while it was parsed');
+    return { file, snapshot };
+}
 function prepareManifestIcons(gameRoot, manifestUrl, manifest, evidenceIcons) {
     const manifestIcons = requireArray(manifest.icons, 'Microsoft Store web app manifest icons');
     if (manifestIcons.length !== evidenceIcons.length) {

package/dist/microsoft-store-starter.d.ts

@@ -6,10 +6,12 @@ export declare const microsoftStoreDocumentationAnchors: {
   readonly 'agent/acceptance.md': '## Verse8 Agent8 Structured Server';
   readonly 'agent/brief.md': undefined;
 };
+export declare const microsoftStoreAdapterMinimumDependencyVersion = "^0.6.0";
 export interface InitializeMicrosoftStoreStarterInput {
   readonly gameRoot: string;
   readonly templateRoot: string;
   readonly defaultKitPath: string;
+  readonly adapterDependencyVersion: string;
   readonly dryRun: boolean;
 }
 export interface InitializeMicrosoftStoreStarterResult {
@@ -25,4 +27,9 @@ export declare function prepareBaseGameTemplateFile(input: {
 }): string | undefined;
 export declare function listMicrosoftStoreInitializerTemplateFiles(): readonly string[];
 export declare function initializeMicrosoftStoreStarter(input: InitializeMicrosoftStoreStarterInput, runtime?: MicrosoftStoreStarterApplyRuntime): InitializeMicrosoftStoreStarterResult;
+/**
+* Floors registry-backed browser adapter versions at the first release that exports the
+* Microsoft Store PWA adapter. Local workspace/link/file specs remain intentionally untouched.
+*/
+export declare function resolveMicrosoftStoreAdapterDependencyVersion(candidate: string): string;
 export {};

package/dist/microsoft-store-starter.js

@@ -23,6 +23,7 @@ const microsoftStoreOnlyTemplateFiles = new Set([
     '.agents/skills/release-microsoft-store/SKILL.md',
     '.agents/skills/release-microsoft-store/agents/openai.yaml',
     'mpgd.microsoft-store.json',
+    'src/platform/buildGateways/microsoftStore.ts',
     'src/platform/microsoftStorePwa.ts',
 ]);
 const microsoftStoreManagedTemplateFiles = new Set([
@@ -33,10 +34,21 @@ const microsoftStoreManagedTemplateFiles = new Set([
 const microsoftStoreTarget = {
     kind: 'web',
     gameApp: '.',
-    adapter: 'browser',
+    adapter: 'microsoft-store',
+    authoritativeGameServices: false,
     icon: { profile: 'microsoft-pwa' },
     output: 'artifacts/microsoft-store',
 };
+const microsoftStoreAdapterBasePackage = '@mpgd/adapter-browser';
+export const microsoftStoreAdapterMinimumDependencyVersion = '^0.6.0';
+const microsoftStoreGatewayResolver = {
+    anchor: "    default:\n      return 'src/platform/buildGateways/browser.ts';",
+    block: "    case 'microsoft-store':\n      return 'src/platform/buildGateways/microsoftStore.ts';",
+};
+const microsoftStoreRuntimeTarget = {
+    anchor: "  'ios',\n  'ait',",
+    line: "  'microsoft-store',",
+};
 export function prepareBaseGameTemplateFile(input) {
     const relativePath = toTemplatePath(input.relativePath);
     if (microsoftStoreOnlyTemplateFiles.has(relativePath)) {
@@ -68,6 +80,10 @@ export function prepareBaseGameTemplateFile(input) {
             });
         case 'src/main.ts':
             return removeMicrosoftStoreBootstrap(withoutBlocks);
+        case 'src/platform/runtimeDetector.ts':
+            return removeMicrosoftStoreRuntimeTarget(withoutBlocks);
+        case 'vite.shared.ts':
+            return removeMicrosoftStoreGatewayResolver(withoutBlocks);
         default:
             return withoutBlocks;
     }
@@ -97,6 +113,7 @@ export function initializeMicrosoftStoreStarter(input, runtime = {}) {
     const packageSource = readRequiredRegularFile(gameRoot, packageFile, 'package.json');
     const packageJson = parseJsonObject(packageSource, 'package.json');
     const scripts = requireJsonObject(packageJson.scripts, 'package.json scripts');
+    const dependencies = requireJsonObject(packageJson.dependencies, 'package.json dependencies');
     const legacyScripts = legacyMicrosoftStoreScripts(input.defaultKitPath);
     for (const [name, command] of Object.entries(microsoftStoreScripts(input.defaultKitPath))) {
         const existing = scripts[name];
@@ -106,6 +123,7 @@ export function initializeMicrosoftStoreStarter(input, runtime = {}) {
         }
         scripts[name] = command;
     }
+    dependencies[microsoftStoreAdapterBasePackage] = resolveAdapterDependency(dependencies[microsoftStoreAdapterBasePackage], input.adapterDependencyVersion);
     plan('package.json', formatJson(packageJson));
     const targetsFile = resolveGameFile(gameRoot, 'mpgd.targets.json');
     const targetsSource = readRequiredRegularFile(gameRoot, targetsFile, 'mpgd.targets.json');
@@ -116,12 +134,23 @@ export function initializeMicrosoftStoreStarter(input, runtime = {}) {
         targets['microsoft-store'] = microsoftStoreTarget;
     }
     else {
-        assertCompatibleMicrosoftStoreTarget(existingTarget);
+        const compatibleTarget = assertCompatibleMicrosoftStoreTarget(existingTarget);
+        targets['microsoft-store'] = {
+            ...compatibleTarget,
+            ...microsoftStoreTarget,
+            ...(compatibleTarget.authoritativeGameServices === undefined
+                ? {}
+                : { authoritativeGameServices: compatibleTarget.authoritativeGameServices }),
+        };
     }
     plan('mpgd.targets.json', formatJson(targetsJson));
     const mainFile = resolveGameFile(gameRoot, 'src/main.ts');
     const mainSource = readRequiredRegularFile(gameRoot, mainFile, 'src/main.ts');
     plan('src/main.ts', addMicrosoftStoreBootstrap(mainSource));
+    const runtimeSource = readRequiredMicrosoftStoreMigrationFile(gameRoot, 'src/platform/runtimeDetector.ts');
+    plan('src/platform/runtimeDetector.ts', addMicrosoftStoreRuntimeTarget(runtimeSource));
+    const viteSource = readRequiredMicrosoftStoreMigrationFile(gameRoot, 'vite.shared.ts');
+    plan('vite.shared.ts', addMicrosoftStoreGatewayResolver(viteSource));
     planGitignore(gameRoot, plan);
     planAgentManifest(gameRoot, plan);
     planManagedDocumentation(gameRoot, templateRoot, plan);
@@ -133,6 +162,7 @@ export function initializeMicrosoftStoreStarter(input, runtime = {}) {
         '.agents/skills/release-microsoft-store/agents/openai.yaml',
         'docs/MPGD_KIT_WORKFLOWS.md',
         'mpgd.microsoft-store.json',
+        'src/platform/buildGateways/microsoftStore.ts',
         'src/platform/microsoftStorePwa.ts',
     ]) {
         const destination = resolveGameFile(gameRoot, relativePath);
@@ -150,6 +180,135 @@ export function initializeMicrosoftStoreStarter(input, runtime = {}) {
     }
     return { changedFiles: writes.map((write) => write.relativePath).sort() };
 }
+/**
+ * Floors registry-backed browser adapter versions at the first release that exports the
+ * Microsoft Store PWA adapter. Local workspace/link/file specs remain intentionally untouched.
+ */
+export function resolveMicrosoftStoreAdapterDependencyVersion(candidate) {
+    return resolveAdapterDependency(candidate, microsoftStoreAdapterMinimumDependencyVersion);
+}
+function dependencyVersion(value) {
+    const normalized = value.trim();
+    if (normalized.length === 0
+        || !/^(?:workspace:\*|[~^]?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/u.test(normalized)) {
+        throw new Error('Microsoft Store adapter dependency version must be workspace:* or a SemVer version/range.');
+    }
+    return normalized;
+}
+function resolveAdapterDependency(existing, required) {
+    const requiredDependency = dependencyVersion(required);
+    if (existing === undefined) {
+        return requiredDependency;
+    }
+    if (typeof existing !== 'string' || existing.trim().length === 0) {
+        throw new Error(`package.json dependency ${microsoftStoreAdapterBasePackage} must be a string.`);
+    }
+    const normalized = existing.trim();
+    if (/^(?:workspace|link|file):/u.test(normalized)) {
+        return normalized;
+    }
+    const currentRange = parseSimpleSemverRange(normalized);
+    const requiredRange = parseSimpleSemverRange(requiredDependency);
+    if (currentRange === undefined) {
+        // A non-simple registry constraint cannot prove that installing it will expose the
+        // Microsoft Store entry point. Fail closed instead of retaining ranges such as
+        // `0.5.x` or `>=0.5.1 <0.6.0` that may resolve below the required release.
+        return requiredDependency;
+    }
+    if (requiredRange !== undefined
+        && compareSemver(currentRange, requiredRange) < 0) {
+        return requiredDependency;
+    }
+    // Preserve simple exact, tilde, and caret ranges already at or above the feature floor.
+    return normalized;
+}
+function parseSimpleSemverRange(value) {
+    const match = /^([~^]?)(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u.exec(value);
+    if (match === null) {
+        return undefined;
+    }
+    return {
+        major: Number(match[2]),
+        minor: Number(match[3]),
+        patch: Number(match[4]),
+        ...(match[5] === undefined ? {} : { prerelease: match[5].split('.') }),
+    };
+}
+function compareSemver(left, right) {
+    const releaseComparison = left.major - right.major
+        || left.minor - right.minor
+        || left.patch - right.patch;
+    if (releaseComparison !== 0) {
+        return releaseComparison;
+    }
+    if (left.prerelease === undefined) {
+        return right.prerelease === undefined ? 0 : 1;
+    }
+    if (right.prerelease === undefined) {
+        return -1;
+    }
+    const identifierCount = Math.max(left.prerelease.length, right.prerelease.length);
+    for (let index = 0; index < identifierCount; index += 1) {
+        const comparison = comparePrereleaseIdentifier(left.prerelease[index], right.prerelease[index]);
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return 0;
+}
+function comparePrereleaseIdentifier(left, right) {
+    if (left === undefined) {
+        return right === undefined ? 0 : -1;
+    }
+    if (right === undefined) {
+        return 1;
+    }
+    const leftNumeric = /^\d+$/u.test(left);
+    const rightNumeric = /^\d+$/u.test(right);
+    if (leftNumeric && rightNumeric) {
+        const leftNumber = BigInt(left);
+        const rightNumber = BigInt(right);
+        if (leftNumber !== rightNumber) {
+            return leftNumber < rightNumber ? -1 : 1;
+        }
+        return 0;
+    }
+    if (leftNumeric !== rightNumeric) {
+        return leftNumeric ? -1 : 1;
+    }
+    if (left === right) {
+        return 0;
+    }
+    return left < right ? -1 : 1;
+}
+function addMicrosoftStoreGatewayResolver(source) {
+    if (source.includes(microsoftStoreGatewayResolver.block)) {
+        return source;
+    }
+    return insertBefore(source, microsoftStoreGatewayResolver.anchor, microsoftStoreGatewayResolver.block, 'vite.shared.ts Microsoft Store gateway resolver');
+}
+function addMicrosoftStoreRuntimeTarget(source) {
+    if (source.includes(microsoftStoreRuntimeTarget.line)) {
+        return source;
+    }
+    return insertAfter(source, microsoftStoreRuntimeTarget.anchor, microsoftStoreRuntimeTarget.line, 'src/platform/runtimeDetector.ts target list');
+}
+function removeMicrosoftStoreRuntimeTarget(source) {
+    const managedLine = `${microsoftStoreRuntimeTarget.line}\n`;
+    const occurrences = source.split(managedLine).length - 1;
+    if (occurrences !== 1) {
+        throw new Error('Template src/platform/runtimeDetector.ts must contain exactly one Microsoft Store target.');
+    }
+    return source.replace(managedLine, '');
+}
+function removeMicrosoftStoreGatewayResolver(source) {
+    const managedBlock = `${microsoftStoreGatewayResolver.block}\n`;
+    const occurrences = source.split(managedBlock).length - 1;
+    if (occurrences !== 1) {
+        throw new Error('Template vite.shared.ts must contain exactly one Microsoft Store gateway resolver block.');
+    }
+    return source.replace(managedBlock, '');
+}
 function microsoftStoreScripts(defaultKitPath) {
     const safeKitPath = requireSafeShellParameterDefaultPath(defaultKitPath);
     const kitPath = `"\${MPGD_KIT_PATH:-${safeKitPath}}"`;
@@ -180,13 +339,18 @@ function requireSafeShellParameterDefaultPath(value) {
 function assertCompatibleMicrosoftStoreTarget(value) {
     const target = requireJsonObject(value, 'microsoft-store target');
     const icon = isJsonObject(target.icon) ? target.icon : undefined;
+    if (target.authoritativeGameServices !== undefined
+        && typeof target.authoritativeGameServices !== 'boolean') {
+        throw new Error('Existing microsoft-store target authoritativeGameServices must be a boolean when present.');
+    }
     if (target.kind !== 'web'
-        || target.adapter !== 'browser'
+        || (target.adapter !== 'browser' && target.adapter !== 'microsoft-store')
         || target.gameApp !== microsoftStoreTarget.gameApp
         || target.output !== microsoftStoreTarget.output
         || icon?.profile !== microsoftStoreTarget.icon.profile) {
-        throw new Error('Existing microsoft-store target must use the game root, Store artifact directory, browser adapter, and microsoft-pwa icon profile.');
+        throw new Error('Existing microsoft-store target must use the game root, Store artifact directory, a supported Store adapter, and microsoft-pwa icon profile.');
     }
+    return target;
 }
 function addMicrosoftStoreBootstrap(source) {
     let output = source;
@@ -401,6 +565,14 @@ function readOptionalRegularFile(gameRoot, file, relativePath) {
     }
     return readRequiredRegularFile(gameRoot, file, relativePath);
 }
+function readRequiredMicrosoftStoreMigrationFile(gameRoot, relativePath) {
+    const source = readOptionalRegularFile(gameRoot, resolveGameFile(gameRoot, relativePath), relativePath);
+    if (source === undefined) {
+        throw new Error('target init microsoft-store requires existing generated starter files: '
+            + 'src/platform/runtimeDetector.ts and vite.shared.ts.');
+    }
+    return source;
+}
 function lstatIfExists(file) {
     try {
         return lstatSync(file);

package/dist/microsoft-store-submission.d.ts

@@ -1,4 +1,20 @@
 export declare const microsoftStoreSubmissionSchemaVersion: 1;
+export interface MicrosoftStoreSubmissionCommerceProduct {
+  readonly logicalProductId: string;
+  /** Add-on Product ID used by the PWA Digital Goods API. */
+  readonly inAppOfferToken: string;
+  /** Partner Center Store ID used by Microsoft collections query and consume APIs. */
+  readonly storeId: string;
+}
+export type MicrosoftStoreSubmissionCommerce = {
+  readonly mode: 'disabled';
+} | {
+  readonly mode: 'microsoft-store';
+  readonly productType: 'developer-managed-consumable';
+  readonly fulfillment: 'authoritative-server';
+  readonly authoritativeGameServices: true;
+  readonly products: readonly MicrosoftStoreSubmissionCommerceProduct[];
+};
 export interface MicrosoftStoreSubmissionConfig {
   readonly schemaVersion: 1;
   readonly productIdentity: {
@@ -23,9 +39,7 @@ export interface MicrosoftStoreSubmissionConfig {
     readonly questionnaireCompleted: true;
     readonly iarcId?: string;
   };
-  readonly commerce: {
-    readonly mode: 'disabled';
-  };
+  readonly commerce: MicrosoftStoreSubmissionCommerce;
 }
 export interface MicrosoftStoreSubmissionEvidence {
   readonly schemaVersion: 1;
@@ -49,6 +63,11 @@ export interface MicrosoftStoreSubmissionEvidence {
       readonly height: number;
     }[];
   };
+  /** Binds preflight evidence to the exact built target contract in every commerce mode. */
+  readonly effectiveTarget: {
+    readonly file: string;
+    readonly sha256: string;
+  };
   readonly listing: {
     readonly category: 'Games';
     readonly supportUrl: string;
@@ -75,5 +94,7 @@ export interface RunMicrosoftStoreSubmissionPreflightInput {
   readonly markdownFile: string;
 }
 export declare function runMicrosoftStoreSubmissionPreflight(input: RunMicrosoftStoreSubmissionPreflightInput): MicrosoftStoreSubmissionEvidence;
+export declare function assertMicrosoftStoreEffectiveTarget(input: unknown, commerce: MicrosoftStoreSubmissionCommerce): void;
 export declare function parseMicrosoftStoreSubmissionConfig(input: unknown): MicrosoftStoreSubmissionConfig;
+export declare function parseMicrosoftStoreSubmissionCommerce(input: Record<string, unknown>): MicrosoftStoreSubmissionCommerce;
 export declare function renderMicrosoftStoreSubmissionMarkdown(evidence: MicrosoftStoreSubmissionEvidence): string;