@mpgd/game-services 0.24.1 → 0.25.1

package/dist/notifications/store.js

@@ -0,0 +1,443 @@
+import { normalizeNotificationTimestamp, } from '@mpgd/platform/notifications';
+export function notificationRowOutcome(row) {
+    switch (row.state.status) {
+        case 'delivered':
+            return { status: 'delivered', alreadyProcessed: false };
+        case 'in-flight':
+            return { status: 'in-flight' };
+        case 'deferred':
+            return { status: 'deferred', reason: row.state.reason, until: row.state.until };
+    }
+}
+/**
+ * How far a recipient's answer got, for a send's result across recipients:
+ * delivered, in flight, waiting, a provider's refusal, a policy refusal, and
+ * last a recipient that did not resolve.
+ */
+function outcomeRank(outcome) {
+    switch (outcome.status) {
+        case 'delivered':
+            return 5;
+        case 'in-flight':
+            return 4;
+        case 'deferred':
+            return 3;
+        case 'unavailable':
+            return outcome.reason === 'no-endpoint' || outcome.reason === 'link-missing' ? 0 : 2;
+        case 'suppressed':
+            return 1;
+    }
+}
+/** The highest-ranked outcome, the earliest among deferred ones, the first among equals. */
+export function bestNotificationOutcome(outcomes) {
+    let best;
+    for (const outcome of outcomes) {
+        if (best === undefined
+            || outcomeRank(outcome) > outcomeRank(best)
+            || (outcome.status === 'deferred'
+                && best.status === 'deferred'
+                && Date.parse(outcome.until) < Date.parse(best.until))) {
+            best = outcome;
+        }
+    }
+    return best;
+}
+/** A send's stored outcome: its best row, or `in-flight` while its first evaluation holds the claim. */
+export function notificationSendOutcome(send) {
+    const stored = bestNotificationOutcome(send.rows.map(notificationRowOutcome));
+    return stored ?? (send.claim === undefined ? undefined : { status: 'in-flight' });
+}
+/** How long an ambiguous delivery is replayed before it is left in flight. */
+export const notificationAmbiguousReplayHours = 24;
+const ambiguousReplayMs = notificationAmbiguousReplayHours * 3_600_000;
+/** When the scheduler may first take the row, or `undefined` when it never will. */
+function rowDueAt(row) {
+    if (row.state.status === 'deferred') {
+        return Date.parse(row.state.until);
+    }
+    if (row.state.status !== 'in-flight') {
+        return undefined;
+    }
+    const lease = Date.parse(row.state.leaseUntil);
+    if (!row.state.attempted || row.firstAttemptedAt === undefined) {
+        return lease;
+    }
+    // The provider may have sent it every time: replays stop after a day, and
+    // the row stays in flight until its key's retention ends.
+    return isNotificationRowAbandoned(row, lease) ? undefined : lease;
+}
+/**
+ * Whether an attempted row is past its replays: its lease would end a day
+ * or more after its first attempt.
+ */
+export function isNotificationRowAbandoned(row, leaseUntil) {
+    return row.firstAttemptedAt !== undefined
+        && leaseUntil - Date.parse(row.firstAttemptedAt) >= ambiguousReplayMs;
+}
+/**
+ * Whether the scheduler may take a row at `at`: a deferred row once `until`
+ * passed, and an in-flight row once its lease expired. That covers a queued
+ * delivery whose message was lost, a claim whose holder failed before the
+ * provider call, and an ambiguous answer, for a device endpoint, a scheduled
+ * send, or a direct platform send whose caller never retries. Ambiguous
+ * replays stop 24 hours after the first attempt.
+ */
+export function isNotificationRowDue(row, at) {
+    const due = rowDueAt(row);
+    return due !== undefined && due <= at;
+}
+/** When the scheduler may first take one of the send's rows, or `undefined` when none waits for it. */
+export function notificationSendDueAt(send) {
+    let due;
+    for (const row of send.rows) {
+        const at = rowDueAt(row);
+        if (at !== undefined && (due === undefined || at < due)) {
+            due = at;
+        }
+    }
+    return due === undefined ? undefined : formatNotificationInstant(due);
+}
+/** Epoch milliseconds of a stored time; one that does not parse is a caller error, as in the D1 store. */
+function instantOf(at) {
+    const millis = Date.parse(at);
+    if (!Number.isFinite(millis)) {
+        throw new TypeError(`Not a timestamp: ${JSON.stringify(at)}`);
+    }
+    return millis;
+}
+function dueOf(entry) {
+    return entry.dueAt === undefined ? undefined : instantOf(entry.dueAt);
+}
+/** The entry as a JSON store keeps it: under its key's player and id, without an undefined `dueAt`. */
+function storedEntry(entry, player, id) {
+    const { dueAt, ...rest } = structuredClone(entry);
+    return { ...rest, player, id, ...(dueAt === undefined ? {} : { dueAt }) };
+}
+/** Refuses an entry whose `dueAt` does not parse before anything is written. */
+function assertDue(entry) {
+    dueOf(entry);
+}
+/** Code-point order, which is UTF-8 byte order: the order of SQLite's BINARY collation. */
+function compareCodePoints(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    const a = Array.from(left);
+    const b = Array.from(right);
+    for (let index = 0; index < Math.min(a.length, b.length); index += 1) {
+        const difference = (a[index]?.codePointAt(0) ?? 0) - (b[index]?.codePointAt(0) ?? 0);
+        if (difference !== 0) {
+            return difference;
+        }
+    }
+    return a.length - b.length;
+}
+export function formatNotificationInstant(millis) {
+    return normalizeNotificationTimestamp(new Date(millis).toISOString());
+}
+/**
+ * A process-local store for tests, conformance runs, and local development.
+ * Every method finishes its change before its first await, so concurrent
+ * callers see each change whole. Production deployments use a durable store.
+ */
+export function createInMemoryNotificationStore() {
+    const consent = [];
+    const endpoints = [];
+    const platformRegistrations = new Map();
+    const noticesGiven = [];
+    const sends = new Map();
+    const history = [];
+    const schedule = new Map();
+    const scheduleKey = (player, id) => JSON.stringify([player, id]);
+    let versions = 0;
+    const nextVersion = () => {
+        versions += 1;
+        return `v${versions}`;
+    };
+    const copy = (value) => structuredClone(value);
+    const noticeName = (notice) => JSON.stringify([
+        notice.player,
+        notice.kind,
+        notice.record.kind,
+        Date.parse(notice.record.at),
+        notice.dueBy,
+    ]);
+    return {
+        inspect() {
+            return copy({
+                consent: consent.map((row) => ({ ...row.record, player: row.player })),
+                endpoints,
+                platformRegistrations: [...platformRegistrations.values()],
+                noticesGiven,
+                sends: [...sends.values()].map((entry) => entry.send),
+                history,
+                schedule: [...schedule.values()].map((held) => held.entry),
+            });
+        },
+        async appendConsent({ player, record, at }) {
+            let millis = Date.parse(at);
+            for (let index = consent.length - 1; index >= 0; index -= 1) {
+                const row = consent[index];
+                if (row !== undefined && row.player === player) {
+                    millis = Math.max(millis, Date.parse(row.record.at) + 1);
+                    break;
+                }
+            }
+            const stored = { ...copy(record), at: formatNotificationInstant(millis) };
+            consent.push({ player, record: stored });
+            return copy(stored);
+        },
+        async listConsent(player) {
+            return copy(consent.filter((row) => row.player === player).map((row) => row.record));
+        },
+        async pruneConsent({ player, at }) {
+            const instants = new Set(at.map(instantOf));
+            let removed = 0;
+            for (let index = consent.length - 1; index >= 0; index -= 1) {
+                const row = consent[index];
+                if (row !== undefined && row.player === player && instants.has(Date.parse(row.record.at))) {
+                    consent.splice(index, 1);
+                    removed += 1;
+                }
+            }
+            for (let index = noticesGiven.length - 1; index >= 0; index -= 1) {
+                const given = noticesGiven[index];
+                if (given !== undefined && given.player === player && instants.has(Date.parse(given.record.at))) {
+                    noticesGiven.splice(index, 1);
+                }
+            }
+            return removed;
+        },
+        async putEndpoint(write) {
+            for (let index = endpoints.length - 1; index >= 0; index -= 1) {
+                const other = endpoints[index];
+                if (other !== undefined
+                    && other.provider === write.provider
+                    && other.address.value === write.address.value
+                    && other.installationId !== write.installationId) {
+                    endpoints.splice(index, 1);
+                }
+            }
+            const index = endpoints.findIndex((endpoint) => endpoint.provider === write.provider && endpoint.installationId === write.installationId);
+            const existing = index === -1 ? undefined : endpoints[index];
+            const dead = existing?.status === 'invalid' && existing.address.value === write.address.value;
+            const stored = {
+                ...copy(write),
+                status: dead ? 'invalid' : 'valid',
+                ...(dead && existing.invalidatedAt !== undefined ? { invalidatedAt: existing.invalidatedAt } : {}),
+            };
+            if (index === -1) {
+                endpoints.push(stored);
+            }
+            else {
+                endpoints[index] = stored;
+            }
+            return copy(stored);
+        },
+        async listEndpoints({ player, provider }) {
+            return copy(endpoints.filter((endpoint) => endpoint.player === player && endpoint.provider === provider));
+        },
+        async getEndpoint({ provider, installationId }) {
+            const endpoint = endpoints.find((candidate) => candidate.provider === provider && candidate.installationId === installationId);
+            return endpoint === undefined ? undefined : copy(endpoint);
+        },
+        async invalidateEndpoint({ provider, installationId, value, at }) {
+            const index = endpoints.findIndex((endpoint) => endpoint.provider === provider
+                && endpoint.installationId === installationId
+                && endpoint.address.value === value);
+            const endpoint = endpoints[index];
+            if (endpoint !== undefined && endpoint.status === 'valid') {
+                endpoints[index] = { ...endpoint, status: 'invalid', invalidatedAt: at };
+            }
+        },
+        async removeEndpoints({ installationId, player, provider }) {
+            for (let index = endpoints.length - 1; index >= 0; index -= 1) {
+                const endpoint = endpoints[index];
+                if (endpoint !== undefined
+                    && endpoint.installationId === installationId
+                    && endpoint.player === player
+                    && (provider === undefined || endpoint.provider === provider)) {
+                    endpoints.splice(index, 1);
+                }
+            }
+        },
+        async removeSessionEndpoints({ sessionId }) {
+            let removed = 0;
+            for (let index = endpoints.length - 1; index >= 0; index -= 1) {
+                if (endpoints[index]?.sessionId === sessionId) {
+                    endpoints.splice(index, 1);
+                    removed += 1;
+                }
+            }
+            return removed;
+        },
+        async extendSessionEndpoints({ sessionId, expiresAt }) {
+            let changed = 0;
+            for (let index = 0; index < endpoints.length; index += 1) {
+                const endpoint = endpoints[index];
+                if (endpoint === undefined
+                    || endpoint.sessionId !== sessionId
+                    || endpoint.sessionExpiresAt === undefined
+                    || (expiresAt !== undefined && Date.parse(endpoint.sessionExpiresAt) >= Date.parse(expiresAt))) {
+                    continue;
+                }
+                const { sessionExpiresAt: _earlier, ...kept } = endpoint;
+                endpoints[index] = expiresAt === undefined ? kept : { ...kept, sessionExpiresAt: expiresAt };
+                changed += 1;
+            }
+            return changed;
+        },
+        async putPlatformRegistration(registration) {
+            platformRegistrations.set(JSON.stringify([registration.player, registration.provider]), copy(registration));
+        },
+        async getPlatformRegistration({ player, provider }) {
+            const registration = platformRegistrations.get(JSON.stringify([player, provider]));
+            return registration === undefined ? undefined : copy(registration);
+        },
+        async addNoticeGiven(notice) {
+            const name = noticeName(notice);
+            if (!noticesGiven.some((given) => noticeName(given) === name)) {
+                noticesGiven.push(copy(notice));
+            }
+        },
+        async listNoticesGiven(player) {
+            return copy(noticesGiven.filter((given) => given.player === player));
+        },
+        async getSend(key) {
+            const entry = sends.get(key);
+            return entry === undefined ? undefined : copy(entry);
+        },
+        async createSend(send) {
+            if (sends.has(send.key)) {
+                return undefined;
+            }
+            const version = nextVersion();
+            sends.set(send.key, { send: copy(send), version });
+            return version;
+        },
+        async updateSend({ key, version, send }) {
+            const entry = sends.get(key);
+            if (entry === undefined || entry.version !== version) {
+                return false;
+            }
+            if (send === undefined) {
+                sends.delete(key);
+            }
+            else {
+                sends.set(key, { send: copy(send), version: nextVersion() });
+            }
+            return true;
+        },
+        async listInFlightSends(player) {
+            return copy([...sends.values()]
+                .map((entry) => entry.send)
+                .filter((send) => send.request.player === player && send.rows.some((row) => row.state.status === 'in-flight')));
+        },
+        async listDueSends({ at, limit }) {
+            const now = instantOf(at);
+            return [...sends.values()]
+                .flatMap(({ send }) => {
+                const due = notificationSendDueAt(send);
+                return due !== undefined && Date.parse(due) <= now ? [{ key: send.key, due: Date.parse(due) }] : [];
+            })
+                .sort((left, right) => left.due - right.due)
+                .slice(0, Math.max(0, limit))
+                .map((entry) => entry.key);
+        },
+        async addHistory(entry) {
+            instantOf(entry.at);
+            if (!history.some((sent) => sent.sendKey === entry.sendKey && sent.provider === entry.provider)) {
+                history.push(copy(entry));
+                history.sort((left, right) => Date.parse(left.at) - Date.parse(right.at));
+            }
+        },
+        async listHistory({ player, since }) {
+            const from = instantOf(since);
+            return copy(history.filter((sent) => sent.player === player && Date.parse(sent.at) >= from));
+        },
+        async countHistory({ provider, since, until }) {
+            const from = instantOf(since);
+            const to = instantOf(until);
+            return history.filter((sent) => sent.provider === provider && Date.parse(sent.at) >= from && Date.parse(sent.at) <= to).length;
+        },
+        async getScheduleEntry({ player, id }) {
+            const held = schedule.get(scheduleKey(player, id));
+            return held === undefined ? undefined : copy(held);
+        },
+        async createScheduleEntry(entry) {
+            assertDue(entry);
+            const key = scheduleKey(entry.player, entry.id);
+            if (schedule.has(key)) {
+                return undefined;
+            }
+            const version = nextVersion();
+            schedule.set(key, { entry: storedEntry(entry, entry.player, entry.id), version });
+            return version;
+        },
+        async updateScheduleEntry({ player, id, version, entry }) {
+            if (entry !== undefined) {
+                assertDue(entry);
+            }
+            const key = scheduleKey(player, id);
+            const held = schedule.get(key);
+            if (held === undefined || held.version !== version) {
+                return false;
+            }
+            if (entry === undefined) {
+                schedule.delete(key);
+            }
+            else {
+                schedule.set(key, { entry: storedEntry(entry, player, id), version: nextVersion() });
+            }
+            return true;
+        },
+        async countPendingReminders(player) {
+            return [...schedule.values()].filter(({ entry }) => entry.player === player
+                && entry.id.startsWith('reminder:')
+                && entry.item.kind === 'reminder'
+                && entry.item.firedAt === undefined).length;
+        },
+        async listDueScheduleEntries({ at, limit }) {
+            const now = instantOf(at);
+            return [...schedule.values()]
+                .flatMap(({ entry }) => {
+                const due = dueOf(entry);
+                return due !== undefined && due <= now ? [{ player: entry.player, id: entry.id, due }] : [];
+            })
+                .sort((left, right) => left.due - right.due || compareCodePoints(left.player, right.player) || compareCodePoints(left.id, right.id))
+                .slice(0, Math.max(0, limit))
+                .map(({ player, id }) => ({ player, id }));
+        },
+        async purge(cutoffs) {
+            for (const cutoff of Object.values(cutoffs)) {
+                instantOf(cutoff);
+            }
+            const before = (at, cutoff) => at !== undefined && Date.parse(at) < Date.parse(cutoff);
+            let sendCount = 0;
+            for (const [key, entry] of [...sends]) {
+                if (before(entry.send.changedAt, cutoffs.sendsChangedBefore)) {
+                    sends.delete(key);
+                    sendCount += 1;
+                }
+            }
+            const historyBefore = history.length;
+            for (let index = history.length - 1; index >= 0; index -= 1) {
+                if (before(history[index]?.at, cutoffs.historyBefore)) {
+                    history.splice(index, 1);
+                }
+            }
+            let endpointCount = 0;
+            for (let index = endpoints.length - 1; index >= 0; index -= 1) {
+                const endpoint = endpoints[index];
+                if (endpoint !== undefined
+                    && ((endpoint.status === 'invalid' && before(endpoint.invalidatedAt, cutoffs.invalidEndpointsBefore))
+                        || before(endpoint.lastRegisteredAt, cutoffs.staleEndpointsBefore)
+                        || before(endpoint.sessionExpiresAt, cutoffs.sessionEndpointsBefore))) {
+                    endpoints.splice(index, 1);
+                    endpointCount += 1;
+                }
+            }
+            return { sends: sendCount, history: historyBefore - history.length, endpoints: endpointCount };
+        },
+    };
+}

package/dist/notifications/text.d.ts

@@ -0,0 +1,2 @@
+/** An error's message for another error's text; never the error's other fields. */
+export declare function describeError(error: unknown): string;

package/dist/notifications/text.js

@@ -0,0 +1,4 @@
+/** An error's message for another error's text; never the error's other fields. */
+export function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/game-services",
-  "version": "0.24.1",
+  "version": "0.25.1",
   "description": "Client, contract, server, store, and test helpers for authoritative mpgd game services.",
   "license": "MIT",
   "repository": {
@@ -129,6 +129,18 @@
       "types": "./dist/notification-delivery.d.ts",
       "default": "./dist/notification-delivery.js"
     },
+    "./notifications": {
+      "types": "./dist/notifications/index.d.ts",
+      "default": "./dist/notifications/index.js"
+    },
+    "./notifications/store-conformance": {
+      "types": "./dist/notifications/store-conformance.d.ts",
+      "default": "./dist/notifications/store-conformance.js"
+    },
+    "./notifications/ait-functional-delivery": {
+      "types": "./dist/notifications/ait-functional-delivery.d.ts",
+      "default": "./dist/notifications/ait-functional-delivery.js"
+    },
     "./platform-order": {
       "types": "./dist/platform-order.d.ts",
       "default": "./dist/platform-order.js"
@@ -203,9 +215,9 @@
     "@orpc/client": "2.0.0-beta.14",
     "@orpc/contract": "2.0.0-beta.14",
     "@orpc/server": "2.0.0-beta.14",
-    "@mpgd/catalog": "0.10.1",
-    "@mpgd/analytics": "0.4.10",
-    "@mpgd/platform": "0.23.1"
+    "@mpgd/platform": "0.25.0",
+    "@mpgd/analytics": "0.4.12",
+    "@mpgd/catalog": "0.10.3"
   },
   "peerDependencies": {
     "@apple/app-store-server-library": "^3.1.0"
@@ -234,7 +246,7 @@
     "fix": "ttsc fix",
     "build": "cd ../.. && node tools/run-ttsx.mjs tools/package/build-packages.ts @mpgd/game-services",
     "test:packed-transport": "pnpm build && node test/runtime-transport-package-import.mjs && node test/reward-evidence-import.mjs",
-    "test:unit": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/client-progress.test.ts && node tools/run-ttsx.mjs packages/game-services/src/runtime.test.ts && node tools/run-ttsx.mjs packages/game-services/src/types.test.ts && node tools/run-ttsx.mjs packages/game-services/src/server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/google-play-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/google-play-publisher-client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/microsoft-store-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/microsoft-store-identity.test.ts && node tools/run-ttsx.mjs packages/game-services/src/platform-order.test.ts && node tools/run-ttsx.mjs packages/game-services/src/progress-link.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notification-delivery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/admob-ssv.test.ts && node tools/run-ttsx.mjs packages/game-services/src/app-store-verifier.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-evidence-verification-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-partner-api.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-durability-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-transport.test.ts && node tools/run-ttsx.mjs packages/game-services/src/guest-session.test.ts && node tools/run-ttsx.mjs packages/game-services/src/client-reward-evidence.test.ts && node tools/run-ttsx.mjs packages/game-services/src/ad-reward-verifier-registry.test.ts && node tools/run-ttsx.mjs packages/game-services/src/oneplay-reward.test.ts && node tools/run-ttsx.mjs packages/game-services/src/oneplay-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-registry-routing.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-registry-server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-ledger-revocation.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-anonymous-auth.test.ts",
+    "test:unit": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/client-progress.test.ts && node tools/run-ttsx.mjs packages/game-services/src/runtime.test.ts && node tools/run-ttsx.mjs packages/game-services/src/types.test.ts && node tools/run-ttsx.mjs packages/game-services/src/server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/google-play-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/google-play-publisher-client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/microsoft-store-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/microsoft-store-identity.test.ts && node tools/run-ttsx.mjs packages/game-services/src/platform-order.test.ts && node tools/run-ttsx.mjs packages/game-services/src/progress-link.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notification-delivery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notifications/service.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notifications/service-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notifications/scheduler.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notifications/fcm.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notifications/store-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notifications/ait-functional-delivery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/admob-ssv.test.ts && node tools/run-ttsx.mjs packages/game-services/src/app-store-verifier.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-evidence-verification-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-partner-api.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-durability-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-transport.test.ts && node tools/run-ttsx.mjs packages/game-services/src/guest-session.test.ts && node tools/run-ttsx.mjs packages/game-services/src/client-reward-evidence.test.ts && node tools/run-ttsx.mjs packages/game-services/src/ad-reward-verifier-registry.test.ts && node tools/run-ttsx.mjs packages/game-services/src/oneplay-reward.test.ts && node tools/run-ttsx.mjs packages/game-services/src/oneplay-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-registry-routing.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-registry-server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-ledger-revocation.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-anonymous-auth.test.ts",
     "test:recovery": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/monetization-recovery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/app-store-recovery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-reconciler.test.ts && node tools/run-ttsx.mjs packages/game-services/src/commerce-reconciler-conformance.test.ts",
     "test": "pnpm test:unit && pnpm test:app-store-server && pnpm test:recovery && pnpm test:packed-transport",
     "test:app-store-server": "vitest run"