@mpgd/game-services 0.3.3 → 0.5.0

package/dist/progress-link.js

@@ -0,0 +1,394 @@
+import { assertOwnEnumerablePropertyLimit } from './validation';
+export const gameProgressLimits = {
+    maxIdentifierLength: 256,
+    maxCompletedIds: 512,
+    maxMetricEntries: 512,
+    maxPayloadDepth: 16,
+    maxPayloadNodes: 2048,
+    maxPayloadStringUnits: 32768,
+};
+const snapshotFields = new Set(['completedIds', 'bestTimesMs', 'bestScores', 'activeProgress']);
+const activeProgressFields = new Set(['id', 'updatedAt', 'payload']);
+/** Process-local test helper. Production services must provide a durable store. */
+export class InMemoryProgressLinkStore {
+    progressByPlayerId = new Map();
+    reconciliationsByIdempotencyKey = new Map();
+    reconciliationsByHandoffNonce = new Map();
+    constructor(initialProgress = []) {
+        for (const record of initialProgress) {
+            const authoritativePlayerId = normalizeIdentifier(record.authoritativePlayerId, 'authoritativePlayerId');
+            this.progressByPlayerId.set(authoritativePlayerId, normalizeGameProgressSnapshot(record.progress));
+        }
+    }
+    async reconcile(input) {
+        const request = normalizeReconcileGuestProgressRequest(input);
+        const byIdempotencyKey = this.reconciliationsByIdempotencyKey.get(request.idempotencyKey);
+        const byHandoffNonce = this.reconciliationsByHandoffNonce.get(request.handoffNonce);
+        if (byIdempotencyKey !== undefined
+            && byHandoffNonce !== undefined
+            && byIdempotencyKey !== byHandoffNonce) {
+            throw new Error('idempotencyKey and handoffNonce belong to different reconciliations.');
+        }
+        const existing = byIdempotencyKey ?? byHandoffNonce;
+        if (existing !== undefined) {
+            assertMatchingProgressLinkIdentity(existing, request);
+            this.reconciliationsByIdempotencyKey.set(request.idempotencyKey, existing);
+            this.reconciliationsByHandoffNonce.set(request.handoffNonce, existing);
+            return {
+                authoritativePlayerId: existing.authoritativePlayerId,
+                progress: normalizeGameProgressSnapshot(existing.progress),
+                alreadyProcessed: true,
+                deduplicatedBy: byIdempotencyKey === undefined ? 'handoff-nonce' : 'idempotency-key',
+            };
+        }
+        const serverProgress = this.progressByPlayerId.get(request.authoritativePlayerId)
+            ?? createEmptyGameProgressSnapshot();
+        const progress = mergeGameProgressSnapshots(serverProgress, request.guestProgress);
+        const reconciliation = {
+            authoritativePlayerId: request.authoritativePlayerId,
+            guestId: request.guestId,
+            progress,
+        };
+        this.progressByPlayerId.set(request.authoritativePlayerId, progress);
+        this.reconciliationsByIdempotencyKey.set(request.idempotencyKey, reconciliation);
+        this.reconciliationsByHandoffNonce.set(request.handoffNonce, reconciliation);
+        return {
+            authoritativePlayerId: request.authoritativePlayerId,
+            progress: normalizeGameProgressSnapshot(progress),
+            alreadyProcessed: false,
+            deduplicatedBy: 'none',
+        };
+    }
+    async getProgress(authoritativePlayerId) {
+        const progress = this.progressByPlayerId.get(normalizeIdentifier(authoritativePlayerId, 'authoritativePlayerId'));
+        return progress === undefined ? undefined : normalizeGameProgressSnapshot(progress);
+    }
+}
+export function createInMemoryProgressLinkStore(initialProgress = []) {
+    return new InMemoryProgressLinkStore(initialProgress);
+}
+export function createProgressLinkService(input) {
+    const now = input.now ?? (() => new Date().toISOString());
+    return {
+        async reconcileGuestProgress(contextInput, handoffInput) {
+            const context = normalizeServerResolvedPlayerContext(contextInput);
+            const metadata = normalizeGuestProgressHandoffMetadata(handoffInput);
+            await verifyProgressHandoff(input.handoffVerifier, context, metadata, now);
+            // These validations deliberately stay at separate trust boundaries: the
+            // client request, verifier output, store input, and store output may each
+            // come from independently implemented code. Payload limits keep every
+            // traversal bounded while preventing a typed-but-unvalidated value from
+            // skipping runtime validation.
+            const guestProgress = normalizeGameProgressSnapshot(handoffInput.guestProgress);
+            const verifiedProgress = normalizeGameProgressSnapshot(await input.progressVerifier.verify({
+                authoritativePlayerId: context.authoritativePlayerId,
+                guestId: metadata.guestId,
+                handoffNonce: metadata.handoffNonce,
+                progress: guestProgress,
+            }));
+            const result = await input.store.reconcile({
+                authoritativePlayerId: context.authoritativePlayerId,
+                ...metadata,
+                guestProgress: verifiedProgress,
+            });
+            return normalizeReconcileGuestProgressResult(result, context.authoritativePlayerId);
+        },
+    };
+}
+export function createEmptyGameProgressSnapshot() {
+    return {
+        completedIds: [],
+        bestTimesMs: {},
+        bestScores: {},
+    };
+}
+export function normalizeGameProgressSnapshot(input) {
+    assertRecord(input, 'GameProgressSnapshot');
+    assertOnlyFields(input, snapshotFields, 'GameProgressSnapshot');
+    if (!Array.isArray(input.completedIds)) {
+        throw new Error('completedIds must be an array.');
+    }
+    assertCollectionLimit(input.completedIds.length, gameProgressLimits.maxCompletedIds, 'completedIds');
+    const completedIds = [...new Set(Array.from(input.completedIds, (id, index) => (normalizeIdentifier(id, `completedIds[${String(index)}]`))))].sort();
+    const bestTimesMs = normalizeMetricMap(input.bestTimesMs, 'bestTimesMs', (value, label) => {
+        if (value < 0) {
+            throw new Error(`${label} must be greater than or equal to zero.`);
+        }
+    });
+    const bestScores = normalizeMetricMap(input.bestScores, 'bestScores');
+    if (input.activeProgress === undefined) {
+        return {
+            completedIds,
+            bestTimesMs,
+            bestScores,
+        };
+    }
+    return {
+        completedIds,
+        bestTimesMs,
+        bestScores,
+        activeProgress: normalizeActiveProgress(input.activeProgress),
+    };
+}
+export function mergeGameProgressSnapshots(serverInput, guestInput) {
+    // This exported helper is also a runtime boundary; TypeScript types alone do
+    // not prove that either snapshot came from a trusted or validated source.
+    const server = normalizeGameProgressSnapshot(serverInput);
+    const guest = normalizeGameProgressSnapshot(guestInput);
+    const activeProgress = selectActiveProgress(server.activeProgress, guest.activeProgress);
+    const completedIds = [...new Set([...server.completedIds, ...guest.completedIds])].sort();
+    assertCollectionLimit(completedIds.length, gameProgressLimits.maxCompletedIds, 'merged completedIds');
+    return {
+        completedIds,
+        bestTimesMs: mergeMetricMaps(server.bestTimesMs, guest.bestTimesMs, Math.min),
+        bestScores: mergeMetricMaps(server.bestScores, guest.bestScores, Math.max),
+        ...(activeProgress === undefined ? {} : { activeProgress }),
+    };
+}
+function normalizeReconcileGuestProgressRequest(input) {
+    assertRecord(input, 'ReconcileGuestProgressRequest');
+    const metadata = normalizeGuestProgressHandoffMetadata(input);
+    return {
+        authoritativePlayerId: normalizeIdentifier(input.authoritativePlayerId, 'authoritativePlayerId'),
+        ...metadata,
+        guestProgress: normalizeGameProgressSnapshot(input.guestProgress),
+    };
+}
+function normalizeServerResolvedPlayerContext(input) {
+    assertRecord(input, 'ServerResolvedPlayerContext');
+    return {
+        authoritativePlayerId: normalizeIdentifier(input.authoritativePlayerId, 'authoritativePlayerId'),
+    };
+}
+function normalizeGuestProgressHandoffMetadata(input) {
+    assertRecord(input, 'GuestProgressHandoffRequest');
+    return {
+        guestId: normalizeIdentifier(input.guestId, 'guestId'),
+        handoffNonce: normalizeIdentifier(input.handoffNonce, 'handoffNonce'),
+        idempotencyKey: normalizeIdentifier(input.idempotencyKey, 'idempotencyKey'),
+    };
+}
+async function verifyProgressHandoff(verifier, context, request, now) {
+    const handoff = await verifier.verify({ handoffNonce: request.handoffNonce });
+    if (handoff === undefined) {
+        throw new Error('Progress handoff is invalid or expired.');
+    }
+    const verified = normalizeVerifiedProgressHandoff(handoff);
+    const currentTime = Date.parse(normalizeTimestamp(now(), 'now()'));
+    const issuedAt = Date.parse(verified.issuedAt);
+    const expiresAt = Date.parse(verified.expiresAt);
+    if (verified.handoffNonce !== request.handoffNonce
+        || verified.authoritativePlayerId !== context.authoritativePlayerId
+        || verified.guestId !== request.guestId
+        || issuedAt > currentTime
+        || expiresAt <= issuedAt
+        || expiresAt <= currentTime) {
+        throw new Error('Progress handoff is invalid or expired.');
+    }
+}
+function normalizeReconcileGuestProgressResult(input, expectedPlayerId) {
+    assertRecord(input, 'ReconcileGuestProgressResult');
+    const authoritativePlayerId = normalizeIdentifier(input.authoritativePlayerId, 'result authoritativePlayerId');
+    if (authoritativePlayerId !== expectedPlayerId) {
+        throw new Error('Progress link store returned a result for another player.');
+    }
+    if (typeof input.alreadyProcessed !== 'boolean') {
+        throw new Error('Progress link store returned an invalid alreadyProcessed value.');
+    }
+    if (input.deduplicatedBy !== 'none'
+        && input.deduplicatedBy !== 'idempotency-key'
+        && input.deduplicatedBy !== 'handoff-nonce') {
+        throw new Error('Progress link store returned an invalid deduplicatedBy value.');
+    }
+    if (input.alreadyProcessed !== (input.deduplicatedBy !== 'none')) {
+        throw new Error('Progress link store returned inconsistent deduplication state.');
+    }
+    return {
+        authoritativePlayerId,
+        progress: normalizeGameProgressSnapshot(input.progress),
+        alreadyProcessed: input.alreadyProcessed,
+        deduplicatedBy: input.deduplicatedBy,
+    };
+}
+function normalizeVerifiedProgressHandoff(input) {
+    assertRecord(input, 'VerifiedProgressHandoff');
+    return {
+        handoffNonce: normalizeIdentifier(input.handoffNonce, 'verified handoffNonce'),
+        authoritativePlayerId: normalizeIdentifier(input.authoritativePlayerId, 'verified authoritativePlayerId'),
+        guestId: normalizeIdentifier(input.guestId, 'verified guestId'),
+        issuedAt: normalizeTimestamp(input.issuedAt, 'verified issuedAt'),
+        expiresAt: normalizeTimestamp(input.expiresAt, 'verified expiresAt'),
+    };
+}
+function normalizeActiveProgress(input) {
+    assertRecord(input, 'activeProgress');
+    assertOnlyFields(input, activeProgressFields, 'activeProgress');
+    return {
+        id: normalizeIdentifier(input.id, 'activeProgress.id'),
+        updatedAt: normalizeTimestamp(input.updatedAt, 'activeProgress.updatedAt'),
+        payload: normalizeProgressPayload(input.payload),
+    };
+}
+function normalizeMetricMap(input, label, validate) {
+    assertRecord(input, label);
+    assertOwnEnumerablePropertyLimit(input, gameProgressLimits.maxMetricEntries, label);
+    const inputEntries = Object.entries(input);
+    const entries = inputEntries.map(([key, value]) => {
+        const normalizedKey = normalizeIdentifier(key, `${label} key`);
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new Error(`${label}.${key} must be a finite number.`);
+        }
+        validate?.(value, `${label}.${key}`);
+        return [normalizedKey, value];
+    });
+    entries.sort(([left], [right]) => compareCodeUnits(left, right));
+    return Object.fromEntries(entries);
+}
+function mergeMetricMaps(server, guest, select) {
+    const keys = [...new Set([...Object.keys(server), ...Object.keys(guest)])].sort();
+    assertCollectionLimit(keys.length, gameProgressLimits.maxMetricEntries, 'merged metric map');
+    const mergedEntries = [];
+    for (const key of keys) {
+        const serverValue = Object.hasOwn(server, key) ? server[key] : undefined;
+        const guestValue = Object.hasOwn(guest, key) ? guest[key] : undefined;
+        if (serverValue === undefined) {
+            if (guestValue !== undefined) {
+                mergedEntries.push([key, guestValue]);
+            }
+            continue;
+        }
+        if (guestValue === undefined) {
+            mergedEntries.push([key, serverValue]);
+            continue;
+        }
+        mergedEntries.push([key, select(serverValue, guestValue)]);
+    }
+    return Object.fromEntries(mergedEntries);
+}
+function selectActiveProgress(server, guest) {
+    if (server === undefined) {
+        return guest;
+    }
+    if (guest === undefined) {
+        return server;
+    }
+    return Date.parse(guest.updatedAt) > Date.parse(server.updatedAt) ? guest : server;
+}
+function normalizeProgressPayload(input) {
+    assertRecord(input, 'activeProgress.payload');
+    const normalized = normalizeGameProgressValue(input, 'activeProgress.payload', new Set(), { nodes: 0, stringUnits: 0 }, 0);
+    if (!isGameProgressRecord(normalized)) {
+        throw new Error('activeProgress.payload must be an object.');
+    }
+    return normalized;
+}
+function normalizeGameProgressValue(input, label, ancestors, budget, depth) {
+    if (depth > gameProgressLimits.maxPayloadDepth) {
+        throw new Error(`activeProgress.payload must not exceed depth ${String(gameProgressLimits.maxPayloadDepth)}.`);
+    }
+    budget.nodes += 1;
+    if (budget.nodes > gameProgressLimits.maxPayloadNodes) {
+        throw new Error(`activeProgress.payload must not exceed ${String(gameProgressLimits.maxPayloadNodes)} nodes.`);
+    }
+    if (input === null
+        || typeof input === 'boolean') {
+        return input;
+    }
+    if (typeof input === 'string') {
+        consumePayloadStringBudget(budget, input.length);
+        return input;
+    }
+    if (typeof input === 'number') {
+        if (!Number.isFinite(input)) {
+            throw new Error(`${label} must contain only finite numbers.`);
+        }
+        return input;
+    }
+    if (typeof input !== 'object') {
+        throw new Error(`${label} must be JSON-compatible.`);
+    }
+    if (ancestors.has(input)) {
+        throw new Error(`${label} must not contain circular references.`);
+    }
+    ancestors.add(input);
+    if (Array.isArray(input)) {
+        assertCollectionLimit(input.length, gameProgressLimits.maxPayloadNodes, 'activeProgress.payload array');
+        const output = Array.from(input, (value, index) => {
+            return normalizeGameProgressValue(value, `${label}[${String(index)}]`, ancestors, budget, depth + 1);
+        });
+        ancestors.delete(input);
+        return output;
+    }
+    assertRecord(input, label);
+    assertOwnEnumerablePropertyLimit(input, gameProgressLimits.maxPayloadNodes, label);
+    const entries = Object.entries(input)
+        .sort(([left], [right]) => compareCodeUnits(left, right))
+        .map(([key, value]) => {
+        const normalizedKey = normalizeIdentifier(key, `${label} key`);
+        consumePayloadStringBudget(budget, normalizedKey.length);
+        return [
+            normalizedKey,
+            normalizeGameProgressValue(value, `${label}.${key}`, ancestors, budget, depth + 1),
+        ];
+    });
+    ancestors.delete(input);
+    return Object.fromEntries(entries);
+}
+function consumePayloadStringBudget(budget, stringUnits) {
+    budget.stringUnits += stringUnits;
+    if (budget.stringUnits > gameProgressLimits.maxPayloadStringUnits) {
+        throw new Error(`activeProgress.payload strings must not exceed ${String(gameProgressLimits.maxPayloadStringUnits)} total characters.`);
+    }
+}
+function isGameProgressRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
+function compareCodeUnits(left, right) {
+    if (left < right) {
+        return -1;
+    }
+    return left > right ? 1 : 0;
+}
+function assertMatchingProgressLinkIdentity(existing, request) {
+    if (existing.authoritativePlayerId !== request.authoritativePlayerId
+        || existing.guestId !== request.guestId) {
+        throw new Error('A reconciliation key cannot be reused for another player or guest.');
+    }
+}
+function assertOnlyFields(input, allowedFields, label) {
+    for (const key of Object.keys(input)) {
+        if (!allowedFields.has(key)) {
+            throw new Error(`${label} contains unsupported field ${key}.`);
+        }
+    }
+}
+function assertCollectionLimit(length, maximum, label) {
+    if (length > maximum) {
+        throw new Error(`${label} must not contain more than ${String(maximum)} entries.`);
+    }
+}
+function assertRecord(input, label) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new Error(`${label} must be an object.`);
+    }
+}
+function normalizeIdentifier(input, label) {
+    if (typeof input !== 'string' || input.length === 0 || input.trim() !== input) {
+        throw new Error(`${label} must be a non-empty, trimmed string.`);
+    }
+    if (input.length > gameProgressLimits.maxIdentifierLength) {
+        throw new Error(`${label} must not exceed ${String(gameProgressLimits.maxIdentifierLength)} characters.`);
+    }
+    if (/[\x00-\x1F\x7F]/u.test(input)) {
+        throw new Error(`${label} must not contain control characters.`);
+    }
+    return input;
+}
+function normalizeTimestamp(input, label) {
+    const value = normalizeIdentifier(input, label);
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp)) {
+        throw new Error(`${label} must be a valid timestamp.`);
+    }
+    return new Date(timestamp).toISOString();
+}

package/dist/runtime.d.ts

@@ -0,0 +1,31 @@
+import type { AnalyticsSink } from '@mpgd/analytics';
+import type { PlatformGateway, PlatformTarget } from '@mpgd/platform';
+import { type GameServicesBackendApi, type GameServicesClient } from './client.js';
+import type { GameServicesLedgerTarget } from './types.js';
+export type GameServicesAuthorityMode = 'production' | 'non-production';
+export type GameServicesRuntimeMode = 'disabled' | 'local' | 'http' | 'orpc';
+export type GameServicesDisabledReason = 'unsupported_target' | 'missing_authoritative_backend' | 'invalid_authoritative_backend' | 'local_backend_not_allowed' | 'local_backend_unavailable';
+export interface GameServicesRuntime {
+  readonly mode: GameServicesRuntimeMode;
+  readonly reason?: GameServicesDisabledReason;
+  readonly baseUrl?: string;
+  readonly target?: GameServicesLedgerTarget;
+  readonly client?: GameServicesClient;
+}
+export interface CreateGameServicesRuntimeInput {
+  readonly gateway: PlatformGateway;
+  readonly playerId: string;
+  readonly authorityMode: GameServicesAuthorityMode;
+  readonly target?: PlatformTarget | string;
+  readonly baseUrl?: string;
+  readonly transport?: 'http' | 'orpc';
+  readonly allowLocalBackend?: boolean;
+  readonly localBackend?: GameServicesBackendApi;
+  readonly analytics?: AnalyticsSink;
+  readonly analyticsSessionId?: string;
+  readonly now?: () => string;
+}
+export declare function createGameServicesRuntime(input: CreateGameServicesRuntimeInput): GameServicesRuntime;
+export declare function resolveGameServicesLedgerTarget(target: PlatformTarget | string): GameServicesLedgerTarget | null;
+export declare function resolveGameServicesAuthorityMode(profile: string): GameServicesAuthorityMode;
+export declare function resolveGameServicesTransport(transport: string | undefined): 'http' | 'orpc';

package/dist/runtime.js

@@ -0,0 +1,198 @@
+import { createGameServicesClient, createGameServicesFetchBackendTransport, createGameServicesHttpBackendApi, createGameServicesOrpcBackendApi, createGameServicesOrpcClient, } from './client.js';
+export function createGameServicesRuntime(input) {
+    assertAuthorityMode(input.authorityMode);
+    assertTransport(input.transport);
+    const target = resolveGameServicesLedgerTarget(input.target ?? input.gateway.target);
+    if (target === null) {
+        return disabledRuntime('unsupported_target');
+    }
+    const baseUrl = normalizeBaseUrl(input.baseUrl);
+    let backend;
+    let mode;
+    if (baseUrl !== undefined) {
+        const url = parseAbsoluteUrl(baseUrl);
+        if (input.authorityMode === 'production' && !isPublicHttpsUrl(url)) {
+            return disabledRuntime('invalid_authoritative_backend', target);
+        }
+        if (url === undefined) {
+            throw new Error('Game Services baseUrl must be a valid absolute URL.');
+        }
+        mode = input.transport === 'orpc' ? 'orpc' : 'http';
+        backend = mode === 'orpc'
+            ? createGameServicesOrpcBackendApi(createGameServicesOrpcClient({ url: baseUrl }))
+            : createGameServicesHttpBackendApi({
+                transport: createGameServicesFetchBackendTransport({ baseUrl }),
+            });
+    }
+    else {
+        if (input.authorityMode === 'production') {
+            return disabledRuntime('missing_authoritative_backend', target);
+        }
+        if (input.allowLocalBackend !== true) {
+            return disabledRuntime('local_backend_not_allowed', target);
+        }
+        if (input.localBackend === undefined) {
+            return disabledRuntime('local_backend_unavailable', target);
+        }
+        mode = 'local';
+        backend = input.localBackend;
+    }
+    return {
+        mode,
+        ...(baseUrl === undefined ? {} : { baseUrl }),
+        target,
+        client: createGameServicesClient({
+            gateway: input.gateway,
+            backend,
+            playerId: input.playerId,
+            target,
+            ...(input.analytics === undefined ? {} : { analytics: input.analytics }),
+            ...(input.analyticsSessionId === undefined
+                ? {}
+                : { analyticsSessionId: input.analyticsSessionId }),
+            ...(input.now === undefined ? {} : { now: input.now }),
+        }),
+    };
+}
+export function resolveGameServicesLedgerTarget(target) {
+    if (target === 'browser'
+        || target === 'android'
+        || target === 'ios'
+        || target === 'ait'
+        || target === 'reddit') {
+        return target;
+    }
+    return null;
+}
+export function resolveGameServicesAuthorityMode(profile) {
+    if (profile.length === 0 || profile.trim() !== profile) {
+        throw new Error('Game Services profile must be non-empty without surrounding whitespace.');
+    }
+    return profile === 'production' ? 'production' : 'non-production';
+}
+export function resolveGameServicesTransport(transport) {
+    if (transport === undefined || transport.length === 0 || transport === 'http') {
+        return 'http';
+    }
+    if (transport === 'orpc') {
+        return 'orpc';
+    }
+    throw new Error('Game Services transport must be http or orpc.');
+}
+function disabledRuntime(reason, target) {
+    return {
+        mode: 'disabled',
+        reason,
+        ...(target === undefined ? {} : { target }),
+    };
+}
+function normalizeBaseUrl(baseUrl) {
+    const normalized = baseUrl?.trim();
+    return normalized === undefined || normalized.length === 0 ? undefined : normalized;
+}
+function isPublicHttpsUrl(url) {
+    return url !== undefined
+        && url.protocol === 'https:'
+        && url.username.length === 0
+        && url.password.length === 0
+        && !isNonPublicHostname(url.hostname);
+}
+function parseAbsoluteUrl(value) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isNonPublicHostname(hostname) {
+    const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/u, '');
+    if (normalized === 'localhost'
+        || normalized.endsWith('.localhost')
+        || normalized.endsWith('.local')) {
+        return true;
+    }
+    if (/^(?:\d{1,3}\.){3}\d{1,3}$/u.test(normalized)) {
+        return isNonPublicIpv4(normalized);
+    }
+    return normalized.includes(':') && isNonPublicIpv6(normalized);
+}
+function isNonPublicIpv4(address) {
+    const [first = 0, second = 0, third = 0] = address.split('.').map(Number);
+    return first === 0
+        || first === 10
+        || first === 127
+        || (first === 100 && second >= 64 && second <= 127)
+        || (first === 169 && second === 254)
+        || (first === 172 && second >= 16 && second <= 31)
+        || (first === 192 && second === 0 && third === 0)
+        || (first === 192 && second === 0 && third === 2)
+        || (first === 192 && second === 168)
+        || (first === 198 && (second === 18 || second === 19))
+        || (first === 198 && second === 51 && third === 100)
+        || (first === 203 && second === 0 && third === 113)
+        || first >= 224;
+}
+function isNonPublicIpv6(address) {
+    const words = expandIpv6(address);
+    if (words === undefined) {
+        return true;
+    }
+    if (words.slice(0, 7).every((word) => word === 0)) {
+        return true;
+    }
+    if (words.slice(0, 5).every((word) => word === 0) && words[5] === 0xffff) {
+        return isNonPublicIpv4(wordsToIpv4(words));
+    }
+    if (words.slice(0, 6).every((word) => word === 0)) {
+        return isNonPublicIpv4(wordsToIpv4(words));
+    }
+    const first = words[0] ?? 0;
+    return (first & 0xfe00) === 0xfc00
+        || (first & 0xffc0) === 0xfe80
+        || (first & 0xff00) === 0xff00
+        || (first === 0x2001 && words[1] === 0x0db8);
+}
+function wordsToIpv4(words) {
+    return `${(words[6] ?? 0) >> 8}.${(words[6] ?? 0) & 0xff}.`
+        + `${(words[7] ?? 0) >> 8}.${(words[7] ?? 0) & 0xff}`;
+}
+function expandIpv6(address) {
+    const sections = address.split('::');
+    if (sections.length > 2) {
+        return undefined;
+    }
+    const head = ipv6Words(sections[0] ?? '');
+    const tail = ipv6Words(sections[1] ?? '');
+    if (head === undefined || tail === undefined) {
+        return undefined;
+    }
+    const omitted = 8 - head.length - tail.length;
+    if ((sections.length === 1 && omitted !== 0) || (sections.length === 2 && omitted < 1)) {
+        return undefined;
+    }
+    return [...head, ...Array.from({ length: omitted }, () => 0), ...tail];
+}
+function ipv6Words(section) {
+    if (section.length === 0) {
+        return [];
+    }
+    const words = [];
+    for (const segment of section.split(':')) {
+        if (!/^[0-9a-f]{1,4}$/u.test(segment)) {
+            return undefined;
+        }
+        words.push(Number.parseInt(segment, 16));
+    }
+    return words;
+}
+function assertAuthorityMode(authorityMode) {
+    if (authorityMode !== 'production' && authorityMode !== 'non-production') {
+        throw new Error('authorityMode must be production or non-production.');
+    }
+}
+function assertTransport(transport) {
+    if (transport !== undefined && transport !== 'http' && transport !== 'orpc') {
+        throw new Error('Game Services transport must be http or orpc.');
+    }
+}

package/dist/server.d.ts

@@ -75,4 +75,5 @@ export declare function createGameServicesRouter(backend: GameServicesBackendApi
 };
 export declare function createGameServicesRpcFetchHandler(router: ReturnType<typeof createGameServicesRouter>, options?: CreateGameServicesRpcFetchHandlerOptions): (request: Request) => Promise<Response>;
 export declare function createGameServicesHttpFetchHandler(handler: GameServicesBackendApiHandler, options?: CreateGameServicesFetchHandlerOptions): (request: Request) => Promise<Response>;
-export {};
+export * from './notification-delivery';
+export * from './progress-link';

package/dist/server.js

@@ -472,3 +472,5 @@ function applyCorsHeaders(headers, corsHeaders) {
         headers.set(key, value);
     }
 }
+export * from './notification-delivery';
+export * from './progress-link';

package/dist/validation.d.ts

@@ -0,0 +1 @@
+export declare function assertOwnEnumerablePropertyLimit(input: Record<string, unknown>, maximum: number, label: string): void;

package/dist/validation.js

@@ -0,0 +1,11 @@
+export function assertOwnEnumerablePropertyLimit(input, maximum, label) {
+    let propertyCount = 0;
+    for (const key in input) {
+        if (Object.hasOwn(input, key)) {
+            propertyCount += 1;
+            if (propertyCount > maximum) {
+                throw new Error(`${label} must not contain more than ${String(maximum)} entries.`);
+            }
+        }
+    }
+}