@mpgd/cli 0.13.0 → 0.15.0

package/dist/index.d.ts

@@ -2,6 +2,9 @@ export { renderGameAcceptanceMarkdown, resolveGameAcceptanceReleaseManifestFile,
 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 { 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 { 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

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import completion from '@gunshi/plugin-completion';
@@ -8,10 +8,17 @@ import resources from '@gunshi/resources';
 import { cli } from 'gunshi';
 import { defaultGameAcceptanceCommandTimeoutMs, resolveGameAcceptanceReleaseManifestFile, runGameAcceptance, } from './game-acceptance.js';
 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 { runMicrosoftStoreSubmissionPreflight } from './microsoft-store-submission.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 { 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';
+export { microsoftStoreSubmissionSchemaVersion, parseMicrosoftStoreSubmissionConfig, renderMicrosoftStoreSubmissionMarkdown, runMicrosoftStoreSubmissionPreflight, } from './microsoft-store-submission.js';
 export { assertProductionTargetReadiness, } from './production-target-readiness.js';
 const sourceDir = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolvePackageRoot(sourceDir);
@@ -19,6 +26,10 @@ const detectedKitRoot = resolveDefaultKitRoot();
 const gameTemplateDir = path.resolve(packageRoot, 'templates/phaser-game');
 const cliVersion = readPackageVersion(packageRoot);
 const recommendedMatrixTargets = 'web,microsoft-store,verse8,ait,reddit';
+const recommendedMatrixTargetsWithoutMicrosoftStore = recommendedMatrixTargets
+    .split(',')
+    .filter((target) => target !== 'microsoft-store')
+    .join(',');
 const defaultDependencyVersion = `^${cliVersion}`;
 const standaloneTemplateDependencyVersionFallbacks = {
     // Initial-published independently from the CLI release line; package metadata wins once concrete.
@@ -183,6 +194,10 @@ const gameCommand = defineI18n({
                     en: 'Print files that would be generated without writing them.',
                     ko: '파일을 쓰지 않고 생성 예정 목록만 출력합니다.',
                 },
+                'microsoft-store': {
+                    en: 'Include the Microsoft Store PWA target and release workflow.',
+                    ko: 'Microsoft Store PWA 타깃과 출시 워크플로를 포함합니다.',
+                },
             }),
             args: {
                 directory: {
@@ -220,6 +235,11 @@ const gameCommand = defineI18n({
                     required: false,
                     description: 'Print files that would be generated without writing them.',
                 },
+                'microsoft-store': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Include the Microsoft Store PWA target and release workflow.',
+                },
             },
             run: (ctx) => {
                 const positionals = readLocalPositionals(ctx.positionals, ['game', 'create']);
@@ -238,6 +258,7 @@ const gameCommand = defineI18n({
                     workspace: ctx.values.workspace === true,
                     ...(kitPath === undefined ? {} : { kitPath }),
                     dryRun: ctx.values['dry-run'] === true,
+                    microsoftStore: ctx.values['microsoft-store'] === true,
                 });
             },
         }),
@@ -727,12 +748,85 @@ const legalCommand = defineI18n({
 });
 const targetCommand = defineI18n({
     name: 'target',
-    description: 'Build and smoke target artifacts with generated game target config.',
+    description: 'Build, smoke, generate, preflight, and accept target release artifacts.',
     resource: commandResource({
-        en: 'Build and smoke target artifacts with generated game target config.',
-        ko: '게임 타깃 설정으로 타깃 산출물을 빌드하고 스모크 검증합니다.',
+        en: 'Build, smoke, generate, preflight, and accept target release artifacts.',
+        ko: '타깃 출시 산출물을 빌드하고 스모크, 패키지 생성, 제출 사전 검증 및 인수 검증을 수행합니다.',
     }),
     subCommands: {
+        init: defineI18n({
+            name: 'init',
+            description: 'Initialize an optional target workflow in an existing game.',
+            resource: commandResource({
+                en: 'Initialize an optional target workflow in an existing game without overwriting conflicts.',
+                ko: '충돌 파일을 덮어쓰지 않고 기존 게임에 선택적 타깃 워크플로를 초기화합니다.',
+            }, {
+                target: {
+                    en: 'Target to initialize. Currently supports microsoft-store.',
+                    ko: '초기화할 타깃. 현재 microsoft-store를 지원합니다.',
+                },
+                game: {
+                    en: 'Existing game root. Defaults to the current directory.',
+                    ko: '기존 게임 루트. 기본값은 현재 디렉터리입니다.',
+                },
+                'kit-path': {
+                    en: 'Default mpgd-kit path written into generated target scripts.',
+                    ko: '생성되는 타깃 스크립트에 기록할 기본 mpgd-kit 경로.',
+                },
+                'dry-run': {
+                    en: 'Validate and print planned file changes without writing them.',
+                    ko: '파일을 쓰지 않고 예정 변경을 검증하고 출력합니다.',
+                },
+            }),
+            args: {
+                target: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Target to initialize. Currently supports microsoft-store.',
+                },
+                game: {
+                    type: 'string',
+                    required: false,
+                    default: '.',
+                    description: 'Existing game root. Defaults to the current directory.',
+                },
+                'kit-path': {
+                    type: 'string',
+                    required: false,
+                    description: 'Default mpgd-kit path written into generated target scripts.',
+                },
+                'dry-run': {
+                    type: 'boolean',
+                    required: false,
+                    description: 'Validate and print planned file changes without writing them.',
+                },
+            },
+            run: (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['target', 'init']);
+                const requestedTarget = readRequiredPositional(positionals, 0, 'target');
+                const target = normalizeConfiguredBuildTarget(requestedTarget);
+                if (target !== 'microsoft-store') {
+                    throw new Error(`Target initialization is only available for microsoft-store; received: ${requestedTarget}`);
+                }
+                const gameRoot = path.resolve(readOptionalString(ctx.values.game) ?? '.');
+                const configuredKitPath = readOptionalString(ctx.values['kit-path']);
+                const resolvedKitPath = configuredKitPath === undefined
+                    ? detectedKitRoot
+                    : assertKitRoot(path.resolve(configuredKitPath));
+                const defaultKitPath = resolvedKitPath === undefined
+                    ? defaultMpgdKitPath
+                    : toTemplatePath(path.relative(gameRoot, resolvedKitPath) || '.');
+                const dryRun = ctx.values['dry-run'] === true;
+                const result = initializeMicrosoftStoreStarter({
+                    gameRoot,
+                    templateRoot: gameTemplateDir,
+                    defaultKitPath,
+                    dryRun,
+                });
+                for (const file of result.changedFiles) {
+                }
+            },
+        }),
         build: defineI18n({
             name: 'build',
             description: 'Build one target artifact.',
@@ -833,6 +927,319 @@ const targetCommand = defineI18n({
                 });
             },
         }),
+        'generate-package': defineI18n({
+            name: 'generate-package',
+            description: 'Generate a packaged target artifact with an external platform service.',
+            resource: commandResource({
+                en: 'Generate a packaged target artifact with an external platform service.',
+                ko: '외부 플랫폼 서비스로 패키징된 타깃 산출물을 생성합니다.',
+            }, {
+                target: {
+                    en: 'Package target. Currently supports microsoft-store.',
+                    ko: '패키지 타깃. 현재 microsoft-store를 지원합니다.',
+                },
+                'pwa-url': {
+                    en: 'Public HTTPS URL of the deployed PWA.',
+                    ko: '배포된 PWA의 공개 HTTPS URL.',
+                },
+                'manifest-url': {
+                    en: 'Public HTTPS URL of the deployed web app manifest.',
+                    ko: '배포된 웹 앱 매니페스트의 공개 HTTPS URL.',
+                },
+                'package-version': {
+                    en: 'Modern Microsoft Store package version.',
+                    ko: '최신 Microsoft Store 패키지 버전.',
+                },
+                'classic-version': {
+                    en: 'Lower classic Microsoft Store package version.',
+                    ko: '최신 버전보다 낮은 클래식 Microsoft Store 패키지 버전.',
+                },
+                'submission-evidence': {
+                    en: 'Submission preflight evidence file.',
+                    ko: '제출 사전 검증 증적 파일.',
+                },
+                'output-file': {
+                    en: 'New game-owned ZIP file for the package generator response.',
+                    ko: '패키지 생성기 응답을 기록할 새 게임 소유 ZIP 파일.',
+                },
+                'output-dir': {
+                    en: 'Directory for package generation evidence.',
+                    ko: '패키지 생성 증적 디렉터리.',
+                },
+                'targets-file': {
+                    en: 'Game target config file.',
+                    ko: '게임 타깃 설정 파일.',
+                },
+            }),
+            args: {
+                target: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Package target. Currently supports microsoft-store.',
+                },
+                'pwa-url': {
+                    type: 'string',
+                    required: true,
+                    description: 'Public HTTPS URL of the deployed PWA.',
+                },
+                'manifest-url': {
+                    type: 'string',
+                    required: true,
+                    description: 'Public HTTPS URL of the deployed web app manifest.',
+                },
+                'package-version': {
+                    type: 'string',
+                    required: true,
+                    description: 'Modern Microsoft Store package version.',
+                },
+                'classic-version': {
+                    type: 'string',
+                    required: true,
+                    description: 'Lower classic Microsoft Store package version.',
+                },
+                'submission-evidence': {
+                    type: 'string',
+                    required: false,
+                    default: 'release-output/microsoft-store/submission-preflight.json',
+                    description: 'Submission preflight evidence file.',
+                },
+                'output-file': {
+                    type: 'string',
+                    required: false,
+                    default: 'release-input/microsoft-store/pwabuilder-package.zip',
+                    description: 'New game-owned ZIP file for the package generator response.',
+                },
+                'output-dir': {
+                    type: 'string',
+                    required: false,
+                    default: 'release-output/microsoft-store',
+                    description: 'Directory for package generation evidence.',
+                },
+                'targets-file': {
+                    type: 'string',
+                    required: false,
+                    default: 'mpgd.targets.json',
+                    description: 'Game target config file.',
+                },
+            },
+            run: async (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['target', 'generate-package']);
+                const target = normalizeBuildTarget(readRequiredPositional(positionals, 0, 'target'));
+                if (target !== 'microsoft-store') {
+                    throw new Error(`Package generation is not available for target: ${target}`);
+                }
+                const targetsFile = path.resolve(readOptionalString(ctx.values['targets-file']) ?? 'mpgd.targets.json');
+                const gameRoot = path.dirname(targetsFile);
+                const outputDir = resolveGameRelativePath(gameRoot, readOptionalString(ctx.values['output-dir']) ?? 'release-output/microsoft-store');
+                assertGameOwnedOutputDirectory(gameRoot, outputDir);
+                resolveMicrosoftStoreArtifactRoot(targetsFile);
+                const evidence = await runMicrosoftStorePackageGeneration({
+                    gameRoot,
+                    submissionEvidenceFile: resolveGameRelativePath(gameRoot, readOptionalString(ctx.values['submission-evidence'])
+                        ?? 'release-output/microsoft-store/submission-preflight.json'),
+                    pwaUrl: readOptionalString(ctx.values['pwa-url']) ?? '',
+                    manifestUrl: readOptionalString(ctx.values['manifest-url']) ?? '',
+                    modernVersion: readOptionalString(ctx.values['package-version']) ?? '',
+                    classicVersion: readOptionalString(ctx.values['classic-version']) ?? '',
+                    outputFile: resolveGameRelativePath(gameRoot, readOptionalString(ctx.values['output-file'])
+                        ?? 'release-input/microsoft-store/pwabuilder-package.zip'),
+                    jsonFile: path.join(outputDir, 'package-generation.json'),
+                    markdownFile: path.join(outputDir, 'package-generation.md'),
+                });
+            },
+        }),
+        preflight: defineI18n({
+            name: 'preflight',
+            description: 'Validate game-owned target submission inputs and write release evidence.',
+            resource: commandResource({
+                en: 'Validate game-owned target submission inputs and write release evidence.',
+                ko: '게임 소유 타깃 제출 입력을 검증하고 출시 증적을 작성합니다.',
+            }, {
+                target: {
+                    en: 'Submission target. Currently supports microsoft-store.',
+                    ko: '제출 타깃. 현재 microsoft-store를 지원합니다.',
+                },
+                'targets-file': {
+                    en: 'Game target config file.',
+                    ko: '게임 타깃 설정 파일.',
+                },
+                'kit-path': {
+                    en: 'Path to the mpgd-kit checkout used to resolve target config tokens.',
+                    ko: '타깃 설정 토큰 해석에 사용할 mpgd-kit 체크아웃 경로.',
+                },
+                'resolved-targets-file': {
+                    en: 'Output path for the resolved target config file.',
+                    ko: '해석된 타깃 설정 파일의 출력 경로.',
+                },
+                'submission-file': {
+                    en: 'Game-owned Microsoft Store submission config file.',
+                    ko: '게임 소유 Microsoft Store 제출 설정 파일.',
+                },
+                'output-dir': {
+                    en: 'Directory for deterministic submission evidence.',
+                    ko: '결정적 제출 증적을 기록할 디렉터리.',
+                },
+            }),
+            args: {
+                target: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Submission target. Currently supports microsoft-store.',
+                },
+                ...targetConfigArgs(),
+                'submission-file': {
+                    type: 'string',
+                    required: false,
+                    default: 'mpgd.microsoft-store.json',
+                    description: 'Game-owned Microsoft Store submission config file.',
+                },
+                'output-dir': {
+                    type: 'string',
+                    required: false,
+                    default: 'release-output/microsoft-store',
+                    description: 'Directory for deterministic submission evidence.',
+                },
+            },
+            run: (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['target', 'preflight']);
+                const target = normalizeBuildTarget(readRequiredPositional(positionals, 0, 'target'));
+                if (target !== 'microsoft-store') {
+                    throw new Error(`Submission preflight is not available for target: ${target}`);
+                }
+                const targetsFile = path.resolve(readOptionalString(ctx.values['targets-file']) ?? 'mpgd.targets.json');
+                const gameRoot = path.dirname(targetsFile);
+                const commandEnv = createTargetCommandEnv(ctx.values);
+                const preparedTargetsFile = commandEnv.MPGD_PLATFORM_TARGETS_FILE;
+                if (preparedTargetsFile === undefined || preparedTargetsFile.length === 0) {
+                    throw new Error('Failed to prepare the game target config for submission preflight.');
+                }
+                const configFile = resolveGameRelativePath(gameRoot, readOptionalString(ctx.values['submission-file']) ?? 'mpgd.microsoft-store.json');
+                const outputDir = resolveGameRelativePath(gameRoot, readOptionalString(ctx.values['output-dir']) ?? 'release-output/microsoft-store');
+                assertGameOwnedOutputDirectory(gameRoot, outputDir);
+                mkdirSync(outputDir, { recursive: true });
+                const evidence = runMicrosoftStoreSubmissionPreflight({
+                    gameRoot,
+                    artifactRoot: resolveMicrosoftStoreArtifactRoot(preparedTargetsFile),
+                    configFile,
+                    jsonFile: path.join(outputDir, 'submission-preflight.json'),
+                    markdownFile: path.join(outputDir, 'submission-preflight.md'),
+                });
+            },
+        }),
+        'accept-package': defineI18n({
+            name: 'accept-package',
+            description: 'Inspect packaged target artifacts and optionally run WACK.',
+            resource: commandResource({
+                en: 'Inspect packaged target artifacts and optionally run WACK.',
+                ko: '패키징된 타깃 산출물을 검사하고 선택적으로 WACK를 실행합니다.',
+            }, {
+                target: {
+                    en: 'Packaged target. Currently supports microsoft-store.',
+                    ko: '패키징 타깃. 현재 microsoft-store를 지원합니다.',
+                },
+                packages: {
+                    en: 'Comma-separated game-relative MSIX or AppX package paths.',
+                    ko: '쉼표로 구분한 게임 상대 MSIX 또는 AppX 패키지 경로.',
+                },
+                'targets-file': {
+                    en: 'Game target config file.',
+                    ko: '게임 타깃 설정 파일.',
+                },
+                'submission-evidence': {
+                    en: 'Submission preflight evidence file.',
+                    ko: '제출 사전 검증 증적 파일.',
+                },
+                'output-dir': {
+                    en: 'Directory for optional WACK reports and acceptance evidence.',
+                    ko: '선택적 WACK 리포트와 인수 증적을 기록할 디렉터리.',
+                },
+                appcert: {
+                    en: 'Optional appcert.exe path to opt into the recommended WACK check.',
+                    ko: '권장 WACK 검사를 선택 실행하기 위한 appcert.exe 경로.',
+                },
+                makeappx: {
+                    en: 'Optional path to makeappx.exe.',
+                    ko: '선택적 makeappx.exe 경로.',
+                },
+            }),
+            args: {
+                target: {
+                    type: 'positional',
+                    required: true,
+                    description: 'Packaged target. Currently supports microsoft-store.',
+                },
+                packages: {
+                    type: 'string',
+                    required: true,
+                    description: 'Comma-separated game-relative MSIX or AppX package paths.',
+                },
+                'targets-file': {
+                    type: 'string',
+                    required: false,
+                    default: 'mpgd.targets.json',
+                    description: 'Game target config file.',
+                },
+                'submission-evidence': {
+                    type: 'string',
+                    required: false,
+                    default: 'release-output/microsoft-store/submission-preflight.json',
+                    description: 'Submission preflight evidence file.',
+                },
+                'output-dir': {
+                    type: 'string',
+                    required: false,
+                    default: 'release-output/microsoft-store',
+                    description: 'Directory for optional WACK reports and acceptance evidence.',
+                },
+                appcert: {
+                    type: 'string',
+                    required: false,
+                    description: 'Optional appcert.exe path to opt into the recommended WACK check.',
+                },
+                makeappx: {
+                    type: 'string',
+                    required: false,
+                    description: 'Optional path to makeappx.exe.',
+                },
+            },
+            run: (ctx) => {
+                const positionals = readLocalPositionals(ctx.positionals, ['target', 'accept-package']);
+                const target = normalizeBuildTarget(readRequiredPositional(positionals, 0, 'target'));
+                if (target !== 'microsoft-store') {
+                    throw new Error(`Package acceptance is not available for target: ${target}`);
+                }
+                const targetsFile = path.resolve(readOptionalString(ctx.values['targets-file']) ?? 'mpgd.targets.json');
+                const gameRoot = path.dirname(targetsFile);
+                const packageList = readOptionalString(ctx.values.packages);
+                if (packageList === undefined) {
+                    throw new Error('--packages must be a non-empty comma-separated list.');
+                }
+                const packages = packageList
+                    .split(',')
+                    .map((file) => file.trim())
+                    .filter((file) => file.length > 0)
+                    .map((file) => resolveGameRelativePath(gameRoot, file));
+                if (packages.length === 0) {
+                    throw new Error('--packages must be a non-empty comma-separated list.');
+                }
+                const outputDir = resolveGameRelativePath(gameRoot, readOptionalString(ctx.values['output-dir']) ?? 'release-output/microsoft-store');
+                const appCertExecutable = readOptionalString(ctx.values.appcert);
+                const makeAppxExecutable = readOptionalString(ctx.values.makeappx);
+                resolveMicrosoftStoreArtifactRoot(targetsFile);
+                assertGameOwnedOutputDirectory(gameRoot, outputDir);
+                mkdirSync(outputDir, { recursive: true });
+                const evidence = runMicrosoftStorePackageAcceptance({
+                    gameRoot,
+                    submissionEvidenceFile: resolveGameRelativePath(gameRoot, readOptionalString(ctx.values['submission-evidence'])
+                        ?? 'release-output/microsoft-store/submission-preflight.json'),
+                    packageFiles: packages,
+                    outputDir,
+                }, createMicrosoftStorePackageAcceptanceRuntime({
+                    ...(appCertExecutable === undefined ? {} : { appCertExecutable }),
+                    ...(makeAppxExecutable === undefined ? {} : { makeAppxExecutable }),
+                }));
+            },
+        }),
         'build-all': defineI18n({
             name: 'build-all',
             description: 'Build multiple target artifacts.',
@@ -1164,17 +1571,54 @@ function createGameApp(input) {
         workspace: input.workspace,
         ...(input.kitPath === undefined ? {} : { kitPath: input.kitPath }),
         ...(input.title === undefined ? {} : { title: input.title }),
+        microsoftStore: input.microsoftStore,
+    });
+    const files = collectTemplateFiles(gameTemplateDir).flatMap((file) => {
+        const prepared = prepareBaseGameTemplateFile({
+            relativePath: file.relativePath,
+            content: file.content,
+        });
+        return prepared === undefined
+            ? []
+            : [{ ...file, content: renderTemplate(prepared, context) }];
     });
-    const files = collectTemplateFiles(gameTemplateDir);
     if (input.dryRun) {
-        for (const file of files) {
+        const plannedFiles = input.microsoftStore
+            ? [...files.map((file) => file.relativePath), ...listMicrosoftStoreInitializerTemplateFiles()]
+            : files.map((file) => file.relativePath);
+        for (const relativePath of [...new Set(plannedFiles)].sort()) {
         }
         return;
     }
-    for (const file of files) {
-        const outputFile = path.join(appDir, file.relativePath);
-        mkdirSync(path.dirname(outputFile), { recursive: true });
-        writeFileSync(outputFile, renderTemplate(file.content, context));
+    let createdAppDirectory = false;
+    try {
+        mkdirSync(path.dirname(appDir), { recursive: true });
+        mkdirSync(appDir);
+        createdAppDirectory = true;
+        for (const file of files) {
+            const outputFile = path.join(appDir, file.relativePath);
+            mkdirSync(path.dirname(outputFile), { recursive: true });
+            writeFileSync(outputFile, file.content);
+        }
+        if (input.microsoftStore) {
+            initializeMicrosoftStoreStarter({
+                gameRoot: appDir,
+                templateRoot: gameTemplateDir,
+                defaultKitPath: context.defaultKitPath,
+                dryRun: false,
+            });
+        }
+    }
+    catch (error) {
+        if (createdAppDirectory) {
+            try {
+                rmSync(appDir, { force: true, recursive: true });
+            }
+            catch (cleanupError) {
+                console.warn(`Failed to clean up incomplete game directory ${appDir}: ${formatError(cleanupError)}`);
+            }
+        }
+        throw error;
     }
 }
 function assertValidGameName(name) {
@@ -1248,7 +1692,10 @@ function createTemplateContext(input) {
         workspaceI18nBuildPrefix: input.workspace
             ? `pnpm --dir ${workspacePrefix} i18n:build && `
             : '',
-        defaultKitPath: kitPath === undefined ? '../mpgd-kit' : workspacePrefix,
+        defaultKitPath: kitPath === undefined ? defaultMpgdKitPath : workspacePrefix,
+        recommendedMatrixTargets: input.microsoftStore
+            ? recommendedMatrixTargets
+            : recommendedMatrixTargetsWithoutMicrosoftStore,
         pnpmWorkspaceKitPackages: input.workspace
             ? [
                 `  - '${workspacePrefix}/packages/*'`,
@@ -1340,6 +1787,7 @@ function renderTemplate(content, context) {
         .replaceAll('__TSCONFIG_WORKSPACE_EXCLUDES__', context.tsconfigWorkspaceExcludes)
         .replaceAll('__WORKSPACE_I18N_BUILD_PREFIX__', context.workspaceI18nBuildPrefix)
         .replaceAll('__DEFAULT_KIT_PATH__', context.defaultKitPath)
+        .replaceAll('__RECOMMENDED_MATRIX_TARGETS__', context.recommendedMatrixTargets)
         .replaceAll('__PNPM_WORKSPACE_KIT_PACKAGES__', context.pnpmWorkspaceKitPackages)
         .replaceAll('__PASCAL_NAME__', context.pascalName)
         .replaceAll('__CAMEL_NAME__', context.camelName);
@@ -1620,6 +2068,47 @@ function readConfiguredTargetsFile(env) {
     }
     return file;
 }
+function resolveMicrosoftStoreArtifactRoot(targetsFile) {
+    const parsed = readJsonForCli(targetsFile);
+    assertJsonObject(parsed, `targets file ${targetsFile}`);
+    assertJsonObject(parsed.targets, `targets in ${targetsFile}`);
+    const target = parsed.targets['microsoft-store'];
+    assertJsonObject(target, `microsoft-store target in ${targetsFile}`);
+    if (target.kind !== 'web') {
+        throw new Error(`Microsoft Store target in ${targetsFile} must use kind web.`);
+    }
+    const output = readOptionalString(target.output);
+    if (output === undefined) {
+        throw new Error(`Microsoft Store target in ${targetsFile} must declare output.`);
+    }
+    return resolveGameRelativePath(path.dirname(targetsFile), output);
+}
+function resolveGameRelativePath(gameRoot, candidate) {
+    return path.resolve(gameRoot, candidate);
+}
+function assertGameOwnedOutputDirectory(gameRoot, outputDir) {
+    const canonicalGameRoot = realpathSync(gameRoot);
+    const canonicalOutputDir = resolvePotentiallyMissingPath(outputDir);
+    const relative = path.relative(canonicalGameRoot, canonicalOutputDir);
+    if (relative.length === 0
+        || relative === '..'
+        || relative.startsWith(`..${path.sep}`)
+        || path.isAbsolute(relative)) {
+        throw new Error(`Microsoft Store submission output directory must stay inside the game root: ${canonicalOutputDir} is not inside ${canonicalGameRoot}.`);
+    }
+}
+function resolvePotentiallyMissingPath(input) {
+    const resolved = path.resolve(input);
+    let existingAncestor = resolved;
+    while (!existsSync(existingAncestor)) {
+        const parent = path.dirname(existingAncestor);
+        if (parent === existingAncestor) {
+            throw new Error(`Could not find an existing ancestor for output path: ${resolved}`);
+        }
+        existingAncestor = parent;
+    }
+    return path.resolve(realpathSync(existingAncestor), path.relative(existingAncestor, resolved));
+}
 function normalizeConfiguredBuildTarget(target) {
     try {
         return normalizeBuildTarget(target);