@mpgd/cli 0.57.0 → 0.58.0

package/dist/capacitor-shell-starter.d.ts

@@ -137,4 +137,34 @@ export declare function androidManifestRemovesExactAlarm(manifest: string): bool
 * returned unchanged.
 */
 export declare function applyAndroidManifestInexactAlarms(manifest: string): string;
+/** The kit's messaging service that renders Android advertising pushes with the opt-out action. */
+export declare const androidAdvertisingRendererService = "dev.mpgd.capacitor.AdvertisingMessagingService";
+/** The messaging service `@capacitor-firebase/messaging` 8.x declares, which the renderer replaces. */
+export declare const androidMessagingPluginService = "io.capawesome.capacitorjs.plugins.firebase.messaging.MessagingService";
+/** The meta-data the renderer's service declares, which `getAdvertisingPushRenderer` reads. */
+export declare const androidAdvertisingRendererMetaData = "dev.mpgd.notifications.advertising_renderer";
+/** The renderer's service element, then the removal of the plugin's service. */
+export declare const androidAdvertisingRendererEntries: readonly string[];
+/**
+* Whether an Android manifest declares the kit's advertising renderer as its
+* messaging service, with the messaging event and its meta-data, and removes
+* the plugin's service. Comments do not count.
+*/
+export declare function androidManifestRendersAdvertising(manifest: string): boolean;
+/**
+* Declares the kit's advertising renderer as the shell's messaging service
+* inside `<application>` (`androidAdvertisingRendererEntries`), binding the
+* tools namespace on the manifest root when missing. Each part is added only
+* when it is missing, so a manifest that has one keeps it once; a renderer
+* service that is declared but incomplete is left for the game to fix (the
+* initializer warns). A manifest this cannot place it in (no `<application>`
+* with a closing tag) is returned unchanged.
+*/
+export declare function applyAndroidManifestAdvertisingRenderer(manifest: string): string;
+/**
+* The initializer's warning for a game-owned Android manifest without the
+* kit's advertising renderer: the manifest lines, the provider wiring, and
+* the deployment switch. `undefined` when the manifest has the renderer.
+*/
+export declare function androidAdvertisingRendererWarning(manifest: string): string | undefined;
 export {};

package/dist/capacitor-shell-starter.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { DOMParser } from '@xmldom/xmldom';
 import { satisfies, valid, validRange } from 'semver';
 import { capacitorGatewayRegistersNotifications, conflictingPushPlugin, notificationsCapacitorGatewayModules, notificationsCapacitorGateways, notificationsCapacitorSupportFiles, notificationsCapacitorTemplateSupportFiles, notificationsCapacitorTemplateSupportImporters, notificationsGameDependencies, notificationsMessagingFirebaseRange, notificationsMessagingPlugin, notificationsProviderId, notificationsShellPlugins, sourceReferencesRelativeModule, wireCapacitorGatewayNotifications, } from './notifications-starter.js';
+import { addIosAppResource, applyAndroidManifestAdId, applyAndroidManifestOrientation, applyIosInfoPlistOrientation, applyIosInfoPlistStorePolicy, applyIosProjectDeviceFamily, iosAppPrivacyManifestFile, iosAppPrivacyManifestXml, isRecord, readGameAdvertisingIdPolicy, readGameNativeOrientation, readIosDeviceFamily, shellUsesAdMob, } from './native-shell-store-policy.js';
 import { isNonPublicServiceHostname } from './production-target-readiness.js';
 import { assertAndroidSettingsAppProject, assertAndroidSettingsNoAppRemap, assertIosReleaseInfoPlistExpansion, assertIosReleasePackagingSettings, assertIosReleaseProductName, assertNativeShellIdentity, hasAndroidDisplayNameResourceOverride, hasAndroidManifestSourceSetOverride, hasAndroidResourceSourceSetOverride, hasGradleIdentityMutation, hasGradleTaskAction, maskGradleStrings, readIosAppTargetId, readIosReleaseInfoPlist, stripGradleComments, } from './native-shell-identity.js';
 const shellPath = 'apps/mobile-capacitor';
@@ -153,6 +154,9 @@ export function planCapacitorShellStarter(input) {
     const cliDevelopmentDependencies = requireObject(cliPackage.devDependencies, 'CLI dev dependencies');
     const typescriptVersion = requireString(cliDevelopmentDependencies.typescript, 'CLI TypeScript version');
     const targetMap = requireObject(targets.targets, 'targets');
+    // Fail before anything is installed or generated when the store-facing
+    // native settings are invalid; they are applied after `cap add`.
+    readNativeShellSettings(gameRoot);
     for (const plugin of capacitorShellProviderPlugins) {
         if (providerIds.includes(plugin.id) && targetMap[plugin.platform] === undefined) {
             throw new Error(`--providers ${plugin.id} installs the ${plugin.platform} store plugin into the native `
@@ -653,7 +657,12 @@ export function materializeCapacitorShellStarter(plan, runner = { run: runComman
             materializeAndroidBackupPolicy(plan.gameRoot);
             if (plan.notificationPlugins.length > 0) {
                 materializeAndroidInexactAlarms(plan.gameRoot);
+                materializeAndroidAdvertisingRenderer(plan.gameRoot);
             }
+            materializeAndroidStorePolicy(plan.gameRoot);
+        }
+        if (platform === 'ios' && generatedNow) {
+            materializeIosStorePolicy(plan.gameRoot);
         }
         if (platform === 'ios') {
             materializeIosArchiveScheme(plan.gameRoot);
@@ -800,6 +809,89 @@ export function applyAndroidManifestBackupPolicy(manifest) {
     applicationTag = applicationTag.replace(/^<application\b/u, `<application${attributes}`);
     return `${manifest.slice(0, root.index)}${rootTag}${manifest.slice(root.index + root[0].length, application.index)}${applicationTag}${manifest.slice(application.index + application[0].length)}`;
 }
+/**
+ * Store-facing Info.plist keys for a freshly generated iOS project only
+ * (`applyIosInfoPlistStorePolicy`); an existing game-owned project is left
+ * alone and the production build reports what it lacks.
+ */
+function materializeIosStorePolicy(gameRoot) {
+    const settings = readNativeShellSettings(gameRoot);
+    const plistFile = safeDestination(gameRoot, `${shellPath}/ios/App/App/Info.plist`);
+    if (existsSync(plistFile) && lstatSync(plistFile).isFile()) {
+        const source = readFileSync(plistFile, 'utf8');
+        let next = applyIosInfoPlistStorePolicy(source);
+        if (settings.orientation !== undefined) {
+            next = applyIosInfoPlistOrientation(next, settings.orientation);
+        }
+        if (next !== source) {
+            writeFileSync(plistFile, next);
+        }
+    }
+    const projectFile = safeDestination(gameRoot, `${shellPath}/ios/App/App.xcodeproj/project.pbxproj`);
+    const source = readFileSync(projectFile, 'utf8');
+    let next = settings.iosDeviceFamily === undefined
+        ? source
+        : applyIosProjectDeviceFamily(source, settings.iosDeviceFamily);
+    // The app-level privacy manifest joins the App group and Resources phase of
+    // the Capacitor-generated layout; any other layout is left to the game and
+    // reported by the build.
+    const manifestFile = safeDestination(gameRoot, `${shellPath}/ios/App/App/${iosAppPrivacyManifestFile}`);
+    const withManifest = addIosAppResource(next, iosAppPrivacyManifestFile);
+    if (withManifest === undefined) {
+        console.warn(`[mpgd] The generated iOS project has an unexpected layout; add ${iosAppPrivacyManifestFile} `
+            + 'to the App target yourself.');
+    }
+    else {
+        if (!existsSync(manifestFile)) {
+            writeFileSync(manifestFile, iosAppPrivacyManifestXml, { flag: 'wx' });
+        }
+        next = withManifest;
+    }
+    if (next !== source) {
+        writeFileSync(projectFile, next);
+    }
+}
+/**
+ * Orientation of a freshly generated Android project's launcher activity,
+ * `android:appCategory="game"`, and the advertising ID permission (declared
+ * when the shell installs AdMob and mpgd.game.json does not set
+ * `ads.admob.advertisingId` to "removed", removed otherwise); an existing
+ * project is only reported by the production build.
+ */
+function materializeAndroidStorePolicy(gameRoot) {
+    const manifestFile = safeDestination(gameRoot, `${shellPath}/android/app/src/main/AndroidManifest.xml`);
+    if (!existsSync(manifestFile) || !lstatSync(manifestFile).isFile()) {
+        return;
+    }
+    const source = readFileSync(manifestFile, 'utf8');
+    const settings = readNativeShellSettings(gameRoot);
+    const shellPackageFile = path.join(gameRoot, shellPath, 'package.json');
+    const usesAds = existsSync(shellPackageFile) && shellUsesAdMob(readJsonObject(shellPackageFile));
+    const next = applyAndroidManifestAdId(applyAndroidManifestOrientation(source, settings.orientation ?? 'any'), usesAds && settings.advertisingId !== 'removed');
+    if (next !== source) {
+        writeFileSync(manifestFile, next);
+    }
+}
+/**
+ * The game's design orientation and advertising ID policy (mpgd.game.json)
+ * and iOS device family (ios target metadata).
+ */
+function readNativeShellSettings(gameRoot) {
+    const gameConfigFile = path.join(gameRoot, 'mpgd.game.json');
+    const gameConfig = existsSync(gameConfigFile)
+        ? parseJsonObject(readFileSync(gameConfigFile, 'utf8'), 'mpgd.game.json')
+        : undefined;
+    const orientation = readGameNativeOrientation(gameConfig);
+    const advertisingId = readGameAdvertisingIdPolicy(gameConfig);
+    const targets = readJsonObject(path.join(gameRoot, 'mpgd.targets.json'));
+    const ios = isRecord(targets.targets) ? targets.targets.ios : undefined;
+    const iosDeviceFamily = readIosDeviceFamily(isRecord(ios) ? ios.metadata : undefined);
+    return {
+        ...(orientation === undefined ? {} : { orientation }),
+        ...(iosDeviceFamily === undefined ? {} : { iosDeviceFamily }),
+        advertisingId,
+    };
+}
 function materializeIosArchiveScheme(gameRoot) {
     const schemeRelative = `${shellPath}/ios/App/App.xcodeproj/xcshareddata/xcschemes/App.xcscheme`;
     const schemeFile = safeDestination(gameRoot, schemeRelative);
@@ -2600,6 +2692,132 @@ export function applyAndroidManifestInexactAlarms(manifest) {
     const head = `${manifest.slice(0, root.index)}${rootTag}${manifest.slice(root.index + root[0].length, close)}`;
     return `${head.trimEnd()}${newline}    ${androidInexactAlarmPermission}${newline}${manifest.slice(close)}`;
 }
+/** The kit's messaging service that renders Android advertising pushes with the opt-out action. */
+export const androidAdvertisingRendererService = 'dev.mpgd.capacitor.AdvertisingMessagingService';
+/** The messaging service `@capacitor-firebase/messaging` 8.x declares, which the renderer replaces. */
+export const androidMessagingPluginService = 'io.capawesome.capacitorjs.plugins.firebase.messaging.MessagingService';
+/** The meta-data the renderer's service declares, which `getAdvertisingPushRenderer` reads. */
+export const androidAdvertisingRendererMetaData = 'dev.mpgd.notifications.advertising_renderer';
+/**
+ * The manifest entries that make the kit's renderer the shell's one Firebase
+ * messaging service (notifications RFC "Capacitor"). Android hands a
+ * messaging event to one service, so the plugin's own is removed from the
+ * merge; the kit's forwards every message it does not render, and every new
+ * token, to the plugin.
+ */
+const androidAdvertisingRendererServiceEntry = [
+    `<service android:name="${androidAdvertisingRendererService}" android:exported="false">`,
+    '    <intent-filter>',
+    '        <action android:name="com.google.firebase.MESSAGING_EVENT" />',
+    '    </intent-filter>',
+    `    <meta-data android:name="${androidAdvertisingRendererMetaData}" android:value="true" />`,
+    '</service>',
+];
+const androidMessagingPluginServiceRemoval = `<service android:name="${androidMessagingPluginService}" tools:node="remove" />`;
+/** The renderer's service element, then the removal of the plugin's service. */
+export const androidAdvertisingRendererEntries = [
+    ...androidAdvertisingRendererServiceEntry,
+    androidMessagingPluginServiceRemoval,
+];
+/** `text` as a literal inside a regular expression. */
+function regexLiteral(text) {
+    // Only syntax characters: the `u` flag refuses an escaped `-` or letter.
+    return text.replace(/[.*+?^${}()|[\]\\/]/gu, '\\$&');
+}
+/** An attribute `name="value"` (or `'value'`) inside a start tag; both are literal. */
+function xmlAttributeLookahead(name, value) {
+    const attribute = `\\s${regexLiteral(name)}\\s*=\\s*`;
+    const literal = regexLiteral(value);
+    return `(?=[^>]*${attribute}(?:"${literal}"|'${literal}'))`;
+}
+/** The manifest's `<service>` element for `name`, self-closed or with a body, or `undefined`. */
+function androidServiceElement(code, name) {
+    return new RegExp(`<service\\b${xmlAttributeLookahead('android:name', name)}[^>]*?(?:/>|>[\\s\\S]*?</service>)`, 'u').exec(code)?.[0];
+}
+/** Whether the manifest removes the messaging plugin's own service from the merge. */
+function androidManifestRemovesMessagingPluginService(code) {
+    return new RegExp(`<service\\b${xmlAttributeLookahead('android:name', androidMessagingPluginService)}`
+        + `${xmlAttributeLookahead('tools:node', 'remove')}[^>]*>`, 'u').test(code);
+}
+/**
+ * Whether an Android manifest declares the kit's advertising renderer as its
+ * messaging service, with the messaging event and its meta-data, and removes
+ * the plugin's service. Comments do not count.
+ */
+export function androidManifestRendersAdvertising(manifest) {
+    const code = withoutXmlComments(manifest);
+    const renderer = androidServiceElement(code, androidAdvertisingRendererService);
+    return renderer !== undefined
+        && renderer.includes('com.google.firebase.MESSAGING_EVENT')
+        && new RegExp(`<meta-data\\b${xmlAttributeLookahead('android:name', androidAdvertisingRendererMetaData)}`
+            + `${xmlAttributeLookahead('android:value', 'true')}`, 'u').test(renderer)
+        && androidManifestRemovesMessagingPluginService(code);
+}
+/**
+ * Declares the kit's advertising renderer as the shell's messaging service
+ * inside `<application>` (`androidAdvertisingRendererEntries`), binding the
+ * tools namespace on the manifest root when missing. Each part is added only
+ * when it is missing, so a manifest that has one keeps it once; a renderer
+ * service that is declared but incomplete is left for the game to fix (the
+ * initializer warns). A manifest this cannot place it in (no `<application>`
+ * with a closing tag) is returned unchanged.
+ */
+export function applyAndroidManifestAdvertisingRenderer(manifest) {
+    if (androidManifestRendersAdvertising(manifest)) {
+        return manifest;
+    }
+    const code = withoutXmlComments(manifest);
+    const missing = [
+        ...(androidServiceElement(code, androidAdvertisingRendererService) === undefined
+            ? androidAdvertisingRendererServiceEntry
+            : []),
+        ...(androidManifestRemovesMessagingPluginService(code) ? [] : [androidMessagingPluginServiceRemoval]),
+    ];
+    const root = /<manifest\b[^>]*?>/u.exec(code);
+    const close = code.lastIndexOf('</application>');
+    const application = /<application\b[^>]*?>/u.exec(code);
+    if (missing.length === 0 || root === null || application === null || close === -1
+        || root[0].endsWith('/>') || application[0].endsWith('/>') || close < application.index
+        || application.index < root.index) {
+        return manifest;
+    }
+    const newline = manifest.includes('\r\n') ? '\r\n' : '\n';
+    let rootTag = manifest.slice(root.index, root.index + root[0].length);
+    if (!/\sxmlns:tools\s*=/u.test(rootTag)) {
+        rootTag = rootTag.replace(/^<manifest\b/u, `<manifest xmlns:tools="${androidToolsNamespace}"`);
+    }
+    const head = `${manifest.slice(0, root.index)}${rootTag}${manifest.slice(root.index + root[0].length, close)}`;
+    const entries = missing.map((line) => `${newline}        ${line}`).join('');
+    return `${head.trimEnd()}${entries}${newline}    ${manifest.slice(close)}`;
+}
+/**
+ * The initializer's warning for a game-owned Android manifest without the
+ * kit's advertising renderer: the manifest lines, the provider wiring, and
+ * the deployment switch. `undefined` when the manifest has the renderer.
+ */
+export function androidAdvertisingRendererWarning(manifest) {
+    if (androidManifestRendersAdvertising(manifest)) {
+        return undefined;
+    }
+    return `${shellPath}/android/app/src/main/AndroidManifest.xml does not declare the kit's advertising `
+        + 'renderer, so under the Korean rules this shell receives no advertising push (the backend '
+        + 'sends Android advertising only to a shell that shows the opt-out action). To render them, '
+        + `add inside <application> (with xmlns:tools on <manifest>): ${androidAdvertisingRendererEntries.join(' ')}; `
+        + 'pass advertisingRenderer: readCapacitorAdvertisingPushRenderer to the Capacitor provider; '
+        + 'and set shellRendersAdvertising: true in notifications/deployment.json before mapping an '
+        + 'advertising topic to android (see docs/NOTIFICATIONS.md).';
+}
+function materializeAndroidAdvertisingRenderer(gameRoot) {
+    const manifestFile = safeDestination(gameRoot, `${shellPath}/android/app/src/main/AndroidManifest.xml`);
+    if (!existsSync(manifestFile) || !lstatSync(manifestFile).isFile()) {
+        return;
+    }
+    const source = readFileSync(manifestFile, 'utf8');
+    const next = applyAndroidManifestAdvertisingRenderer(source);
+    if (next !== source) {
+        writeFileSync(manifestFile, next);
+    }
+}
 function materializeAndroidInexactAlarms(gameRoot) {
     const manifestFile = safeDestination(gameRoot, `${shellPath}/android/app/src/main/AndroidManifest.xml`);
     if (!existsSync(manifestFile) || !lstatSync(manifestFile).isFile()) {
@@ -2668,10 +2886,10 @@ function planNotificationsProvider(input) {
             + `@mpgd/adapter-capacitor ${String(adapter.version)} does not export; upgrade the game's kit `
             + 'packages (mpgd kit upgrade) first.');
     }
-    // The starter's provider module also imports the settings opener, which
-    // an adapter older than this CLI's notifications starter does not have.
-    // The subpath's declared types file (dist/notifications.d.ts today), and
-    // the module it re-exports the opener from.
+    // The starter's provider module also imports the settings opener and the
+    // advertising renderer read, which an adapter older than this CLI's
+    // notifications starter does not have. The subpath's declared types file
+    // (dist/notifications.d.ts today), and the modules it re-exports them from.
     const adapterRoot = path.join(gameRoot, 'node_modules/@mpgd/adapter-capacitor');
     const declaredTypes = adapterExports['./notifications'];
     const typesPath = typeof declaredTypes === 'object' && declaredTypes !== null
@@ -2679,14 +2897,22 @@ function planNotificationsProvider(input) {
         ? declaredTypes.types
         : './dist/notifications.d.ts';
     const adapterTypes = readExisting(path.join(adapterRoot, typesPath));
-    const openerTypes = readExisting(path.join(adapterRoot, path.dirname(typesPath), 'notifications-settings.d.ts'));
-    // Refused only when the declarations show the opener is absent: an
+    const helperTypes = ['notifications-settings.d.ts', 'notifications-renderer.d.ts']
+        .map((file) => readExisting(path.join(adapterRoot, path.dirname(typesPath), file)) ?? '')
+        .join('\n');
+    // Refused only when the declarations show a helper is absent: an
     // `export *` the check cannot follow passes, and the build then decides.
-    if (adapterTypes !== undefined && !/\bexport\s*\*/u.test(adapterTypes)
-        && !`${adapterTypes}\n${openerTypes ?? ''}`.includes('openCapacitorNotificationSettings')) {
-        throw new Error(`The game's @mpgd/adapter-capacitor ${String(adapter.version)} has no `
-            + 'openCapacitorNotificationSettings, which the notifications starter uses; upgrade the '
-            + "game's kit packages (mpgd kit upgrade) first.");
+    // The advertising renderer read came after the opener (AR1).
+    for (const helper of [
+        'openCapacitorNotificationSettings',
+        'readCapacitorAdvertisingPushRenderer',
+    ]) {
+        if (adapterTypes !== undefined && !/\bexport\s*\*/u.test(adapterTypes)
+            && !`${adapterTypes}\n${helperTypes}`.includes(helper)) {
+            throw new Error(`The game's @mpgd/adapter-capacitor ${String(adapter.version)} has no `
+                + `${helper}, which the notifications starter uses; upgrade the `
+                + "game's kit packages (mpgd kit upgrade) first.");
+        }
     }
     // The adapter's other peers (Capacitor core) must accept the game's
     // installed copies too; the plugins get their own message below.
@@ -2831,6 +3057,12 @@ function planNotificationsProvider(input) {
             + '@capacitor/local-notifications adds; reminders are inexact, so add '
             + `${androidInexactAlarmPermission} to the manifest.`);
     }
+    const rendererWarning = androidManifest === undefined
+        ? undefined
+        : androidAdvertisingRendererWarning(androidManifest);
+    if (rendererWarning !== undefined) {
+        warnings.push(rendererWarning);
+    }
     if (readExisting(safeDestination(gameRoot, `${shellPath}/android/app/google-services.json`)) === undefined) {
         warnings.push(`Android push needs ${shellPath}/android/app/google-services.json from the Firebase console `
             + '(see the mpgd-kit Firebase guide); without it the push half fails closed.');

package/dist/index.js

@@ -1,5 +1,5 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmdirSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import completion from '@gunshi/plugin-completion';
@@ -12,7 +12,7 @@ import { buildAssetPacks } from './asset-pack-build.js';
 import { verifyAssetPackDelivery } from './asset-pack-verify.js';
 import { buildAssetPackTarget } from './asset-pack-target.js';
 import { publishAssetPacks } from './asset-pack-publish.js';
-import { assertLegalProjectPath, publishLegalSiteFiles } from './legal-site-output.js';
+import { assertLegalProjectPath, publishLegalSiteFiles, resolveAppAdsTxt, } from './legal-site-output.js';
 import { assertAssetPackTargetPolicy } from '@mpgd/target-config/asset-packs';
 import { materializeCapacitorShellStarter, planCapacitorShellStarter, } from './capacitor-shell-starter.js';
 import { doctorNativeDeployment, initializeDeployConfig, parseDeployTargets, planNativeDeployment, readNativeDeploymentPlan, writeNativeDeploymentPlan, } from './deploy-planning.js';
@@ -973,7 +973,19 @@ const gameCommand = defineI18n({
 const defaultLegalDir = 'legal';
 const defaultLegalOutDir = 'artifacts/legal-site';
 const legalPageSlugs = ['privacy', 'support', 'terms'];
+/**
+ * Built when its source exists: the account deletion request page whose URL
+ * Google Play's Data safety form asks for. A missing one is warned about.
+ */
+const optionalLegalPageSlugs = ['delete-account'];
 const legalPageFileList = legalPageSlugs.map((slug) => `${slug}.html`).join(', ');
+const optionalLegalPageFileList = optionalLegalPageSlugs.map((slug) => `${slug}.html`).join(', ');
+/** The account deletion page's slug, whose URL the Play Data safety form asks for. */
+const deleteAccountLegalSlug = optionalLegalPageSlugs[0];
+/** Where a legal page is published: `<out-dir>/<slug>/index.html`, served at `/<slug>/`. */
+function legalPageOutputFile(outDir, slug) {
+    return path.join(outDir, slug, 'index.html');
+}
 function acceptGame(input) {
     if (input.skipTargetBuild && !input.skipTargetSmoke) {
         throw new Error('Use --skip-target-smoke when --skip-target-build is set.');
@@ -1540,6 +1552,11 @@ const legalCommand = defineI18n({
                     check: false,
                 });
                 console.info(`Built legal site: ${result.outDir}`);
+                if (result.deleteAccountPath !== undefined) {
+                    console.info(`Account deletion page: ${result.deleteAccountPath} on the legal site. Enter its full URL `
+                        + 'in Play Console > App content > Data safety > Delete account URL, and link it from '
+                        + 'the privacy policy.');
+                }
             },
         }),
         check: defineI18n({
@@ -2760,7 +2777,7 @@ function legalArgs() {
             type: 'string',
             required: false,
             default: defaultLegalDir,
-            description: `Directory containing ${legalPageFileList}.`,
+            description: `Directory containing ${legalPageFileList} (and optionally ${optionalLegalPageFileList}).`,
         },
         'out-dir': {
             type: 'string',
@@ -2773,8 +2790,8 @@ function legalArgs() {
 function legalArgResources() {
     return {
         'legal-dir': {
-            en: `Directory containing ${legalPageFileList}.`,
-            ko: `${legalPageFileList} 이 있는 디렉터리.`,
+            en: `Directory containing ${legalPageFileList} (and optionally ${optionalLegalPageFileList}).`,
+            ko: `${legalPageFileList} (선택: ${optionalLegalPageFileList}) 이 있는 디렉터리.`,
         },
         'out-dir': {
             en: 'Output directory for the static legal site.',
@@ -2794,8 +2811,58 @@ function buildLegalSite(input) {
     assertLegalProjectPath('legal-dir', legalDir);
     assertLegalProjectPath('out-dir', outDir);
     const outputs = createLegalSiteOutputs(legalDir, outDir);
+    const deleteAccountPath = `/${deleteAccountLegalSlug}/`;
+    const deleteAccountBuilt = outputs.some((output) => output.file === legalPageOutputFile(outDir, deleteAccountLegalSlug));
+    const deleteAccountResult = deleteAccountBuilt ? { deleteAccountPath } : {};
+    if (!deleteAccountBuilt) {
+        const linking = outputs
+            // Any quoting of the link (or a full URL ending in the path).
+            .filter((output) => output.content.includes(deleteAccountPath))
+            .map((output) => path.relative(process.cwd(), output.file));
+        const source = path.join(path.relative(process.cwd(), legalDir) || '.', `${deleteAccountLegalSlug}.html`);
+        if (linking.length > 0) {
+            // The starter's privacy, support, and terms pages link to it: a site
+            // without it would publish dead deletion links, so it is required then.
+            throw new Error(`No ${source}, but these pages link to ${deleteAccountPath}: ${linking.join(', ')}. `
+                + 'Google Play needs that page (Play Console > App content > Data safety): copy '
+                + 'legal/delete-account.html from a game created with the current kit, or remove the links.');
+        }
+        console.warn(`No ${source}: `
+            + 'Google Play needs a web page where players request account deletion without reinstalling '
+            + 'the game (Play Console > App content > Data safety). Copy legal/delete-account.html from a '
+            + 'game created with the current kit.');
+    }
+    // app-ads.txt and the optional pages are stale once their source is gone.
+    const optionalOutputs = [
+        { file: path.join(outDir, 'app-ads.txt'), source: 'app-ads.txt' },
+        ...optionalLegalPageSlugs.map((slug) => ({
+            file: legalPageOutputFile(outDir, slug),
+            source: `${slug}.html`,
+        })),
+    ];
+    const orphans = optionalOutputs.filter(({ file }) => {
+        if (outputs.some((output) => output.file === file)) {
+            return false;
+        }
+        const stat = lstatIfExists(file);
+        if (stat === undefined) {
+            return false;
+        }
+        assertLegalProjectPath('out-dir', file);
+        if (!stat.isFile()) {
+            throw new Error(`Legal site output is not a regular file: ${file}`);
+        }
+        return true;
+    });
+    warnLegalPlaceholders(outputs);
     if (input.check) {
         assertLegalProjectPath('out-dir', outDir);
+        if (orphans.length > 0) {
+            throw new Error([
+                'Legal site output is stale. Run "mpgd legal build".',
+                ...orphans.map(({ file, source }) => `- ${path.relative(process.cwd(), file)} (no ${source} source)`),
+            ].join('\n'));
+        }
         const stale = outputs.filter((output) => {
             assertLegalProjectPath('out-dir', output.file);
             if (!existsSync(output.file)) {
@@ -2811,18 +2878,47 @@ function buildLegalSite(input) {
         }
         return {
             outDir,
+            ...deleteAccountResult,
         };
     }
     publishLegalSiteFiles(outDir, outputs);
+    for (const { file } of orphans) {
+        // Checked again right before removing: the directory may have changed.
+        assertLegalProjectPath('out-dir', file);
+        rmSync(file, { force: true });
+        if (path.dirname(file) !== outDir) {
+            // The page's own directory, once empty.
+            try {
+                rmdirSync(path.dirname(file));
+            }
+            catch (error) {
+                // Not empty, or already gone: leave it. Anything else is reported.
+                const code = error.code;
+                if (code !== 'ENOTEMPTY' && code !== 'EEXIST' && code !== 'ENOENT' && code !== 'ENOTDIR') {
+                    console.warn(`Could not remove the empty legal page directory ${path.relative(process.cwd(), path.dirname(file))}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    }
     return {
         outDir,
+        ...deleteAccountResult,
     };
 }
 function createLegalSiteOutputs(legalDir, outDir) {
     assertLegalProjectPath('legal-dir', legalDir);
     assertLegalProjectPath('out-dir', outDir);
     const sourceRoot = toTemplatePath(path.relative(process.cwd(), legalDir) || '.');
-    const outputs = legalPageSlugs.map((slug) => {
+    const optionalSlugs = optionalLegalPageSlugs.filter((slug) => {
+        const sourceFile = path.join(legalDir, `${slug}.html`);
+        if (lstatIfExists(sourceFile) === undefined) {
+            return false;
+        }
+        assertLegalProjectPath('legal-dir', sourceFile);
+        return true;
+    });
+    const slugs = [...legalPageSlugs, ...optionalSlugs];
+    const outputs = slugs.map((slug) => {
         const sourceFile = path.join(legalDir, `${slug}.html`);
         // existsSync and readFileSync follow a page symlink. Check the file
         // itself, not only the legal directory, immediately before reading it.
@@ -2832,12 +2928,16 @@ function createLegalSiteOutputs(legalDir, outDir) {
         }
         assertLegalProjectPath('legal-dir', sourceFile);
         return {
-            file: path.join(outDir, slug, 'index.html'),
+            file: legalPageOutputFile(outDir, slug),
             content: normalizeLegalHtml(readFileSync(sourceFile, 'utf8'), sourceFile),
         };
     });
+    const appAdsTxt = readLegalAppAdsTxt(legalDir);
     return [
         ...outputs,
+        ...(appAdsTxt === undefined
+            ? []
+            : [{ file: path.join(outDir, 'app-ads.txt'), content: appAdsTxt }]),
         {
             file: path.join(outDir, '_headers'),
             content: [
@@ -2852,9 +2952,7 @@ function createLegalSiteOutputs(legalDir, outDir) {
             file: path.join(outDir, '_redirects'),
             content: [
                 '/ /support/ 302',
-                '/privacy /privacy/ 301',
-                '/support /support/ 301',
-                '/terms /terms/ 301',
+                ...slugs.map((slug) => `/${slug} /${slug}/ 301`),
                 '',
             ].join('\n'),
         },
@@ -2862,7 +2960,7 @@ function createLegalSiteOutputs(legalDir, outDir) {
             file: path.join(outDir, 'legal-site.json'),
             content: `${JSON.stringify({
                 version: 1,
-                pages: legalPageSlugs.map((slug) => ({
+                pages: slugs.map((slug) => ({
                     slug,
                     path: `/${slug}/`,
                     source: `${sourceRoot}/${slug}.html`,
@@ -2871,6 +2969,58 @@ function createLegalSiteOutputs(legalDir, outDir) {
         },
     ];
 }
+/**
+ * `app-ads.txt` for the legal site root: `<legal-dir>/app-ads.txt`, else the
+ * AdMob line for `ads.admob.publisherId` in the project's `mpgd.game.json`
+ * (the project root is the working directory, as for the legal sources).
+ */
+function readLegalAppAdsTxt(legalDir) {
+    const ownAppAds = path.join(legalDir, 'app-ads.txt');
+    const ownExists = lstatIfExists(ownAppAds) !== undefined;
+    if (ownExists) {
+        assertLegalProjectPath('legal-dir', ownAppAds);
+    }
+    const gameConfigFile = path.join(process.cwd(), 'mpgd.game.json');
+    let gameConfig;
+    if (lstatIfExists(gameConfigFile) !== undefined) {
+        assertLegalProjectPath('mpgd.game.json', gameConfigFile);
+        try {
+            gameConfig = JSON.parse(readFileSync(gameConfigFile, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`mpgd.game.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return resolveAppAdsTxt({
+        ...(ownExists ? { ownFile: readFileSync(ownAppAds, 'utf8') } : {}),
+        ...(gameConfig === undefined ? {} : { gameConfig }),
+    });
+}
+function lstatIfExists(file) {
+    try {
+        return lstatSync(file);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT' || code === 'ENOTDIR') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+/**
+ * The starter's legal pages mark what only the game owner can write with
+ * `[REPLACE: ...]`. Building with them is allowed (a new game builds its
+ * Pages host at once), but the store listing must not link to them.
+ */
+function warnLegalPlaceholders(outputs) {
+    const pending = outputs
+        .filter((output) => output.content.includes('[REPLACE:'))
+        .map((output) => path.relative(process.cwd(), output.file));
+    if (pending.length > 0) {
+        console.warn(`Legal pages still contain [REPLACE: ...] markers; fill them in before linking the site from a store listing: ${pending.join(', ')}`);
+    }
+}
 function normalizeLegalHtml(content, sourceFile) {
     if (!/^<!doctype html>/iu.test(content) || !/<html[\s>]/iu.test(content)) {
         throw new Error(`${sourceFile} must be a complete HTML document.`);
@@ -2916,10 +3066,19 @@ function applyLiteTemplateOverlay(baseFiles, overlayFiles) {
         if (file.relativePath === 'mpgd.targets.json') {
             return [{ ...file, content: liteTemplateTargets(file.content) }];
         }
+        if (file.relativePath === 'mpgd.game.json') {
+            return [{ ...file, content: liteTemplateGameConfig(file.content) }];
+        }
         return [file];
     });
     return [...merged, ...overlay.values()];
 }
+/** The lite tap game is orientation-agnostic; the Phaser template's landscape lock does not apply. */
+function liteTemplateGameConfig(content) {
+    const config = JSON.parse(content);
+    config.native = { ...config.native, orientation: 'any' };
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
 function liteTemplateTargets(content) {
     const value = JSON.parse(content);
     const reddit = value.targets.reddit;

package/dist/legal-site-output.d.ts

@@ -10,3 +10,21 @@ export interface LegalSiteFile {
 export declare function assertLegalProjectPath(label: string, resolved: string): void;
 /** Stage the site beside the destination, then publish with rename. */
 export declare function publishLegalSiteFiles(outDir: string, outputs: readonly LegalSiteFile[]): void;
+/**
+* Google's AdMob line for `app-ads.txt` (`f08c47fec0942fa0` is Google's
+* certification authority ID). AdMob shows the exact line for an account
+* under Apps > View all apps > app-ads.txt; use a game-owned
+* `legal/app-ads.txt` instead when it differs or mediation partners add lines.
+*/
+export declare function admobAppAdsTxtLine(publisherId: string): string;
+/**
+* The `app-ads.txt` the legal site serves at its root, or undefined: a
+* game-owned `<legal-dir>/app-ads.txt` verbatim, else the AdMob line for
+* `ads.admob.publisherId` in the game's `mpgd.game.json`. Store listings
+* name this site as the developer website (Play) or marketing URL (App
+* Store), which is where ad buyers look for the file.
+*/
+export declare function resolveAppAdsTxt(input: {
+  readonly ownFile?: string;
+  readonly gameConfig?: unknown;
+}): string | undefined;