@webpieces/ipc-bridge 0.4.751

package/README.md

@@ -0,0 +1,53 @@
+# Portable IPC bridge
+
+`@webpieces/ipc-bridge` exports both `IpcClientFactory` and `IpcServerFactory` for browser, React Native and Node. Install one package on each side of a trusted JSON transport connection. Either side can create client proxies and register server implementations.
+
+```typescript
+import { IpcClientFactory, IpcServerFactory } from '@webpieces/ipc-bridge';
+```
+
+Declare a shared abstract API and an `IpcContract` from `@webpieces/core-util/ipc` beside it. Its `IpcMethods<Api>` mapping requires one `IpcMethod` per API member. Each method declares an explicit stable wire ID, request schema, response schema, masking spec and request/notification kind. Schemas implement `parse(unknown)` and validate/reconstruct a DTO. Methods accept exactly one non-null DTO and return a Promise. Use `IpcVoidSchema` for acknowledged void. Notifications also acknowledge failures; they never silently swallow them.
+
+```typescript
+abstract class PlaybackApi {
+    abstract play(request: PlayRequest): Promise<void>;
+}
+class PlaybackMethods {
+    readonly play = new IpcMethod('play.v1', new PlayRequestSchema(), new IpcVoidSchema(), new MaskSpec({}));
+}
+const playbackContract = new IpcContract('playback.v1', PlaybackApi, new PlaybackMethods());
+const clients = new IpcClientFactory(connection, logging);
+const playback = clients.createClient(playbackContract);
+await playback.play(new PlayRequest('track-id'));
+```
+
+The schema, DTO, IDs and metadata live in the shared contract package. The names of the abstract class and controller are never sent on the wire. Proxy inspection, symbols and `then` do not send requests.
+
+Construct `IpcConnection` with an `IpcTransport` adapter and `IpcConnectionOptions`: a positive timeout, a connection-wide unique ID generator, a scheduler returning timer cancellation functions, and an error owner. The adapter sends strings and subscribes once to incoming strings, transport errors and close events. Its send Promise must reject on send failure; parse/message-error callbacks go to the failure subscriber. A vendor bus adapter must not expose vendor Node declarations through its public contract. Do not install a second vendor handler for every API.
+
+`IpcLogging.context(call)` is required and supplies an active per-call `ApiCallContext` carrying the transaction/call/parent IDs in the host logger. Both factories invoke framework `LogApiCallImpl`; receiver logging happens before encoding failures and sender completion logging happens after decoding. `UserError` is rethrown but remains a successful monitoring outcome. Configure the normal framework logging backend at bootstrap. Masking affects logs, never wire DTOs.
+
+Use `clients.withContext(inboundContext)` when making nested calls; this copies the transaction and makes the inbound call the parent. No ambient mutable state is held across awaits. `createScoped` on the server supports constructing a controller with a scoped client factory.
+
+Timeout rejects with the existing `TimeoutError`. Send/close/disposal rejects with local `IpcTransportError`, preserving the original failure as standard `cause`. This extends `Error`, not semantic `ApiError`, and is never a remote wire category. A receiver throwing `ServiceUnavailableError` still arrives as that canonical semantic error, so callers can distinguish a failed local bridge from an unavailable remote implementation. A timeout does not cancel remote side effects, and the framework never replays requests. `dispose()` rejects pending requests and closes the adapter. Late replies are reported and ignored. Malformed envelopes and correlation mismatches fail the connection, including its pending calls. Observe all OS-callback send Promises or route rejections to the application's explicit error owner.
+
+Host responsibilities: validate WebView origins/navigation/session identity and expose only authorized APIs. Suspension/resume, coalescing native state, durable usage journals and installed shell protocol minimums are application policies. Generic IPC cannot make suspended website JavaScript execute. Android/iOS lifecycle and locked-screen tests remain downstream integration work.
+
+The required compatibility build checks published declarations without Node/DOM ambient types, scans transitive runtime dependencies, bundles Android/iOS with Metro and compiles Hermes bytecode. Hermes/device execution is a separate verification claim and must only be made when actually run.
+
+## Receiver registration
+
+`IpcServerFactory` registers explicit shared contracts and already-constructed implementations. It does not create a bus or import an HTTP server, DI container, React Native runtime or Node request context.
+
+```typescript
+const server = new IpcServerFactory(logging);
+server.create(playbackContract, new NativePlaybackController(player));
+server.create(navigationContract, new NavigationController(router));
+connection.setHandler(server.handle); // exactly once, before sending any calls
+```
+
+One connection has one dispatcher containing multiple APIs. Duplicate registrations fail. Unknown API/method IDs return canonical `EndpointNotFoundError`, distinct from a missing domain entity. Schemas validate both request and reply; successful void is encoded explicitly as null. Receiver exceptions are logged then encoded with the same `ApiErrorCodec` used by the sender to reconstruct canonical errors.
+
+`createScoped(contract, scope)` accepts an `IpcControllerScope<T>` whose `create(context)` supplies the implementation for that invocation. Inject a `clients.withContext(context)` proxy into this controller when it calls back or invokes another API. Concurrent calls have separate context objects and do not overwrite a global async context.
+
+A host may register receivers and create client proxies on both ends of the same connection. `IpcConnection` owns transport parse/send failures and disposal; see the connection and logging contracts above for the transport and logging contracts, error ownership, security responsibilities and downstream native lifecycle tests.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@webpieces/ipc-bridge",
+  "version": "0.4.751",
+  "description": "Portable typed duplex IPC client and server factories for browser, React Native and Node",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "author": "Dean Hiller",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deanhiller/webpieces-ts.git",
+    "directory": "packages/core/ipc-bridge"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@webpieces/core-util": "0.4.751"
+  }
+}

package/src/IpcClientFactory.d.ts

@@ -0,0 +1,11 @@
+import { IpcCallContext, IpcConnection, IpcContract, IpcLogging } from '@webpieces/core-util/ipc';
+/** Typed proxies on one trusted duplex connection; no HTTP decorators or container required. */
+export declare class IpcClientFactory {
+    private readonly connection;
+    private readonly logging;
+    private readonly parent?;
+    constructor(connection: IpcConnection, logging: IpcLogging, parent?: IpcCallContext | undefined);
+    /** Explicit scope propagation is safe across concurrent async calls in browser and RN. */
+    withContext(context: IpcCallContext): IpcClientFactory;
+    createClient<T extends object>(contract: IpcContract<T>): T;
+}

package/src/IpcClientFactory.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpcClientFactory = void 0;
+const errors_1 = require("@webpieces/core-util/errors");
+const ipc_1 = require("@webpieces/core-util/ipc");
+/** Typed proxies on one trusted duplex connection; no HTTP decorators or container required. */
+class IpcClientFactory {
+    connection;
+    logging;
+    parent;
+    constructor(connection, logging, parent) {
+        this.connection = connection;
+        this.logging = logging;
+        this.parent = parent;
+    }
+    /** Explicit scope propagation is safe across concurrent async calls in browser and RN. */
+    withContext(context) {
+        return new IpcClientFactory(this.connection, this.logging, context);
+    }
+    createClient(contract) {
+        // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+        const methods = new Map();
+        for (const key of Object.keys(contract.methods)) {
+            // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+            const method = contract.methods[key];
+            // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+            methods.set(key, async (request) => {
+                const context = this.connection.newContext(this.parent);
+                return ipc_1.IpcCallLogger.execute(this.logging, context, 'client', contract.id, method.id, method.mask, request, async () => {
+                    const body = method.request.parse(request);
+                    if (body === null || body === undefined)
+                        throw new errors_1.InternalError('IPC requests require one non-null DTO');
+                    const reply = await this.connection.request(new ipc_1.IpcRequest(contract.id, method.id, context, body));
+                    if (reply.type === 'failure')
+                        throw errors_1.ApiErrorCodec.decode(reply.error);
+                    return method.response.parse(reply.body);
+                });
+            });
+        }
+        return new Proxy(Object.create(null), new IpcProxyHandler(methods));
+    }
+}
+exports.IpcClientFactory = IpcClientFactory;
+class IpcProxyHandler {
+    methods;
+    constructor(
+    // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+    methods) {
+        this.methods = methods;
+    }
+    // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+    get(_target, key) {
+        // Promise assimilation, inspection, symbols and framework instrumentation aren't RPC methods.
+        return this.methods.get(key);
+    }
+    has(_target, key) {
+        return this.methods.has(key);
+    }
+}
+//# sourceMappingURL=IpcClientFactory.js.map

package/src/IpcClientFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IpcClientFactory.js","sourceRoot":"","sources":["../../../../../packages/core/ipc-bridge/src/IpcClientFactory.ts"],"names":[],"mappings":";;;AAAA,wDAA2E;AAC3E,kDAQkC;AAElC,gGAAgG;AAChG,MAAa,gBAAgB;IAEJ;IACA;IACA;IAHrB,YACqB,UAAyB,EACzB,OAAmB,EACnB,MAAuB;QAFvB,eAAU,GAAV,UAAU,CAAe;QACzB,YAAO,GAAP,OAAO,CAAY;QACnB,WAAM,GAAN,MAAM,CAAiB;IACzC,CAAC;IAEJ,0FAA0F;IAC1F,WAAW,CAAC,OAAuB;QAC/B,OAAO,IAAI,gBAAgB,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACxE,CAAC;IAED,YAAY,CAAmB,QAAwB;QACnD,0IAA0I;QAC1I,MAAM,OAAO,GAAG,IAAI,GAAG,EAAuD,CAAC;QAC/E,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9C,0IAA0I;YAC1I,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAc,CAAgC,CAAC;YAC/E,0IAA0I;YAC1I,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,OAAgB,EAAoB,EAAE;gBAC1D,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACxD,OAAO,mBAAa,CAAC,OAAO,CACxB,IAAI,CAAC,OAAO,EACZ,OAAO,EACP,QAAQ,EACR,QAAQ,CAAC,EAAE,EACX,MAAM,CAAC,EAAE,EACT,MAAM,CAAC,IAAI,EACX,OAAO,EACP,KAAK,IAAI,EAAE;oBACP,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;oBAC3C,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS;wBACnC,MAAM,IAAI,sBAAa,CAAC,uCAAuC,CAAC,CAAC;oBACrE,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CACvC,IAAI,gBAAU,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,CACxD,CAAC;oBACF,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS;wBAAE,MAAM,sBAAa,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBACtE,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC7C,CAAC,CACJ,CAAC;YACN,CAAC,CAAC,CAAC;QACP,CAAC;QACD,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAM,EAAE,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7E,CAAC;CACJ;AA5CD,4CA4CC;AAED,MAAM,eAAe;IAGI;IAFrB;IACI,0IAA0I;IACzH,OAAyE;QAAzE,YAAO,GAAP,OAAO,CAAkE;IAC3F,CAAC;IACJ,0IAA0I;IAC1I,GAAG,CAAC,OAAU,EAAE,GAAoB;QAChC,8FAA8F;QAC9F,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IACD,GAAG,CAAC,OAAU,EAAE,GAAoB;QAChC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;CACJ","sourcesContent":["import { ApiErrorCodec, InternalError } from '@webpieces/core-util/errors';\nimport {\n    IpcCallContext,\n    IpcConnection,\n    IpcContract,\n    IpcLogging,\n    IpcMethod,\n    IpcRequest,\n    IpcCallLogger,\n} from '@webpieces/core-util/ipc';\n\n/** Typed proxies on one trusted duplex connection; no HTTP decorators or container required. */\nexport class IpcClientFactory {\n    constructor(\n        private readonly connection: IpcConnection,\n        private readonly logging: IpcLogging,\n        private readonly parent?: IpcCallContext,\n    ) {}\n\n    /** Explicit scope propagation is safe across concurrent async calls in browser and RN. */\n    withContext(context: IpcCallContext): IpcClientFactory {\n        return new IpcClientFactory(this.connection, this.logging, context);\n    }\n\n    createClient<T extends object>(contract: IpcContract<T>): T {\n        // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n        const methods = new Map<PropertyKey, (request: unknown) => Promise<unknown>>();\n        for (const key of Object.keys(contract.methods)) {\n            // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n            const method = contract.methods[key as keyof T] as IpcMethod<unknown, unknown>;\n            // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n            methods.set(key, async (request: unknown): Promise<unknown> => {\n                const context = this.connection.newContext(this.parent);\n                return IpcCallLogger.execute(\n                    this.logging,\n                    context,\n                    'client',\n                    contract.id,\n                    method.id,\n                    method.mask,\n                    request,\n                    async () => {\n                        const body = method.request.parse(request);\n                        if (body === null || body === undefined)\n                            throw new InternalError('IPC requests require one non-null DTO');\n                        const reply = await this.connection.request(\n                            new IpcRequest(contract.id, method.id, context, body),\n                        );\n                        if (reply.type === 'failure') throw ApiErrorCodec.decode(reply.error);\n                        return method.response.parse(reply.body);\n                    },\n                );\n            });\n        }\n        return new Proxy(Object.create(null) as T, new IpcProxyHandler(methods));\n    }\n}\n\nclass IpcProxyHandler<T extends object> implements ProxyHandler<T> {\n    constructor(\n        // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n        private readonly methods: ReadonlyMap<PropertyKey, (request: unknown) => Promise<unknown>>,\n    ) {}\n    // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n    get(_target: T, key: string | symbol): unknown {\n        // Promise assimilation, inspection, symbols and framework instrumentation aren't RPC methods.\n        return this.methods.get(key);\n    }\n    has(_target: T, key: string | symbol): boolean {\n        return this.methods.has(key);\n    }\n}\n"]}

package/src/IpcServerFactory.d.ts

@@ -0,0 +1,16 @@
+import { IpcCallContext, IpcContract, IpcLogging, IpcReply, IpcRequest } from '@webpieces/core-util/ipc';
+/** Construct a receiver using explicit call context when it needs to make nested outbound calls. */
+export interface IpcControllerScope<T> {
+    create(context: IpcCallContext): T;
+}
+/** One dispatcher hosts multiple explicitly registered APIs and never enumerates controller members. */
+export declare class IpcServerFactory {
+    private readonly logging;
+    private readonly registrations;
+    constructor(logging: IpcLogging);
+    create<T extends object>(contract: IpcContract<T>, controller: T): void;
+    createScoped<T extends object>(contract: IpcContract<T>, scope: IpcControllerScope<T>): void;
+    private register;
+    /** Bootstrap passes this function to the ONE connection's setHandler before sending calls. */
+    readonly handle: (request: IpcRequest) => Promise<IpcReply>;
+}

package/src/IpcServerFactory.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpcServerFactory = void 0;
+const errors_1 = require("@webpieces/core-util/errors");
+const ipc_1 = require("@webpieces/core-util/ipc");
+class IpcRegistration {
+    invoke;
+    // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+    constructor(invoke) {
+        this.invoke = invoke;
+    }
+}
+/** One dispatcher hosts multiple explicitly registered APIs and never enumerates controller members. */
+class IpcServerFactory {
+    logging;
+    registrations = new Map();
+    constructor(logging) {
+        this.logging = logging;
+    }
+    create(contract, controller) {
+        this.register(contract, () => controller);
+    }
+    createScoped(contract, scope) {
+        this.register(contract, (context) => scope.create(context));
+    }
+    register(contract, controller) {
+        if (this.registrations.has(contract.id))
+            throw new errors_1.InternalError(`Duplicate IPC API registration: ${contract.id}`);
+        const methods = new Map();
+        for (const key of Object.keys(contract.methods)) {
+            // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+            const method = contract.methods[key];
+            methods.set(method.id, new IpcRegistration(async (request) => {
+                // Logging wraps validation and invocation; only handle() below encodes exceptions.
+                return ipc_1.IpcCallLogger.execute(this.logging, request.context, 'server', contract.id, method.id, method.mask, request.body, async () => {
+                    const body = method.request.parse(request.body);
+                    if (body === null || body === undefined)
+                        throw new errors_1.InternalError('IPC requests require one non-null DTO');
+                    const instance = controller(request.context);
+                    const invoke = instance[key];
+                    if (typeof invoke !== 'function')
+                        throw new errors_1.InternalError(`IPC implementation is missing ${contract.id}.${method.id}`);
+                    const result = await // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation
+                     invoke.call(instance, body);
+                    return method.response.parse(result);
+                });
+            }));
+        }
+        this.registrations.set(contract.id, methods);
+    }
+    /** Bootstrap passes this function to the ONE connection's setHandler before sending calls. */
+    handle = async (request) => {
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- receiver translates to a failure reply; the generated client reconstructs and throws it
+        try {
+            const method = this.registrations.get(request.apiId)?.get(request.methodId);
+            if (!method)
+                throw new errors_1.EndpointNotFoundError('Unknown IPC API or method');
+            const body = await method.invoke(request);
+            return new ipc_1.IpcSuccess(request.context, body === undefined ? null : body);
+        }
+        catch (err) {
+            const error = (0, ipc_1.toError)(err);
+            return new ipc_1.IpcFailure(request.context, errors_1.ApiErrorCodec.encode(error));
+        }
+    };
+}
+exports.IpcServerFactory = IpcServerFactory;
+//# sourceMappingURL=IpcServerFactory.js.map

package/src/IpcServerFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IpcServerFactory.js","sourceRoot":"","sources":["../../../../../packages/core/ipc-bridge/src/IpcServerFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiErrorCodec, EndpointNotFoundError, InternalError } from '@webpieces/core-util/errors';\nimport {\n    IpcCallContext,\n    IpcContract,\n    IpcFailure,\n    IpcLogging,\n    IpcMethod,\n    IpcReply,\n    IpcRequest,\n    IpcSuccess,\n    IpcCallLogger,\n    toError,\n} from '@webpieces/core-util/ipc';\n\n/** Construct a receiver using explicit call context when it needs to make nested outbound calls. */\nexport interface IpcControllerScope<T> {\n    create(context: IpcCallContext): T;\n}\nclass IpcRegistration {\n    // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n    constructor(readonly invoke: (request: IpcRequest) => Promise<unknown>) {}\n}\n\n/** One dispatcher hosts multiple explicitly registered APIs and never enumerates controller members. */\nexport class IpcServerFactory {\n    private readonly registrations = new Map<string, Map<string, IpcRegistration>>();\n    constructor(private readonly logging: IpcLogging) {}\n\n    create<T extends object>(contract: IpcContract<T>, controller: T): void {\n        this.register(contract, () => controller);\n    }\n\n    createScoped<T extends object>(contract: IpcContract<T>, scope: IpcControllerScope<T>): void {\n        this.register(contract, (context) => scope.create(context));\n    }\n\n    private register<T extends object>(\n        contract: IpcContract<T>,\n        controller: (context: IpcCallContext) => T,\n    ): void {\n        if (this.registrations.has(contract.id))\n            throw new InternalError(`Duplicate IPC API registration: ${contract.id}`);\n        const methods = new Map<string, IpcRegistration>();\n        for (const key of Object.keys(contract.methods)) {\n            // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n            const method = contract.methods[key as keyof T] as IpcMethod<unknown, unknown>;\n            methods.set(\n                method.id,\n                new IpcRegistration(async (request) => {\n                    // Logging wraps validation and invocation; only handle() below encodes exceptions.\n                    return IpcCallLogger.execute(\n                        this.logging,\n                        request.context,\n                        'server',\n                        contract.id,\n                        method.id,\n                        method.mask,\n                        request.body,\n                        async () => {\n                            const body = method.request.parse(request.body);\n                            if (body === null || body === undefined)\n                                throw new InternalError('IPC requests require one non-null DTO');\n                            const instance = controller(request.context);\n                            const invoke = instance[key as keyof T];\n                            if (typeof invoke !== 'function')\n                                throw new InternalError(\n                                    `IPC implementation is missing ${contract.id}.${method.id}`,\n                                );\n                            const result =\n                                await // webpieces-disable no-any-unknown -- untrusted IPC data is schema-validated; generic dispatch cannot assume a DTO type before validation\n                                (invoke as (request: unknown) => Promise<unknown>).call(\n                                    instance,\n                                    body,\n                                );\n                            return method.response.parse(result);\n                        },\n                    );\n                }),\n            );\n        }\n        this.registrations.set(contract.id, methods);\n    }\n\n    /** Bootstrap passes this function to the ONE connection's setHandler before sending calls. */\n    readonly handle = async (request: IpcRequest): Promise<IpcReply> => {\n        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions -- receiver translates to a failure reply; the generated client reconstructs and throws it\n        try {\n            const method = this.registrations.get(request.apiId)?.get(request.methodId);\n            if (!method) throw new EndpointNotFoundError('Unknown IPC API or method');\n            const body = await method.invoke(request);\n            return new IpcSuccess(request.context, body === undefined ? null : body);\n        } catch (err: unknown) {\n            const error = toError(err);\n            return new IpcFailure(request.context, ApiErrorCodec.encode(error));\n        }\n    };\n}\n"]}

package/src/index.d.ts

@@ -0,0 +1,3 @@
+export { IpcClientFactory } from './IpcClientFactory';
+export { IpcServerFactory } from './IpcServerFactory';
+export type { IpcControllerScope } from './IpcServerFactory';

package/src/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpcServerFactory = exports.IpcClientFactory = void 0;
+var IpcClientFactory_1 = require("./IpcClientFactory");
+Object.defineProperty(exports, "IpcClientFactory", { enumerable: true, get: function () { return IpcClientFactory_1.IpcClientFactory; } });
+var IpcServerFactory_1 = require("./IpcServerFactory");
+Object.defineProperty(exports, "IpcServerFactory", { enumerable: true, get: function () { return IpcServerFactory_1.IpcServerFactory; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/core/ipc-bridge/src/index.ts"],"names":[],"mappings":";;;AAAA,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA;AACzB,uDAAsD;AAA7C,oHAAA,gBAAgB,OAAA","sourcesContent":["export { IpcClientFactory } from './IpcClientFactory';\nexport { IpcServerFactory } from './IpcServerFactory';\nexport type { IpcControllerScope } from './IpcServerFactory';\n"]}