@mpgd/cli 0.70.0 → 0.71.0

package/dist/index.js

@@ -41,9 +41,7 @@ import { promotePlayRelease } from './play-release-promote.js';
 import { applyStoreProducts, planStoreProducts, saveStoreProductPlan, } from './store-products-command.js';
 import { formatAppStoreProductPlan } from './store-products-app-store.js';
 import { formatPlayProductPlan } from './store-products-play.js';
-import { applyStorePresence, planStorePresence, saveStorePresencePlan, } from './store-presence-command.js';
-import { formatPlayPresencePlan } from './store-presence-play.js';
-import { formatAppStorePresencePlan } from './store-presence-app-store.js';
+import { applyStorePresence, planStorePresence, renderStorePresencePlan, saveStorePresencePlan, } from './store-presence-command.js';
 import { applyAppStoreReleaseCommand, changeAppStorePhasedReleaseCommand, planAppStoreReleaseCommand, publishAppStoreVersionCommand, readAppStoreReleaseStatusCommand, saveAppStoreReleasePlan, } from './app-store-release-command.js';
 import { formatAppStoreReleasePlan } from './app-store-release.js';
 import { changePlayRollout } from './play-release-rollout.js';
@@ -953,21 +951,28 @@ const storeCommand = defineI18n({
                         store: { type: 'string', required: true, description: 'google-play or app-store.' },
                         presence: { type: 'string', required: false, description: 'Store presence file path, relative to the current directory; defaults to mpgd.store-presence.json in the game.' },
                         out: { type: 'string', required: false, description: 'New plan JSON path for apply; existing files are not overwritten.' },
+                        json: { type: 'boolean', required: false, description: 'Print the plan (warnings included) as one JSON document.' },
                     },
                     run: async (ctx) => {
                         const presence = readOptionalString(ctx.values.presence);
+                        const json = ctx.values.json === true;
                         const result = await planStorePresence({
                             game: readOptionalString(ctx.values.game) ?? '.',
                             profile: readOptionalString(ctx.values.profile) ?? 'beta',
                             store: readRequiredCliOption(ctx.values.store, '--store'),
                             ...(presence === undefined ? {} : { presenceFile: presence }),
                         });
-                        console.info(result.plan.store === 'google-play'
-                            ? formatPlayPresencePlan(result.plan)
-                            : formatAppStorePresencePlan(result.plan));
+                        process.stdout.write(`${renderStorePresencePlan(result, json)}\n`);
                         const out = readOptionalString(ctx.values.out);
                         if (out !== undefined) {
-                            console.info(`Wrote store presence plan: ${saveStorePresencePlan(out, result)}`);
+                            // With --json, stdout carries only the JSON document.
+                            const written = `Wrote store presence plan: ${saveStorePresencePlan(out, result)}`;
+                            if (json) {
+                                console.error(written);
+                            }
+                            else {
+                                console.info(written);
+                            }
                         }
                     },
                 }),

package/dist/native-build-info.json

@@ -1,5 +1,5 @@
 {
-  "kitGitSha": "1fc86080fee3e7f6089a6ba5d063a892fa8524bb",
+  "kitGitSha": "481d1c53f2f0d4c5127eeeedfa7ebe306c0459ea",
   "kitDirty": false,
-  "packageVersion": "0.70.0"
+  "packageVersion": "0.71.0"
 }

package/dist/native-build-target.js

@@ -4557,7 +4557,8 @@ var notificationSuppressionReasons = Object.freeze([
   "quiet-hours",
   "frequency-capped",
   "provider-limit",
-  "advertising-sender-missing"
+  "advertising-sender-missing",
+  "reconfirmation-overdue"
 ]);
 var notificationInputBounds = Object.freeze({
   keyLength: 2048,
@@ -4693,6 +4694,33 @@ var notificationNoticeVariantFallbacks = Object.freeze({
   "consent-result.advertising.refused": "consent-result.advertising.withdrawn",
   "consent-result.night.refused": "consent-result.night.withdrawn"
 });
+var everyRequiredNoticeVariant = Object.freeze(notificationNoticeVariants.filter((variant) => notificationNoticeVariantFallbacks[variant] === void 0));
+var notificationReconfirmationListDays = 60;
+var notificationNoticeLeadDays = 7;
+var notificationRefreshedConsentKinds = Object.freeze([
+  "advertising",
+  "night"
+]);
+var koreanRefreshIntervalMonths = 24;
+var notificationKoreanConsentRefresh = deepFreeze({
+  advertising: {
+    intervalMonths: koreanRefreshIntervalMonths,
+    noticeLeadDays: notificationReconfirmationListDays,
+    pushLeadDays: notificationNoticeLeadDays,
+    onOverdue: "pause"
+  },
+  night: {
+    intervalMonths: koreanRefreshIntervalMonths,
+    noticeLeadDays: notificationReconfirmationListDays,
+    pushLeadDays: notificationNoticeLeadDays,
+    onOverdue: "pause"
+  }
+});
+var noConsentRefresh = Object.freeze({});
+var notificationKoreanNoticePolicy = deepFreeze({
+  consentResults: true,
+  refresh: notificationKoreanConsentRefresh
+});
 function isNotificationCalendarDate(date) {
   return !Number.isNaN(calendarDateMillis(date));
 }
@@ -17213,6 +17241,7 @@ var phaserEdits = {
         "import {",
         "  NotificationSettingsScene,",
         "  routeNotificationSettingsOpens,",
+        "  showNotificationLaunchNotices,",
         "} from '../scenes/NotificationSettingsScene';",
         ""
       ].join("\n")
@@ -17227,6 +17256,8 @@ var phaserEdits = {
         "        ownGameAudio(game, input.context);",
         "        // The advertising opt-out action and consent notices open the settings screen.",
         "        routeNotificationSettingsOpens(game, input.context);",
+        "        // Listed consent notices, once per launch, without pausing the game.",
+        "        showNotificationLaunchNotices(game, input.context);",
         ""
       ].join("\n")
     }

package/dist/notifications-starter.js

@@ -280,6 +280,7 @@ const phaserEdits = {
                 'import {',
                 '  NotificationSettingsScene,',
                 '  routeNotificationSettingsOpens,',
+                '  showNotificationLaunchNotices,',
                 "} from '../scenes/NotificationSettingsScene';",
                 '',
             ].join('\n'),
@@ -294,6 +295,8 @@ const phaserEdits = {
                 '        ownGameAudio(game, input.context);',
                 '        // The advertising opt-out action and consent notices open the settings screen.',
                 '        routeNotificationSettingsOpens(game, input.context);',
+                '        // Listed consent notices, once per launch, without pausing the game.',
+                '        showNotificationLaunchNotices(game, input.context);',
                 '',
             ].join('\n'),
         },

package/dist/store-presence-command.d.ts

@@ -35,6 +35,12 @@ export interface StorePresencePorts {
   }>;
 }
 export declare function planStorePresence(options: StorePresencePlanOptions, environment?: NodeJS.ProcessEnv, ports?: Partial<StorePresencePorts>): Promise<StorePresencePlanFile>;
+/**
+* What `store presence plan` prints: the plan for the terminal, or with
+* `--json` the plan file itself (the same document `--out` saves, warnings
+* included) as one JSON document.
+*/
+export declare function renderStorePresencePlan(result: StorePresencePlanFile, json: boolean): string;
 export declare function saveStorePresencePlan(file: string, plan: StorePresencePlanFile): string;
 export interface StorePresenceApplyOptions {
   readonly planFile: string;

package/dist/store-presence-command.js

@@ -2,8 +2,8 @@ import { existsSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { openAscStorePresenceSession } from './app-store-presence-asc.js';
 import { readStorePresenceSource, storePresencePlanCommand, } from './store-presence.js';
-import { applyAppStorePresence, planAppStorePresence, } from './store-presence-app-store.js';
-import { applyPlayPresence, planPlayPresence, } from './store-presence-play.js';
+import { applyAppStorePresence, formatAppStorePresencePlan, planAppStorePresence, } from './store-presence-app-store.js';
+import { applyPlayPresence, formatPlayPresencePlan, planPlayPresence, } from './store-presence-play.js';
 import { assertStoreSyncStore, readStorePlanFile, relocateStoreSyncFile, resolveStoreSyncApp, StorePlanStaleError, writeStorePlanFile, } from './store-sync.js';
 const defaultPorts = {
     googlePlay: loadPlayStoreListing,
@@ -36,6 +36,19 @@ export async function planStorePresence(options, environment = process.env, port
         plan,
     };
 }
+/**
+ * What `store presence plan` prints: the plan for the terminal, or with
+ * `--json` the plan file itself (the same document `--out` saves, warnings
+ * included) as one JSON document.
+ */
+export function renderStorePresencePlan(result, json) {
+    if (json) {
+        return JSON.stringify(result, null, 2);
+    }
+    return result.plan.store === 'google-play'
+        ? formatPlayPresencePlan(result.plan)
+        : formatAppStorePresencePlan(result.plan);
+}
 export function saveStorePresencePlan(file, plan) {
     return writeStorePlanFile(file, plan);
 }

package/dist/store-presence-play.d.ts

@@ -66,6 +66,13 @@ export interface PlayPresencePlan {
   readonly imageRemovals: number;
   readonly changed: boolean;
   readonly notes: readonly string[];
+  /**
+  * Where Play's default language listing would fall short of Play's
+  * publishing requirements or recommendations once apply has run (Play's
+  * images plus the file's changes). Never blocks apply, and not part of
+  * the stale check.
+  */
+  readonly warnings: readonly string[];
   /** What the sync cannot do; the reviewer does it in Play Console. */
   readonly manual: readonly string[];
   /** Digest of everything read from Play. */
@@ -82,6 +89,36 @@ export interface PlayPresencePlanInput {
 }
 /** Read Play through a throwaway edit and plan; never writes. */
 export declare function planPlayPresence(input: PlayPresencePlanInput, port: PlayStoreListingPort): Promise<PlayPresencePlan>;
+/**
+* Google Play's store listing graphics rules, from Play Console Help, "Add
+* preview assets to showcase your app"
+* (https://support.google.com/googleplay/android-developer/answer/9866151),
+* checked 2026-11-01:
+*
+* - "You must provide an app icon to publish your store listing" and "You
+*   must provide a feature graphic to publish your store listing."
+* - "You must provide a minimum of two screenshots across different device
+*   types to publish your store listing", and "up to 8 screenshots for each
+*   supported device type". The help page does not say which device
+*   types count; the sync asks for two in the phone set.
+* - Tablets (7-inch and 10-inch) and Chromebooks: "you can add a minimum of
+*   4 screenshots", 1,080 to 7,680 px, 16:9 or 9:16. That is a
+*   recommendation, not a publishing requirement; the help page states no
+*   effect of a missing tablet set on tablet visibility, and the large
+*   screen badge depends on the adaptive app quality tiers
+*   (https://developer.android.com/docs/quality-guidelines/adaptive-app-quality),
+*   not on screenshots.
+*
+* Translations need no graphics of their own: "If you add text translations
+* without localized graphic assets, your app's graphic assets show from the
+* default language"
+* (https://support.google.com/googleplay/android-developer/answer/9844778).
+* So only the default language is checked.
+*/
+export declare const googlePlayPublishingGraphics: Readonly<{
+  phoneScreenshots: 2;
+  largeScreenScreenshots: 4;
+}>;
 export interface PlayPresenceApplyResult {
   readonly packageName: string;
   readonly status: 'committed' | 'unchanged';

package/dist/store-presence-play.js

@@ -12,7 +12,7 @@ export async function planPlayPresence(input, port) {
     const local = readLocalGraphics(input.directory, play);
     const editId = await port.insertEdit(input.packageName, input.signal);
     try {
-        return await planInEdit(input, play, local, port, editId);
+        return await planInEdit(input, play, local, port, editId, true);
     }
     finally {
         await discardEdit(port, input.packageName, editId);
@@ -48,7 +48,7 @@ function readLocalGraphics(directory, play) {
     }
     return result;
 }
-async function planInEdit(input, play, local, port, editId) {
+async function planInEdit(input, play, local, port, editId, checkPublishing) {
     const { packageName, signal } = input;
     const [details, remoteListings] = await Promise.all([
         port.getDetails(packageName, editId, signal),
@@ -98,13 +98,39 @@ async function planInEdit(input, play, local, port, editId) {
         .map((listing) => String(listing.language))
         .filter((language) => !named.has(language.toLowerCase()))
         .sort();
-    const defaultLanguage = typeof details.defaultLanguage === 'string'
+    // An empty value is no default language.
+    const defaultLanguage = typeof details.defaultLanguage === 'string' && details.defaultLanguage.trim() !== ''
         ? details.defaultLanguage
         : undefined;
     if (defaultLanguage !== undefined && !named.has(defaultLanguage.toLowerCase())) {
         notes.push(`Play's default language ${defaultLanguage} is not in the file; its listing stays as Play has it.`);
     }
     const plannedDetails = planDetails(details, play, notes);
+    if (checkPublishing && defaultLanguage === undefined) {
+        notes.push("Play reports no default language, so the listing's publishing graphics were not checked.");
+    }
+    let warnings = [];
+    if (checkPublishing && defaultLanguage !== undefined) {
+        try {
+            warnings = await publishingWarnings({
+                input,
+                editId,
+                port,
+                language: defaultLanguage,
+                remote: remoteByLanguage.get(defaultLanguage.toLowerCase()),
+                planned: planned.find((language) => language.language.toLowerCase() === defaultLanguage.toLowerCase()),
+            });
+        }
+        catch (error) {
+            // Warnings are advisory: a failed read leaves them unchecked, but a
+            // cancelled plan stays cancelled.
+            if (signal?.aborted === true || (error instanceof Error && error.name === 'AbortError')) {
+                throw error;
+            }
+            notes.push(`Play's ${defaultLanguage} images could not be read (${error instanceof Error ? error.message : String(error)}), `
+                + "so the listing's publishing graphics were not checked.");
+        }
+    }
     const manual = manualSteps(input.presence);
     const imageRemovals = planned.reduce((sum, language) => sum + language.images.reduce((count, slot) => count + (slot.complete && isMultiImage(slot.imageType) ? slot.remove.length : 0), 0), 0);
     const changed = plannedDetails !== undefined || planned.some((language) => language.action !== 'unchanged' || language.images.some((slot) => slot.action !== 'unchanged'));
@@ -130,6 +156,7 @@ async function planInEdit(input, play, local, port, editId) {
         imageRemovals,
         changed,
         notes,
+        warnings,
         manual,
         remoteSha256,
         desiredSha256,
@@ -266,6 +293,91 @@ function planDetails(details, play, notes) {
     }
     return { changes, write };
 }
+/**
+ * Google Play's store listing graphics rules, from Play Console Help, "Add
+ * preview assets to showcase your app"
+ * (https://support.google.com/googleplay/android-developer/answer/9866151),
+ * checked 2026-11-01:
+ *
+ * - "You must provide an app icon to publish your store listing" and "You
+ *   must provide a feature graphic to publish your store listing."
+ * - "You must provide a minimum of two screenshots across different device
+ *   types to publish your store listing", and "up to 8 screenshots for each
+ *   supported device type". The help page does not say which device
+ *   types count; the sync asks for two in the phone set.
+ * - Tablets (7-inch and 10-inch) and Chromebooks: "you can add a minimum of
+ *   4 screenshots", 1,080 to 7,680 px, 16:9 or 9:16. That is a
+ *   recommendation, not a publishing requirement; the help page states no
+ *   effect of a missing tablet set on tablet visibility, and the large
+ *   screen badge depends on the adaptive app quality tiers
+ *   (https://developer.android.com/docs/quality-guidelines/adaptive-app-quality),
+ *   not on screenshots.
+ *
+ * Translations need no graphics of their own: "If you add text translations
+ * without localized graphic assets, your app's graphic assets show from the
+ * default language"
+ * (https://support.google.com/googleplay/android-developer/answer/9844778).
+ * So only the default language is checked.
+ */
+export const googlePlayPublishingGraphics = Object.freeze({
+    phoneScreenshots: 2,
+    largeScreenScreenshots: 4,
+});
+const publishingSlots = [
+    'icon',
+    'featureGraphic',
+    'phoneScreenshots',
+    'sevenInchScreenshots',
+    'tenInchScreenshots',
+];
+/**
+ * Warnings for Play's default language listing, counted after apply: the
+ * plan's result for each slot the file names, Play's images for the others.
+ */
+async function publishingWarnings(input) {
+    const { packageName, signal } = input.input;
+    const plannedSlots = new Map((input.planned?.images ?? []).map((slot) => [slot.imageType, slot]));
+    const unread = input.remote === undefined
+        ? []
+        : publishingSlots.filter((slot) => !plannedSlots.has(slot));
+    const remoteCounts = await mapWithConcurrency(unread, readConcurrency, async (imageType) => {
+        const images = await input.port.listImages({
+            packageName,
+            editId: input.editId,
+            language: String(input.remote?.language),
+            imageType,
+            ...(signal === undefined ? {} : { signal }),
+        });
+        return [imageType, images.length];
+    });
+    const remote = new Map(remoteCounts);
+    const count = (imageType) => {
+        const slot = plannedSlots.get(imageType);
+        return slot === undefined
+            ? (remote.get(imageType) ?? 0)
+            : slot.keep.length + slot.upload.length;
+    };
+    const prefix = `${input.planned?.language ?? input.language} (Play's default language)`;
+    const warnings = [];
+    if (count('icon') === 0) {
+        warnings.push(`${prefix} has no icon after apply; Play needs one to publish the store listing.`);
+    }
+    if (count('featureGraphic') === 0) {
+        warnings.push(`${prefix} has no featureGraphic after apply; Play needs a feature graphic to publish the store listing.`);
+    }
+    const phone = count('phoneScreenshots');
+    if (phone < googlePlayPublishingGraphics.phoneScreenshots) {
+        warnings.push(`${prefix} has ${phone} phoneScreenshots after apply; Play needs at least `
+            + `${googlePlayPublishingGraphics.phoneScreenshots} screenshots across device types to publish the store `
+            + `listing, and the sync asks for ${googlePlayPublishingGraphics.phoneScreenshots} in the phone set.`);
+    }
+    if (count('sevenInchScreenshots') === 0 && count('tenInchScreenshots') === 0) {
+        warnings.push(`${prefix} has no sevenInchScreenshots or tenInchScreenshots after apply; Play does not require tablet `
+            + `screenshots to publish, but recommends at least ${googlePlayPublishingGraphics.largeScreenScreenshots} `
+            + '(1,080 to 7,680 px, 16:9 or 9:16) to show the app on tablets.');
+    }
+    return warnings;
+}
 function manualSteps(presence) {
     const steps = [];
     if (presence.privacyPolicyUrl !== undefined) {
@@ -312,7 +424,8 @@ export async function applyPlayPresence(input) {
     // A commit that failed without a definitive answer may have landed.
     let commitUncertain = false;
     try {
-        const current = await planInEdit(input.plan, play, local, port, editId);
+        // Warnings never block apply, so apply does not read Play for them.
+        const current = await planInEdit(input.plan, play, local, port, editId, false);
         if (!current.changed) {
             await discardEdit(port, packageName, editId);
             return { packageName, status: 'unchanged', languages: [] };
@@ -485,6 +598,9 @@ export function formatPlayPresencePlan(plan) {
     if (plan.imageRemovals > 0) {
         lines.push(`  IMAGE REMOVAL: ${plan.imageRemovals} image(s); apply needs --confirm-image-removal`);
     }
+    for (const warning of plan.warnings) {
+        lines.push(`  warning   ${warning}`);
+    }
     for (const note of plan.notes) {
         lines.push(`  note      ${note}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/cli",
-  "version": "0.70.0",
+  "version": "0.71.0",
   "description": "Gunshi CLI for mpgd-kit starter generation and target workflow orchestration.",
   "license": "MIT",
   "repository": {
@@ -70,10 +70,10 @@
     "parse5": "7.3.0",
     "postcss": "8.5.28",
     "postcss-value-parser": "4.2.0",
-    "@mpgd/catalog": "0.15.2",
-    "@mpgd/platform": "0.36.0",
-    "@mpgd/target-config": "0.24.9",
-    "@mpgd/phaser-assets": "0.10.0"
+    "@mpgd/catalog": "0.15.3",
+    "@mpgd/platform": "0.37.0",
+    "@mpgd/phaser-assets": "0.10.0",
+    "@mpgd/target-config": "0.24.10"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
@@ -81,19 +81,19 @@
     "@types/yauzl": "3.4.0",
     "ttsc": "0.34.2",
     "typescript": "7.0.2",
-    "@mpgd/adapter-ait": "0.21.11",
-    "@mpgd/adapter-browser": "0.12.6",
-    "@mpgd/adapter-capacitor": "0.19.3",
-    "@mpgd/adapter-devvit": "0.15.0",
-    "@mpgd/adapter-verse8": "0.7.22",
-    "@mpgd/bridge": "0.19.1",
-    "@mpgd/capacitor-play-billing": "0.6.4",
-    "@mpgd/capacitor-storekit": "0.7.3",
-    "@mpgd/game-runtime": "0.10.3",
-    "@mpgd/analytics": "0.5.10",
-    "@mpgd/game-services": "0.35.0",
-    "@mpgd/lite-shell": "0.1.0",
-    "@mpgd/i18n": "0.6.31"
+    "@mpgd/adapter-ait": "0.22.0",
+    "@mpgd/adapter-browser": "0.12.7",
+    "@mpgd/adapter-capacitor": "0.19.4",
+    "@mpgd/adapter-verse8": "0.7.23",
+    "@mpgd/analytics": "0.5.11",
+    "@mpgd/bridge": "0.20.0",
+    "@mpgd/capacitor-play-billing": "0.6.5",
+    "@mpgd/game-runtime": "0.10.4",
+    "@mpgd/capacitor-storekit": "0.7.4",
+    "@mpgd/game-services": "0.36.0",
+    "@mpgd/adapter-devvit": "0.15.1",
+    "@mpgd/i18n": "0.6.32",
+    "@mpgd/lite-shell": "0.1.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/templates/notifications-overlay/common/docs/NOTIFICATIONS.md

@@ -15,6 +15,7 @@ left for you.
 | `src/platform/capacitorNotifications.ts` | The Android and iOS provider (FCM and local reminders), registered by the Capacitor gateways. |
 | `src/platform/notificationSettings.ts` | The settings screen's logic: permission, reminders, advertising and night consent, notices. |
 | `src/platform/notificationOpens.ts` | The game's one listener for notification opens: the settings route, and an `other` route for your topics. |
+| `src/platform/launchNoticesBanner.ts` | The box that shows the listed consent notices once per launch. |
 | `src/scenes/NotificationSettingsScene.ts` or `src/lite/notificationSettingsPanel.ts` | The settings screen the game renders. |
 | `tools/validate-notifications.ts` | `pnpm validate:notifications`. |
 
@@ -137,6 +138,18 @@ advertising consent is granted, and turning advertising consent off also
 withdraws a granted night consent in the same call (two records, two result
 notices).
 
+**Consent notices at launch.** Once per launch, after the notifications
+runtime starts (10 seconds at most), the game reads the consent notices the
+server lists and, when there is one, shows them in a small box at the top
+that does not pause the game, overdue ones first, and records each one as
+given once the player can see it: on screen while the page is visible
+(`showStarterLaunchNotices`). A player who signs in after launch gets the
+read when the session becomes current. Under the Korean rules advertising to a player
+pauses while a re-confirmation (every two years) is past its due date and
+not recorded, so this is how a player who never opens the settings screen
+ends the pause. Keep it, or show the notices in your own launch UI and
+record them the same way.
+
 ## Try it locally
 
 You can see the settings switches record consent before you have an

package/templates/notifications-overlay/common/src/platform/launchNoticesBanner.ts

@@ -0,0 +1,102 @@
+import {
+  createStarterNoticeVisibility,
+  starterNotificationLabelsFor,
+  type StarterLaunchNotices,
+} from './notificationSettings';
+
+/**
+ * The launch notices (`showStarterLaunchNotices`) as a small box at the top
+ * of the page, over the game: a heading, each notice, and a close button.
+ * It takes no focus and pauses nothing; only its own area takes taps, and the
+ * game goes on under and around it. `onSeen` runs once for each notice the
+ * player can see: on screen, not scrolled out of the box, while the page is
+ * visible (`createStarterNoticeVisibility`), so a notice is recorded only
+ * once it was seen. Returns the disposer, which closing the box also runs.
+ */
+export function mountStarterLaunchNotices(
+  notices: StarterLaunchNotices['notices'],
+  locale: string,
+  options: {
+    readonly onSeen: (index: number) => void;
+    readonly parent?: HTMLElement;
+  },
+): () => void {
+  const text = starterNotificationLabelsFor(locale);
+  const box = document.createElement('div');
+  box.setAttribute('role', 'status');
+  box.setAttribute('aria-label', text.notices);
+  Object.assign(box.style, {
+    position: 'fixed',
+    top: '12px',
+    left: '50%',
+    transform: 'translateX(-50%)',
+    width: 'min(560px, calc(100% - 32px))',
+    maxHeight: '50vh',
+    overflowY: 'auto',
+    boxSizing: 'border-box',
+    padding: '12px 16px',
+    borderRadius: '8px',
+    background: 'rgba(15, 23, 42, 0.94)',
+    color: '#d6dee8',
+    font: '14px Arial, sans-serif',
+    zIndex: '1000',
+  });
+  const heading = document.createElement('strong');
+  heading.textContent = text.notices;
+  box.append(heading);
+  const visibility = createStarterNoticeVisibility({
+    pageVisible: () => document.visibilityState === 'visible',
+    onSeen: options.onSeen,
+  });
+  const paragraphs = notices.map((notice, index) => {
+    const paragraph = document.createElement('p');
+    paragraph.style.whiteSpace = 'pre-line';
+    paragraph.textContent = `${notice.title}\n${notice.body}`;
+    paragraph.dataset['noticeIndex'] = String(index);
+    box.append(paragraph);
+    return paragraph;
+  });
+  const close = document.createElement('button');
+  close.type = 'button';
+  close.textContent = text.close;
+  box.append(close);
+  // A notice counts as seen once most of it shows in the box (its scroll
+  // area, which stays on screen), or, for one taller than the box, once it
+  // fills most of the box. Without IntersectionObserver every notice counts
+  // as on screen, so it is seen while the page is visible.
+  const observer = typeof IntersectionObserver === 'function'
+    ? new IntersectionObserver((entries) => {
+        for (const entry of entries) {
+          const index = Number((entry.target as HTMLElement).dataset['noticeIndex']);
+          const shown = entry.intersectionRect.height;
+          const area = entry.rootBounds?.height ?? 0;
+          visibility.intersecting(
+            index,
+            entry.isIntersecting && (entry.intersectionRatio >= 0.6 || (area > 0 && shown >= area * 0.6)),
+          );
+        }
+      }, { root: box, threshold: Array.from({ length: 21 }, (_, step) => step / 20) })
+    : undefined;
+  const onVisibilityChange = (): void => visibility.pageVisibilityChanged();
+  document.addEventListener('visibilitychange', onVisibilityChange);
+  (options.parent ?? document.body).append(box);
+  if (observer === undefined) {
+    paragraphs.forEach((_paragraph, index) => visibility.intersecting(index, true));
+  } else {
+    for (const paragraph of paragraphs) {
+      observer.observe(paragraph);
+    }
+  }
+  let disposed = false;
+  const dispose = (): void => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    observer?.disconnect();
+    document.removeEventListener('visibilitychange', onVisibilityChange);
+    box.remove();
+  };
+  close.addEventListener('click', dispose);
+  return dispose;
+}

package/templates/notifications-overlay/common/src/platform/notificationBackend.ts

@@ -31,6 +31,8 @@ import type { TargetConfiguredGateway } from '@mpgd/target-config';
 export interface StarterNotificationBackend {
   readonly runtime: NotificationRuntime;
   listConsent(): Promise<readonly NotificationConsentRecord[]>;
+  /** Settles once the runtime has started, or failed to (logged); it never rejects. */
+  readonly started?: Promise<void>;
 }
 
 /** The server-backed session the Worker client needs (see `serverSession.ts`). */
@@ -153,10 +155,10 @@ export function createStarterWorkerNotificationBackend(
       },
     });
     // It subscribes to the provider at once; a backend that cannot answer yet does not fail the game.
-    runtime.start().catch((error: unknown) => {
+    const started = runtime.start().catch((error: unknown) => {
       console.error('[notifications] the runtime could not start.', error);
     });
-    return { runtime, listConsent: () => client.listConsent() };
+    return { runtime, listConsent: () => client.listConsent(), started };
   } catch (error) {
     // A configuration the client refuses turns notifications off, never the game.
     input.log('[notifications] the notifications backend could not be created.', error);
@@ -261,10 +263,10 @@ export function createStarterHostedNotificationBackend(
         console.error('[notifications]', error);
       },
     });
-    runtime.start().catch((error: unknown) => {
+    const started = runtime.start().catch((error: unknown) => {
       console.error('[notifications] the runtime could not start.', error);
     });
-    return { runtime, listConsent: () => backend.listConsent() };
+    return { runtime, listConsent: () => backend.listConsent(), started };
   } catch (error) {
     // A configuration the runtime refuses turns notifications off, never the game.
     input.log('[notifications] the notifications backend could not be created.', error);

package/templates/notifications-overlay/common/src/platform/notificationSettings.ts

@@ -732,7 +732,7 @@ function combinedState(
  */
 function renderNotices(
   listed: readonly NotificationNotice[],
-  input: StarterNotificationSettingsInput,
+  input: Pick<StarterNotificationSettingsInput, 'noticeCopy' | 'locale' | 'defaultLocale'>,
 ): readonly { readonly notice: NotificationNotice; readonly text: { readonly title: string; readonly body: string } }[] {
   const noticeCopy = input.noticeCopy;
   if (noticeCopy === undefined) {
@@ -759,3 +759,148 @@ function renderNotices(
     ];
   });
 }
+
+/**
+ * The consent notices shown once at launch, so a player who never opens the
+ * settings screen still sees them: under the Korean rules advertising pauses
+ * while a re-confirmation is overdue, until the game records it (notifications
+ * RFC "Consent refresh").
+ */
+export interface StarterLaunchNotices {
+  /** In the player's language, overdue ones (past their `dueBy`) first. */
+  readonly notices: readonly { readonly title: string; readonly body: string; readonly overdue: boolean }[];
+  /**
+   * Records the notices at these indexes of `notices` as given in the game,
+   * each at most once; call it for the ones the player has seen. Never throws.
+   */
+  record(indexes: readonly number[]): Promise<void>;
+}
+
+export interface StarterLaunchNoticesInput {
+  /** The game's notifications runtime; nothing is read without one. */
+  readonly runtime: NotificationRuntime | undefined;
+  /** `gateway.notificationsV2`; nothing is read on a target without notifications. */
+  readonly provider: NotificationProvider | undefined;
+  /**
+   * Settles once the runtime has started; the notices are read after it, or
+   * after `startTimeoutMs` at the latest, since `notices.list()` checks the
+   * session and the capability itself.
+   */
+  readonly started?: Promise<unknown>;
+  /** How long the read waits for `started`; 10 seconds by default. */
+  readonly startTimeoutMs?: number;
+  /** `notices.copy` of the catalog; without it no notice can be shown. */
+  readonly noticeCopy?: NotificationNoticeCopy;
+  readonly defaultLocale: string;
+  readonly locale: string;
+  /** The clock that says which notices are overdue; the device's by default. */
+  readonly now?: () => string;
+}
+
+/** How long the launch read waits for the runtime to start, at most. */
+export const starterLaunchNoticesStartTimeoutMs = 10_000;
+
+/**
+ * Reads the listed notices once the runtime has started (or its start has
+ * taken `startTimeoutMs`) and renders them, or `undefined` when there is
+ * nothing to show (no runtime, no provider, no copy, no notice, or a read
+ * that failed, which is logged). It never throws and never prompts: the
+ * game goes on while it reads.
+ */
+export async function readStarterLaunchNotices(
+  input: StarterLaunchNoticesInput,
+): Promise<StarterLaunchNotices | undefined> {
+  const { runtime } = input;
+  if (runtime === undefined || input.provider === undefined || input.noticeCopy === undefined) {
+    return undefined;
+  }
+  try {
+    if (input.started !== undefined) {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      await Promise.race([
+        input.started,
+        new Promise<void>((resolve) => {
+          timer = setTimeout(resolve, input.startTimeoutMs ?? starterLaunchNoticesStartTimeoutMs);
+        }),
+      ]).finally(() => clearTimeout(timer));
+    }
+    const shown = renderNotices(await runtime.notices.list(), input);
+    if (shown.length === 0) {
+      return undefined;
+    }
+    const today = toSeoulCalendarDate(input.now?.() ?? new Date().toISOString());
+    const ordered = shown
+      .map((entry) => ({ ...entry, overdue: entry.notice.dueBy < today }))
+      // Overdue first; the list's own order (by dueBy) otherwise.
+      .sort((left, right) => Number(right.overdue) - Number(left.overdue));
+    const recorded = new Set<number>();
+    return {
+      notices: ordered.map(({ text, overdue }) => ({ ...text, overdue })),
+      async record(indexes) {
+        const fresh = [...new Set(indexes)].flatMap((index) => {
+          const entry = recorded.has(index) ? undefined : ordered[index];
+          if (entry === undefined) {
+            return [];
+          }
+          recorded.add(index);
+          return [entry.notice];
+        });
+        // `async` so a runtime that throws synchronously is a rejection here too.
+        const results = await Promise.allSettled(
+          fresh.map(async (notice) => runtime.notices.recordShown(notice)),
+        );
+        for (const result of results) {
+          if (result.status === 'rejected') {
+            // The settings screen lists it again, and the server may push it.
+            console.warn('[notifications] a launch notice could not be recorded.', result.reason);
+          }
+        }
+      },
+    };
+  } catch (error) {
+    console.warn('[notifications] the launch notices could not be read.', error);
+    return undefined;
+  }
+}
+
+/**
+ * Which launch notices the player has seen: one that is on screen while the
+ * page is visible. The banner reports each notice's intersection with the
+ * screen and each page visibility change; a notice on screen while the page
+ * is hidden counts once the page shows again. `onSeen` runs once per notice.
+ */
+export function createStarterNoticeVisibility(input: {
+  readonly pageVisible: () => boolean;
+  readonly onSeen: (index: number) => void;
+}): {
+  readonly intersecting: (index: number, onScreen: boolean) => void;
+  readonly pageVisibilityChanged: () => void;
+} {
+  const onScreen = new Set<number>();
+  const seen = new Set<number>();
+  const see = (index: number): void => {
+    if (!seen.has(index)) {
+      seen.add(index);
+      input.onSeen(index);
+    }
+  };
+  return {
+    intersecting(index, visible) {
+      if (!visible) {
+        onScreen.delete(index);
+        return;
+      }
+      onScreen.add(index);
+      if (input.pageVisible()) {
+        see(index);
+      }
+    },
+    pageVisibilityChanged() {
+      if (input.pageVisible()) {
+        for (const index of onScreen) {
+          see(index);
+        }
+      }
+    },
+  };
+}

package/templates/notifications-overlay/common/src/platform/notifications.ts

@@ -14,6 +14,8 @@ import { resolveStarterServerSession } from './serverSession';
 import { routeNotificationOpens, type NotificationOpenRoutes } from './notificationOpens';
 import {
   createStarterNotificationSettings,
+  readStarterLaunchNotices,
+  type StarterLaunchNotices,
   type StarterNotificationSettings,
 } from './notificationSettings';
 
@@ -179,6 +181,95 @@ export function createStarterNotificationSettingsModel(
   });
 }
 
+/** Gateways whose launch notices were read this launch. */
+const launchNoticesRead = new WeakSet<TargetConfiguredGateway>();
+
+/**
+ * Shows the consent notices the server lists, once per launch: once the
+ * runtime has started (or its start has taken 10 seconds), it reads the
+ * listed notices and, when there is one, calls `show` with them in the
+ * player's language, overdue ones first. `show` mounts them and calls
+ * `seen(index)` for each one the player can see; only those are recorded as
+ * given. Under the Korean rules advertising pauses while a re-confirmation
+ * is overdue, until the game records it, so a player who never opens the
+ * settings screen still ends the pause at the next launch.
+ *
+ * - **Signed out at launch.** With a server session whose player is not
+ *   signed in yet, it reads once a session becomes current
+ *   (`onAuthenticated`), while `signal` is not aborted.
+ * - **Never in the way.** It runs in the background: it never blocks the
+ *   game or throws. A target without notifications or a game without a
+ *   backend shows nothing. When `show` answers `false` (the game went away),
+ *   nothing is recorded, and a later call in this process reads again.
+ */
+export function showStarterLaunchNotices(
+  platform: TargetConfiguredGateway,
+  input: {
+    readonly locale: string;
+    readonly show: (
+      notices: StarterLaunchNotices['notices'],
+      seen: (index: number) => void,
+    ) => boolean;
+    /** Aborted when the game goes away: a pending sign-in read is dropped. */
+    readonly signal?: AbortSignal;
+  },
+): Promise<void> {
+  if (launchNoticesRead.has(platform) || input.signal?.aborted === true) {
+    return Promise.resolve();
+  }
+  const backend = starterNotificationBackend(platform);
+  if (backend === undefined) {
+    return Promise.resolve();
+  }
+  launchNoticesRead.add(platform);
+  const session = hostedBackendFor(platform) ? undefined : resolveStarterServerSession();
+  if (session !== undefined && session.current() === undefined) {
+    // Signed out at launch: read once a player signs in, while the game runs.
+    launchNoticesRead.delete(platform);
+    let stop: (() => void) | undefined;
+    const retry = (): void => {
+      stop?.();
+      input.signal?.removeEventListener('abort', cancel);
+      void showStarterLaunchNotices(platform, input);
+    };
+    const cancel = (): void => stop?.();
+    stop = session.onAuthenticated(retry);
+    input.signal?.addEventListener('abort', cancel, { once: true });
+    return Promise.resolve();
+  }
+  return (async () => {
+    const launch = await readStarterLaunchNotices({
+      runtime: backend.runtime,
+      provider: platform.notificationsV2,
+      ...(backend.started === undefined ? {} : { started: backend.started }),
+      ...(starterNotificationCatalog.notices === undefined
+        ? {}
+        : { noticeCopy: starterNotificationCatalog.notices.copy }),
+      defaultLocale: starterNotificationCatalog.defaultLocale,
+      locale: input.locale,
+    });
+    if (launch === undefined) {
+      return;
+    }
+    const shown = input.signal?.aborted !== true
+      && input.show(launch.notices, (index) => {
+        void launch.record([index]);
+      });
+    if (!shown) {
+      // Not on screen: nothing was given, so a later mount may read again.
+      launchNoticesRead.delete(platform);
+    }
+  })().catch((error: unknown) => {
+    console.warn('[notifications] the launch notices could not be shown.', error);
+  });
+}
+
+/** Whether this gateway's notifications run over a hosted backend (Devvit), which needs no game session. */
+function hostedBackendFor(platform: TargetConfiguredGateway): boolean {
+  return platform.notificationsV2 !== undefined
+    && resolveStarterHostedNotificationBackend(platform.configTarget) !== undefined;
+}
+
 /**
  * The game's one listener for notification opens (see
  * `routeNotificationOpens` in `notificationOpens.ts`), over the runtime when

package/templates/notifications-overlay/lite/src/lite/notificationSettingsPanel.ts

@@ -1,3 +1,4 @@
+import { mountStarterLaunchNotices } from '../platform/launchNoticesBanner';
 import {
   starterNotificationLabelsFor,
   type StarterNotificationSettings,
@@ -5,6 +6,7 @@ import {
 } from '../platform/notificationSettings';
 import {
   createStarterNotificationSettingsModel,
+  showStarterLaunchNotices,
   subscribeStarterNotificationOpens,
 } from '../platform/notifications';
 import type { StarterContext } from '../runtime/gameContext';
@@ -15,7 +17,8 @@ import type { StarterContext } from '../runtime/gameContext';
  * the advertising and night consent (`notificationSettings.ts` holds the
  * logic). Every change is a tap; no switch starts on. A notification open
  * whose route is the settings screen (the advertising opt-out action, a
- * consent notice) opens the panel too. Returns the disposer.
+ * consent notice) opens the panel too, and the listed consent notices show
+ * once per launch (`showStarterLaunchNotices`). Returns the disposer.
  */
 export function mountNotificationSettingsPanel(mount: HTMLElement, context: StarterContext): () => void {
   if (context.platform.notificationsV2 === undefined) {
@@ -192,8 +195,27 @@ export function mountNotificationSettingsPanel(mount: HTMLElement, context: Star
     mount.style.position = 'relative';
   }
   mount.append(openButton, panel);
+  // Once per launch, the listed consent notices in a box that does not pause
+  // the game, each recorded as given once the player can see it: an overdue
+  // re-confirmation pauses advertising under the Korean rules until the game
+  // records it.
+  const lifetime = new AbortController();
+  let disposeLaunchNotices: (() => void) | undefined;
+  void showStarterLaunchNotices(context.platform, {
+    locale: context.locale,
+    signal: lifetime.signal,
+    show: (notices, seen) => {
+      if (lifetime.signal.aborted) {
+        return false;
+      }
+      disposeLaunchNotices = mountStarterLaunchNotices(notices, context.locale, { onSeen: seen });
+      return true;
+    },
+  });
   return () => {
+    lifetime.abort();
     unsubscribe();
+    disposeLaunchNotices?.();
     openButton.remove();
     panel.remove();
   };

package/templates/notifications-overlay/phaser/src/scenes/NotificationSettingsScene.ts

@@ -1,5 +1,6 @@
 import Phaser from 'phaser';
 
+import { mountStarterLaunchNotices } from '../platform/launchNoticesBanner';
 import {
   starterNotificationLabelsFor,
   type StarterNotificationLabels,
@@ -8,6 +9,7 @@ import {
 } from '../platform/notificationSettings';
 import {
   createStarterNotificationSettingsModel,
+  showStarterLaunchNotices,
   subscribeStarterNotificationOpens,
 } from '../platform/notifications';
 import { starterContextKey, type StarterContext } from '../runtime/gameContext';
@@ -70,6 +72,33 @@ export function routeNotificationSettingsOpens(game: Phaser.Game, context: Start
   });
 }
 
+/**
+ * Shows the consent notices the server lists once per launch, in a small box
+ * over the game that does not pause it, and records them as given (see
+ * `showStarterLaunchNotices`): a player who never opens the settings screen
+ * still sees an overdue re-confirmation, which under the Korean rules pauses
+ * advertising until it is recorded.
+ */
+export function showNotificationLaunchNotices(game: Phaser.Game, context: StarterContext): void {
+  let dispose: (() => void) | undefined;
+  const lifetime = new AbortController();
+  game.events.once('destroy', () => {
+    lifetime.abort();
+    dispose?.();
+  });
+  void showStarterLaunchNotices(context.platform, {
+    locale: context.locale,
+    signal: lifetime.signal,
+    show: (notices, seen) => {
+      if (lifetime.signal.aborted) {
+        return false;
+      }
+      dispose = mountStarterLaunchNotices(notices, context.locale, { onSeen: seen });
+      return true;
+    },
+  });
+}
+
 /**
  * The game-rendered notification settings: the OS or host permission,
  * reminder topics, and the advertising consent the Korean rules require