@mpgd/bridge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 imjlk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/fixtures.d.ts

@@ -0,0 +1,7 @@
+import type { BridgeRequest, BridgeResponse } from './index';
+export declare const validBridgeRequest: BridgeRequest;
+export declare const validBridgeOkResponse: BridgeResponse<{
+  readonly nativeAds: boolean;
+}>;
+export declare const validBridgeErrorResponse: BridgeResponse;
+export declare const invalidBridgeRequests: readonly unknown[];

package/dist/fixtures.js

@@ -0,0 +1,44 @@
+export const validBridgeRequest = {
+    id: 'bridge-request-1',
+    method: 'runtime.getCapabilities',
+    payload: {},
+    meta: {
+        target: 'android',
+        appVersion: '1.0.0',
+        buildId: 'build-1',
+        sentAt: '2026-07-03T00:00:00.000Z',
+    },
+};
+export const validBridgeOkResponse = {
+    id: validBridgeRequest.id,
+    ok: true,
+    data: {
+        nativeAds: true,
+    },
+};
+export const validBridgeErrorResponse = {
+    id: validBridgeRequest.id,
+    ok: false,
+    error: {
+        code: 'UNSUPPORTED_METHOD',
+        message: 'Unsupported bridge method.',
+        retryable: false,
+    },
+};
+export const invalidBridgeRequests = [
+    {
+        ...validBridgeRequest,
+        id: 42,
+    },
+    {
+        ...validBridgeRequest,
+        method: 'unknown.method',
+    },
+    {
+        ...validBridgeRequest,
+        meta: {
+            ...validBridgeRequest.meta,
+            sentAt: 42,
+        },
+    },
+];

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export type BridgeMethod = 'runtime.getCapabilities' | 'identity.getPlayer' | 'commerce.getProducts' | 'commerce.purchase' | 'commerce.restore' | 'commerce.getEntitlements' | 'ads.preload' | 'ads.showRewarded' | 'ads.showInterstitial' | 'leaderboard.submitScore' | 'leaderboard.open' | 'storage.load' | 'storage.save';
+export interface BridgeRequest<TPayload = unknown> {
+  readonly id: string;
+  readonly method: BridgeMethod;
+  readonly payload: TPayload;
+  readonly meta: {
+    readonly target: string;
+    readonly appVersion: string;
+    readonly buildId: string;
+    readonly sentAt: string;
+  };
+}
+export type BridgeResponse<TData = unknown> = {
+  readonly id: string;
+  readonly ok: true;
+  readonly data: TData;
+} | {
+  readonly id: string;
+  readonly ok: false;
+  readonly error: {
+    readonly code: string;
+    readonly message: string;
+    readonly retryable: boolean;
+  };
+};
+export declare const assertBridgeRequest: (input: unknown) => BridgeRequest<unknown>;
+export declare const assertBridgeResponse: (input: unknown) => BridgeResponse<unknown>;
+export declare function createBridgeError(id: string, code: string, message: string, retryable?: boolean): BridgeResponse;

package/dist/index.js

@@ -0,0 +1,173 @@
+import * as _a from "typia/lib/internal/_assertGuard";
+import typia from 'typia';
+export const assertBridgeRequest = (() => {
+    const _iv0 = new Set(["ads.preload", "ads.showInterstitial", "ads.showRewarded", "commerce.getEntitlements", "commerce.getProducts", "commerce.purchase", "commerce.restore", "identity.getPlayer", "leaderboard.open", "leaderboard.submitScore", "runtime.getCapabilities", "storage.load", "storage.save"]);
+    const _av0 = new Set(["ads.preload", "ads.showInterstitial", "ads.showRewarded", "commerce.getEntitlements", "commerce.getProducts", "commerce.purchase", "commerce.restore", "identity.getPlayer", "leaderboard.open", "leaderboard.submitScore", "runtime.getCapabilities", "storage.load", "storage.save"]);
+    const _ae0 = "(\"ads.preload\" | \"ads.showInterstitial\" | \"ads.showRewarded\" | \"commerce.getEntitlements\" | \"commerce.getProducts\" | \"commerce.purchase\" | \"commerce.restore\" | \"identity.getPlayer\" | \"leaderboard.open\" | \"leaderboard.submitScore\" | \"runtime.getCapabilities\" | \"storage.load\" | \"storage.save\")";
+    const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".id",
+        expected: "string",
+        value: input.id
+    }, _errorFactory)) && (true === _av0.has(input.method) || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".method",
+        expected: _ae0,
+        value: input.method
+    }, _errorFactory)) && true && (("object" === typeof input.meta && null !== input.meta || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".meta",
+        expected: "{ readonly target: string; readonly appVersion: string; readonly buildId: string; readonly sentAt: string; }",
+        value: input.meta
+    }, _errorFactory)) && _ao1(input.meta, _path + ".meta", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".meta",
+        expected: "{ readonly target: string; readonly appVersion: string; readonly buildId: string; readonly sentAt: string; }",
+        value: input.meta
+    }, _errorFactory));
+    const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.target || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".target",
+        expected: "string",
+        value: input.target
+    }, _errorFactory)) && ("string" === typeof input.appVersion || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".appVersion",
+        expected: "string",
+        value: input.appVersion
+    }, _errorFactory)) && ("string" === typeof input.buildId || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".buildId",
+        expected: "string",
+        value: input.buildId
+    }, _errorFactory)) && ("string" === typeof input.sentAt || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".sentAt",
+        expected: "string",
+        value: input.sentAt
+    }, _errorFactory));
+    const _io0 = input => "string" === typeof input.id && true === _iv0.has(input.method) && true && ("object" === typeof input.meta && null !== input.meta && _io1(input.meta));
+    const _io1 = input => "string" === typeof input.target && "string" === typeof input.appVersion && "string" === typeof input.buildId && "string" === typeof input.sentAt;
+    const __is = input => "object" === typeof input && null !== input && _io0(input);
+    let _errorFactory;
+    return (input, errorFactory) => {
+        if (false === __is(input)) {
+            _errorFactory = errorFactory;
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
+                method: "typia.createAssert",
+                path: _path + "",
+                expected: "BridgeRequest<unknown>",
+                value: input
+            }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
+                method: "typia.createAssert",
+                path: _path + "",
+                expected: "BridgeRequest<unknown>",
+                value: input
+            }, _errorFactory))(input, "$input", true);
+        }
+        return input;
+    };
+})();
+export const assertBridgeResponse = (() => {
+    const _ip0 = input => "string" === typeof input["id"];
+    const _ae0 = "({ readonly id: string; readonly ok: false; readonly error: { readonly code: string; readonly message: string; readonly retryable: boolean; }; } | { readonly id: string; readonly ok: true; readonly data: unknown; })";
+    const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".id",
+        expected: "string",
+        value: input["id"]
+    }, _errorFactory);
+    const _ae1 = "({ readonly id: string; readonly ok: true; readonly data: unknown; } | { readonly id: string; readonly ok: false; readonly error: { readonly code: string; readonly message: string; readonly retryable: boolean; }; })";
+    const _ao0 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (true === input.ok || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".ok",
+        expected: "true",
+        value: input.ok
+    }, _errorFactory)) && true;
+    const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (false === input.ok || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".ok",
+        expected: "false",
+        value: input.ok
+    }, _errorFactory)) && (("object" === typeof input.error && null !== input.error || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".error",
+        expected: "{ readonly code: string; readonly message: string; readonly retryable: boolean; }",
+        value: input.error
+    }, _errorFactory)) && _ao2(input.error, _path + ".error", true && _exceptionable) || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".error",
+        expected: "{ readonly code: string; readonly message: string; readonly retryable: boolean; }",
+        value: input.error
+    }, _errorFactory));
+    const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.code || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".code",
+        expected: "string",
+        value: input.code
+    }, _errorFactory)) && ("string" === typeof input.message || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".message",
+        expected: "string",
+        value: input.message
+    }, _errorFactory)) && ("boolean" === typeof input.retryable || _a._assertGuard(_exceptionable, {
+        method: "typia.createAssert",
+        path: _path + ".retryable",
+        expected: "boolean",
+        value: input.retryable
+    }, _errorFactory));
+    const _au0 = (input, _path, _exceptionable = true) => (() => {
+        if (true === input.ok)
+            return _ao0(input, _path, true && _exceptionable);
+        else if (false === input.ok)
+            return _ao1(input, _path, true && _exceptionable);
+        else
+            return _a._assertGuard(_exceptionable, {
+                method: "typia.createAssert",
+                path: _path,
+                expected: _ae1,
+                value: input
+            }, _errorFactory);
+    })();
+    const _io0 = input => _ip0(input) && true === input.ok && true;
+    const _io1 = input => _ip0(input) && false === input.ok && ("object" === typeof input.error && null !== input.error && _io2(input.error));
+    const _io2 = input => "string" === typeof input.code && "string" === typeof input.message && "boolean" === typeof input.retryable;
+    const _iu0 = input => (() => {
+        if (true === input.ok)
+            return _io0(input);
+        else if (false === input.ok)
+            return _io1(input);
+        else
+            return false;
+    })();
+    const __is = input => "object" === typeof input && null !== input && _iu0(input);
+    let _errorFactory;
+    return (input, errorFactory) => {
+        if (false === __is(input)) {
+            _errorFactory = errorFactory;
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
+                method: "typia.createAssert",
+                path: _path + "",
+                expected: _ae0,
+                value: input
+            }, _errorFactory)) && _au0(input, _path + "", true) || _a._assertGuard(true, {
+                method: "typia.createAssert",
+                path: _path + "",
+                expected: _ae0,
+                value: input
+            }, _errorFactory))(input, "$input", true);
+        }
+        return input;
+    };
+})();
+export function createBridgeError(id, code, message, retryable = false) {
+    return {
+        id,
+        ok: false,
+        error: {
+            code,
+            message,
+            retryable,
+        },
+    };
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@mpgd/bridge",
+  "version": "0.1.0",
+  "description": "Typed native bridge protocol for mpgd platform adapters.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/imjlk/mpgd-kit.git",
+    "directory": "packages/bridge"
+  },
+  "bugs": {
+    "url": "https://github.com/imjlk/mpgd-kit/issues"
+  },
+  "homepage": "https://github.com/imjlk/mpgd-kit#readme",
+  "keywords": [
+    "mpgd",
+    "phaser",
+    "vite",
+    "typescript",
+    "capacitor",
+    "apps-in-toss",
+    "game-development",
+    "game-distribution"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "typia": "rc"
+  },
+  "devDependencies": {
+    "ttsc": "0.16.9",
+    "typescript": "7.0.1-rc"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check": "ttsc --noEmit",
+    "lint": "ttsc --noEmit",
+    "format": "ttsc format",
+    "fix": "ttsc fix",
+    "test": "cd ../.. && node tools/run-ttsx.mjs packages/bridge/src/bridge-protocol.test.ts"
+  }
+}