@novasamatech/host-container 0.7.9-5 → 0.7.9-6

package/dist/createContainer.d.ts

@@ -1,3 +1,3 @@
 import type { Provider } from '@novasamatech/host-api';
-import type { Container } from './types.js';
-export declare function createContainer(provider: Provider): Container;
+import type { Container, CreateContainerOptions } from './types.js';
+export declare function createContainer(provider: Provider, options?: CreateContainerOptions): Container;

package/dist/createContainer.js

@@ -1,6 +1,7 @@
 import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr, CreateProofErr, CreateTransactionErr, DeriveEntropyErr, DevicePermission, GenericError, GetUserIdErr, LoginErr, NavigateToErr, PaymentBalanceErr, PaymentRequestErr, PaymentStatusErr, PaymentTopUpErr, PreimageSubmitErr, PushNotificationError, RemotePermission, RequestCredentialsErr, ResourceAllocationErr, SigningErr, StatementProofErr, StorageErr, createTransport, enumValue, isEnumVariant, resultErr, resultOk, } from '@novasamatech/host-api';
 import { err, errAsync, ok, okAsync } from 'neverthrow';
 import { createChainConnectionManager } from './chainConnectionManager.js';
+import { emitHostApiDebugMessage, registerHostApiDebugSource } from './debugBus.js';
 const UNSUPPORTED_MESSAGE_FORMAT_ERROR = 'Unsupported message format';
 const NOT_IMPLEMENTED = 'Not implemented';
 function guardVersion(value, tag, error) {
@@ -12,11 +13,21 @@ function guardVersion(value, tag, error) {
     }
     return err(error);
 }
-export function createContainer(provider) {
+export function createContainer(provider, options = {}) {
     const transport = createTransport(provider);
     if (!transport.isCorrectEnvironment()) {
         throw new Error('Transport is not available: dapp provider has incorrect environment');
     }
+    const { productId } = options;
+    // EXPERIMENTAL: forward every transport-level message into the
+    // process-global debug bus, tagged with this container's productId.
+    // The forwarder is registered as a bus *source* and only attaches to
+    // `transport.onDebugMessage` while the bus has at least one subscriber —
+    // otherwise the transport's lazy `Message.dec` path stays cold.
+    const unregisterGlobalDebugSource = registerHostApiDebugSource(() => transport.onDebugMessage(({ direction, requestId, payload }) => {
+        emitHostApiDebugMessage({ direction, productId, requestId, payload });
+    }));
+    transport.onDestroy(unregisterGlobalDebugSource);
     function init() {
         // init status subscription
         transport.isReady();
@@ -625,5 +636,10 @@ export function createContainer(provider) {
         dispose() {
             transport.destroy();
         },
+        onDebugMessage(callback) {
+            return transport.onDebugMessage(({ direction, requestId, payload }) => {
+                callback({ direction, productId, requestId, payload });
+            });
+        },
     };
 }

package/dist/debugBus.d.ts

@@ -0,0 +1,18 @@
+import type { HostApiDebugMessageEvent } from './types.js';
+type DebugSource = () => VoidFunction;
+/** @internal Used by `createContainer` to forward its transport's debug events. */
+export declare function emitHostApiDebugMessage(event: HostApiDebugMessageEvent): void;
+/**
+ * @internal Register a transport-level forwarder for the global bus.
+ * The source is activated only while the bus has at least one subscriber
+ * and deactivated when the last one unsubscribes — this preserves the
+ * transport's lazy decode path (no `Message.dec` per frame) when nobody
+ * is listening downstream.
+ */
+export declare function registerHostApiDebugSource(source: DebugSource): VoidFunction;
+/**
+ * EXPERIMENTAL. Subscribe to every host ↔ product message across all
+ * containers in the current process. Returns an unsubscribe function.
+ */
+export declare function onHostApiDebugMessage(callback: (event: HostApiDebugMessageEvent) => void): VoidFunction;
+export {};

package/dist/debugBus.js

@@ -0,0 +1,73 @@
+import { createNanoEvents } from 'nanoevents';
+/**
+ * EXPERIMENTAL: process-global bus that aggregates debug events from
+ * every container created in this process. Subscribing here gives a
+ * single subscriber visibility into all host ↔ product traffic across
+ * every active container, annotated with the `productId` passed to
+ * `createContainer` (if any).
+ */
+const bus = createNanoEvents();
+const sources = new Set();
+const activeSources = new Map();
+let subscriberCount = 0;
+function activateSource(source) {
+    if (activeSources.has(source))
+        return;
+    activeSources.set(source, source());
+}
+function deactivateSource(source) {
+    const unsubscribe = activeSources.get(source);
+    if (!unsubscribe)
+        return;
+    activeSources.delete(source);
+    unsubscribe();
+}
+/** @internal Used by `createContainer` to forward its transport's debug events. */
+export function emitHostApiDebugMessage(event) {
+    bus.emit('message', event);
+}
+/**
+ * @internal Register a transport-level forwarder for the global bus.
+ * The source is activated only while the bus has at least one subscriber
+ * and deactivated when the last one unsubscribes — this preserves the
+ * transport's lazy decode path (no `Message.dec` per frame) when nobody
+ * is listening downstream.
+ */
+export function registerHostApiDebugSource(source) {
+    sources.add(source);
+    if (subscriberCount > 0)
+        activateSource(source);
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        sources.delete(source);
+        deactivateSource(source);
+    };
+}
+/**
+ * EXPERIMENTAL. Subscribe to every host ↔ product message across all
+ * containers in the current process. Returns an unsubscribe function.
+ */
+export function onHostApiDebugMessage(callback) {
+    const wasZero = subscriberCount === 0;
+    subscriberCount++;
+    if (wasZero) {
+        for (const source of sources)
+            activateSource(source);
+    }
+    const unsubscribe = bus.on('message', callback);
+    let disposed = false;
+    return () => {
+        if (disposed)
+            return;
+        disposed = true;
+        unsubscribe();
+        subscriberCount--;
+        if (subscriberCount === 0) {
+            for (const source of [...activeSources.keys()])
+                deactivateSource(source);
+        }
+    };
+}

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 export { createWebviewProvider } from './createWebviewProvider.js';
 export { createIframeProvider } from './createIframeProvider.js';
 export { createContainer } from './createContainer.js';
-export type { Container, ContainerHandlerOf } from './types.js';
+export type { Container, ContainerHandlerOf, CreateContainerOptions, HostApiDebugMessageEvent } from './types.js';
+export { onHostApiDebugMessage } from './debugBus.js';
 export { deriveProductEntropy } from './deriveEntropy.js';
 export { createRateLimiter } from './rateLimiter.js';
 export type { CreateRateLimiterConfig, RateLimiter, RateLimiterConfig, RateLimiterStrategy } from './rateLimiter.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { createWebviewProvider } from './createWebviewProvider.js';
 export { createIframeProvider } from './createIframeProvider.js';
 export { createContainer } from './createContainer.js';
+export { onHostApiDebugMessage } from './debugBus.js';
 export { deriveProductEntropy } from './deriveEntropy.js';
 export { createRateLimiter } from './rateLimiter.js';

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { Codec, CodecType, ConnectionStatus, HexString, HostApiProtocol, Subscription, VersionedProtocolRequest, VersionedProtocolSubscription } from '@novasamatech/host-api';
+import type { Codec, CodecType, ConnectionStatus, HexString, HostApiProtocol, MessagePayloadSchema, Subscription, VersionedProtocolRequest, VersionedProtocolSubscription } from '@novasamatech/host-api';
 import { CustomRendererNode } from '@novasamatech/host-api';
 import type { ResultAsync, errAsync } from 'neverthrow';
 import { okAsync } from 'neverthrow';
@@ -52,6 +52,25 @@ type InferRequestHandler<V extends string, T extends VersionedProtocolRequest> =
 type InferSubscribeHandler<V extends string, T extends VersionedProtocolSubscription> = (callback: (params: WithVersion<V, CodecValue<T['start']>>, send: (payload: WithVersion<V, CodecValue<T['receive']>>) => void, interrupt: (payload: WithVersion<V, CodecValue<T['interrupt']>>) => void) => VoidFunction) => VoidFunction;
 type InferHandler<V extends string, T extends VersionedProtocolRequest | VersionedProtocolSubscription> = T extends VersionedProtocolRequest ? InferRequestHandler<V, T> : T extends VersionedProtocolSubscription ? InferSubscribeHandler<V, T> : never;
 export type ContainerHandlerOf<T extends (...args: any[]) => any> = Parameters<T>[0];
+/**
+ * EXPERIMENTAL. Event describing a single message observed on a
+ * container's transport, in decoded form, tagged with the productId
+ * that was passed to `createContainer`.
+ */
+export type HostApiDebugMessageEvent = {
+    direction: 'incoming' | 'outgoing';
+    productId: string | undefined;
+    requestId: string;
+    payload: MessagePayloadSchema;
+};
+export type CreateContainerOptions = {
+    /**
+     * Optional identifier for the product this container talks to.
+     * When set, every debug event emitted via `onDebugMessage` and the
+     * global `onHostApiDebugMessage` bus is tagged with this value.
+     */
+    productId?: string;
+};
 export type Container = {
     handleFeatureSupported: InferHandler<'v1', HostApiProtocol['host_feature_supported']>;
     handleDevicePermission: InferHandler<'v1', HostApiProtocol['host_device_permission']>;
@@ -102,5 +121,11 @@ export type Container = {
     isReady(): Promise<boolean>;
     dispose(): void;
     subscribeProductConnectionStatus(callback: (connectionStatus: ConnectionStatus) => void): VoidFunction;
+    /**
+     * EXPERIMENTAL. Subscribe to every message crossing this container's
+     * transport in either direction, in decoded form. Returns an
+     * unsubscribe function.
+     */
+    onDebugMessage(callback: (event: HostApiDebugMessageEvent) => void): VoidFunction;
 };
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-container",
   "type": "module",
-  "version": "0.7.9-5",
+  "version": "0.7.9-6",
   "description": "Host container for hosting and managing products within the Polkadot ecosystem.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,8 @@
     "@noble/hashes": "2.2.0",
     "polkadot-api": ">=2",
     "@polkadot-api/substrate-client": "^0.7.0",
-    "@novasamatech/host-api": "0.7.9-5",
+    "@novasamatech/host-api": "0.7.9-6",
+    "nanoevents": "9.1.0",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0"
   },