@getuserfeedback/react-native 5.4.0 → 5.5.1

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import type { AppEventExternalId, PublicCommandPayload } from "@getuserfeedback/protocol";
-import type { CapabilitiesInput, ConfigureOptions, EventOptions, EventProperties, GraphOperations, InitOptions, OpenRequestedCallback } from "@getuserfeedback/sdk";
+import type { ActionRegistration, CapabilitiesInput, ConfigureOptions, EventOptions, EventProperties, GraphOperations, InitOptions, OpenRequestedCallback } from "@getuserfeedback/sdk";
 export type { EventOptions, EventProperties, OpenRequestedCallback, OpenRequestedEvent, TrackOptions, } from "@getuserfeedback/sdk";
 type IdentifyTraits = Record<string, unknown>;
 type OpenCommand = Extract<PublicCommandPayload, {
@@ -19,8 +19,14 @@ type HostContext = Extract<PublicCommandPayload, {
 type CommandOptions = {
     idempotencyKey?: string;
 };
+/** A customer-defined action implemented by the React Native host app. */
+export type NativeActionRegistration = Extract<ActionRegistration, {
+    kind: "custom";
+}>;
 /** React Native provider initialization options. */
-export type ClientOptions = Omit<InitOptions, "capabilities" | "hostCapabilities"> & {
+export type ClientOptions = Omit<InitOptions, "capabilities" | "hostActions" | "hostCapabilities"> & {
+    /** Widget actions implemented by the current app version. */
+    actions?: NativeActionRegistration[] | undefined;
     /** Capabilities supported by the current app version. */
     capabilities?: CapabilitiesInput | undefined;
 };

package/dist/native-core-command-channel.d.ts

@@ -2,6 +2,7 @@ import { type CoreCommandEnvelope } from "@getuserfeedback/protocol";
 import { type EventHandleInvalidated } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
 import { type EventCommandSettled } from "@getuserfeedback/protocol/internal/core-host-command-settlement";
 import type { CoreWebViewHostConnection } from "./core-webview-host-controller.js";
+import { createNativeHostActionRpcHandler } from "./native-host-action-rpc.js";
 export type NativeCoreCommandChannel = {
     post: (envelope: CoreCommandEnvelope) => void;
     subscribe: (listener: (message: EventCommandSettled) => void) => () => void;
@@ -12,7 +13,14 @@ type OwnedNativeCoreCommandChannel = {
 };
 export declare function createNativeCoreCommandChannel(input: {
     coreConnection: CoreWebViewHostConnection;
+    hostActions?: {
+        getHandler: Parameters<typeof createNativeHostActionRpcHandler>[0]["getHandler"];
+        getActiveViewIds: () => readonly string[];
+        instanceId: string;
+        subscribeToViewActivity: (listener: () => void) => () => void;
+    };
     onHandleInvalidated?: (message: EventHandleInvalidated) => void;
+    onHostActionError?: (error: Error) => void;
     onInvalidMessage?: (error: Error, value: unknown) => void;
     onSessionFailure?: (error: Error) => void;
 }): OwnedNativeCoreCommandChannel;

package/dist/native-core-command-channel.js

@@ -3,11 +3,34 @@ import { eventHandleInvalidatedSchema, } from "@getuserfeedback/protocol/interna
 import { eventCommandSettledSchema, } from "@getuserfeedback/protocol/internal/core-host-command-settlement";
 import { CORE_SESSION_FAILED_CODE, eventCoreSessionFailedSchema, } from "@getuserfeedback/protocol/internal/core-session-failure";
 import { buildRpcResponse, rpcRequestSchema, } from "@getuserfeedback/protocol/internal/v3-rpc-messages";
+import { createNativeHostActionRpcHandler } from "./native-host-action-rpc.js";
 const DISPOSED_MESSAGE = "Core command channel is disposed";
 const isRecord = (value) => typeof value === "object" && value !== null;
 export function createNativeCoreCommandChannel(input) {
+    var _a;
     const listeners = new Set();
     let disposed = false;
+    const hostActions = input.hostActions;
+    const hostActionRpcHandler = hostActions
+        ? createNativeHostActionRpcHandler({
+            generation: input.coreConnection.generation,
+            getHandler: hostActions.getHandler,
+            instanceId: hostActions.instanceId,
+            isViewActive: (viewId) => hostActions.getActiveViewIds().includes(viewId),
+            onError: input.onHostActionError,
+            postToCore: input.coreConnection.transport.postMessage,
+        })
+        : null;
+    let activeViewIds = new Set((_a = hostActions === null || hostActions === void 0 ? void 0 : hostActions.getActiveViewIds()) !== null && _a !== void 0 ? _a : []);
+    const unsubscribeViewActivity = hostActions === null || hostActions === void 0 ? void 0 : hostActions.subscribeToViewActivity(() => {
+        const nextActiveViewIds = new Set(hostActions.getActiveViewIds());
+        for (const viewId of activeViewIds) {
+            if (!nextActiveViewIds.has(viewId)) {
+                hostActionRpcHandler === null || hostActionRpcHandler === void 0 ? void 0 : hostActionRpcHandler.releaseView(viewId);
+            }
+        }
+        activeViewIds = nextActiveViewIds;
+    });
     const handleMessage = (value) => {
         var _a, _b, _c, _d, _e, _f;
         if (disposed || !isRecord(value)) {
@@ -19,6 +42,9 @@ export function createNativeCoreCommandChannel(input) {
                 parsed.data.gen !== input.coreConnection.generation) {
                 return;
             }
+            if (hostActionRpcHandler === null || hostActionRpcHandler === void 0 ? void 0 : hostActionRpcHandler.handle(parsed.data)) {
+                return;
+            }
             let result;
             if (parsed.data.method === TRAFFIC_TELEMETRY_RPC_METHOD) {
                 const params = trafficTelemetryRpcParamsSchema.safeParse(parsed.data.params);
@@ -133,6 +159,8 @@ export function createNativeCoreCommandChannel(input) {
                 return;
             }
             disposed = true;
+            unsubscribeViewActivity === null || unsubscribeViewActivity === void 0 ? void 0 : unsubscribeViewActivity();
+            hostActionRpcHandler === null || hostActionRpcHandler === void 0 ? void 0 : hostActionRpcHandler.dispose();
             unsubscribeTransport();
             listeners.clear();
         },

package/dist/native-host-action-rpc.d.ts

@@ -0,0 +1,15 @@
+import type { HostActionDefinition } from "@getuserfeedback/protocol/host";
+import { type RpcRequest } from "@getuserfeedback/protocol/internal/v3-rpc-messages";
+export declare const createNativeHostActionRpcHandler: (input: {
+    generation: number;
+    getHandler: (definition: HostActionDefinition) => (() => void | Promise<void>) | undefined;
+    instanceId: string;
+    isViewActive: (viewId: string) => boolean;
+    now?: () => number;
+    onError?: (error: Error) => void;
+    postToCore: (message: unknown) => void;
+}) => {
+    dispose: () => void;
+    handle: (request: RpcRequest) => boolean;
+    releaseView: (viewId: string) => void;
+};

package/dist/native-host-action-rpc.js

@@ -0,0 +1,180 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { buildFlowActionSucceededV1 } from "@getuserfeedback/protocol";
+import { HOST_ACTION_EXECUTE_RPC_METHOD, HOST_ACTION_SETTLEMENT_AVAILABILITY_RPC_METHOD, toHostActionExecuteParams, } from "@getuserfeedback/protocol/internal/host-action-rpc";
+import { buildEventFlowActionSucceeded } from "@getuserfeedback/protocol/internal/host-core-flow-action-succeeded";
+import { buildRpcResponse, } from "@getuserfeedback/protocol/internal/v3-rpc-messages";
+const isSameExecution = (execution, request, params) => execution.attemptId === request.idemKey &&
+    execution.params.viewId === params.viewId &&
+    execution.params.generation === params.generation &&
+    execution.params.instanceId === params.instanceId &&
+    execution.params.definition.key === params.definition.key &&
+    execution.params.definition.version === params.definition.version;
+export const createNativeHostActionRpcHandler = (input) => {
+    let disposed = false;
+    const executions = new Map();
+    const reportError = (error) => {
+        var _a;
+        try {
+            (_a = input.onError) === null || _a === void 0 ? void 0 : _a.call(input, error instanceof Error ? error : new Error(String(error)));
+        }
+        catch (_b) {
+            // Diagnostics cannot change host action settlement.
+        }
+    };
+    const postToCore = (message) => {
+        try {
+            input.postToCore(message);
+        }
+        catch (error) {
+            reportError(error);
+        }
+    };
+    const respond = (request, outcome) => {
+        postToCore(buildRpcResponse({
+            gen: request.gen,
+            ok: true,
+            result: outcome
+                ? { handled: outcome === "success", outcome }
+                : { handled: false },
+            rpcId: request.rpcId,
+            viewId: request.viewId,
+        }));
+    };
+    return {
+        dispose: () => {
+            disposed = true;
+            for (const execution of executions.values()) {
+                execution.active = false;
+                execution.waiters.splice(0);
+            }
+            executions.clear();
+        },
+        handle: (request) => {
+            var _a;
+            if (request.method === HOST_ACTION_SETTLEMENT_AVAILABILITY_RPC_METHOD) {
+                postToCore(buildRpcResponse({
+                    gen: request.gen,
+                    ok: true,
+                    result: { close: true, link: false, remain: true },
+                    rpcId: request.rpcId,
+                    viewId: request.viewId,
+                }));
+                return true;
+            }
+            if (request.method !== HOST_ACTION_EXECUTE_RPC_METHOD) {
+                return false;
+            }
+            const parsedParams = toHostActionExecuteParams(request.params);
+            const params = parsedParams
+                ? Object.assign(Object.assign({}, parsedParams), { invocationId: (_a = parsedParams.invocationId) !== null && _a !== void 0 ? _a : request.idemKey }) : null;
+            const existing = params ? executions.get(params.invocationId) : undefined;
+            if (params && existing) {
+                if (existing.released || !isSameExecution(existing, request, params)) {
+                    respond(request, null);
+                }
+                else if (existing.outcome) {
+                    respond(request, existing.outcome);
+                }
+                else {
+                    existing.waiters.push(request);
+                }
+                return true;
+            }
+            if (params === null ||
+                params.generation !== input.generation ||
+                params.instanceId !== input.instanceId ||
+                !input.isViewActive(params.viewId)) {
+                respond(request, null);
+                return true;
+            }
+            const { invocationId: _invocationId } = params, boundParams = __rest(params, ["invocationId"]);
+            const execution = {
+                active: true,
+                attemptId: request.idemKey,
+                hasExplicitInvocationId: typeof (parsedParams === null || parsedParams === void 0 ? void 0 : parsedParams.invocationId) === "string",
+                invocationId: params.invocationId,
+                outcome: null,
+                params: Object.assign(Object.assign({}, boundParams), { definition: Object.assign({}, boundParams.definition) }),
+                released: false,
+                started: false,
+                waiters: [request],
+            };
+            executions.set(execution.invocationId, execution);
+            const settle = (outcome) => {
+                var _a;
+                if (disposed || !execution.active || execution.outcome)
+                    return;
+                execution.outcome = outcome;
+                for (const waiter of execution.waiters.splice(0)) {
+                    respond(waiter, outcome);
+                }
+                const seed = execution.params.flowActionSucceededSeed;
+                if (outcome !== "success" ||
+                    seed === undefined ||
+                    !execution.hasExplicitInvocationId)
+                    return;
+                try {
+                    postToCore(buildEventFlowActionSucceeded({
+                        event: buildFlowActionSucceededV1({
+                            actionInvocationId: execution.invocationId,
+                            actionKey: execution.params.definition.key,
+                            actionKind: seed.actionKind,
+                            actionPlacementId: seed.actionPlacementId,
+                            actionVersion: execution.params.definition.version,
+                            flowId: seed.flowId,
+                            flowRunId: seed.flowRunId,
+                            flowSurface: "widget",
+                            flowVersionId: seed.flowVersionId,
+                            flowVersionNumber: seed.flowVersionNumber,
+                        }),
+                        gen: request.gen,
+                        instanceId: execution.params.instanceId,
+                        timestamp: ((_a = input.now) !== null && _a !== void 0 ? _a : Date.now)(),
+                    }));
+                }
+                catch (error) {
+                    reportError(error);
+                }
+            };
+            const handler = input.getHandler(params.definition);
+            if (handler === undefined) {
+                settle("unavailable");
+                return true;
+            }
+            void Promise.resolve()
+                .then(() => {
+                if (!execution.active || !input.isViewActive(params.viewId))
+                    return;
+                execution.started = true;
+                return handler();
+            })
+                .then(() => {
+                if (execution.started)
+                    settle("success");
+            }, () => settle("failure"));
+            return true;
+        },
+        releaseView: (viewId) => {
+            for (const [invocationId, execution] of executions) {
+                if (execution.params.viewId !== viewId)
+                    continue;
+                execution.released = true;
+                execution.waiters.splice(0);
+                if (execution.started || execution.outcome !== null)
+                    continue;
+                execution.active = false;
+                executions.delete(invocationId);
+            }
+        },
+    };
+};

package/dist/native-provider.d.ts

@@ -1,6 +1,6 @@
 import { type ComponentType, type ReactElement, type ReactNode } from "react";
 import type { Client, ClientOptions } from "./client.js";
-export type { Client, ClientOptions, EventOptions, EventProperties, FlowRun, OpenRequestedCallback, OpenRequestedEvent, TrackOptions, } from "./client.js";
+export type { Client, ClientOptions, EventOptions, EventProperties, FlowRun, NativeActionRegistration, OpenRequestedCallback, OpenRequestedEvent, TrackOptions, } from "./client.js";
 export type { UseFlowContainerReturn } from "./flow-container.js";
 export { FlowContent, useFlowContainer } from "./flow-container.js";
 /**

package/dist/native-provider.js

@@ -11,7 +11,8 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import { parseInitOptions } from "@getuserfeedback/protocol";
 import { createUniqueId } from "@getuserfeedback/protocol/host";
-import { createContext, createElement, Fragment, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { createActionRegistry, } from "@getuserfeedback/sdk/internal/action-registry";
+import { createContext, createElement, Fragment, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
 import { NativeStandardFlowContainer } from "./flow-container.js";
 import { NativeFlowContainerContext, } from "./native-flow-container-context.js";
 import { createNativeProviderClientController } from "./native-provider-client-controller.js";
@@ -34,9 +35,33 @@ const toClientOptionsKey = (value) => {
         .join(",")}}`;
 };
 const compareClientOptionsKeys = (left, right) => left < right ? -1 : left > right ? 1 : 0;
-const parseNativeInitOptions = (_a) => {
-    var { capabilities } = _a, clientOptions = __rest(_a, ["capabilities"]);
-    const initOptions = parseInitOptions(Object.assign(Object.assign({}, clientOptions), (capabilities !== undefined
+const haveSameActionRegistrations = (left, right) => left.length === right.length &&
+    left.every((identity, index) => identity === right[index]);
+const useNativeActionRegistry = (actions) => {
+    const nextRegistry = createActionRegistry(actions);
+    if (nextRegistry.getOpenUrlHandler() !== undefined) {
+        throw new TypeError('React Native actions support only registrations with kind "custom"');
+    }
+    const registryRef = useRef(null);
+    const currentRegistry = registryRef.current;
+    if (currentRegistry !== null &&
+        !haveSameActionRegistrations(currentRegistry.listRegistrationIdentities(), nextRegistry.listRegistrationIdentities())) {
+        throw new Error("actions definitions cannot be changed after widget init; keeping original registrations");
+    }
+    if (currentRegistry === null) {
+        registryRef.current = nextRegistry;
+    }
+    useLayoutEffect(() => {
+        registryRef.current = nextRegistry;
+    }, [nextRegistry]);
+    const getHandler = useCallback((definition) => { var _a; return (_a = registryRef.current) === null || _a === void 0 ? void 0 : _a.getHandler(definition); }, []);
+    return { definitions: nextRegistry.listDefinitions(), getHandler };
+};
+const parseNativeInitOptions = (_a, hostActions) => {
+    var { actions: _actions, capabilities } = _a, clientOptions = __rest(_a, ["actions", "capabilities"]);
+    const initOptions = parseInitOptions(Object.assign(Object.assign(Object.assign({}, clientOptions), (hostActions !== undefined && hostActions.length > 0
+        ? { hostActions }
+        : {})), (capabilities !== undefined
         ? {
             hostCapabilities: capabilities.map((capability) => typeof capability === "string"
                 ? { key: capability }
@@ -64,7 +89,8 @@ export function GetUserFeedbackProvider({ children, clientOptions, instanceId: i
     const [contentOwner, setContentOwner] = useState(null);
     const [projection, setProjection] = useState(null);
     const contentOwnerRef = useRef(null);
-    const normalizedClientOptions = parseNativeInitOptions(clientOptions);
+    const actionRegistry = useNativeActionRegistry(clientOptions.actions);
+    const normalizedClientOptions = parseNativeInitOptions(clientOptions, actionRegistry.definitions);
     const clientOptionsKey = toClientOptionsKey(normalizedClientOptions);
     const coreUrl = (_b = (_a = normalizedClientOptions.runtimeEndpoints) === null || _a === void 0 ? void 0 : _a.coreUrl) !== null && _b !== void 0 ? _b : REACT_NATIVE_PINNED_CORE_URL;
     const onErrorRef = useRef(onError);
@@ -143,6 +169,7 @@ export function GetUserFeedbackProvider({ children, clientOptions, instanceId: i
         instanceId,
         key: clientOptionsKey,
         getRuntimeConfiguration,
+        getHostActionHandler: actionRegistry.getHandler,
         onCommandSessionChange: handleCommandSessionChange,
         onError: reportError,
         onHandleInvalidated: handleHandleInvalidated,

package/dist/native-runtime-root.d.ts

@@ -1,6 +1,7 @@
 import type { CoreCommandEnvelope } from "@getuserfeedback/protocol";
 import type { EventHandleInvalidated } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
 import type { ConfigureOptions, InitOptions } from "@getuserfeedback/sdk";
+import type { ActionRegistry } from "@getuserfeedback/sdk/internal/action-registry";
 import type { OpenRequestDispatcher } from "@getuserfeedback/sdk/internal/open-request-dispatcher";
 import { type ReactElement } from "react";
 import { type CoreWebViewHostProps } from "./core-webview-host.js";
@@ -12,6 +13,10 @@ export type NativeRuntimeRootProps = {
     coreUrl: string;
     coreWebViewComponent?: CoreWebViewHostProps["webViewComponent"];
     createStartupCommand?: () => NativeRuntimeInitCommand;
+    hostActions?: {
+        getHandler: ActionRegistry["getHandler"];
+        instanceId: string;
+    };
     onCommandSessionChange?: (session: NativeCoreCommandSession | null) => void;
     onError?: (error: Error) => void;
     onHandleInvalidated?: (message: EventHandleInvalidated) => void;
@@ -34,8 +39,9 @@ type NativeProviderRuntimeProps = Omit<NativeRuntimeRootProps, "createStartupCom
     initOptions: InitOptions;
     instanceId: string;
     getRuntimeConfiguration?: () => ConfigureOptions;
+    getHostActionHandler?: ActionRegistry["getHandler"];
     onCommandSessionChange?: (session: NativeDirectCommandSession | null) => void;
 };
-export declare function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewComponent, createStartupCommand, onCommandSessionChange, onError, onHandleInvalidated, onInvalidMessage, observeOpenRequest, onStartupTerminalError, startupCommandSettlementTimeoutMs, viewNativeViewComponent, viewWebViewComponent, }: NativeRuntimeRootProps): ReactElement;
-export declare function NativeProviderRuntime({ directSessionController, getRuntimeConfiguration, initOptions, instanceId, onCommandSessionChange, onError, ...runtimeProps }: NativeProviderRuntimeProps): ReactElement;
+export declare function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewComponent, createStartupCommand, hostActions, onCommandSessionChange, onError, onHandleInvalidated, onInvalidMessage, observeOpenRequest, onStartupTerminalError, startupCommandSettlementTimeoutMs, viewNativeViewComponent, viewWebViewComponent, }: NativeRuntimeRootProps): ReactElement;
+export declare function NativeProviderRuntime({ directSessionController, getHostActionHandler, getRuntimeConfiguration, initOptions, instanceId, onCommandSessionChange, onError, ...runtimeProps }: NativeProviderRuntimeProps): ReactElement;
 export {};

package/dist/native-runtime-root.js

@@ -20,7 +20,7 @@ import { createNativeViewRecordController, } from "./native-view-record-controll
 import { createProviderCommandEnvelope, REACT_NATIVE_CLIENT_META, } from "./provider-command-helpers.js";
 const DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS = 30000;
 const getEmptyRuntimeConfiguration = () => ({});
-export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewComponent, createStartupCommand, onCommandSessionChange, onError, onHandleInvalidated, onInvalidMessage, observeOpenRequest, onStartupTerminalError, startupCommandSettlementTimeoutMs = DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS, viewNativeViewComponent, viewWebViewComponent, }) {
+export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewComponent, createStartupCommand, hostActions, onCommandSessionChange, onError, onHandleInvalidated, onInvalidMessage, observeOpenRequest, onStartupTerminalError, startupCommandSettlementTimeoutMs = DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS, viewNativeViewComponent, viewWebViewComponent, }) {
     const [coreHostRevision, setCoreHostRevision] = useState(0);
     const [session, setSession] = useState(null);
     const sessionRef = useRef(null);
@@ -40,6 +40,8 @@ export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewCo
     onStartupTerminalErrorRef.current = onStartupTerminalError;
     const createStartupCommandRef = useRef(createStartupCommand);
     createStartupCommandRef.current = createStartupCommand;
+    const hostActionsRef = useRef(hostActions);
+    hostActionsRef.current = hostActions;
     const reportError = useCallback((error) => {
         var _a;
         try {
@@ -87,6 +89,18 @@ export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewCo
         });
         const commandChannelOwner = createNativeCoreCommandChannel({
             coreConnection,
+            hostActions: hostActionsRef.current
+                ? {
+                    getHandler: (definition) => { var _a; return (_a = hostActionsRef.current) === null || _a === void 0 ? void 0 : _a.getHandler(definition); },
+                    getActiveViewIds: () => controller
+                        .getSnapshot()
+                        .filter((record) => record.isActive)
+                        .map((record) => record.viewId),
+                    instanceId: hostActionsRef.current.instanceId,
+                    subscribeToViewActivity: controller.subscribe,
+                }
+                : undefined,
+            onHostActionError: reportError,
             onSessionFailure: (error) => {
                 reportError(error);
                 coreConnection.disconnect();
@@ -243,7 +257,7 @@ export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewCo
         }));
 }
 export function NativeProviderRuntime(_a) {
-    var { directSessionController, getRuntimeConfiguration = getEmptyRuntimeConfiguration, initOptions, instanceId, onCommandSessionChange, onError } = _a, runtimeProps = __rest(_a, ["directSessionController", "getRuntimeConfiguration", "initOptions", "instanceId", "onCommandSessionChange", "onError"]);
+    var { directSessionController, getHostActionHandler, getRuntimeConfiguration = getEmptyRuntimeConfiguration, initOptions, instanceId, onCommandSessionChange, onError } = _a, runtimeProps = __rest(_a, ["directSessionController", "getHostActionHandler", "getRuntimeConfiguration", "initOptions", "instanceId", "onCommandSessionChange", "onError"]);
     const directSessionRef = useRef(null);
     useLayoutEffect(() => {
         directSessionController.beginAttachmentAttempt();
@@ -282,5 +296,7 @@ export function NativeProviderRuntime(_a) {
             instanceId,
         });
     }, [getRuntimeConfiguration, initOptions, instanceId]);
-    return createElement(NativeRuntimeRoot, Object.assign(Object.assign({}, runtimeProps), { onCommandSessionChange: handleCommandSessionChange, onError, onStartupTerminalError: handleStartupTerminalError, createStartupCommand }));
+    return createElement(NativeRuntimeRoot, Object.assign(Object.assign({}, runtimeProps), { hostActions: getHostActionHandler
+            ? { getHandler: getHostActionHandler, instanceId }
+            : undefined, onCommandSessionChange: handleCommandSessionChange, onError, onStartupTerminalError: handleStartupTerminalError, createStartupCommand }));
 }

package/dist/version.js

@@ -3,4 +3,4 @@ const reactNativeSdkVersion = typeof __GX_REACT_NATIVE_SDK_VERSION__ === "string
     : "";
 // Build scripts patch this fallback to the package version for published artifacts.
 // Source-linked workspace usage keeps the local fallback.
-export const REACT_NATIVE_SDK_VERSION = reactNativeSdkVersion.length > 0 ? reactNativeSdkVersion : "5.4.0";
+export const REACT_NATIVE_SDK_VERSION = reactNativeSdkVersion.length > 0 ? reactNativeSdkVersion : "5.5.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "5.4.0",
+  "version": "5.5.1",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^5.4.0",
-    "@getuserfeedback/sdk": "^0.16.2",
+    "@getuserfeedback/protocol": "^5.4.1",
+    "@getuserfeedback/sdk": "^0.17.1",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {