@getuserfeedback/react-native 5.3.4 → 5.5.0

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import type { AppEventExternalId, PublicCommandPayload } from "@getuserfeedback/protocol";
-import type { CapabilitiesInput, ConfigureOptions, EventOptions, EventProperties, GraphOperations, InitOptions } from "@getuserfeedback/sdk";
-export type { EventOptions, EventProperties, TrackOptions, } 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, {
     kind: "open";
@@ -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;
 };
@@ -65,6 +71,22 @@ export interface Client {
     flow: (flowId: string) => FlowRun;
     /** Closes every open flow owned by this provider. */
     close: () => Promise<void>;
+    /**
+     * Subscribe to explicit SDK and client-side targeting open requests, or
+     * suppress them, for example when the user should not be interrupted.
+     * Prevention applies only to that presentation attempt; it does not create a
+     * public retry schedule.
+     *
+     * @example Suppress open requests while the user is busy
+     * ```ts
+     * client.onOpenRequested((event) => {
+     *   if (userIsBusy()) {
+     *     event.preventDefault();
+     *   }
+     * });
+     * ```
+     */
+    onOpenRequested: (callback: OpenRequestedCallback) => () => void;
     /** Resets widget state, authentication, and the current user identity. */
     reset: (options?: CommandOptions) => Promise<void>;
     /** Updates app navigation and environment context used by targeting. */

package/dist/core-webview-bridge-adapter.js

@@ -1,4 +1,4 @@
-import { CORE_HOST_BOOTSTRAP_GLOBAL_KEY, CORE_HOST_BOOTSTRAP_PROTOCOL_VERSION, CORE_HOST_BOOTSTRAP_READY_EVENT_NAME, CORE_HOST_BOOTSTRAP_REQUIRED_FRAGMENT, } from "@getuserfeedback/protocol/internal/core-host-bootstrap";
+import { CORE_HOST_BOOTSTRAP_GLOBAL_KEY, CORE_HOST_BOOTSTRAP_PROTOCOL_VERSION, CORE_HOST_BOOTSTRAP_READY_EVENT_NAME, CORE_HOST_BOOTSTRAP_REQUIRED_FRAGMENT, } from "@getuserfeedback/protocol/internal/core-host-bootstrap-v3";
 import { parseWebViewConnectionBridgeMessage, } from "./webview-connection-bridge-message.js";
 import { buildWebViewConnectionBridgeScript, } from "./webview-connection-bridge-script.js";
 import { buildWebViewConnectionHostMessageScript, serializeForJavaScript, } from "./webview-connection-host-message-script.js";

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-client-controller.d.ts

@@ -1,5 +1,6 @@
 import type { EventHandleInvalidated } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
 import type { ConfigureOptions } from "@getuserfeedback/sdk";
+import { type OpenRequestDispatcher } from "@getuserfeedback/sdk/internal/open-request-dispatcher";
 export declare function createNativeProviderClientController(input: {
     instanceId: string;
     onError?: (error: Error) => void;
@@ -7,6 +8,7 @@ export declare function createNativeProviderClientController(input: {
     client: import("./client.js").Client;
     directSessionController: import("./native-direct-command-session-controller.js").NativeDirectCommandSessionController;
     getRuntimeConfiguration: () => ConfigureOptions;
+    observeOpenRequest: (payload: Parameters<OpenRequestDispatcher["dispatch"]>[0]) => ReturnType<OpenRequestDispatcher["dispatch"]>;
     dispose: () => void;
     onHandleInvalidated: (message: EventHandleInvalidated) => void;
     onSessionEnded: () => void;

package/dist/native-provider-client-controller.js

@@ -1,4 +1,5 @@
 import { parsePublicCommand } from "@getuserfeedback/protocol";
+import { createOpenRequestDispatcher, } from "@getuserfeedback/sdk/internal/open-request-dispatcher";
 import { createNativeProviderClient, parseRequiredString, } from "./native-provider-client.js";
 import { createNativeProviderCommandController } from "./native-provider-command-controller.js";
 import { createNativeProviderFlowRegistry } from "./native-provider-flow-registry.js";
@@ -14,6 +15,19 @@ export function createNativeProviderClientController(input) {
     const commands = createNativeProviderCommandController(input);
     const flows = createNativeProviderFlowRegistry(commands);
     const session = commands.directSessionController;
+    const openRequestDispatcher = createOpenRequestDispatcher();
+    const reportOpenRequestObserverError = (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) {
+            // Error observers cannot become open-request authority.
+        }
+    };
+    const observeOpenRequest = (payload) => openRequestDispatcher.dispatch(payload, {
+        onListenerError: reportOpenRequestObserverError,
+    });
     const client = createNativeProviderClient({
         dispatchCommand: async (command, options) => {
             if (command.kind === "close" || command.kind === "reset") {
@@ -37,11 +51,13 @@ export function createNativeProviderClientController(input) {
         },
         flow: (flowId) => flows.flow(parseRequiredString("flowId", flowId)),
         instanceId: input.instanceId,
+        openRequestDispatcher,
     });
     return {
         client,
         directSessionController: session,
         getRuntimeConfiguration: () => (Object.assign({}, runtimeConfiguration)),
+        observeOpenRequest,
         dispose: () => {
             flows.reset();
             commands.dispose();

package/dist/native-provider-client.d.ts

@@ -1,4 +1,5 @@
 import type { PublicCommandPayload } from "@getuserfeedback/protocol";
+import { type OpenRequestDispatcher } from "@getuserfeedback/sdk/internal/open-request-dispatcher";
 import type { Client } from "./client.js";
 type NativeProviderClientCommand = Extract<PublicCommandPayload, {
     kind: "configure" | "identify" | "track" | "close" | "reset" | "updateHostContext" | "emitHostSignal";
@@ -8,7 +9,8 @@ type NativeProviderClientOptions = {
     dispatchCommand: (command: NativeProviderClientCommand, options?: NativeProviderCommandOptions) => Promise<void>;
     flow: Client["flow"];
     instanceId: string;
+    openRequestDispatcher?: OpenRequestDispatcher;
 };
 export declare const parseRequiredString: (name: string, value?: string) => string;
-export declare function createNativeProviderClient({ dispatchCommand, flow, instanceId, }: NativeProviderClientOptions): Client;
+export declare function createNativeProviderClient({ dispatchCommand, flow, instanceId, openRequestDispatcher, }: NativeProviderClientOptions): Client;
 export {};

package/dist/native-provider-client.js

@@ -1,5 +1,6 @@
 import { assertNoSegmentExternalIdsInValueArgument } from "@getuserfeedback/protocol/host";
 import { buildCustomerOccurrenceCommand } from "@getuserfeedback/sdk/internal/customer-occurrence-command";
+import { createOpenRequestDispatcher, } from "@getuserfeedback/sdk/internal/open-request-dispatcher";
 export const parseRequiredString = (name, value) => {
     const normalized = value === null || value === void 0 ? void 0 : value.trim();
     if (!normalized) {
@@ -34,7 +35,7 @@ const toIdentifyCommandPayload = (identifyInput, traitsOrOptions, options) => {
         options: options !== null && options !== void 0 ? options : traitsOrOptions,
     };
 };
-export function createNativeProviderClient({ dispatchCommand, flow, instanceId, }) {
+export function createNativeProviderClient({ dispatchCommand, flow, instanceId, openRequestDispatcher = createOpenRequestDispatcher(), }) {
     const track = (eventName, properties, options) => {
         return dispatchCommand(buildCustomerOccurrenceCommand({
             type: "track",
@@ -61,6 +62,7 @@ export function createNativeProviderClient({ dispatchCommand, flow, instanceId,
         },
         flow,
         close: () => dispatchCommand({ kind: "close" }),
+        onOpenRequested: openRequestDispatcher.subscribe,
         reset: (options) => dispatchCommand({ kind: "reset" }, options),
         updateHostContext: (context, options) => dispatchCommand({ kind: "updateHostContext", context }, options),
         emitHostSignal: (name, data, options) => dispatchCommand(Object.assign({ kind: "emitHostSignal", name: parseRequiredString("name", name) }, (data === undefined ? {} : { data })), options),

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, 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,9 +169,11 @@ export function GetUserFeedbackProvider({ children, clientOptions, instanceId: i
         instanceId,
         key: clientOptionsKey,
         getRuntimeConfiguration,
+        getHostActionHandler: actionRegistry.getHandler,
         onCommandSessionChange: handleCommandSessionChange,
         onError: reportError,
         onHandleInvalidated: handleHandleInvalidated,
+        observeOpenRequest: controller.observeOpenRequest,
         viewWebViewComponent: webViewComponent,
     }))));
 }

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

@@ -5,4 +5,4 @@
  * docs/specs/2026-08-02-flow-interaction-model.md (Projection protocol and
  * rollout).
  */
-export declare const REACT_NATIVE_PINNED_CORE_URL: "https://cdn.getuserfeedback.com/widget/core/v3/core.html";
+export declare const REACT_NATIVE_PINNED_CORE_URL: "https://cdn.getuserfeedback.com/widget/core/v6/core.html";

package/dist/native-runtime-endpoints.js

@@ -5,4 +5,4 @@
  * docs/specs/2026-08-02-flow-interaction-model.md (Projection protocol and
  * rollout).
  */
-export const REACT_NATIVE_PINNED_CORE_URL = "https://cdn.getuserfeedback.com/widget/core/v3/core.html";
+export const REACT_NATIVE_PINNED_CORE_URL = "https://cdn.getuserfeedback.com/widget/core/v6/core.html";

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

@@ -1,6 +1,8 @@
 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";
 import { type NativeCoreCommandSession } from "./native-core-command-session.js";
@@ -11,10 +13,15 @@ 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;
     onInvalidMessage?: (error: Error, value: unknown) => void;
+    observeOpenRequest?: (payload: Parameters<OpenRequestDispatcher["dispatch"]>[0]) => ReturnType<OpenRequestDispatcher["dispatch"]>;
     onStartupTerminalError?: (error: Error) => void;
     startupCommandSettlementTimeoutMs?: number;
     attachViewProjection?: (projection: NativeViewProjection) => () => void;
@@ -32,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, 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, 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);
@@ -34,10 +34,14 @@ export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewCo
     onHandleInvalidatedRef.current = onHandleInvalidated;
     const onInvalidMessageRef = useRef(onInvalidMessage);
     onInvalidMessageRef.current = onInvalidMessage;
+    const observeOpenRequestRef = useRef(observeOpenRequest);
+    observeOpenRequestRef.current = observeOpenRequest;
     const onStartupTerminalErrorRef = useRef(onStartupTerminalError);
     onStartupTerminalErrorRef.current = onStartupTerminalError;
     const createStartupCommandRef = useRef(createStartupCommand);
     createStartupCommandRef.current = createStartupCommand;
+    const hostActionsRef = useRef(hostActions);
+    hostActionsRef.current = hostActions;
     const reportError = useCallback((error) => {
         var _a;
         try {
@@ -81,9 +85,22 @@ export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewCo
         const controller = createNativeViewRecordController({
             coreConnection,
             onError: reportError,
+            observeOpenRequest: (payload) => { var _a, _b; return (_b = (_a = observeOpenRequestRef.current) === null || _a === void 0 ? void 0 : _a.call(observeOpenRequestRef, payload)) !== null && _b !== void 0 ? _b : { allowed: true }; },
         });
         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();
@@ -240,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();
@@ -279,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/native-view-record-controller.d.ts

@@ -1,4 +1,5 @@
 import { type EventViewSize } from "@getuserfeedback/protocol/internal/view-host-control-messages";
+import type { OpenRequestDispatcher } from "@getuserfeedback/sdk/internal/open-request-dispatcher";
 import type { CoreWebViewHostConnection } from "./core-webview-host-controller.js";
 import type { ViewWebViewHostConnection } from "./view-webview-host-controller.js";
 type NativeViewSizeReport = Omit<EventViewSize, "gen" | "t" | "viewId">;
@@ -35,8 +36,10 @@ export type NativeViewRecordController = {
     getSnapshot(): readonly NativeViewRecord[];
     subscribe(listener: () => void): () => void;
 };
+type NativeOpenRequestObserver = (payload: Parameters<OpenRequestDispatcher["dispatch"]>[0]) => ReturnType<OpenRequestDispatcher["dispatch"]>;
 export declare function createNativeViewRecordController(input: {
     coreConnection: CoreWebViewHostConnection;
     onError: (error: Error) => void;
+    observeOpenRequest?: NativeOpenRequestObserver;
 }): NativeViewRecordController;
 export {};

package/dist/native-view-record-controller.js

@@ -1,6 +1,6 @@
-import { coreViewHostActionSchema, } from "@getuserfeedback/protocol/internal/core-view-host-actions";
+import { coreViewHostActionSchema, } from "@getuserfeedback/protocol/internal/core-view-host-actions-v3";
 import { actionRequestCloseViewSchema, actionViewConnectSchema, buildEventLayoutTransactionCommitted, buildEventViewSize, eventViewSizeSchema, } from "@getuserfeedback/protocol/internal/view-host-control-messages";
-import { buildEventViewActivated, buildEventViewAllocationFailed, buildEventViewClosed, buildEventViewCloseFailed, buildEventViewPrerendered, } from "@getuserfeedback/protocol/internal/view-host-lifecycle-events";
+import { buildEventViewActivated, buildEventViewActivationDecided, buildEventViewAllocationFailed, buildEventViewClosed, buildEventViewCloseFailed, buildEventViewPrerendered, } from "@getuserfeedback/protocol/internal/view-host-lifecycle-events-v3";
 import { bindViewHostControlEnvelope, bindViewToCoreRelayEnvelope, parseCoreToViewRelayEnvelope, } from "@getuserfeedback/protocol/internal/view-relay-contract";
 import { createViewPreparationReadinessRegistry, createViewPreparationRegistry, } from "./view-orchestration-runtime.js";
 const createNativeViewReadinessRegistry = () => createViewPreparationReadinessRegistry();
@@ -157,6 +157,21 @@ export function createNativeViewRecordController(input) {
             failCoreConnection(error, "Native view close failure delivery failed");
         }
     };
+    const postViewActivationDecision = (action, allowed) => {
+        try {
+            input.coreConnection.transport.postMessage(buildEventViewActivationDecided({
+                gen: action.gen,
+                viewId: action.viewId,
+                activationAttemptId: action.activationAttemptId,
+                allowed,
+            }));
+            return true;
+        }
+        catch (error) {
+            failCoreConnection(error, "Native view activation decision delivery failed");
+            return false;
+        }
+    };
     const failAllocation = (entry, allocationError) => {
         const resourceErrors = [];
         const observerErrors = [];
@@ -255,7 +270,9 @@ export function createNativeViewRecordController(input) {
             failAllocation(entry, error);
         }
     };
+    // Governing contract: docs/specs/2026-08-29-sdk-open-request-interception.md.
     const handleActivate = (action) => {
+        var _a;
         const entry = entries.get(action.viewId);
         if (!entry ||
             entry.instanceId !== action.instanceId ||
@@ -263,6 +280,27 @@ export function createNativeViewRecordController(input) {
             failCoreConnection(new Error(`Unknown native projection binding ${action.viewId}`), "Unknown native projection binding");
             return;
         }
+        let allowed = true;
+        if (((_a = action.openRequest) === null || _a === void 0 ? void 0 : _a.flowId) && input.observeOpenRequest) {
+            const payload = Object.assign({ instanceId: action.instanceId, source: action.openRequest.source, flowId: action.openRequest.flowId }, (action.openRequest.source === "command"
+                ? {
+                    flowHandleId: action.openRequest.flowHandleId,
+                    hideCloseButton: action.openRequest.hideCloseButton,
+                }
+                : {}));
+            try {
+                allowed = input.observeOpenRequest(payload).allowed;
+            }
+            catch (error) {
+                reportError(error, "Native open request observer failed");
+            }
+        }
+        if (!postViewActivationDecision(action, allowed)) {
+            return;
+        }
+        if (!allowed) {
+            return;
+        }
         if (!entry.isActive) {
             entry.isActive = true;
             notify();

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.3.4";
+export const REACT_NATIVE_SDK_VERSION = reactNativeSdkVersion.length > 0 ? reactNativeSdkVersion : "5.5.0";

package/package.json

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