@mpgd/cli 0.12.0 → 0.14.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

@@ -8,10 +8,16 @@ 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 { 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);
@@ -727,10 +733,10 @@ 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: {
         build: defineI18n({
@@ -833,6 +839,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.',
@@ -1620,6 +1939,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);

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

@@ -0,0 +1,54 @@
+export declare const microsoftStorePackageAcceptanceSchemaVersion: 1;
+export interface MicrosoftStorePackageIdentity {
+  readonly name: string;
+  readonly publisher: string;
+  readonly version: string;
+}
+export interface MicrosoftStorePackageAcceptanceEvidence {
+  readonly schemaVersion: 1;
+  readonly target: 'microsoft-store';
+  readonly submissionEvidenceFile: string;
+  readonly submissionEvidenceSha256: string;
+  readonly productIdentity: {
+    readonly packageId: string;
+    readonly publisherId: string;
+    readonly publisherDisplayName: string;
+    readonly reservedName: string;
+  };
+  readonly packages: readonly {
+    readonly file: string;
+    readonly sizeBytes: number;
+    readonly sha256: string;
+    readonly identity: MicrosoftStorePackageIdentity;
+    readonly payloadIdentities: readonly MicrosoftStorePackageIdentity[];
+    readonly certification: {
+      readonly result: 'NOT_RUN';
+    } | {
+      readonly result: 'PASS';
+      readonly reportFile: string;
+      readonly reportSha256: string;
+    };
+  }[];
+}
+export interface RunMicrosoftStorePackageAcceptanceInput {
+  readonly gameRoot: string;
+  readonly submissionEvidenceFile: string;
+  readonly packageFiles: readonly string[];
+  readonly outputDir: string;
+}
+export interface MicrosoftStorePackageAcceptanceRuntime {
+  readonly platform: NodeJS.Platform;
+  readonly appCertExecutable?: string;
+  readonly makeAppxExecutable: string;
+  readonly runCommand: (command: string, args: readonly string[]) => void;
+}
+export interface CreateMicrosoftStorePackageAcceptanceRuntimeInput {
+  readonly appCertExecutable?: string;
+  readonly makeAppxExecutable?: string;
+}
+export declare function createMicrosoftStorePackageAcceptanceRuntime(input?: CreateMicrosoftStorePackageAcceptanceRuntimeInput): MicrosoftStorePackageAcceptanceRuntime;
+export declare function findMicrosoftStoreMakeAppxExecutable(windowsKitsDir: string, architecture: NodeJS.Architecture): string;
+export declare function runMicrosoftStorePackageAcceptance(input: RunMicrosoftStorePackageAcceptanceInput, runtime?: MicrosoftStorePackageAcceptanceRuntime): MicrosoftStorePackageAcceptanceEvidence;
+export declare function parseMicrosoftStorePackageIdentity(xml: string): MicrosoftStorePackageIdentity;
+export declare function parseWindowsAppCertificationResult(xml: string): 'PASS' | 'FAIL';
+export declare function renderMicrosoftStorePackageAcceptanceMarkdown(evidence: MicrosoftStorePackageAcceptanceEvidence): string;