@mpgd/bridge 0.5.0 → 0.6.1

package/dist/cloudflare-pages.d.ts

@@ -1,5 +1,5 @@
-import { type BridgeRequest, type BridgeResponse } from './index';
-import { type BridgeRpcPrefix } from './orpc';
+import { type BridgeRequest, type BridgeResponse } from './index.js';
+import { type BridgeRpcPrefix } from './orpc.js';
 export declare const defaultCloudflarePagesBridgeEndpoint: '/api/mpgd/bridge';
 export declare const defaultCloudflarePagesGameServicesPrefix: '/api/game-services';
 export declare const defaultCloudflarePagesGameServicesForwardHeaders: readonly ['accept', 'authorization', 'content-type'];

package/dist/cloudflare-pages.js

@@ -1,5 +1,5 @@
-import { assertBridgeRequest, createBridgeError, } from './index';
-import { createBridgeRpcFetchHandler, createBridgeRpcRouter, defaultBridgeRpcEndpoint, } from './orpc';
+import { assertBridgeRequest, bridgeStorageLoadProtocol, createBridgeError, } from './index.js';
+import { createBridgeRpcFetchHandler, createBridgeRpcRouter, defaultBridgeRpcEndpoint, } from './orpc.js';
 export const defaultCloudflarePagesBridgeEndpoint = '/api/mpgd/bridge';
 export const defaultCloudflarePagesGameServicesPrefix = '/api/game-services';
 export const defaultCloudflarePagesGameServicesForwardHeaders = [
@@ -137,7 +137,10 @@ export function createMpgdCloudflarePagesBridgeHandler() {
             case 'leaderboard.open':
                 return createBridgeError(input.bridgeRequest.id, 'CLOUDFLARE_PAGES_LEADERBOARD_OPEN_UNAVAILABLE', 'Cloudflare Pages host does not provide a native leaderboard UI.');
             case 'storage.load':
-                return ok(input.bridgeRequest, null);
+                return ok(input.bridgeRequest, {
+                    __mpgdBridgeProtocol: bridgeStorageLoadProtocol,
+                    found: false,
+                });
             case 'storage.save':
                 return ok(input.bridgeRequest, {
                     saved: false,

package/dist/index.d.ts

@@ -23,6 +23,18 @@ export type BridgeResponse<TData = unknown> = {
     readonly retryable: boolean;
   };
 };
+export declare const bridgeStorageLoadProtocol: 'mpgd.storage.load.v1';
+export type BridgeStorageLoadData = {
+  readonly __mpgdBridgeProtocol: typeof bridgeStorageLoadProtocol;
+  readonly found: false;
+} | {
+  readonly __mpgdBridgeProtocol: typeof bridgeStorageLoadProtocol;
+  readonly found: true;
+  readonly value: unknown;
+};
 export declare const assertBridgeRequest: (input: unknown) => BridgeRequest<unknown>;
 export declare const assertBridgeResponse: (input: unknown) => BridgeResponse<unknown>;
+export declare function decodeBridgeStorageLoadData(input: unknown): {
+  readonly value: unknown;
+} | null;
 export declare function createBridgeError(id: string, code: string, message: string, retryable?: boolean): BridgeResponse;

package/dist/index.js

@@ -1,46 +1,47 @@
-import * as _a from "typia/lib/internal/_assertGuard";
+import * as _assertGuard_1 from "typia/lib/internal/_assertGuard";
 import typia from 'typia';
+export const bridgeStorageLoadProtocol = 'mpgd.storage.load.v1';
 export const assertBridgeRequest = (() => {
     const _iv0 = new Set(["ads.preload", "ads.showInterstitial", "ads.showRewarded", "commerce.getEntitlements", "commerce.getProducts", "commerce.purchase", "commerce.restore", "identity.getPlayer", "identity.getSession", "identity.requestUpgrade", "leaderboard.open", "leaderboard.submitScore", "notifications.getStatus", "notifications.requestSubscription", "presentation.getLaunchIntent", "presentation.requestGameSurface", "runtime.getCapabilities", "share.readInboundShare", "share.share", "storage.load", "storage.save"]);
     const _av0 = new Set(["ads.preload", "ads.showInterstitial", "ads.showRewarded", "commerce.getEntitlements", "commerce.getProducts", "commerce.purchase", "commerce.restore", "identity.getPlayer", "identity.getSession", "identity.requestUpgrade", "leaderboard.open", "leaderboard.submitScore", "notifications.getStatus", "notifications.requestSubscription", "presentation.getLaunchIntent", "presentation.requestGameSurface", "runtime.getCapabilities", "share.readInboundShare", "share.share", "storage.load", "storage.save"]);
     const _ae0 = "(\"ads.preload\" | \"ads.showInterstitial\" | \"ads.showRewarded\" | \"commerce.getEntitlements\" | \"commerce.getProducts\" | \"commerce.purchase\" | \"commerce.restore\" | \"identity.getPlayer\" | \"identity.getSession\" | \"identity.requestUpgrade\" | \"leaderboard.open\" | \"leaderboard.submitScore\" | \"notifications.getStatus\" | \"notifications.requestSubscription\" | \"presentation.getLaunchIntent\" | \"presentation.requestGameSurface\" | \"runtime.getCapabilities\" | \"share.readInboundShare\" | \"share.share\" | \"storage.load\" | \"storage.save\")";
-    const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _a._assertGuard(_exceptionable, {
+    const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".id",
         expected: "string",
         value: input.id
-    }, _errorFactory)) && (true === _av0.has(input.method) || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && (true === _av0.has(input.method) || _assertGuard_1._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, {
+    }, _errorFactory)) && true && (("object" === typeof input.meta && null !== input.meta || _assertGuard_1._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, {
+    }, _errorFactory)) && _ao1(input.meta, _path + ".meta", true && _exceptionable) || _assertGuard_1._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, {
+    const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.target || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".target",
         expected: "string",
         value: input.target
-    }, _errorFactory)) && ("string" === typeof input.appVersion || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && ("string" === typeof input.appVersion || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".appVersion",
         expected: "string",
         value: input.appVersion
-    }, _errorFactory)) && ("string" === typeof input.buildId || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && ("string" === typeof input.buildId || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".buildId",
         expected: "string",
         value: input.buildId
-    }, _errorFactory)) && ("string" === typeof input.sentAt || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && ("string" === typeof input.sentAt || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".sentAt",
         expected: "string",
@@ -53,12 +54,12 @@ export const assertBridgeRequest = (() => {
     return (input, errorFactory) => {
         if (false === __is(input)) {
             _errorFactory = errorFactory;
-            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
                 method: "typia.createAssert",
                 path: _path + "",
                 expected: "BridgeRequest<unknown>",
                 value: input
-            }, _errorFactory)) && _ao0(input, _path + "", true) || _a._assertGuard(true, {
+            }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
                 method: "typia.createAssert",
                 path: _path + "",
                 expected: "BridgeRequest<unknown>",
@@ -71,46 +72,46 @@ export const assertBridgeRequest = (() => {
 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, {
+    const _ap0 = (input, _path, _exceptionable = true) => "string" === typeof input["id"] || _assertGuard_1._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, {
+    const _ao0 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (true === input.ok || _assertGuard_1._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, {
+    const _ao1 = (input, _path, _exceptionable = true) => _ap0(input, _path, true && _exceptionable) && (false === input.ok || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".ok",
         expected: "false",
         value: input.ok
-    }, _errorFactory)) && (("object" === typeof input.error && null !== input.error || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && (("object" === typeof input.error && null !== input.error || _assertGuard_1._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, {
+    }, _errorFactory)) && _ao2(input.error, _path + ".error", true && _exceptionable) || _assertGuard_1._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, {
+    const _ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.code || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".code",
         expected: "string",
         value: input.code
-    }, _errorFactory)) && ("string" === typeof input.message || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && ("string" === typeof input.message || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".message",
         expected: "string",
         value: input.message
-    }, _errorFactory)) && ("boolean" === typeof input.retryable || _a._assertGuard(_exceptionable, {
+    }, _errorFactory)) && ("boolean" === typeof input.retryable || _assertGuard_1._assertGuard(_exceptionable, {
         method: "typia.createAssert",
         path: _path + ".retryable",
         expected: "boolean",
@@ -122,7 +123,7 @@ export const assertBridgeResponse = (() => {
         else if (false === input.ok)
             return _ao1(input, _path, true && _exceptionable);
         else
-            return _a._assertGuard(_exceptionable, {
+            return _assertGuard_1._assertGuard(_exceptionable, {
                 method: "typia.createAssert",
                 path: _path,
                 expected: _ae1,
@@ -145,12 +146,12 @@ export const assertBridgeResponse = (() => {
     return (input, errorFactory) => {
         if (false === __is(input)) {
             _errorFactory = errorFactory;
-            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _a._assertGuard(true, {
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
                 method: "typia.createAssert",
                 path: _path + "",
                 expected: _ae0,
                 value: input
-            }, _errorFactory)) && _au0(input, _path + "", true) || _a._assertGuard(true, {
+            }, _errorFactory)) && _au0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
                 method: "typia.createAssert",
                 path: _path + "",
                 expected: _ae0,
@@ -160,6 +161,30 @@ export const assertBridgeResponse = (() => {
         return input;
     };
 })();
+export function decodeBridgeStorageLoadData(input) {
+    if (input === null) {
+        return null;
+    }
+    if (input === undefined) {
+        throw new Error('Storage bridge load returned an invalid response.');
+    }
+    if (typeof input !== 'object' ||
+        !(input !== null && '__mpgdBridgeProtocol' in input) ||
+        input.__mpgdBridgeProtocol !== bridgeStorageLoadProtocol) {
+        return { value: input };
+    }
+    const response = input;
+    if (response.found === false) {
+        return null;
+    }
+    if (response.found !== true) {
+        throw new Error('Storage bridge load returned an invalid response.');
+    }
+    if (!Object.prototype.hasOwnProperty.call(response, 'value')) {
+        throw new Error('Storage bridge load returned an invalid response.');
+    }
+    return { value: response.value };
+}
 export function createBridgeError(id, code, message, retryable = false) {
     return {
         id,

package/dist/orpc-node.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type BridgeRpcPrefix, type BridgeRpcRouter } from './orpc.js';
+export interface CreateBridgeRpcNodeHandlerOptions {
+  readonly maxBodySize?: number;
+  readonly prefix?: BridgeRpcPrefix;
+}
+export type BridgeRpcNodeHandler = (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+/**
+* Creates a bridge transport that writes oRPC responses directly to Node HTTP.
+* The boolean result is false when another route should handle the request.
+*/
+export declare function createBridgeRpcNodeHandler(router: BridgeRpcRouter, options?: CreateBridgeRpcNodeHandlerOptions): BridgeRpcNodeHandler;

package/dist/orpc-node.js

@@ -0,0 +1,52 @@
+import { BodyLimitHandlerPlugin, RPCHandler } from '@orpc/server/node';
+import { defaultBridgeRpcEndpoint } from './orpc.js';
+/**
+ * Creates a bridge transport that writes oRPC responses directly to Node HTTP.
+ * The boolean result is false when another route should handle the request.
+ */
+export function createBridgeRpcNodeHandler(router, options = {}) {
+    const handler = new RPCHandler(router, {
+        plugins: [
+            new BodyLimitHandlerPlugin({
+                maxBodySize: options.maxBodySize ?? 1000000,
+            }),
+        ],
+    });
+    const prefix = options.prefix ?? defaultBridgeRpcEndpoint;
+    return async (request, response) => {
+        try {
+            const result = await handler.handle(request, response, {
+                prefix,
+                context: {
+                    request,
+                },
+            });
+            return result.matched;
+        }
+        catch (error) {
+            console.error('Bridge RPC internal error:', error);
+            finishInternalErrorResponse(response);
+            return true;
+        }
+    };
+}
+function finishInternalErrorResponse(response) {
+    if (response.headersSent) {
+        if (!response.writableEnded) {
+            response.destroy();
+        }
+        return;
+    }
+    if (response.destroyed) {
+        return;
+    }
+    const payload = JSON.stringify({
+        error: 'BRIDGE_RPC_INTERNAL_ERROR',
+    });
+    response.statusCode = 500;
+    response.setHeader('cache-control', 'no-store');
+    response.setHeader('content-length', Buffer.byteLength(payload));
+    response.setHeader('content-type', 'application/json; charset=utf-8');
+    response.setHeader('x-content-type-options', 'nosniff');
+    response.end(payload);
+}

package/dist/orpc.d.ts

@@ -1,6 +1,6 @@
 import type { StandardUrl } from '@orpc/client/standard';
 import { type RouterContractClient } from '@orpc/contract';
-import { type BridgeRequest, type BridgeResponse } from './index';
+import { type BridgeRequest, type BridgeResponse } from './index.js';
 export type BridgeRpcEndpoint = StandardUrl;
 export type BridgeRpcPrefix = `/${string}`;
 export declare const defaultBridgeRpcEndpoint = "/api/mpgd/rpc";

package/dist/orpc.js

@@ -3,7 +3,7 @@ import { RPCLink } from '@orpc/client/fetch';
 import { oc, type as orpcType } from '@orpc/contract';
 import { implement } from '@orpc/server';
 import { RPCHandler } from '@orpc/server/fetch';
-import { assertBridgeRequest, createBridgeError, } from './index';
+import { assertBridgeRequest, createBridgeError, } from './index.js';
 export const defaultBridgeRpcEndpoint = '/api/mpgd/rpc';
 export const bridgeRpcContract = oc.router({
     request: oc.input(orpcType()).output(orpcType()),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/bridge",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Typed native bridge protocol for mpgd platform adapters.",
   "license": "MIT",
   "repository": {
@@ -33,6 +33,10 @@
       "types": "./dist/orpc.d.ts",
       "default": "./dist/orpc.js"
     },
+    "./orpc/node": {
+      "types": "./dist/orpc-node.d.ts",
+      "default": "./dist/orpc-node.js"
+    },
     "./cloudflare-pages": {
       "types": "./dist/cloudflare-pages.d.ts",
       "default": "./dist/cloudflare-pages.js"
@@ -45,11 +49,12 @@
     "@orpc/client": "2.0.0-beta.14",
     "@orpc/contract": "2.0.0-beta.14",
     "@orpc/server": "2.0.0-beta.14",
-    "typia": "rc"
+    "typia": "13.0.2"
   },
   "devDependencies": {
-    "ttsc": "0.16.9",
-    "typescript": "7.0.1-rc"
+    "@types/node": "^24.0.0",
+    "ttsc": "0.18.4",
+    "typescript": "7.0.2"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -61,6 +66,6 @@
     "lint": "ttsc --noEmit",
     "format": "ttsc format",
     "fix": "ttsc fix",
-    "test": "cd ../.. && node tools/run-ttsx.mjs packages/bridge/src/bridge-protocol.test.ts && node tools/run-ttsx.mjs packages/bridge/src/orpc.test.ts && node tools/run-ttsx.mjs packages/bridge/src/cloudflare-pages.test.ts"
+    "test": "cd ../.. && node tools/run-ttsx.mjs packages/bridge/src/bridge-protocol.test.ts && node tools/run-ttsx.mjs packages/bridge/src/orpc.test.ts && node tools/run-ttsx.mjs packages/bridge/src/orpc-node.test.ts && node tools/run-ttsx.mjs packages/bridge/src/cloudflare-pages.test.ts && node packages/bridge/test/orpc-node-dist-import.mjs"
   }
 }