@mpgd/platform 0.22.0 → 0.23.0

package/dist/route-vectors.d.ts

@@ -0,0 +1,23 @@
+/**
+* Shared vectors for `@mpgd/platform/routes`. Every package that turns a
+* game-supplied root-relative link into a path on the game or mini-app origin
+* runs these, so a new escape is added here once and caught everywhere.
+*/
+export interface RootRelativeRouteVectors {
+  /** Root-relative inputs `normalizeRootRelativeRoute` accepts, with the route it returns. */
+  readonly normalized: readonly (readonly [input: string, route: string])[];
+  /** Root-relative inputs a client could read as another host: `normalizeRootRelativeRoute` answers `undefined`. */
+  readonly rejected: readonly string[];
+}
+export declare const rootRelativeRouteVectors: RootRelativeRouteVectors;
+/**
+* Shared vectors for `normalizeShareLink`, next to the root-relative routes
+* and escapes above, which share links follow too.
+*/
+export interface ShareLinkVectors {
+  /** Absolute links `normalizeShareLink` accepts, with the link it returns. */
+  readonly normalized: readonly (readonly [input: string, link: string])[];
+  /** Links outside the `ShareIntent.deepLink` contract: `normalizeShareLink` answers `undefined`. */
+  readonly rejected: readonly string[];
+}
+export declare const shareLinkVectors: ShareLinkVectors;

package/dist/route-vectors.js

@@ -0,0 +1,96 @@
+export const rootRelativeRouteVectors = {
+    normalized: [
+        ['/', '/'],
+        ['/daily', '/daily'],
+        ['/levels//3?from=push#start', '/levels//3?from=push#start'],
+        ['/levels/../daily', '/daily'],
+        ['/%2e%2e/levels', '/levels'],
+        ['/?//x', '/?//x'],
+        ['/#//x', '/#//x'],
+        ['/a/%2Fb', '/a/%2Fb'],
+        ['/a/%09b', '/a/%09b'],
+        ['/a/b\\c', '/a/b/c'],
+        ['/%252F/x', '/%252F/x'],
+        ['/search%3Fq', '/search%3Fq'],
+        ['/é', '/%C3%A9'],
+        ['/?q=a b', '/?q=a%20b'],
+    ],
+    rejected: [
+        // A second slash or a backslash after the leading slash parses as an authority.
+        '//evil.example/daily',
+        '/\\evil.example/daily',
+        '/\\ x',
+        '/\\ evil.example/daily',
+        '/\\mpgd.invalid/daily',
+        '/\\mpgd.invalid//evil.example/daily',
+        '/\\user:pw@mpgd.invalid:443/daily',
+        // Control characters; URL parsing would drop the tab or newline.
+        '/\t/ x',
+        '/\t/evil.example/daily',
+        '/\n/mpgd.invalid/daily',
+        '/daily\u0000',
+        '/daily\u007f',
+        // Dot segments collapse into a leading `//`.
+        '/.//evil.example/daily',
+        '/levels/..//evil.example/daily',
+        '/%2e//evil.example/daily',
+        '/%2E%2E//evil.example/daily',
+        '/./\\evil.example/daily',
+        // One percent-decode turns these into the shapes above.
+        '/%2F%2Fevil.example/daily',
+        '/%5cevil.example/daily',
+        '/%09/evil.example/daily',
+        '/%0A%0d/evil.example/daily',
+        '/%09%5Cevil.example/daily',
+        '/%09.//evil.example/daily',
+        '/.%2F/evil.example/daily',
+        '/levels/..%2F%2Fevil.example/daily',
+        // A double-encoded dot segment resolves after one decode.
+        '/%252e%252e//evil.example/daily',
+        // A client may keep a decoded `?` or `#` in the path, or end the path at any of them.
+        '/%3F%2F..%2F%2Fevil.example/daily',
+        '/%23%2F..%2F%2Fevil.example/daily',
+        '/a%3Fb%23%2F..%2F%2Fevil.example/daily',
+        '/.%2F%2Fevil.example%3F%2F..%2F..',
+        '/.%2F%2Fevil.example%23%2F..%2F..',
+        '/.%2F%2Fevil.example%3F%2F..%2F..%3F%2F..%2F..',
+        '/a%2F..%2F%2Fevil.example%3F%2F..%2F..%2F..',
+        '/a%23%2F..%2F%2Fevil.example%3F%2F..%2F..',
+        '/a%3F%2F..%2F%2Fevil.example%23%2F..%2F..',
+        '/a%3F%2F..%2F%2Fevil.example%3F%2F..%2F..',
+    ],
+};
+export const shareLinkVectors = {
+    normalized: [
+        [
+            'https://game.example/daily?challengeToken=x#result',
+            'https://game.example/daily?challengeToken=x#result',
+        ],
+        ['HTTPS://Game.Example/levels/../daily', 'https://game.example/daily'],
+        ['http://game.example', 'http://game.example/'],
+        ['https://game.example/levels//3', 'https://game.example/levels//3'],
+    ],
+    rejected: [
+        // Page-relative or empty links, which hosts would resolve differently.
+        '',
+        ' /daily',
+        './daily',
+        'daily?x=1',
+        '?challengeToken=x',
+        '#top',
+        // Other schemes, including an Apps in Toss link for another app.
+        'javascript:alert(1)',
+        'data:text/html,hi',
+        'intoss://other-app/daily',
+        '\\\\evil.example/daily',
+        // Absolute links that are not spelled out as HTTP(S), carry credentials,
+        // or keep a path a client could read as another host.
+        'https:/daily',
+        'https:evil.example/x',
+        'https://user:pw@game.example/daily',
+        'https://game.example//evil.example/x',
+        'https://game.example/.//evil.example/x',
+        'https://game.example/%2F%2Fevil.example/x',
+        'https://game.example/daily\n',
+    ],
+};

package/dist/routes.d.ts

@@ -0,0 +1,60 @@
+import type { ShareAdapter, ShareIntent } from './index.js';
+/** Whether `value` contains an ASCII control character (C0 or DEL). */
+export declare function hasRouteControlCharacter(value: string): boolean;
+/**
+* Whether a normalized URL path could be read as a network-path reference to
+* another host. Dot segments (also percent-encoded) can collapse `/.//host`
+* into `//host`. A consumer that percent-decodes the path once and parses it
+* again can reach the same shape from `/%2F/host`, `/%5Chost`, `/%09/host`,
+* or `/.%2F/host`: URL parsing drops tabs and newlines, reads a backslash as a
+* slash, and removes dot segments, so the decoded path is checked after the
+* same steps. A consumer may also end the decoded path at any `?` or `#`, or
+* keep them all in it, so each of those readings is checked:
+* `/.%2F%2Fhost%3F%2F..%2F..` reaches `//host` when the path ends at the `?`,
+* and `/%3F%2F..%2F%2Fhost` when it keeps it. A path with more than 16
+* decoded `?` and `#` is answered `true`. `pathname` is a URL's path (it
+* starts with `/`); anything else is answered `true`, so a caller fails
+* closed.
+*/
+export declare function hasNetworkPathPrefix(pathname: string): boolean;
+/**
+* Normalizes a root-relative link to the `pathname`, `search`, and `hash` it
+* names on the game's own origin, or answers `undefined` when a client could
+* read it as another host: a second slash or a backslash right after the
+* leading slash (`//host`, `/\host`), a control character, or a path whose
+* normalized form begins with an empty segment, also once percent-decoded
+* (see `hasNetworkPathPrefix`, which also refuses a path with more than 16
+* percent-encoded `?` and `#`, `%3F` and `%23`).
+* Dot segments that stay on the origin resolve (`/levels/../daily` is
+* `/daily`), and a normalized route normalizes to itself. The result is not
+* length-capped, because percent-encoding can grow it; callers apply their
+* own limits.
+*/
+export declare function normalizeRootRelativeRoute(input: string): string | undefined;
+/**
+* Normalizes a `ShareIntent.deepLink`, or answers `undefined` for a link
+* outside its contract. A root-relative link becomes the route
+* `normalizeRootRelativeRoute` returns. An absolute link must spell out
+* `https://` or `http://`, carry no credentials, and keep a path no client
+* can read as another host; it comes back serialized. Anything else is
+* refused: a page-relative link (`./daily`, `?x=1`), another scheme
+* (`javascript:`, `intoss:`), and any link with a control character.
+*/
+export declare function normalizeShareLink(deepLink: string): string | undefined;
+/**
+* Reads a `share` intent under the `ShareIntent` contract: the intent with its
+* `deepLink` normalized by `normalizeShareLink`, or `undefined` when it is not
+* an object, its kind is unsupported, its title or text is not a string, or
+* its `deepLink` is not a link that
+* rule accepts. The intent may come from untyped game code, so none of this
+* is assumed.
+*/
+export declare function readShareIntent(intent: unknown): ShareIntent | undefined;
+/**
+* Puts `readShareIntent` in front of an adapter's `share`: the adapter and its
+* host see only intents the contract accepts, with the link normalized, and
+* any other intent answers `unavailable` without reaching them. Every other
+* member is kept as is. Adapters wrap their `sharing` with it, and their tests
+* run `@mpgd/platform/share-link-conformance`.
+*/
+export declare function withShareIntentCheck(sharing: ShareAdapter): ShareAdapter;

package/dist/routes.js

@@ -0,0 +1,209 @@
+/**
+ * Route safety for links a game hands to the kit, such as notification deep
+ * links and share links. A URL parser treats `\` as `/`, drops tabs and
+ * newlines, and resolves dot segments, and some clients percent-decode a path
+ * once before routing it. Any of these can turn a root-relative link into a
+ * protocol-relative one (`//evil.example/x`) that a client opens on another
+ * host.
+ */
+/** Collapse HTTP(S) path segments without requiring the DOM URL global. */
+function normalizePath(path) {
+    const segments = path.replace(/\\/gu, '/').slice(1).split('/');
+    const result = [];
+    for (const [index, segment] of segments.entries()) {
+        const dot = segment.replace(/%2e/giu, '.');
+        if (dot === '.' || dot === '..') {
+            if (dot === '..') {
+                result.pop();
+            }
+            if (index === segments.length - 1) {
+                result.push('');
+            }
+        }
+        else {
+            result.push(segment);
+        }
+    }
+    return `/${result.join('/')}`;
+}
+/** WHATWG HTTP(S) component encoding; existing percent escapes stay intact. */
+function encodeRouteComponent(value, component) {
+    const extra = component === 'path' ? ' "#<>?^`{}' : component === 'query' ? ' "#<>\'' : ' "<>`';
+    let result = '';
+    for (const character of value) {
+        const code = character.codePointAt(0) ?? 0;
+        if (code > 0x7e || code <= 0x20 || extra.includes(character)) {
+            const scalar = code >= 0xd800 && code <= 0xdfff ? '\uFFFD' : character;
+            // encodeURIComponent leaves an apostrophe unescaped, unlike a special query.
+            result += character === "'" ? '%27' : encodeURIComponent(scalar);
+        }
+        else {
+            result += character;
+        }
+    }
+    return result;
+}
+/** Whether `value` contains an ASCII control character (C0 or DEL). */
+export function hasRouteControlCharacter(value) {
+    return /[\x00-\x1F\x7F]/u.test(value);
+}
+/**
+ * The most decoded `?` and `#` a path may carry. Each one is a reading
+ * `hasNetworkPathPrefix` parses, so a path with more is refused instead.
+ */
+const maxPathDelimiters = 16;
+/**
+ * Whether a normalized URL path could be read as a network-path reference to
+ * another host. Dot segments (also percent-encoded) can collapse `/.//host`
+ * into `//host`. A consumer that percent-decodes the path once and parses it
+ * again can reach the same shape from `/%2F/host`, `/%5Chost`, `/%09/host`,
+ * or `/.%2F/host`: URL parsing drops tabs and newlines, reads a backslash as a
+ * slash, and removes dot segments, so the decoded path is checked after the
+ * same steps. A consumer may also end the decoded path at any `?` or `#`, or
+ * keep them all in it, so each of those readings is checked:
+ * `/.%2F%2Fhost%3F%2F..%2F..` reaches `//host` when the path ends at the `?`,
+ * and `/%3F%2F..%2F%2Fhost` when it keeps it. A path with more than 16
+ * decoded `?` and `#` is answered `true`. `pathname` is a URL's path (it
+ * starts with `/`); anything else is answered `true`, so a caller fails
+ * closed.
+ */
+export function hasNetworkPathPrefix(pathname) {
+    if (!pathname.startsWith('/')) {
+        return true;
+    }
+    const decoded = pathname
+        .replace(/%([0-7][0-9a-f])/giu, (_escape, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        .replace(/[\t\n\r]/gu, '');
+    if (/^[/\\]{2}/u.test(decoded)) {
+        return true;
+    }
+    const delimiters = [];
+    for (const match of decoded.matchAll(/[?#]/gu)) {
+        if (delimiters.length === maxPathDelimiters) {
+            return true;
+        }
+        delimiters.push(match.index);
+    }
+    // Each reading is a prefix of the decoded path, so it starts with one slash
+    // and no second slash or backslash: parsing it cannot fail or reach another
+    // origin. A `?` or `#` left in a reading is escaped so it stays in the path,
+    // and the path-only normalizer keeps trailing spaces and controls, as when
+    // the rest of the link follows, instead of stripping them as URL input.
+    return [...delimiters, decoded.length].some((end) => {
+        const reading = decoded
+            .slice(0, end)
+            .replace(/[?#]/gu, (delimiter) => (delimiter === '?' ? '%3F' : '%23'));
+        return normalizePath(reading).startsWith('//');
+    });
+}
+/**
+ * Normalizes a root-relative link to the `pathname`, `search`, and `hash` it
+ * names on the game's own origin, or answers `undefined` when a client could
+ * read it as another host: a second slash or a backslash right after the
+ * leading slash (`//host`, `/\host`), a control character, or a path whose
+ * normalized form begins with an empty segment, also once percent-decoded
+ * (see `hasNetworkPathPrefix`, which also refuses a path with more than 16
+ * percent-encoded `?` and `#`, `%3F` and `%23`).
+ * Dot segments that stay on the origin resolve (`/levels/../daily` is
+ * `/daily`), and a normalized route normalizes to itself. The result is not
+ * length-capped, because percent-encoding can grow it; callers apply their
+ * own limits.
+ */
+export function normalizeRootRelativeRoute(input) {
+    if (!input.startsWith('/')
+        || input.startsWith('//')
+        || input.startsWith('/\\')
+        || hasRouteControlCharacter(input)) {
+        return undefined;
+    }
+    // Match the HTTP(S) URL path algorithm with string operations so pure
+    // notification/catalog validation also works in runtimes with no URL.
+    const trimmed = input.replace(/ +$/u, '');
+    const hashIndex = trimmed.indexOf('#');
+    const beforeHash = hashIndex < 0 ? trimmed : trimmed.slice(0, hashIndex);
+    const queryIndex = beforeHash.indexOf('?');
+    const path = queryIndex < 0 ? beforeHash : beforeHash.slice(0, queryIndex);
+    const query = queryIndex < 0 ? '' : beforeHash.slice(queryIndex + 1);
+    const fragment = hashIndex < 0 ? '' : trimmed.slice(hashIndex + 1);
+    const pathname = encodeRouteComponent(normalizePath(path), 'path');
+    const search = query === '' ? '' : `?${encodeRouteComponent(query, 'query')}`;
+    const hash = fragment === '' ? '' : `#${encodeRouteComponent(fragment, 'hash')}`;
+    return hasNetworkPathPrefix(pathname) ? undefined : `${pathname}${search}${hash}`;
+}
+/**
+ * Normalizes a `ShareIntent.deepLink`, or answers `undefined` for a link
+ * outside its contract. A root-relative link becomes the route
+ * `normalizeRootRelativeRoute` returns. An absolute link must spell out
+ * `https://` or `http://`, carry no credentials, and keep a path no client
+ * can read as another host; it comes back serialized. Anything else is
+ * refused: a page-relative link (`./daily`, `?x=1`), another scheme
+ * (`javascript:`, `intoss:`), and any link with a control character.
+ */
+export function normalizeShareLink(deepLink) {
+    if (hasRouteControlCharacter(deepLink)) {
+        return undefined;
+    }
+    if (deepLink.startsWith('/')) {
+        return normalizeRootRelativeRoute(deepLink);
+    }
+    // `https:/daily` and `https:host/x` parse as absolute links to another host
+    // without a base but resolve on the page with one, so only the full form counts.
+    if (!/^https?:\/\//iu.test(deepLink)) {
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = new URL(deepLink);
+    }
+    catch {
+        return undefined;
+    }
+    return parsed.username === ''
+        && parsed.password === ''
+        && !hasNetworkPathPrefix(parsed.pathname)
+        ? parsed.href
+        : undefined;
+}
+/**
+ * Reads a `share` intent under the `ShareIntent` contract: the intent with its
+ * `deepLink` normalized by `normalizeShareLink`, or `undefined` when it is not
+ * an object, its kind is unsupported, its title or text is not a string, or
+ * its `deepLink` is not a link that
+ * rule accepts. The intent may come from untyped game code, so none of this
+ * is assumed.
+ */
+export function readShareIntent(intent) {
+    if (typeof intent !== 'object' || intent === null || Array.isArray(intent)) {
+        return undefined;
+    }
+    const { kind, title, text, deepLink } = intent;
+    const link = typeof deepLink === 'string' ? normalizeShareLink(deepLink) : undefined;
+    return (kind === 'daily-result' || kind === 'friend-challenge' || kind === 'invite')
+        && typeof title === 'string' && typeof text === 'string' && link !== undefined
+        ? { ...intent, kind, title, text, deepLink: link }
+        : undefined;
+}
+/**
+ * Puts `readShareIntent` in front of an adapter's `share`: the adapter and its
+ * host see only intents the contract accepts, with the link normalized, and
+ * any other intent answers `unavailable` without reaching them. Every other
+ * member is kept as is. Adapters wrap their `sharing` with it, and their tests
+ * run `@mpgd/platform/share-link-conformance`.
+ */
+export function withShareIntentCheck(sharing) {
+    const share = sharing.share?.bind(sharing);
+    const readInboundShare = sharing.readInboundShare?.bind(sharing);
+    const checkedShare = share === undefined
+        ? undefined
+        : async (intent) => {
+            const checked = readShareIntent(intent);
+            return checked === undefined ? { status: 'unavailable' } : share(checked);
+        };
+    // The bound methods also cover an adapter whose methods live on a prototype,
+    // which the spread does not copy.
+    return {
+        ...sharing,
+        ...(checkedShare === undefined ? {} : { share: checkedShare }),
+        ...(readInboundShare === undefined ? {} : { readInboundShare }),
+    };
+}

package/dist/share-link-conformance.d.ts

@@ -0,0 +1,47 @@
+import type { ShareIntent, ShareResult } from './index.js';
+/** How a fixture observes what its host was handed. */
+export interface ShareLinkConformanceHost {
+  /**
+  * What the host was handed for each share that reached it, oldest first:
+  * the link, or `null` for a host that takes no link (a WeChat card).
+  */
+  readonly handedLinks: () => readonly (string | null)[];
+  /**
+  * What the host is handed for a link `normalizeShareLink` accepted: the
+  * normalized route or absolute URL as the adapter maps it, or `null` for a
+  * host that takes no link.
+  */
+  readonly expectedLink: (link: string) => string | null;
+}
+export interface ShareLinkConformanceFixture {
+  /** Names the fixture in failures. */
+  readonly name: string;
+  /** The adapter's `share`, called as a game calls it. */
+  readonly share: (intent: ShareIntent) => Promise<ShareResult>;
+  /** The answer for a share the host presented. */
+  readonly sharedResult: ShareResult;
+  /**
+  * Omit only for a host that cannot be observed, such as a sandbox bridge
+  * that answers by itself; the runner then checks the answers alone.
+  */
+  readonly host?: ShareLinkConformanceHost;
+}
+export interface ShareLinkConformanceReport {
+  readonly name: string;
+  /** Intents answered `unavailable` without reaching the host. */
+  readonly refused: number;
+  /** Intents shared with the expected link. */
+  readonly shared: number;
+}
+/**
+* Runs the `ShareIntent.deepLink` contract against one adapter's `share`:
+* every escape in `rootRelativeRouteVectors.rejected`, every link outside the
+* contract in `shareLinkVectors.rejected`, and malformed intents answer
+* `unavailable` and never reach the host; every route in
+* `rootRelativeRouteVectors.normalized` and absolute link in
+* `shareLinkVectors.normalized` is shared, and the host is handed the
+* normalized link as the adapter maps it. Every adapter that hands share
+* links to a host runs it, so a new escape added to the vectors is checked
+* on every target. It throws one error listing every failure.
+*/
+export declare function runShareLinkConformance(fixture: ShareLinkConformanceFixture): Promise<ShareLinkConformanceReport>;

package/dist/share-link-conformance.js

@@ -0,0 +1,100 @@
+import { rootRelativeRouteVectors, shareLinkVectors } from './route-vectors.js';
+const baseIntent = { kind: 'invite', title: 'Join', text: 'Join me' };
+/**
+ * Intents from untyped game code that every adapter refuses whatever their
+ * link, because the contract needs an object with a string `text` and
+ * `deepLink`.
+ */
+const malformedIntents = [
+    ['a null intent', null],
+    ['a string intent', '/daily'],
+    ['an array intent', []],
+    ['an intent without text', { kind: 'invite', title: 'Join', deepLink: '/daily' }],
+    ['an intent with a number for text', { ...baseIntent, text: 1, deepLink: '/daily' }],
+    ['an intent without a deep link', { ...baseIntent }],
+    ['an intent with a null deep link', { ...baseIntent, deepLink: null }],
+    [
+        'an intent with a URL object for its deep link',
+        { ...baseIntent, deepLink: new URL('https://game.example/daily') },
+    ],
+];
+/**
+ * Runs the `ShareIntent.deepLink` contract against one adapter's `share`:
+ * every escape in `rootRelativeRouteVectors.rejected`, every link outside the
+ * contract in `shareLinkVectors.rejected`, and malformed intents answer
+ * `unavailable` and never reach the host; every route in
+ * `rootRelativeRouteVectors.normalized` and absolute link in
+ * `shareLinkVectors.normalized` is shared, and the host is handed the
+ * normalized link as the adapter maps it. Every adapter that hands share
+ * links to a host runs it, so a new escape added to the vectors is checked
+ * on every target. It throws one error listing every failure.
+ */
+export async function runShareLinkConformance(fixture) {
+    const failures = [];
+    let refused = 0;
+    let shared = 0;
+    const handedCount = () => fixture.host?.handedLinks().length ?? 0;
+    async function attempt(label, intent) {
+        try {
+            return await fixture.share(intent);
+        }
+        catch (error) {
+            failures.push(`${label}: share rejected instead of answering (${errorMessage(error)})`);
+            return undefined;
+        }
+    }
+    async function expectRefused(label, intent) {
+        const before = handedCount();
+        const result = await attempt(label, intent);
+        if (result !== undefined && !isSameResult(result, { status: 'unavailable' })) {
+            failures.push(`${label}: answered ${JSON.stringify(result)} instead of unavailable`);
+        }
+        if (handedCount() !== before) {
+            failures.push(`${label}: reached the host`);
+        }
+        refused += 1;
+    }
+    async function expectShared(label, deepLink, link) {
+        const before = handedCount();
+        const result = await attempt(label, { ...baseIntent, deepLink });
+        if (result !== undefined && !isSameResult(result, fixture.sharedResult)) {
+            failures.push(`${label}: answered ${JSON.stringify(result)} instead of ${JSON.stringify(fixture.sharedResult)}`);
+        }
+        if (fixture.host !== undefined) {
+            const handed = fixture.host.handedLinks().slice(before);
+            const expected = fixture.host.expectedLink(link);
+            if (handed.length !== 1 || handed[0] !== expected) {
+                failures.push(`${label}: the host was handed ${JSON.stringify(handed)} instead of ${JSON.stringify([expected])}`);
+            }
+        }
+        shared += 1;
+    }
+    for (const [label, intent] of malformedIntents) {
+        await expectRefused(label, intent);
+    }
+    for (const deepLink of [...rootRelativeRouteVectors.rejected, ...shareLinkVectors.rejected]) {
+        await expectRefused(JSON.stringify(deepLink), { ...baseIntent, deepLink });
+    }
+    for (const [deepLink, link] of [
+        ...rootRelativeRouteVectors.normalized,
+        ...shareLinkVectors.normalized,
+    ]) {
+        await expectShared(JSON.stringify(deepLink), deepLink, link);
+    }
+    if (failures.length > 0) {
+        throw new Error(`${fixture.name}: share link conformance failed:\n- ${failures.join('\n- ')}`);
+    }
+    return { name: fixture.name, refused, shared };
+}
+function isSameResult(actual, expected) {
+    if (typeof actual !== 'object' || actual === null) {
+        return false;
+    }
+    const record = actual;
+    return record['status'] === expected.status
+        && record['completion'] === expected.completion
+        && Object.keys(record).every((key) => key === 'status' || key === 'completion');
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/platform",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Shared platform gateway, monetization, ads, leaderboard, identity, lifecycle, and storage contracts for mpgd games.",
   "license": "MIT",
   "repository": {
@@ -60,6 +60,30 @@
     "./commerce-wallet": {
       "types": "./dist/commerce-wallet.d.ts",
       "default": "./dist/commerce-wallet.js"
+    },
+    "./notifications": {
+      "types": "./dist/notifications.d.ts",
+      "default": "./dist/notifications.js"
+    },
+    "./notifications-vectors": {
+      "types": "./dist/notifications-vectors.d.ts",
+      "default": "./dist/notifications-vectors.js"
+    },
+    "./notifications-conformance": {
+      "types": "./dist/notifications-conformance.d.ts",
+      "default": "./dist/notifications-conformance.js"
+    },
+    "./routes": {
+      "types": "./dist/routes.d.ts",
+      "default": "./dist/routes.js"
+    },
+    "./route-vectors": {
+      "types": "./dist/route-vectors.d.ts",
+      "default": "./dist/route-vectors.js"
+    },
+    "./share-link-conformance": {
+      "types": "./dist/share-link-conformance.d.ts",
+      "default": "./dist/share-link-conformance.js"
     }
   },
   "files": [
@@ -84,6 +108,6 @@
     "lint": "ttsc --noEmit",
     "format": "ttsc format",
     "fix": "ttsc fix",
-    "test": "vitest run && node test/capability-conformance-dist-import.mjs && node test/storage-conformance-dist-import.mjs && node test/ads-dist-import.mjs && node test/commerce-dist-import.mjs && node test/commerce-conformance-dist-import.mjs && node test/wallet-commerce-dist-import.mjs && cd ../.. && node tools/run-ttsx.mjs packages/platform/test/commerce-derived-key-parity.ts"
+    "test": "vitest run && node test/capability-conformance-dist-import.mjs && node test/storage-conformance-dist-import.mjs && node test/ads-dist-import.mjs && node test/commerce-dist-import.mjs && node test/commerce-conformance-dist-import.mjs && node test/wallet-commerce-dist-import.mjs && node test/notifications-dist-import.mjs && node test/notifications-conformance-dist-import.mjs && node test/routes-dist-import.mjs && node test/share-link-conformance-dist-import.mjs && cd ../.. && node tools/run-ttsx.mjs packages/platform/test/commerce-derived-key-parity.ts"
   }
 }