@getuserfeedback/react-native 3.0.58 → 3.0.65

package/dist/index.js

@@ -9,15 +9,14 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementError, CommandSettlementTimeoutError, createFlowCommandHandleController, getFlowHandleFromSettlementDetail, getWidgetLayoutPlanNowMs, REACT_NATIVE_WEBVIEW_TRANSPORT_CAPABILITIES, } from "@getuserfeedback/protocol/host";
+import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementError, CommandSettlementTimeoutError, createFlowCommandHandleController, getFlowHandleFromSettlementDetail, getWidgetLayoutPlanNowMs, } from "@getuserfeedback/protocol/host";
 import { parseWebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useResolvedHostViewport } from "./host-viewport.js";
-import { toCommandSettlementError, toReactNativeOneShotCommand, } from "./provider-command-helpers.js";
+import { createProviderCommandEnvelope, REACT_NATIVE_LOADER_CLIENT_META, toCommandSettlementError, toReactNativeOneShotCommand, } from "./provider-command-helpers.js";
 import { useProviderCommandTransport } from "./provider-command-transport.js";
 import { createProviderWidgetHostLifecycleController, HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY, } from "./provider-widget-host-lifecycle.js";
 import { ProviderWidgetHostOverlay, toProviderWidgetHostStyle, toProviderWidgetSheetHostLayoutPlan, } from "./provider-widget-host-overlay.js";
-import { REACT_NATIVE_SDK_VERSION } from "./version.js";
 import { WidgetHost, } from "./widget-host.js";
 export { REACT_NATIVE_SDK_VERSION } from "./version.js";
 export { buildNativeMessageInjectionScript, buildWebViewBridgeScript, } from "./webview-bridge-script.js";
@@ -122,15 +121,6 @@ const createReactNativeFlowRunController = (flowId, { enqueueFlowCommand, enqueu
         resetIdleHandle,
     };
 };
-const CLIENT_META = {
-    clientName: "@getuserfeedback/react-native",
-    clientVersion: REACT_NATIVE_SDK_VERSION,
-    loader: "sdk",
-    protocolCapabilities: [
-        REACT_NATIVE_WEBVIEW_TRANSPORT_CAPABILITIES.LAYOUT_TRANSITION_POLICY,
-    ],
-    transport: "loader",
-};
 const createUniqueId = (prefix) => {
     if (typeof globalThis.crypto !== "undefined" &&
         typeof globalThis.crypto.randomUUID === "function") {
@@ -138,7 +128,6 @@ const createUniqueId = (prefix) => {
     }
     return `${prefix}_${Date.now()}_${Math.random().toString(16).slice(2)}`;
 };
-const createCommandRequestId = () => createUniqueId("req");
 const createTransportMessageId = () => createUniqueId("native");
 const normalizeOptionalString = (value) => {
     if (value === undefined) {
@@ -265,19 +254,15 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         }, 0);
     }, [onCommandError]);
     const enqueueTransportCommand = useCallback((command, options, { isStartup = false, preserveFlowHandle = false, prioritizeStartup = false, } = {}) => {
-        var _a;
-        const requestId = createCommandRequestId();
-        const idempotencyKey = (_a = normalizeOptionalString(options === null || options === void 0 ? void 0 : options.idempotencyKey)) !== null && _a !== void 0 ? _a : requestId;
-        const envelope = {
-            version: "1",
-            instanceId,
-            requestId,
-            idempotencyKey,
-            clientMeta: CLIENT_META,
+        const envelope = createProviderCommandEnvelope({
+            clientMeta: REACT_NATIVE_LOADER_CLIENT_META,
             command: preserveFlowHandle
                 ? command
                 : toReactNativeOneShotCommand(command),
-        };
+            idempotencyKey: options === null || options === void 0 ? void 0 : options.idempotencyKey,
+            instanceId,
+        });
+        const { requestId } = envelope;
         const message = {
             kind: "enqueueCommand",
             id: createTransportMessageId(),
@@ -321,8 +306,13 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 clearTimeout(pendingCommand.timeout);
                 pendingCommand.timeout = null;
             }
-            const command = pendingCommand.result.envelope.command;
-            const nextEnvelope = Object.assign(Object.assign({}, pendingCommand.result.envelope), { command: toReactNativeOneShotCommand(command), requestId: createCommandRequestId() });
+            const previousEnvelope = pendingCommand.result.envelope;
+            const nextEnvelope = createProviderCommandEnvelope({
+                clientMeta: previousEnvelope.clientMeta,
+                command: toReactNativeOneShotCommand(previousEnvelope.command),
+                idempotencyKey: previousEnvelope.idempotencyKey,
+                instanceId: previousEnvelope.instanceId,
+            });
             const nextMessage = parseWebViewTransportNativeMessage({
                 kind: "enqueueCommand",
                 id: createTransportMessageId(),

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

@@ -0,0 +1,14 @@
+import { type CoreCommandEnvelope } from "@getuserfeedback/protocol";
+import { type CommandSettledDetail } from "@getuserfeedback/protocol/host";
+import type { NativeCoreCommandChannel } from "./native-core-command-channel.js";
+export type NativeCoreCommandSession = {
+    dispatch: (envelope: CoreCommandEnvelope) => Promise<CommandSettledDetail>;
+};
+type NativeCoreCommandSessionOwner = {
+    dispose: () => void;
+    session: NativeCoreCommandSession;
+};
+export declare function createNativeCoreCommandSession(input: {
+    channel: NativeCoreCommandChannel;
+}): NativeCoreCommandSessionOwner;
+export {};

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

@@ -0,0 +1,61 @@
+import { coreCommandEnvelopeSchema, } from "@getuserfeedback/protocol";
+import { toCommandSettlementError, } from "@getuserfeedback/protocol/host";
+import { createPendingCommandTracker } from "./view-orchestration-runtime.js";
+class NativeCoreCommandSessionClosedError extends Error {
+    constructor(requestId) {
+        super("Native core command session closed before settlement");
+        this.name = "NativeCoreCommandSessionClosedError";
+        this.requestId = requestId;
+    }
+}
+function toCommandSettledDetail(settlement) {
+    var _a, _b;
+    if (settlement.ok) {
+        return Object.assign({ instanceId: (_a = settlement.instanceId) !== null && _a !== void 0 ? _a : null, kind: settlement.kind, ok: true, requestId: settlement.requestId }, (settlement.result === undefined ? {} : { result: settlement.result }));
+    }
+    return {
+        error: settlement.error,
+        instanceId: (_b = settlement.instanceId) !== null && _b !== void 0 ? _b : null,
+        kind: settlement.kind,
+        ok: false,
+        requestId: settlement.requestId,
+    };
+}
+export function createNativeCoreCommandSession(input) {
+    const pendingCommands = createPendingCommandTracker();
+    let disposed = false;
+    const unsubscribe = input.channel.subscribe((settlement) => {
+        const detail = toCommandSettledDetail(settlement);
+        if (detail.ok) {
+            pendingCommands.resolve(detail.requestId, detail);
+            return;
+        }
+        pendingCommands.reject(detail.requestId, toCommandSettlementError(detail));
+    });
+    return {
+        session: {
+            dispatch: async (envelope) => {
+                if (disposed) {
+                    return Promise.reject(new Error("Native core command session is closed"));
+                }
+                const canonicalEnvelope = coreCommandEnvelopeSchema.parse(envelope);
+                const settlement = pendingCommands.waitFor(canonicalEnvelope.requestId);
+                try {
+                    input.channel.post(canonicalEnvelope);
+                }
+                catch (error) {
+                    pendingCommands.reject(canonicalEnvelope.requestId, error instanceof Error ? error : new Error(String(error)));
+                }
+                return settlement;
+            },
+        },
+        dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            unsubscribe();
+            pendingCommands.reset((requestId) => new NativeCoreCommandSessionClosedError(requestId));
+        },
+    };
+}

package/dist/native-direct-command-session.d.ts

@@ -0,0 +1,27 @@
+import type { CommandEnvelopeWithInstanceId, CommandSettledDetail } from "@getuserfeedback/protocol/host";
+import { type CoreTranslatablePublicCommandPayload } from "@getuserfeedback/protocol/internal/public-core-command";
+import type { NativeCoreCommandSession } from "./native-core-command-session.js";
+type FlowLifecycleCommandPayload = Extract<CoreTranslatablePublicCommandPayload, {
+    kind: "open" | "prefetch" | "prerender" | "close";
+}>;
+/** Public commands that can be sent directly to the settled native core session. */
+type NativeDirectCommandPayload = Exclude<CoreTranslatablePublicCommandPayload, FlowLifecycleCommandPayload | {
+    kind: "init";
+}>;
+/** Public command envelope accepted by the direct native provider session. */
+export type NativeDirectCommandEnvelope = Omit<CommandEnvelopeWithInstanceId, "command"> & {
+    command: NativeDirectCommandPayload;
+};
+export type NativeDirectCommandSession = {
+    dispatch: (envelope: NativeDirectCommandEnvelope) => Promise<CommandSettledDetail>;
+};
+/**
+ * Adapt direct public commands to the already-settled native core session.
+ *
+ * Flow lifecycle and container commands stay outside this adapter until their
+ * shared orchestration contract is ready.
+ */
+export declare function createNativeDirectCommandSession(input: {
+    coreSession: NativeCoreCommandSession;
+}): NativeDirectCommandSession;
+export {};

package/dist/native-direct-command-session.js

@@ -0,0 +1,15 @@
+import { toCoreCommandPayload, } from "@getuserfeedback/protocol/internal/public-core-command";
+/**
+ * Adapt direct public commands to the already-settled native core session.
+ *
+ * Flow lifecycle and container commands stay outside this adapter until their
+ * shared orchestration contract is ready.
+ */
+export function createNativeDirectCommandSession(input) {
+    return {
+        dispatch: (envelope) => {
+            const coreEnvelope = Object.assign(Object.assign({}, envelope), { command: toCoreCommandPayload(envelope.command) });
+            return input.coreSession.dispatch(coreEnvelope);
+        },
+    };
+}

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

@@ -1,16 +1,19 @@
 import type { CoreCommandEnvelope } from "@getuserfeedback/protocol";
+import type { InitOptions } from "@getuserfeedback/sdk";
 import { type ReactElement } from "react";
 import { type CoreWebViewHostProps } from "./core-webview-host.js";
-import { type NativeCoreCommandChannel } from "./native-core-command-channel.js";
+import { type NativeCoreCommandSession } from "./native-core-command-session.js";
+import { type NativeDirectCommandSession } from "./native-direct-command-session.js";
 import { type NativeViewHostProjectionProps } from "./native-view-host-projection.js";
 export type NativeRuntimeRootProps = {
     coreUrl: string;
     coreWebViewComponent?: CoreWebViewHostProps["webViewComponent"];
     coreWebViewProps?: CoreWebViewHostProps["webViewProps"];
     instanceRegistrationEnvelope?: NativeRuntimeInstanceRegistrationEnvelope;
-    onCommandChannelChange?: (channel: NativeCoreCommandChannel | null) => void;
+    onCommandSessionChange?: (session: NativeCoreCommandSession | null) => void;
     onError?: (error: Error) => void;
     onInvalidMessage?: (error: Error, value: unknown) => void;
+    registrationSettlementTimeoutMs?: number;
     viewWebViewComponent?: NativeViewHostProjectionProps["webViewComponent"];
     viewWebViewProps?: NativeViewHostProjectionProps["webViewProps"];
 };
@@ -19,5 +22,11 @@ type NativeRuntimeInstanceRegistrationEnvelope = Omit<CoreCommandEnvelope, "comm
         kind: "init";
     }>;
 };
-export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, instanceRegistrationEnvelope, onCommandChannelChange, onError, onInvalidMessage, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;
+type NativeProviderRuntimeProps = Omit<NativeRuntimeRootProps, "instanceRegistrationEnvelope" | "onCommandSessionChange"> & {
+    initOptions: InitOptions;
+    instanceId: string;
+    onCommandSessionChange?: (session: NativeDirectCommandSession | null) => void;
+};
+export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, instanceRegistrationEnvelope, onCommandSessionChange, onError, onInvalidMessage, registrationSettlementTimeoutMs, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;
+export declare function NativeProviderRuntime({ initOptions, instanceId, onCommandSessionChange, ...runtimeProps }: NativeProviderRuntimeProps): ReactElement;
 export {};

package/dist/native-runtime-root.js

@@ -1,11 +1,39 @@
-import { createElement, Fragment, useCallback, useEffect, useRef, useState, } from "react";
+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 { CommandSettlementError, CommandSettlementTimeoutError, } from "@getuserfeedback/protocol/host";
+import { createElement, Fragment, useCallback, useEffect, useMemo, useRef, useState, } from "react";
 import { CoreWebViewHost, } from "./core-webview-host.js";
-import { createNativeCoreCommandChannel, } from "./native-core-command-channel.js";
+import { createNativeCoreCommandChannel } from "./native-core-command-channel.js";
+import { createNativeCoreCommandSession, } from "./native-core-command-session.js";
+import { createNativeDirectCommandSession, } from "./native-direct-command-session.js";
 import { NativeViewHostProjection, } from "./native-view-host-projection.js";
 import { createNativeViewRecordController, } from "./native-view-record-controller.js";
-// TODO(architecture): Compose provider-owned startup state with the private native runtime without changing the default loader-backed path.
-// [from=protocol-owned-native-command-bootstrap-routing] [to=provider-owned-native-registration-composition] [scope=slice] [principle=preserve-provider-runtime] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=80]
-export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, instanceRegistrationEnvelope, onCommandChannelChange, onError, onInvalidMessage, viewWebViewComponent, viewWebViewProps, }) {
+import { createProviderCommandEnvelope, REACT_NATIVE_CLIENT_META, } from "./provider-command-helpers.js";
+const DEFAULT_REGISTRATION_SETTLEMENT_TIMEOUT_MS = 30000;
+function dispatchRegistration(input) {
+    let timeoutId;
+    const timeout = new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => reject(new CommandSettlementTimeoutError(input.envelope.requestId)), Math.max(0, input.timeoutMs));
+    });
+    return Promise.race([
+        input.commandSession.dispatch(input.envelope).then(() => undefined),
+        timeout,
+    ]).finally(() => {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+    });
+}
+export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, instanceRegistrationEnvelope, onCommandSessionChange, onError, onInvalidMessage, registrationSettlementTimeoutMs = DEFAULT_REGISTRATION_SETTLEMENT_TIMEOUT_MS, viewWebViewComponent, viewWebViewProps, }) {
     const [coreHostRevision, setCoreHostRevision] = useState(0);
     const [session, setSession] = useState(null);
     const sessionRef = useRef(null);
@@ -13,8 +41,8 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
     const registrationRetryAttemptedRef = useRef(false);
     const onErrorRef = useRef(onError);
     onErrorRef.current = onError;
-    const onCommandChannelChangeRef = useRef(onCommandChannelChange);
-    onCommandChannelChangeRef.current = onCommandChannelChange;
+    const onCommandSessionChangeRef = useRef(onCommandSessionChange);
+    onCommandSessionChangeRef.current = onCommandSessionChange;
     const onInvalidMessageRef = useRef(onInvalidMessage);
     onInvalidMessageRef.current = onInvalidMessage;
     const instanceRegistrationEnvelopeRef = useRef(instanceRegistrationEnvelope);
@@ -28,9 +56,9 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
             // Error observers cannot change native runtime settlement.
         }
     }, []);
-    const notifyCommandChannelObserver = useCallback((observer, channel) => {
+    const notifyCommandSessionObserver = useCallback((observer, commandSession) => {
         try {
-            observer === null || observer === void 0 ? void 0 : observer(channel);
+            observer === null || observer === void 0 ? void 0 : observer(commandSession);
         }
         catch (error) {
             reportError(error);
@@ -40,10 +68,13 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
         const previousSession = sessionRef.current;
         if (previousSession) {
             sessionRef.current = null;
+            previousSession.commandSessionOwner.dispose();
             previousSession.commandChannelOwner.dispose();
             previousSession.controller.dispose();
             setSession(null);
-            notifyCommandChannelObserver(previousSession.observer, null);
+            if (previousSession.ready) {
+                notifyCommandSessionObserver(previousSession.commandSessionObserver, null);
+            }
         }
         const controller = createNativeViewRecordController({
             coreConnection,
@@ -53,64 +84,99 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
             coreConnection,
             onInvalidMessage: (error, value) => { var _a; return (_a = onInvalidMessageRef.current) === null || _a === void 0 ? void 0 : _a.call(onInvalidMessageRef, error, value); },
         });
+        const commandSessionOwner = createNativeCoreCommandSession({
+            channel: commandChannelOwner.channel,
+        });
         const nextSession = {
             commandChannelOwner,
+            commandSessionOwner,
             controller,
+            commandSessionObserver: onCommandSessionChangeRef.current,
             key: nextSessionKeyRef.current + 1,
-            observer: onCommandChannelChangeRef.current,
+            ready: false,
+        };
+        sessionRef.current = nextSession;
+        const commitSession = () => {
+            if (sessionRef.current !== nextSession) {
+                return;
+            }
+            registrationRetryAttemptedRef.current = false;
+            nextSession.ready = true;
+            nextSessionKeyRef.current = nextSession.key;
+            setSession(nextSession);
+            notifyCommandSessionObserver(nextSession.commandSessionObserver, commandSessionOwner.session);
         };
         const registrationEnvelope = instanceRegistrationEnvelopeRef.current;
         if (registrationEnvelope) {
-            try {
-                commandChannelOwner.channel.post(registrationEnvelope);
-            }
-            catch (error) {
+            void dispatchRegistration({
+                commandSession: commandSessionOwner.session,
+                envelope: registrationEnvelope,
+                timeoutMs: registrationSettlementTimeoutMs,
+            })
+                .then(commitSession)
+                .catch((error) => {
+                if (sessionRef.current !== nextSession) {
+                    return;
+                }
+                sessionRef.current = null;
+                commandSessionOwner.dispose();
                 commandChannelOwner.dispose();
                 controller.dispose();
-                if (!registrationRetryAttemptedRef.current) {
+                if (!(error instanceof CommandSettlementError) &&
+                    !registrationRetryAttemptedRef.current) {
                     registrationRetryAttemptedRef.current = true;
                     setCoreHostRevision((revision) => revision + 1);
                 }
                 reportError(error);
-                return;
-            }
+            });
+            return;
         }
-        registrationRetryAttemptedRef.current = false;
-        nextSessionKeyRef.current = nextSession.key;
-        sessionRef.current = nextSession;
-        setSession(nextSession);
-        notifyCommandChannelObserver(nextSession.observer, commandChannelOwner.channel);
-    }, [notifyCommandChannelObserver, reportError]);
+        commitSession();
+    }, [
+        notifyCommandSessionObserver,
+        registrationSettlementTimeoutMs,
+        reportError,
+    ]);
     const handleDisconnected = useCallback(() => {
         const currentSession = sessionRef.current;
         if (!currentSession) {
             return;
         }
         sessionRef.current = null;
+        currentSession.commandSessionOwner.dispose();
         currentSession.commandChannelOwner.dispose();
         currentSession.controller.dispose();
         setSession(null);
-        notifyCommandChannelObserver(currentSession.observer, null);
-    }, [notifyCommandChannelObserver]);
+        if (currentSession.ready) {
+            notifyCommandSessionObserver(currentSession.commandSessionObserver, null);
+        }
+    }, [notifyCommandSessionObserver]);
     useEffect(() => {
         const currentSession = sessionRef.current;
-        if (!currentSession || currentSession.observer === onCommandChannelChange) {
+        if (!currentSession ||
+            currentSession.commandSessionObserver === onCommandSessionChange) {
+            return;
+        }
+        const previousObserver = currentSession.commandSessionObserver;
+        currentSession.commandSessionObserver = onCommandSessionChange;
+        if (!currentSession.ready) {
             return;
         }
-        const previousObserver = currentSession.observer;
-        currentSession.observer = onCommandChannelChange;
-        notifyCommandChannelObserver(previousObserver, null);
-        notifyCommandChannelObserver(onCommandChannelChange, currentSession.commandChannelOwner.channel);
-    }, [notifyCommandChannelObserver, onCommandChannelChange]);
+        notifyCommandSessionObserver(previousObserver, null);
+        notifyCommandSessionObserver(onCommandSessionChange, currentSession.commandSessionOwner.session);
+    }, [notifyCommandSessionObserver, onCommandSessionChange]);
     useEffect(() => () => {
         const currentSession = sessionRef.current;
         sessionRef.current = null;
         if (currentSession) {
+            currentSession.commandSessionOwner.dispose();
             currentSession.commandChannelOwner.dispose();
             currentSession.controller.dispose();
-            notifyCommandChannelObserver(currentSession.observer, null);
+            if (currentSession.ready) {
+                notifyCommandSessionObserver(currentSession.commandSessionObserver, null);
+            }
         }
-    }, [notifyCommandChannelObserver]);
+    }, [notifyCommandSessionObserver]);
     return createElement(Fragment, null, createElement(CoreWebViewHost, {
         coreUrl,
         key: `${coreUrl}:${coreHostRevision}`,
@@ -129,3 +195,19 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
             webViewProps: viewWebViewProps,
         }));
 }
+// TODO(architecture): Extract the host-neutral flow-command seam from loader before attaching flow lifecycle commands here; keep direct commands on the settled core session.
+// [from=provider-owned-native-direct-command-routing] [to=shared-flow-command-orchestration] [scope=slice] [principle=core-owned-flow-lifecycle] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=120]
+export function NativeProviderRuntime(_a) {
+    var { initOptions, instanceId, onCommandSessionChange } = _a, runtimeProps = __rest(_a, ["initOptions", "instanceId", "onCommandSessionChange"]);
+    const handleCommandSessionChange = useCallback((session) => {
+        onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(session === null
+            ? null
+            : createNativeDirectCommandSession({ coreSession: session }));
+    }, [onCommandSessionChange]);
+    const instanceRegistrationEnvelope = useMemo(() => createProviderCommandEnvelope({
+        clientMeta: REACT_NATIVE_CLIENT_META,
+        command: { kind: "init", opts: initOptions },
+        instanceId,
+    }), [initOptions, instanceId]);
+    return createElement(NativeRuntimeRoot, Object.assign(Object.assign({}, runtimeProps), { instanceRegistrationEnvelope, onCommandSessionChange: handleCommandSessionChange }));
+}

package/dist/provider-command-helpers.d.ts

@@ -1,6 +1,25 @@
+import type { ClientMeta } from "@getuserfeedback/protocol";
 import { CommandSettlementError } from "@getuserfeedback/protocol/host";
 import type { WebViewCommandEnvelope, WebViewTransportHostEvent } from "@getuserfeedback/protocol/webview-transport";
 type ReactNativeWidgetCommand = WebViewCommandEnvelope["command"];
+type ReactNativeInitCommand = Extract<ReactNativeWidgetCommand, {
+    kind: "init";
+}>;
+export declare const REACT_NATIVE_CLIENT_META: ClientMeta;
+export declare const REACT_NATIVE_LOADER_CLIENT_META: ClientMeta;
+type CreateProviderCommandEnvelopeInput = {
+    clientMeta?: ClientMeta;
+    command: ReactNativeWidgetCommand;
+    idempotencyKey?: string;
+    instanceId: string;
+    requestId?: string;
+};
+export declare function createProviderCommandEnvelope(input: CreateProviderCommandEnvelopeInput & {
+    command: ReactNativeInitCommand;
+}): Omit<WebViewCommandEnvelope, "command"> & {
+    command: ReactNativeInitCommand;
+};
+export declare function createProviderCommandEnvelope(input: CreateProviderCommandEnvelopeInput): WebViewCommandEnvelope;
 export type CommandSettledEvent = Extract<WebViewTransportHostEvent, {
     name: "instance:command:settled";
 }>;

package/dist/provider-command-helpers.js

@@ -9,7 +9,28 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { CommandSettlementError } from "@getuserfeedback/protocol/host";
+import { CommandSettlementError, createCommandEnvelopeWithInstanceId, REACT_NATIVE_WEBVIEW_TRANSPORT_CAPABILITIES, } from "@getuserfeedback/protocol/host";
+import { REACT_NATIVE_SDK_VERSION } from "./version.js";
+export const REACT_NATIVE_CLIENT_META = {
+    clientName: "@getuserfeedback/react-native",
+    clientVersion: REACT_NATIVE_SDK_VERSION,
+    loader: "sdk",
+    protocolCapabilities: [
+        REACT_NATIVE_WEBVIEW_TRANSPORT_CAPABILITIES.LAYOUT_TRANSITION_POLICY,
+    ],
+};
+export const REACT_NATIVE_LOADER_CLIENT_META = Object.assign(Object.assign({}, REACT_NATIVE_CLIENT_META), { transport: "loader" });
+export function createProviderCommandEnvelope({ clientMeta, command, idempotencyKey, instanceId, requestId, }) {
+    const resolvedCommand = command.kind === "init" && clientMeta !== undefined
+        ? Object.assign(Object.assign({}, command), { opts: Object.assign(Object.assign({}, command.opts), { clientMeta }) }) : command;
+    return createCommandEnvelopeWithInstanceId({
+        clientMeta,
+        command: resolvedCommand,
+        idempotencyKey,
+        instanceId,
+        requestId,
+    });
+}
 function isReactNativeFlowCommand(command) {
     return (command.kind === "open" ||
         command.kind === "prefetch" ||

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

package/dist/view-orchestration-runtime.js

@@ -32,6 +32,57 @@ function createActiveViewSnapshotListController() {
     }
   };
 }
+// ../view-orchestration/src/pending-command-tracker.ts
+var createDeferred = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((nextResolve, nextReject) => {
+    resolve = nextResolve;
+    reject = nextReject;
+  });
+  return { promise, resolve, reject };
+};
+
+class PendingCommandTracker {
+  pendingByRequestId = new Map;
+  waitFor(requestId) {
+    if (this.pendingByRequestId.has(requestId)) {
+      throw new Error(`Duplicate pending command requestId: "${requestId}"`);
+    }
+    const deferred = createDeferred();
+    this.pendingByRequestId.set(requestId, deferred);
+    return deferred.promise;
+  }
+  resolve(requestId, value) {
+    const deferred = this.pendingByRequestId.get(requestId);
+    if (!deferred) {
+      return false;
+    }
+    this.pendingByRequestId.delete(requestId);
+    deferred.resolve(value);
+    return true;
+  }
+  reject(requestId, error) {
+    const deferred = this.pendingByRequestId.get(requestId);
+    if (!deferred) {
+      return false;
+    }
+    this.pendingByRequestId.delete(requestId);
+    deferred.reject(error);
+    return true;
+  }
+  reset(createError) {
+    for (const requestId of this.pendingByRequestId.keys()) {
+      this.reject(requestId, createError(requestId));
+    }
+  }
+  has(requestId) {
+    return this.pendingByRequestId.has(requestId);
+  }
+  size() {
+    return this.pendingByRequestId.size;
+  }
+}
 // ../view-orchestration/src/view-activation-machine.ts
 import { createMachine, interpret, state, transition } from "robot3";
 var VIEW_ACTIVATION_STATES = {
@@ -212,6 +263,9 @@ function createViewPreparationRegistry() {
   };
 }
 // src/view-orchestration-runtime.ts
+function createPendingCommandTracker() {
+  return new PendingCommandTracker;
+}
 function createActiveViewSnapshotListController2() {
   return createActiveViewSnapshotListController();
 }
@@ -228,5 +282,6 @@ export {
   createViewPreparationRegistry2 as createViewPreparationRegistry,
   createViewPreparationReadinessRegistry2 as createViewPreparationReadinessRegistry,
   createViewActivationController2 as createViewActivationController,
+  createPendingCommandTracker,
   createActiveViewSnapshotListController2 as createActiveViewSnapshotListController
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "3.0.58",
+  "version": "3.0.65",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.16.0",
-    "@getuserfeedback/sdk": "^0.10.20",
+    "@getuserfeedback/protocol": "^3.17.2",
+    "@getuserfeedback/sdk": "^0.11.2",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {