@mpgd/cli 0.20.1 → 0.22.0

package/dist/microsoft-store-submission.js

@@ -41,6 +41,7 @@ export function runMicrosoftStoreSubmissionPreflight(input) {
     const artifactRoot = readCanonicalDirectoryInside(gameRoot, input.artifactRoot, 'Microsoft Store artifact root');
     const configFile = readCanonicalFileInside(gameRoot, input.configFile, 'Microsoft Store submission config');
     const config = parseMicrosoftStoreSubmissionConfig(readJson(configFile, 'submission config'));
+    const effectiveTarget = readMicrosoftStoreEffectiveTarget(artifactRoot, config.commerce);
     const manifestFile = readCanonicalFileInside(artifactRoot, path.join(artifactRoot, 'manifest.webmanifest'), 'Microsoft Store web app manifest');
     const manifestSnapshot = readJsonSnapshot(manifestFile, 'web app manifest', 1024 * 1024);
     const manifest = parseManifest(manifestSnapshot.value, artifactRoot);
@@ -48,6 +49,7 @@ export function runMicrosoftStoreSubmissionPreflight(input) {
     const protectedFiles = [
         { file: configFile, label: 'Microsoft Store submission config' },
         { file: manifestFile, label: 'Microsoft Store web app manifest' },
+        { file: effectiveTarget.file, label: 'Microsoft Store effective target config' },
         ...manifest.icons.map((icon) => ({
             file: icon.file,
             label: 'Microsoft Store web app manifest icon',
@@ -97,6 +99,10 @@ export function runMicrosoftStoreSubmissionPreflight(input) {
                 height: icon.height,
             })),
         },
+        effectiveTarget: {
+            file: relativeOrAbsolute(gameRoot, effectiveTarget.file),
+            sha256: effectiveTarget.sha256,
+        },
         listing: {
             category: config.listing.category,
             supportUrl: config.listing.supportUrl,
@@ -117,6 +123,70 @@ export function runMicrosoftStoreSubmissionPreflight(input) {
     writeFileSync(markdownFile, renderMicrosoftStoreSubmissionMarkdown(evidence));
     return evidence;
 }
+function readMicrosoftStoreEffectiveTarget(artifactRoot, commerce) {
+    const file = readCanonicalFileInside(artifactRoot, path.join(artifactRoot, 'mpgd-effective-target.json'), 'Microsoft Store effective target config');
+    const snapshot = readJsonSnapshot(file, 'Microsoft Store effective target config', 4 * 1024 * 1024);
+    assertMicrosoftStoreEffectiveTarget(snapshot.value, commerce);
+    return { file, sha256: hashBytes(snapshot.bytes) };
+}
+export function assertMicrosoftStoreEffectiveTarget(input, commerce) {
+    const root = requireRecord(input, 'Microsoft Store effective target config');
+    if (root.target !== 'microsoft-store' || root.runtime !== 'microsoft-store-pwa') {
+        throw new Error('Microsoft Store effective target config must target the microsoft-store-pwa runtime.');
+    }
+    const monetization = requireRecord(root.monetization, 'Microsoft Store effective target config monetization');
+    const rawProducts = requireArray(monetization.products, 'Microsoft Store effective target config products');
+    if (commerce.mode === 'disabled') {
+        if (monetization.iap !== false) {
+            throw new Error('Microsoft Store effective target config must disable IAP when commerce mode is disabled.');
+        }
+        for (const [index, rawProduct] of rawProducts.entries()) {
+            const product = requireRecord(rawProduct, `Microsoft Store effective target config products[${String(index)}]`);
+            if (product.enabled !== false) {
+                throw new Error(`Microsoft Store effective target config products[${String(index)}] must be disabled when commerce mode is disabled.`);
+            }
+        }
+        return;
+    }
+    if (monetization.iap !== true) {
+        throw new Error('Microsoft Store effective target config must enable IAP.');
+    }
+    const seenProductIds = new Set();
+    const seenPlatformProductIds = new Set();
+    const products = rawProducts.flatMap((rawProduct, index) => {
+        const product = requireRecord(rawProduct, `Microsoft Store effective target config products[${String(index)}]`);
+        if (product.enabled !== true) {
+            return [];
+        }
+        if (product.type !== 'consumable') {
+            throw new Error('Microsoft Store effective target config can only enable consumables.');
+        }
+        const id = requireProductionString(product.id, `Microsoft Store effective target config products[${String(index)}].id`);
+        const platformProductId = requireProductionString(product.platformProductId, `Microsoft Store effective target config products[${String(index)}].platformProductId`);
+        if (seenProductIds.has(id)) {
+            throw new Error(`Microsoft Store effective target config duplicates product ${id}.`);
+        }
+        if (seenPlatformProductIds.has(platformProductId)) {
+            throw new Error(`Microsoft Store effective target config duplicates platformProductId ${platformProductId}.`);
+        }
+        seenProductIds.add(id);
+        seenPlatformProductIds.add(platformProductId);
+        return [{ id, platformProductId }];
+    });
+    if (products.length !== commerce.products.length) {
+        throw new Error('commerce.products must exactly match enabled Microsoft Store consumables in the built artifact.');
+    }
+    const productsById = new Map(products.map((product) => [product.id, product]));
+    for (const product of commerce.products) {
+        const effectiveProduct = productsById.get(product.logicalProductId);
+        if (effectiveProduct === undefined) {
+            throw new Error(`commerce product ${product.logicalProductId} is not present in the built artifact effective target.`);
+        }
+        if (effectiveProduct.platformProductId !== product.inAppOfferToken) {
+            throw new Error(`commerce product ${product.logicalProductId} InAppOfferToken ${product.inAppOfferToken} does not match built artifact platformProductId ${effectiveProduct.platformProductId}.`);
+        }
+    }
+}
 export function parseMicrosoftStoreSubmissionConfig(input) {
     const root = requireRecord(input, 'Microsoft Store submission config');
     if (root.schemaVersion !== microsoftStoreSubmissionSchemaVersion) {
@@ -141,9 +211,7 @@ export function parseMicrosoftStoreSubmissionConfig(input) {
     if (ageRating.questionnaireCompleted !== true) {
         throw new Error('ageRating.questionnaireCompleted must be true before submission.');
     }
-    if (commerce.mode !== 'disabled') {
-        throw new Error('commerce.mode must stay disabled until Microsoft Store commerce is backed by server-side ledger verification.');
-    }
+    const parsedCommerce = parseMicrosoftStoreSubmissionCommerce(commerce);
     const iarcId = optionalProductionString(ageRating.iarcId, 'ageRating.iarcId');
     return {
         schemaVersion: microsoftStoreSubmissionSchemaVersion,
@@ -166,9 +234,56 @@ export function parseMicrosoftStoreSubmissionConfig(input) {
             questionnaireCompleted: true,
             ...(iarcId === undefined ? {} : { iarcId }),
         },
-        commerce: { mode: 'disabled' },
+        commerce: parsedCommerce,
     };
 }
+export function parseMicrosoftStoreSubmissionCommerce(input) {
+    if (input.mode === 'disabled') {
+        return { mode: 'disabled' };
+    }
+    if (input.mode !== 'microsoft-store') {
+        throw new Error('commerce.mode must be disabled or microsoft-store.');
+    }
+    if (input.productType !== 'developer-managed-consumable') {
+        throw new Error('commerce.productType must be developer-managed-consumable for Digital Goods purchases.');
+    }
+    if (input.fulfillment !== 'authoritative-server') {
+        throw new Error('commerce.fulfillment must be authoritative-server for server-side ledger verification.');
+    }
+    if (input.authoritativeGameServices !== true) {
+        throw new Error('commerce.authoritativeGameServices must be true.');
+    }
+    const rawProducts = requireArray(input.products, 'commerce.products');
+    if (rawProducts.length === 0) {
+        throw new Error('commerce.products must contain at least one product.');
+    }
+    const logicalProductIds = new Set();
+    const inAppOfferTokens = new Set();
+    const storeIds = new Set();
+    const products = rawProducts.map((rawProduct, index) => {
+        const product = requireRecord(rawProduct, `commerce.products[${String(index)}]`);
+        const logicalProductId = requireProductionString(product.logicalProductId, `commerce.products[${String(index)}].logicalProductId`);
+        const inAppOfferToken = requireProductionString(product.inAppOfferToken, `commerce.products[${String(index)}].inAppOfferToken`);
+        const storeId = requireProductionString(product.storeId, `commerce.products[${String(index)}].storeId`);
+        assertUniqueCommerceIdentifier(logicalProductIds, logicalProductId, 'logicalProductId');
+        assertUniqueCommerceIdentifier(inAppOfferTokens, inAppOfferToken, 'inAppOfferToken');
+        assertUniqueCommerceIdentifier(storeIds, storeId, 'storeId');
+        return { logicalProductId, inAppOfferToken, storeId };
+    });
+    return {
+        mode: 'microsoft-store',
+        productType: 'developer-managed-consumable',
+        fulfillment: 'authoritative-server',
+        authoritativeGameServices: true,
+        products,
+    };
+}
+function assertUniqueCommerceIdentifier(seen, value, field) {
+    if (seen.has(value)) {
+        throw new Error(`commerce.products must use unique ${field} values; duplicate value "${value}" found.`);
+    }
+    seen.add(value);
+}
 export function renderMicrosoftStoreSubmissionMarkdown(evidence) {
     const lines = [
         '# Microsoft Store Submission Preflight',
@@ -178,11 +293,22 @@ export function renderMicrosoftStoreSubmissionMarkdown(evidence) {
         `- Publisher ID: ${escapeMarkdownInline(evidence.productIdentity.publisherId)}`,
         `- Reserved name: ${escapeMarkdownInline(evidence.productIdentity.reservedName)}`,
         `- Manifest: ${escapeMarkdownInline(evidence.manifest.file)} (${evidence.manifest.sha256})`,
+        `- Effective target: ${escapeMarkdownInline(evidence.effectiveTarget.file)} (${evidence.effectiveTarget.sha256})`,
         `- Manifest icons: ${evidence.manifest.iconCount}`,
         `- Commerce: ${evidence.commerce.mode}`,
         `- Personal data accessed or transmitted: ${String(evidence.listing.personalData.accessedOrTransmitted)}`,
         `- Privacy policy: ${escapeMarkdownInline(evidence.listing.personalData.privacyPolicyUrl ?? 'Not required')}`,
         '',
+        ...(evidence.commerce.mode === 'microsoft-store'
+            ? [
+                '## Commerce Products',
+                '',
+                '| Logical product | InAppOfferToken | Store ID |',
+                '| --- | --- | --- |',
+                ...evidence.commerce.products.map((product) => (`| ${escapeMarkdownTable(product.logicalProductId)} | ${escapeMarkdownTable(product.inAppOfferToken)} | ${escapeMarkdownTable(product.storeId)} |`)),
+                '',
+            ]
+            : []),
         '## Store Listings',
         '',
         '| Locale | Screenshots | Description |',
@@ -495,6 +621,7 @@ function requireProductionString(input, label) {
     const exactTemplateToken = /^(?:TODO|FIXME|PLACEHOLDER|DUMMY|(?:CHANGE|REPLACE)[-_ ]?ME|LOREM(?:_IPSUM)?)$/iu;
     const templateIdentityField = label.startsWith('productIdentity.')
         || label.startsWith('web app manifest')
+        || label.startsWith('commerce.products[')
         || label === 'ageRating.iarcId';
     if (exactTemplateToken.test(value)
         || (templateIdentityField

package/dist/offline-playtest.d.ts

@@ -0,0 +1,31 @@
+export declare const defaultOfflinePlaytestArtifactDir = "artifacts/web-preview";
+export declare const defaultOfflinePlaytestOutputDir = "artifacts/offline-playtest";
+export declare const defaultOfflinePlaytestMaximumBytes: number;
+export declare const offlinePlaytestSchemaVersion = "1";
+export interface RunOfflinePlaytestPackagingInput {
+  readonly gameRoot: string;
+  readonly artifactDir?: string;
+  readonly outputDir?: string;
+  readonly maximumBytes?: number;
+}
+export interface OfflinePlaytestEvidence {
+  readonly schemaVersion: typeof offlinePlaytestSchemaVersion;
+  readonly purpose: 'test-play-only';
+  readonly releaseTarget: false;
+  readonly sourceTarget: 'web-preview';
+  readonly sourceRuntime: 'web-preview';
+  readonly networkPolicy: 'deny-network';
+  readonly entryFile: 'index.html';
+  readonly bytes: number;
+  readonly sha256: string;
+  readonly inlinedAssetCount: number;
+  readonly limitations: readonly string[];
+}
+export interface RunOfflinePlaytestPackagingResult {
+  readonly outputDir: string;
+  readonly entryFile: string;
+  readonly readmeFile: string;
+  readonly evidenceFile: string;
+  readonly evidence: OfflinePlaytestEvidence;
+}
+export declare function runOfflinePlaytestPackaging(input: RunOfflinePlaytestPackagingInput): Promise<RunOfflinePlaytestPackagingResult>;