@novasamatech/host-api 0.7.9-4 → 0.7.9-6

package/dist/hostApi.js

@@ -8,6 +8,7 @@ import { DeriveEntropyErr } from './protocol/v1/deriveEntropy.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
 import { StorageErr } from './protocol/v1/localStorage.js';
 import { NavigateToErr } from './protocol/v1/navigation.js';
+import { PushNotificationError } from './protocol/v1/notification.js';
 import { PaymentRequestErr, PaymentTopUpErr } from './protocol/v1/payments.js';
 import { PreimageSubmitErr } from './protocol/v1/preimage.js';
 import { ResourceAllocationErr } from './protocol/v1/resourceAllocation.js';
@@ -44,6 +45,12 @@ export function createHostApi(transport) {
         },
         pushNotification(payload) {
             return makeRequest(transport.request('host_push_notification', payload), reason => ({
+                tag: payload.tag,
+                value: new PushNotificationError.Unknown({ reason }),
+            }));
+        },
+        pushNotificationCancel(payload) {
+            return makeRequest(transport.request('host_push_notification_cancel', payload), reason => ({
                 tag: payload.tag,
                 value: new GenericError({ reason }),
             }));

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export type { ConnectionStatus, HostApiMethod, Logger, RequestHandler, Subscription, SubscriptionHandler, Transport, } from './types.js';
+export type { ConnectionStatus, DebugMessageEvent, HostApiMethod, Logger, RequestHandler, Subscription, SubscriptionHandler, Transport, } from './types.js';
+export type { MessagePayloadSchema } from './protocol/messageCodec.js';
 export type { Provider } from './provider.js';
 export { createRequestId } from './helpers.js';
 export type { HostApi } from './hostApi.js';
@@ -21,7 +22,7 @@ export { SignedStatement, SignedStatementsPage, Statement, StatementProofErr, To
 export { StorageErr } from './protocol/v1/localStorage.js';
 export { DevicePermission } from './protocol/v1/devicePermission.js';
 export { RemotePermission } from './protocol/v1/remotePermission.js';
-export { PushNotification } from './protocol/v1/notification.js';
+export { NotificationId, PushNotification, PushNotificationError } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
 export { AllocatableResource, AllocationOutcome, ResourceAllocationErr } from './protocol/v1/resourceAllocation.js';

package/dist/index.js

@@ -16,7 +16,7 @@ export { SignedStatement, SignedStatementsPage, Statement, StatementProofErr, To
 export { StorageErr } from './protocol/v1/localStorage.js';
 export { DevicePermission } from './protocol/v1/devicePermission.js';
 export { RemotePermission } from './protocol/v1/remotePermission.js';
-export { PushNotification } from './protocol/v1/notification.js';
+export { NotificationId, PushNotification, PushNotificationError } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
 export { AllocatableResource, AllocationOutcome, ResourceAllocationErr } from './protocol/v1/resourceAllocation.js';

package/dist/protocol/impl.d.ts

@@ -36,9 +36,10 @@ export declare const hostApiProtocol: {
         readonly v1: [Codec<{
             text: string;
             deeplink: string | undefined;
-        }>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            scheduledAt: bigint | undefined;
+        }>, Codec<import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
             reason: string;
-        }, "GenericError">>>];
+        }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>>];
     }>;
     readonly host_navigate_to: VersionedProtocolRequest<{
         readonly v1: [Codec<string>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
@@ -982,5 +983,10 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>>];
     }>;
+    readonly host_push_notification_cancel: VersionedProtocolRequest<{
+        readonly v1: [Codec<number>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
 };
 export {};

package/dist/protocol/impl.js

@@ -10,7 +10,7 @@ import { FeatureV1_request, FeatureV1_response } from './v1/feature.js';
 import { HandshakeV1_request, HandshakeV1_response } from './v1/handshake.js';
 import { StorageClearV1_request, StorageClearV1_response, StorageReadV1_request, StorageReadV1_response, StorageWriteV1_request, StorageWriteV1_response, } from './v1/localStorage.js';
 import { NavigateToV1_request, NavigateToV1_response } from './v1/navigation.js';
-import { PushNotificationV1_request, PushNotificationV1_response } from './v1/notification.js';
+import { PushNotificationCancelV1_request, PushNotificationCancelV1_response, PushNotificationV1_request, PushNotificationV1_response, } from './v1/notification.js';
 import { PaymentBalanceSubscribeV1_interrupt, PaymentBalanceSubscribeV1_receive, PaymentBalanceSubscribeV1_start, PaymentRequestV1_request, PaymentRequestV1_response, PaymentStatusSubscribeV1_interrupt, PaymentStatusSubscribeV1_receive, PaymentStatusSubscribeV1_start, PaymentTopUpV1_request, PaymentTopUpV1_response, } from './v1/payments.js';
 import { PreimageLookupSubscribeV1_interrupt, PreimageLookupSubscribeV1_receive, PreimageLookupSubscribeV1_start, PreimageSubmitV1_request, PreimageSubmitV1_response, } from './v1/preimage.js';
 import { RemotePermissionV1_request, RemotePermissionV1_response } from './v1/remotePermission.js';
@@ -211,4 +211,7 @@ export const hostApiProtocol = {
     remote_statement_store_create_proof_authorized: versionedRequest({
         v1: [StatementStoreCreateProofAuthorizedV1_request, StatementStoreCreateProofAuthorizedV1_response],
     }),
+    host_push_notification_cancel: versionedRequest({
+        v1: [PushNotificationCancelV1_request, PushNotificationCancelV1_response],
+    }),
 };

package/dist/protocol/messageCodec.d.ts

@@ -28,11 +28,12 @@ export declare const MessagePayload: EnumCodec<Record<"host_handshake_request",
     readonly v1: Codec<{
         text: string;
         deeplink: string | undefined;
+        scheduledAt: bigint | undefined;
     }>;
 }>> & Record<"host_push_notification_response", EnumCodec<{
-    readonly v1: Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    readonly v1: Codec<import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
         reason: string;
-    }, "GenericError">>>;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>>;
 }>> & Record<"host_navigate_to_request", EnumCodec<{
     readonly v1: Codec<string>;
 }>> & Record<"host_navigate_to_response", EnumCodec<{
@@ -1050,6 +1051,12 @@ export declare const MessagePayload: EnumCodec<Record<"host_handshake_request",
     }, import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>>;
+}>> & Record<"host_push_notification_cancel_request", EnumCodec<{
+    readonly v1: Codec<number>;
+}>> & Record<"host_push_notification_cancel_response", EnumCodec<{
+    readonly v1: Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "GenericError">>>;
 }>>>;
 export declare const Message: Codec<{
     requestId: string;
@@ -1091,15 +1098,16 @@ export declare const Message: Codec<{
             value: {
                 text: string;
                 deeplink: string | undefined;
+                scheduledAt: bigint | undefined;
             };
         };
     } | {
         tag: "host_push_notification_response";
         value: {
             tag: "v1";
-            value: import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            value: import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
                 reason: string;
-            }, "GenericError">>;
+            }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>;
         };
     } | {
         tag: "host_navigate_to_request";
@@ -2583,6 +2591,20 @@ export declare const Message: Codec<{
                 reason: string;
             }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>;
         };
+    } | {
+        tag: "host_push_notification_cancel_request";
+        value: {
+            tag: "v1";
+            value: number;
+        };
+    } | {
+        tag: "host_push_notification_cancel_response";
+        value: {
+            tag: "v1";
+            value: import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+                reason: string;
+            }, "GenericError">>;
+        };
     };
 }>;
 export type MessageAction = MessagePayloadSchema['tag'];

package/dist/protocol/v1/notification.d.ts

@@ -1,11 +1,39 @@
+export declare const NotificationId: import("scale-ts").Codec<number>;
 export declare const PushNotification: import("scale-ts").Codec<{
     text: string;
     deeplink: string | undefined;
+    scheduledAt: bigint | undefined;
 }>;
+export declare const PushNotificationError: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>;
+} & {
+    readonly ScheduleLimitReached: import("@novasamatech/scale").ErrCodec<undefined, "PushNotificationError::ScheduleLimitReached">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "PushNotificationError::Unknown">;
+} & {
+    [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">;
+};
 export declare const PushNotificationV1_request: import("scale-ts").Codec<{
     text: string;
     deeplink: string | undefined;
+    scheduledAt: bigint | undefined;
 }>;
-export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>>;
+export declare const PushNotificationCancelV1_request: import("scale-ts").Codec<number>;
+export declare const PushNotificationCancelV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "GenericError">>>;

package/dist/protocol/v1/notification.js

@@ -1,8 +1,17 @@
-import { Option, Result, Struct, _void, str } from 'scale-ts';
-import { GenericError } from '../commonCodecs.js';
+import { ErrEnum } from '@novasamatech/scale';
+import { Option, Result, Struct, _void, str, u32, u64 } from 'scale-ts';
+import { GenericErr, GenericError } from '../commonCodecs.js';
+export const NotificationId = u32;
 export const PushNotification = Struct({
     text: str,
     deeplink: Option(str),
+    scheduledAt: Option(u64),
+});
+export const PushNotificationError = ErrEnum('PushNotificationError', {
+    ScheduleLimitReached: [_void, 'Schedule limit reached'],
+    Unknown: [GenericErr, 'Unknown error'],
 });
 export const PushNotificationV1_request = PushNotification;
-export const PushNotificationV1_response = Result(_void, GenericError);
+export const PushNotificationV1_response = Result(NotificationId, PushNotificationError);
+export const PushNotificationCancelV1_request = NotificationId;
+export const PushNotificationCancelV1_response = Result(_void, GenericError);

package/dist/transport.js

@@ -79,6 +79,27 @@ export function createTransport(provider) {
     const messageProvider = createMessageProvider(provider);
     // subscriptions management (multiplexing)
     const activeSubscriptions = new Map();
+    // Lazy provider subscription — zero per-message decode cost while no
+    // debug listener is attached.
+    let debugListenerCount = 0;
+    let debugProviderUnsubscribe = null;
+    function ensureDebugProviderSubscription() {
+        if (debugProviderUnsubscribe)
+            return;
+        debugProviderUnsubscribe = messageProvider.subscribe(message => {
+            events.emit('debugMessage', {
+                direction: 'incoming',
+                requestId: message.requestId,
+                payload: message.payload,
+            });
+        });
+    }
+    function maybeDisposeDebugProviderSubscription() {
+        if (debugListenerCount > 0)
+            return;
+        debugProviderUnsubscribe?.();
+        debugProviderUnsubscribe = null;
+    }
     const transport = {
         provider,
         isCorrectEnvironment() {
@@ -288,6 +309,9 @@ export function createTransport(provider) {
         },
         postMessage(requestId, payload) {
             checks();
+            if (debugListenerCount > 0) {
+                events.emit('debugMessage', { direction: 'outgoing', requestId, payload });
+            }
             messageProvider.postMessage({ requestId, payload });
         },
         listenMessages(action, callback, onError) {
@@ -311,12 +335,44 @@ export function createTransport(provider) {
         },
         destroy() {
             disposed = true;
+            debugProviderUnsubscribe?.();
+            debugProviderUnsubscribe = null;
+            debugListenerCount = 0;
             provider.dispose();
             changeConnectionStatus('disconnected');
             events.emit('destroy');
             events.events = {};
             handshakeAbortController.abort('Transport disposed');
         },
+        onDebugMessage(callback) {
+            debugListenerCount++;
+            ensureDebugProviderSubscription();
+            // Wrap each listener individually: nanoevents iterates listeners
+            // synchronously and a throw aborts the loop, so without per-listener
+            // isolation a single broken listener could starve siblings *and*
+            // (on the incoming side) starve unrelated messageProvider subscribers.
+            // Route to console.error (not provider.logger.error) so debug-callback
+            // bugs stay distinct from real protocol errors — matches the same
+            // policy used by host-papp's debugBus.
+            const safeCallback = (event) => {
+                try {
+                    callback(event);
+                }
+                catch (e) {
+                    console.error('debug listener threw', e);
+                }
+            };
+            const unsubscribe = events.on('debugMessage', safeCallback);
+            let disposed = false;
+            return () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                unsubscribe();
+                debugListenerCount--;
+                maybeDisposeDebugProviderSubscription();
+            };
+        },
     };
     if (provider.isCorrectEnvironment()) {
         transport.handleRequest('host_handshake', async (version) => {

package/dist/transport.spec.js

@@ -1,5 +1,7 @@
+import { enumValue } from '@novasamatech/scale';
 import { createNanoEvents } from 'nanoevents';
 import { describe, expect, it, vi } from 'vitest';
+import { JAM_CODEC_PROTOCOL_ID } from './constants.js';
 import { createDefaultLogger } from './logger.js';
 import { createTransport } from './transport.js';
 function createProviders() {
@@ -18,6 +20,7 @@ function createProviders() {
         sdk: createProvider('toSdk', 'toHost'),
     };
 }
+const samplePayload = () => enumValue('host_handshake_request', enumValue('v1', JAM_CODEC_PROTOCOL_ID));
 describe('transport', () => {
     describe('subscription', () => {
         it('should multiplex subscriptions', () => {
@@ -55,4 +58,118 @@ describe('transport', () => {
             expect(s2Handler).toHaveBeenCalledTimes(2);
         });
     });
+    describe('debug hook', () => {
+        it('emits outgoing events when postMessage is called and still delivers the message', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const debugListener = vi.fn();
+            host.onDebugMessage(debugListener);
+            const sdkReceived = vi.fn();
+            sdk.listenMessages('host_handshake_request', sdkReceived);
+            const requestId = 'req-1';
+            const payload = samplePayload();
+            host.postMessage(requestId, payload);
+            expect(debugListener).toHaveBeenCalledTimes(1);
+            expect(debugListener).toHaveBeenCalledWith(expect.objectContaining({ direction: 'outgoing', requestId, payload }));
+            expect(sdkReceived).toHaveBeenCalledTimes(1);
+            expect(sdkReceived).toHaveBeenCalledWith(requestId, expect.objectContaining({ tag: 'host_handshake_request' }));
+        });
+        it('emits incoming events with decoded payload', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const debugListener = vi.fn();
+            host.onDebugMessage(debugListener);
+            const requestId = 'req-2';
+            const payload = samplePayload();
+            sdk.postMessage(requestId, payload);
+            // host receives sdk's message, plus host's own outgoing handshake
+            // attempts (none yet, since isReady() wasn't called). Filter to incoming.
+            const incoming = debugListener.mock.calls.map(([event]) => event).filter(e => e.direction === 'incoming');
+            expect(incoming).toHaveLength(1);
+            expect(incoming[0]).toEqual(expect.objectContaining({
+                direction: 'incoming',
+                requestId,
+                payload: expect.objectContaining({ tag: 'host_handshake_request' }),
+            }));
+        });
+        it('supports multiple listeners and stops after unsubscribe', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            const a = vi.fn();
+            const b = vi.fn();
+            const unsubscribeA = host.onDebugMessage(a);
+            host.onDebugMessage(b);
+            host.postMessage('req-a', samplePayload());
+            expect(a).toHaveBeenCalledTimes(1);
+            expect(b).toHaveBeenCalledTimes(1);
+            unsubscribeA();
+            // calling unsubscribe twice must be a no-op
+            unsubscribeA();
+            host.postMessage('req-b', samplePayload());
+            expect(a).toHaveBeenCalledTimes(1);
+            expect(b).toHaveBeenCalledTimes(2);
+        });
+        it('survives a throwing listener without breaking delivery', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            // Swap console.error directly so the expected throws don't pollute test
+            // output. Transport routes debug-callback failures to console.error (not
+            // provider.logger) so they stay distinct from real protocol errors.
+            const originalConsoleError = console.error;
+            const errorSpy = vi.fn();
+            console.error = errorSpy;
+            try {
+                host.onDebugMessage(() => {
+                    throw new Error('listener boom');
+                });
+                const goodListener = vi.fn();
+                host.onDebugMessage(goodListener);
+                const sdkReceived = vi.fn();
+                sdk.listenMessages('host_handshake_request', sdkReceived);
+                // outgoing: a throwing listener must not block messageProvider.postMessage
+                host.postMessage('out-1', samplePayload());
+                expect(sdkReceived).toHaveBeenCalledTimes(1);
+                // incoming: a throwing listener must not block other host listenMessages subscribers
+                const hostReceived = vi.fn();
+                host.listenMessages('host_handshake_request', hostReceived);
+                sdk.postMessage('in-1', samplePayload());
+                expect(hostReceived).toHaveBeenCalledTimes(1);
+                // the second good listener still fired despite the first one throwing
+                expect(goodListener).toHaveBeenCalled();
+                // and the throws were observed on console.error, not propagated
+                expect(errorSpy).toHaveBeenCalled();
+            }
+            finally {
+                console.error = originalConsoleError;
+            }
+        });
+        it('cleans up the debug subscription on destroy() and blocks further sends', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const listener = vi.fn();
+            host.onDebugMessage(listener);
+            host.destroy();
+            // postMessage on a destroyed transport throws
+            expect(() => host.postMessage('after-destroy', samplePayload())).toThrow(/Transport is disposed/);
+            // incoming traffic from the peer no longer surfaces to the listener
+            sdk.postMessage('in-after-destroy', samplePayload());
+            expect(listener).not.toHaveBeenCalled();
+        });
+        it('does not emit outgoing events when no listener is attached', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            // sanity: no listener attached, postMessage works fine
+            expect(() => host.postMessage('req', samplePayload())).not.toThrow();
+            // attach + detach + send: no events should fire to the (now-detached) listener
+            const listener = vi.fn();
+            const unsubscribe = host.onDebugMessage(listener);
+            unsubscribe();
+            host.postMessage('req2', samplePayload());
+            expect(listener).not.toHaveBeenCalled();
+        });
+    });
 });

package/dist/types.d.ts

@@ -19,6 +19,16 @@ export type MessageProvider = {
     postMessage(message: CodecType<typeof Message>): void;
     subscribe(fn: (message: CodecType<typeof Message>) => void): VoidFunction;
 };
+/**
+ * EXPERIMENTAL. A single message observed on the transport, in its
+ * decoded (non-SCALE) form. Intended for host-side introspection.
+ */
+export type DebugMessageEvent = {
+    /** `outgoing` = sent by this side via `postMessage`; `incoming` = received from the peer. */
+    direction: 'incoming' | 'outgoing';
+    requestId: string;
+    payload: MessagePayloadSchema;
+};
 export type Transport = {
     readonly provider: Provider;
     isCorrectEnvironment(): boolean;
@@ -32,4 +42,12 @@ export type Transport = {
     handleSubscription<const Method extends HostApiMethod>(method: Method, handler: SubscriptionHandler<Method>): VoidFunction;
     postMessage(requestId: string, payload: MessagePayloadSchema): void;
     listenMessages<const Action extends MessageAction>(action: Action, callback: (requestId: string, data: PickMessagePayload<Action>) => void, onError?: (error: unknown) => void): VoidFunction;
+    /**
+     * EXPERIMENTAL. Subscribe to every message crossing this transport
+     * in either direction, in decoded form. Returns an unsubscribe
+     * function. Multiple listeners are supported; the underlying
+     * provider is subscribed lazily — there is no per-message cost
+     * while no listener is attached.
+     */
+    onDebugMessage(callback: (event: DebugMessageEvent) => void): VoidFunction;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.7.9-4",
+  "version": "0.7.9-6",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
@@ -22,7 +22,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.7.9-4",
+    "@novasamatech/scale": "0.7.9-6",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0",