@getuserfeedback/react-native 5.14.2 → 5.15.3

package/README.md

@@ -45,6 +45,22 @@ export function App() {
 
 That is enough to receive flows published for automatic Widget delivery.
 
+## Native color scheme
+
+For flows using the native renderer, set `clientOptions.colorScheme` to
+`"light"`, `"dark"`, or `"system"`. Omitted values and browser auto-detect
+objects follow the device appearance on native (light when unavailable).
+
+Scheme-only prop changes and `client.configure({ colorScheme: "dark" })`
+repaint the SDK's default native palette without restarting the flow or
+clearing its draft. An unchanged prop does not override a later configure call.
+The selection belongs to that client: runtime recreation retains it, while a
+replacement client (for example, a new API key) starts from its initial prop.
+Native repaint does not wait for Core: configure still forwards to Core and
+retains its existing promise/error behavior, but remote failure does not roll
+back native appearance. WebView flows keep their existing scheme forwarding
+and browser auto-detection behavior. This does not add a style override API.
+
 - [React Native SDK guide](https://getuserfeedback.com/docs/get-started/react-native-sdk)
 - [React Native SDK reference](https://getuserfeedback.com/docs/reference/react-native-sdk-reference)
 - [Package versions](https://www.npmjs.com/package/@getuserfeedback/react-native?activeTab=versions)

package/dist/native-color-scheme.d.ts

@@ -0,0 +1,31 @@
+export declare const NativeColorSchemeContext: import("react").Context<import("@getuserfeedback/protocol/host").ColorSchemeConfig | undefined>;
+export declare function useNativeColorScheme(): {
+    scheme: "dark" | "light";
+    palette: {
+        background: string;
+        text: string;
+        muted: string;
+        input: string;
+        border: string;
+        placeholder: string;
+        button: string;
+        buttonText: string;
+        accent: string;
+        disabled: string;
+        disabledText: string;
+        error: string;
+    } | {
+        background: string;
+        text: string;
+        muted: string;
+        input: string;
+        border: string;
+        placeholder: string;
+        button: string;
+        buttonText: string;
+        accent: string;
+        disabled: string;
+        disabledText: string;
+        error: string;
+    };
+};

package/dist/native-color-scheme.js

@@ -0,0 +1,44 @@
+import { createContext, useContext } from "react";
+// Host-local presentation only; never the acknowledged Core configuration.
+export const NativeColorSchemeContext = createContext(undefined);
+const palettes = {
+    light: {
+        background: "#ffffff",
+        text: "#17202a",
+        muted: "#475569",
+        input: "#ffffff",
+        border: "#64748b",
+        placeholder: "#64748b",
+        button: "#e7eefb",
+        buttonText: "#17202a",
+        accent: "#2563eb",
+        disabled: "#e5e7eb",
+        disabledText: "#4b5563",
+        error: "#aa0000",
+    },
+    dark: {
+        background: "#111827",
+        text: "#f3f4f6",
+        muted: "#cbd5e1",
+        input: "#1f2937",
+        border: "#94a3b8",
+        placeholder: "#94a3b8",
+        button: "#1e3a5f",
+        buttonText: "#f8fafc",
+        accent: "#93c5fd",
+        disabled: "#374151",
+        disabledText: "#cbd5e1",
+        error: "#fca5a5",
+    },
+};
+export function useNativeColorScheme() {
+    const requested = useContext(NativeColorSchemeContext);
+    const device = require("react-native").useColorScheme();
+    // Browser auto-detection has no DOM on native; use the device preference.
+    const scheme = requested === "light" || requested === "dark"
+        ? requested
+        : device === "dark"
+            ? "dark"
+            : "light";
+    return { scheme, palette: palettes[scheme] };
+}

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

@@ -12,7 +12,15 @@ class NativeCoreCommandSessionClosedError extends Error {
 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 }));
+        const detail = {
+            instanceId: (_a = settlement.instanceId) !== null && _a !== void 0 ? _a : null,
+            kind: settlement.kind,
+            ok: true,
+            requestId: settlement.requestId,
+        };
+        if (settlement.result !== undefined)
+            detail.result = settlement.result;
+        return detail;
     }
     return {
         error: settlement.error,

package/dist/native-flow-content.d.ts

@@ -0,0 +1,8 @@
+import type { NativeViewPresentationMode } from "./native-view-presentation-surface.js";
+import type { NativeViewRecord, NativeViewRecordController } from "./native-view-record-controller.js";
+/** Thin native editor: drafts only. Core owns validation, navigation and submission. */
+export declare function NativeFlowContent({ controller, presentationMode, record, }: {
+    controller: NativeViewRecordController;
+    presentationMode?: NativeViewPresentationMode;
+    record: NativeViewRecord;
+}): import("react").ReactElement<Record<string, unknown>, string | import("react").JSXElementConstructor<any>>;

package/dist/native-flow-content.js

@@ -0,0 +1,188 @@
+import { createElement, useLayoutEffect, useRef, useState, } from "react";
+import { useNativeColorScheme } from "./native-color-scheme.js";
+/** Thin native editor: drafts only. Core owns validation, navigation and submission. */
+export function NativeFlowContent({ controller, presentationMode = "overlay", record, }) {
+    const flow = record.nativeFlow;
+    if (!flow)
+        throw new Error("Native content requires a native allocation");
+    const { projection, interaction } = flow;
+    const { View, Text, TextInput, Pressable, ScrollView, useWindowDimensions, } = require("react-native");
+    const { height: windowHeight } = useWindowDimensions();
+    const { scheme, palette } = useNativeColorScheme();
+    const [draft, setDraft] = useState(projection.answers);
+    const rawDraft = useRef(draft);
+    const scroll = useRef(null);
+    const editorPage = useRef({
+        allocationId: record.allocationId,
+        nodeId: projection.nodeId,
+    });
+    const binding = useRef(null);
+    useLayoutEffect(() => {
+        const mounted = controller.attachNativeContent({
+            viewId: record.viewId,
+            allocationId: record.allocationId,
+        });
+        binding.current = mounted;
+        return () => {
+            binding.current = null;
+            mounted === null || mounted === void 0 ? void 0 : mounted.dispose();
+        };
+    }, [controller, record.viewId, record.allocationId]);
+    useLayoutEffect(() => {
+        var _a;
+        if (editorPage.current.allocationId === record.allocationId &&
+            editorPage.current.nodeId === projection.nodeId)
+            return;
+        editorPage.current = {
+            allocationId: record.allocationId,
+            nodeId: projection.nodeId,
+        };
+        rawDraft.current = projection.answers;
+        setDraft(projection.answers);
+        (_a = scroll.current) === null || _a === void 0 ? void 0 : _a.scrollTo({ x: 0, y: 0, animated: false });
+    }, [projection, record.allocationId]);
+    const update = (key, value) => {
+        const nextDraft = Object.assign(Object.assign({}, rawDraft.current), { [key]: value });
+        if (!controller.interactNativeFlow({
+            viewId: record.viewId,
+            allocationId: record.allocationId,
+            projection,
+            intent: "draft",
+            draft: nextDraft,
+        }))
+            return;
+        rawDraft.current = nextDraft;
+        setDraft(rawDraft.current);
+    };
+    const interact = (intent) => controller.interactNativeFlow({
+        viewId: record.viewId,
+        allocationId: record.allocationId,
+        projection,
+        intent,
+        draft: Object.assign({}, rawDraft.current),
+    });
+    const disabled = interaction === "action" || !record.isActive;
+    const button = (label, onPress, buttonDisabled = interaction !== "idle" || !record.isActive) => createElement(Pressable, {
+        key: label,
+        accessibilityRole: "button",
+        accessibilityLabel: label,
+        disabled: buttonDisabled,
+        onPress,
+        style: {
+            padding: 12,
+            backgroundColor: buttonDisabled ? palette.disabled : palette.button,
+            borderRadius: 6,
+            marginTop: 8,
+        },
+    }, createElement(Text, {
+        style: {
+            color: buttonDisabled ? palette.disabledText : palette.buttonText,
+        },
+    }, label));
+    return createElement(ScrollView, {
+        ref: scroll,
+        style: Object.assign(Object.assign({}, (presentationMode === "content"
+            ? { flexGrow: 0, flexShrink: 1, maxHeight: windowHeight }
+            : { flex: 1, maxHeight: "100%" })), { width: "100%", backgroundColor: palette.background }),
+        keyboardShouldPersistTaps: "handled",
+        nestedScrollEnabled: presentationMode === "content",
+        // Report the actual viewport, never the window ceiling or inner content.
+        // Content mode can measure before its auto-height parent has any height.
+        onLayout: (event) => { var _a; return (_a = binding.current) === null || _a === void 0 ? void 0 : _a.onLayout(event.nativeEvent.layout); },
+    }, createElement(View, {
+        testID: "native-flow-renderer",
+        style: { padding: 24, gap: 12 },
+    }, projection.mode === "simulated"
+        ? createElement(Text, {
+            testID: "native-flow-simulated",
+            style: { color: palette.muted },
+        }, "SIMULATED — no response is saved")
+        : null, ...projection.blocks.map((block) => {
+        var _a;
+        if (block.kind === "statement")
+            return createElement(View, { key: block.key }, ...block.paragraphs.map((text, index) => createElement(Text, { key: index, style: { color: palette.text } }, text)));
+        const value = draft[block.key];
+        const requiredLabel = block.required ? ", required" : "";
+        const selected = Array.isArray(value)
+            ? ((_a = value[0]) !== null && _a !== void 0 ? _a : "")
+            : (value !== null && value !== void 0 ? value : "");
+        return createElement(View, { key: block.key, style: { gap: 6 } }, createElement(Text, { style: { color: palette.text } }, block.label + (block.required ? " *" : "")), block.description
+            ? createElement(Text, { style: { color: palette.muted } }, block.description)
+            : null, block.kind === "text"
+            ? createElement(TextInput, {
+                accessibilityLabel: block.label + requiredLabel,
+                accessibilityHint: block.description,
+                value: selected,
+                placeholder: block.placeholder,
+                placeholderTextColor: palette.placeholder,
+                keyboardAppearance: scheme,
+                selectionColor: palette.accent,
+                cursorColor: palette.accent,
+                editable: !disabled,
+                maxLength: 4000,
+                onChangeText: (text) => update(block.key, text),
+                style: {
+                    color: disabled ? palette.disabledText : palette.text,
+                    backgroundColor: disabled ? palette.disabled : palette.input,
+                    borderWidth: 1,
+                    borderColor: palette.border,
+                    borderRadius: 4,
+                    padding: 10,
+                },
+            })
+            : createElement(View, {
+                accessibilityRole: "radiogroup",
+                accessibilityLabel: block.label + requiredLabel,
+                accessibilityHint: block.description,
+                accessible: false,
+            }, ...block.options.map((option) => createElement(Pressable, {
+                key: option.value,
+                accessibilityRole: "radio",
+                accessibilityLabel: `${block.label}: ${option.label}${requiredLabel}`,
+                accessibilityHint: block.description,
+                accessible: true,
+                accessibilityState: {
+                    checked: selected === option.value,
+                    disabled,
+                },
+                disabled,
+                onPress: () => update(block.key, option.value),
+                style: { padding: 10 },
+            }, createElement(Text, {
+                style: {
+                    color: disabled ? palette.disabledText : palette.text,
+                },
+            }, `${selected === option.value ? "●" : "○"} ${option.label}`)))), projection.errors[block.key]
+            ? createElement(Text, { accessibilityRole: "alert", style: { color: palette.error } }, projection.errors[block.key])
+            : null);
+    }), ...projection.formErrors.map((text, index) => createElement(Text, {
+        key: `error-${index}`,
+        accessibilityRole: "alert",
+        style: { color: palette.error },
+    }, text)), ...projection.terminal.map((text, index) => createElement(Text, { key: `terminal-${index}`, style: { color: palette.text } }, text)), projection.status === "succeeded" &&
+        (projection.mode === "simulated" || projection.terminal.length === 0)
+        ? createElement(Text, { testID: "native-flow-complete", style: { color: palette.text } }, projection.mode === "simulated"
+            ? "SIMULATED completion — nothing saved"
+            : "Thank you")
+        : null, projection.canGoBack ? button("Back", () => interact("back")) : null, interaction === "draft-failed"
+        ? button("Retry refresh", () => interact("draft"), !record.isActive)
+        : null, projection.status !== "succeeded"
+        ? button(interaction === "action"
+            ? "Working…"
+            : projection.status === "ready-to-submit"
+                ? "Submit"
+                : "Continue", () => interact(projection.status === "ready-to-submit" ? "submit" : "continue"))
+        : null, projection.canClose
+        ? createElement(Pressable, {
+            accessibilityRole: "button",
+            accessibilityLabel: "Close",
+            disabled: !record.isActive,
+            onPress: () => controller.closeNativeFlow(record),
+            style: { padding: 12 },
+        }, createElement(Text, {
+            style: {
+                color: !record.isActive ? palette.disabledText : palette.text,
+            },
+        }, "Close"))
+        : null));
+}

package/dist/native-link-router-rpc.js

@@ -138,7 +138,11 @@ export const createNativeLinkRouterRpcHandler = (input) => {
             }
             let handled = false;
             try {
-                invokeLinkRouter(router, Object.assign({ url: params.url }, (params.target === undefined ? {} : { target: params.target })));
+                const linkRequest = { url: params.url };
+                if (params.target !== undefined) {
+                    linkRequest.target = params.target;
+                }
+                invokeLinkRouter(router, linkRequest);
                 handled = true;
             }
             catch (error) {

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

@@ -4,10 +4,13 @@ import { type OpenRequestDispatcher } from "@getuserfeedback/sdk/internal/open-r
 export declare function createNativeProviderClientController(input: {
     instanceId: string;
     onError?: (error: Error) => void;
+    initialColorScheme?: ConfigureOptions["colorScheme"];
 }): {
     client: import("./client.js").Client;
     directSessionController: import("./native-direct-command-session-controller.js").NativeDirectCommandSessionController;
     flowRegistry: import("./native-provider-flow-registry.js").NativeProviderFlowRegistry;
+    getNativeColorScheme: () => import("@getuserfeedback/protocol/host").ColorSchemeConfig | undefined;
+    subscribeNativeColorScheme: (listener: () => void) => () => void;
     getRuntimeConfiguration: () => ConfigureOptions;
     observeOpenRequest: (payload: Parameters<OpenRequestDispatcher["dispatch"]>[0]) => ReturnType<OpenRequestDispatcher["dispatch"]>;
     dispose: () => void;

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

@@ -4,6 +4,9 @@ import { createNativeProviderClient, parseRequiredString, } from "./native-provi
 import { createNativeProviderCommandController } from "./native-provider-command-controller.js";
 import { createNativeProviderFlowRegistry } from "./native-provider-flow-registry.js";
 export function createNativeProviderClientController(input) {
+    // Presentation belongs to this client, independently of Core acknowledgement.
+    let nativeColorScheme = input.initialColorScheme;
+    const colorSchemeListeners = new Set();
     let runtimeConfiguration = {};
     const updateRuntimeConfiguration = (updates) => {
         runtimeConfiguration = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, runtimeConfiguration), (updates.auth === undefined ? {} : { auth: updates.auth })), (updates.capabilities === undefined
@@ -44,7 +47,15 @@ export function createNativeProviderClientController(input) {
             catch (error) {
                 return commands.reject(error);
             }
-            const settlement = await commands.runOperation((dispatch) => dispatch(canonicalCommand), options);
+            const settlement = await commands.runOperation((dispatch) => {
+                if (canonicalCommand.kind === "configure" &&
+                    canonicalCommand.opts.colorScheme !== undefined) {
+                    nativeColorScheme = canonicalCommand.opts.colorScheme;
+                    for (const listener of colorSchemeListeners)
+                        listener();
+                }
+                return dispatch(canonicalCommand);
+            }, options);
             if (canonicalCommand.kind === "configure" && settlement !== undefined) {
                 updateRuntimeConfiguration(canonicalCommand.opts);
             }
@@ -57,9 +68,17 @@ export function createNativeProviderClientController(input) {
         client,
         directSessionController: session,
         flowRegistry: flows,
+        getNativeColorScheme: () => nativeColorScheme,
+        subscribeNativeColorScheme: (listener) => {
+            colorSchemeListeners.add(listener);
+            return () => {
+                colorSchemeListeners.delete(listener);
+            };
+        },
         getRuntimeConfiguration: () => (Object.assign({}, runtimeConfiguration)),
         observeOpenRequest,
         dispose: () => {
+            colorSchemeListeners.clear();
             flows.reset();
             commands.dispose();
         },

package/dist/native-provider.js

@@ -9,12 +9,13 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { parseInitOptions } from "@getuserfeedback/protocol";
+import { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS, parseInitOptions, } from "@getuserfeedback/protocol";
 import { createUniqueId } from "@getuserfeedback/protocol/host";
 import { createActionRegistry, } from "@getuserfeedback/sdk/internal/action-registry";
 import { resolveLinkRouter } from "@getuserfeedback/sdk/internal/link-router";
-import { createContext, createElement, Fragment, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { createContext, createElement, Fragment, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from "react";
 import { NativeStandardFlowContainer } from "./flow-container.js";
+import { NativeColorSchemeContext } from "./native-color-scheme.js";
 import { NativeFlowContainerContext, } from "./native-flow-container-context.js";
 import { createNativeProviderClientController } from "./native-provider-client-controller.js";
 import { REACT_NATIVE_PINNED_CORE_URL } from "./native-runtime-endpoints.js";
@@ -87,15 +88,17 @@ const toInitFlags = (flags) => {
 const parseNativeInitOptions = (_a, hostActions) => {
     var { actions: _actions, capabilities, flags, links: _links } = _a, clientOptions = __rest(_a, ["actions", "capabilities", "flags", "links"]);
     const normalizedFlags = toInitFlags(flags);
-    const initOptions = parseInitOptions(Object.assign(Object.assign(Object.assign(Object.assign({}, clientOptions), (normalizedFlags === undefined ? {} : { flags: normalizedFlags })), (hostActions !== undefined && hostActions.length > 0
-        ? { hostActions }
-        : {})), (capabilities !== undefined
-        ? {
-            hostCapabilities: capabilities.map((capability) => typeof capability === "string"
-                ? { key: capability }
-                : Object.assign({}, capability)),
-        }
-        : {})));
+    const initInput = Object.assign({}, clientOptions);
+    if (normalizedFlags !== undefined) {
+        initInput.flags = normalizedFlags;
+    }
+    if (hostActions !== undefined && hostActions.length > 0) {
+        initInput.hostActions = hostActions;
+    }
+    if (capabilities !== undefined) {
+        initInput.hostCapabilities = capabilities.map((capability) => typeof capability === "string" ? { key: capability } : Object.assign({}, capability));
+    }
+    const initOptions = parseInitOptions(initInput);
     const hostCapabilities = initOptions.hostCapabilities;
     const normalizedHostCapabilities = hostCapabilities === null || hostCapabilities === void 0 ? void 0 : hostCapabilities.map((capability) => ({
         capability,
@@ -121,7 +124,9 @@ export function GetUserFeedbackProvider({ children, clientOptions, instanceId: i
     const actionRegistry = useNativeActionRegistry(clientOptions.actions);
     const linkRouter = useNativeLinkRouter(clientOptions.links);
     const normalizedClientOptions = parseNativeInitOptions(clientOptions, actionRegistry.definitions);
-    const clientOptionsKey = toClientOptionsKey(normalizedClientOptions);
+    const { colorScheme } = normalizedClientOptions, runtimeIdentityOptions = __rest(normalizedClientOptions, ["colorScheme"]);
+    const clientOptionsKey = toClientOptionsKey(runtimeIdentityOptions);
+    const colorSchemePropKey = toClientOptionsKey(colorScheme);
     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);
     onErrorRef.current = onError;
@@ -138,14 +143,40 @@ export function GetUserFeedbackProvider({ children, clientOptions, instanceId: i
         apiKey: normalizedClientOptions.apiKey,
         hostCapabilities: normalizedClientOptions.hostCapabilities,
     });
-    const controllerOwner = useMemo(() => ({
+    const createControllerOwner = () => ({
         identityKey: clientIdentityKey,
+        colorSchemePropKey,
         controller: createNativeProviderClientController({
             instanceId,
             onError: reportError,
+            initialColorScheme: colorScheme,
         }),
-    }), [clientIdentityKey, instanceId, reportError]);
+    });
+    let [controllerOwner, setControllerOwner] = useState(createControllerOwner);
+    // Initialize the whole owner together, before committing a replacement client.
+    // Scheme-only prop changes update that owner without replacing it.
+    if (controllerOwner.identityKey !== clientIdentityKey) {
+        controllerOwner = createControllerOwner();
+        setControllerOwner(controllerOwner);
+    }
     const controller = controllerOwner.controller;
+    const hostColorScheme = useSyncExternalStore(controller.subscribeNativeColorScheme, controller.getNativeColorScheme, controller.getNativeColorScheme);
+    useLayoutEffect(() => {
+        if (controllerOwner.colorSchemePropKey === colorSchemePropKey)
+            return;
+        controllerOwner.colorSchemePropKey = colorSchemePropKey;
+        // Prop changes share configure's forwarding path, not runtime identity.
+        // Unchanged props must not undo a later imperative configure.
+        void controller.client
+            .configure({
+            colorScheme: colorScheme !== null && colorScheme !== void 0 ? colorScheme : {
+                autoDetectColorScheme: [...DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS],
+            },
+        })
+            .catch(() => {
+            // The controller reports remote failures; local appearance is retained.
+        });
+    }, [colorScheme, colorSchemePropKey, controller, controllerOwner]);
     const attachViewProjection = useCallback((nextProjection) => {
         setProjection(nextProjection);
         return () => setProjection((current) => current === nextProjection ? null : current);
@@ -197,7 +228,7 @@ export function GetUserFeedbackProvider({ children, clientOptions, instanceId: i
     }, [controller]);
     const getRuntimeConfiguration = useCallback(() => controller.getRuntimeConfiguration(), [controller]);
     const handleHandleInvalidated = useCallback((message) => controller.onHandleInvalidated(message), [controller]);
-    return createElement(GetUserFeedbackContext.Provider, { value: controller.client }, createElement(NativeFlowContainerContext.Provider, { value: flowContainerContext }, createElement(Fragment, null, children, createElement(NativeStandardFlowContainer), createElement(NativeProviderRuntime, {
+    return createElement(NativeColorSchemeContext.Provider, { value: hostColorScheme }, createElement(GetUserFeedbackContext.Provider, { value: controller.client }, createElement(NativeFlowContainerContext.Provider, { value: flowContainerContext }, createElement(Fragment, null, children, createElement(NativeStandardFlowContainer), createElement(NativeProviderRuntime, {
         attachViewProjection,
         coreUrl,
         coreWebViewComponent: webViewComponent,
@@ -213,7 +244,7 @@ export function GetUserFeedbackProvider({ children, clientOptions, instanceId: i
         onHandleInvalidated: handleHandleInvalidated,
         observeOpenRequest: controller.observeOpenRequest,
         viewWebViewComponent: webViewComponent,
-    }))));
+    })))));
 }
 /**
  * Returns the React Native SDK client from the nearest provider.

package/dist/native-runtime-root.js

@@ -40,7 +40,9 @@ export function NativeRuntimeRoot({ attachViewProjection, coreUrl, coreWebViewCo
     const onStartupTerminalErrorRef = useRef(onStartupTerminalError);
     onStartupTerminalErrorRef.current = onStartupTerminalError;
     const createStartupCommandRef = useRef(createStartupCommand);
-    createStartupCommandRef.current = createStartupCommand;
+    useLayoutEffect(() => {
+        createStartupCommandRef.current = createStartupCommand;
+    }, [createStartupCommand]);
     const hostActionsRef = useRef(hostActions);
     hostActionsRef.current = hostActions;
     const linkRouterRef = useRef(linkRouter);

package/dist/native-view-host-projection.d.ts

@@ -11,9 +11,10 @@ export type NativeViewHostProjectionProps = {
 export type NativeViewProjection = Readonly<Omit<NativeViewHostProjectionProps, "presentationMode"> & {
     key: number;
 }>;
-export declare function NativeProjectedViewContent({ controller, onInvalidMessage, record, webViewComponent, }: {
+export declare function NativeProjectedViewContent({ controller, onInvalidMessage, presentationMode, record, webViewComponent, }: {
     controller: NativeViewRecordController;
     onInvalidMessage?: (error: Error, value: unknown) => void;
+    presentationMode?: NativeViewPresentationMode;
     record: NativeViewRecord;
     webViewComponent?: ComponentType<Record<string, unknown>>;
 }): ReactElement;

package/dist/native-view-host-projection.js

@@ -1,7 +1,8 @@
 import { createElement, Fragment, useCallback, useEffect, useLayoutEffect, useRef, useSyncExternalStore, } from "react";
+import { NativeFlowContent } from "./native-flow-content.js";
 import { NativeViewPresentationSurface } from "./native-view-presentation-surface.js";
 import { ViewWebViewHost } from "./view-webview-host.js";
-export function NativeProjectedViewContent({ controller, onInvalidMessage, record, webViewComponent, }) {
+export function NativeProjectedViewContent({ controller, onInvalidMessage, presentationMode, record, webViewComponent, }) {
     const detachConnectionRef = useRef(null);
     const detachConnection = useCallback(() => {
         const detach = detachConnectionRef.current;
@@ -18,6 +19,12 @@ export function NativeProjectedViewContent({ controller, onInvalidMessage, recor
         }
     }, [controller, record.allocationId]);
     useEffect(() => detachConnection, [detachConnection]);
+    if (record.nativeFlow)
+        return createElement(NativeFlowContent, {
+            controller,
+            record,
+            presentationMode,
+        });
     return createElement(ViewWebViewHost, {
         generation: record.generation,
         onActivationRetryExhausted: (error) => {
@@ -76,6 +83,7 @@ function NativeViewHostProjectionEntry({ controller, nativeViewComponent, onInva
     }, createElement(NativeProjectedViewContent, {
         controller,
         onInvalidMessage,
+        presentationMode,
         record,
         webViewComponent,
     }));

package/dist/native-view-presentation-surface.js

@@ -24,13 +24,24 @@ const CONTENT_HOST_SURFACE_STYLE = {
     maxHeight: "100%",
     maxWidth: "100%",
 };
+const NATIVE_CONTENT_PREPARATION_STYLE = {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    opacity: 0,
+};
+const NATIVE_CONTENT_FRAME_STYLE = {
+    flexShrink: 1,
+    width: "100%",
+};
 const TOP_PLACEMENT_STYLE = {
     justifyContent: "flex-start",
 };
 const BOTTOM_PLACEMENT_STYLE = {
     justifyContent: "flex-end",
 };
-const PREPARING_VIEW_FRAME_STYLE = {
+const FILL_AVAILABLE_BOUNDS_STYLE = {
     height: "100%",
     width: "100%",
 };
@@ -63,9 +74,11 @@ export function NativeViewPresentationSurface({ children, presentationMode = "ov
     var _a;
     const NativeView = nativeViewComponent !== null && nativeViewComponent !== void 0 ? nativeViewComponent : resolveNativeView();
     const isPresented = record.isActive && record.size !== null;
-    const hostStyle = presentationMode === "content" && isPresented
-        ? CONTENT_HOST_SURFACE_STYLE
-        : Object.assign(Object.assign(Object.assign({}, HOST_SURFACE_STYLE), (((_a = record.size) === null || _a === void 0 ? void 0 : _a.placement) === "docked-top"
+    const isNativeContent = presentationMode === "content" && !!record.nativeFlow;
+    const hostStyle = isNativeContent && !isPresented
+        ? NATIVE_CONTENT_PREPARATION_STYLE
+        : presentationMode === "content" && isPresented
+            ? Object.assign(Object.assign({}, CONTENT_HOST_SURFACE_STYLE), (isNativeContent ? NATIVE_CONTENT_FRAME_STYLE : {})) : Object.assign(Object.assign(Object.assign({}, HOST_SURFACE_STYLE), (((_a = record.size) === null || _a === void 0 ? void 0 : _a.placement) === "docked-top"
             ? TOP_PLACEMENT_STYLE
             : BOTTOM_PLACEMENT_STYLE)), (isPresented
             ? PRESENTED_HOST_SURFACE_STYLE
@@ -78,16 +91,20 @@ export function NativeViewPresentationSurface({ children, presentationMode = "ov
         testID: `gx-native-view-presentation-${record.viewId}`,
     }, createElement(NativeViewPresentationFrame, {
         children,
+        isNativeContent,
         nativeViewComponent,
         record,
         transitionSchedule,
     }));
 }
-function NativeViewPresentationFrame({ children, nativeViewComponent, record, transitionSchedule, }) {
+function NativeViewPresentationFrame({ children, isNativeContent, nativeViewComponent, record, transitionSchedule, }) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const NativeView = nativeViewComponent !== null && nativeViewComponent !== void 0 ? nativeViewComponent : resolveNativeView();
     const isPresented = record.isActive && record.size !== null;
-    const hasMeasuredFrame = isPresented || ((_a = record.size) === null || _a === void 0 ? void 0 : _a.layoutTransactionId) !== undefined;
+    // Native size reports describe this frame's viewport, not a content-size
+    // request. Keep it host-relative so a smaller layout cannot cap later growth.
+    const hasMeasuredFrame = !record.nativeFlow &&
+        (isPresented || ((_a = record.size) === null || _a === void 0 ? void 0 : _a.layoutTransactionId) !== undefined);
     const cornerRadii = toNativeWidgetCornerRadii((_b = record.size) === null || _b === void 0 ? void 0 : _b.frameAppearance);
     const shadow = toNativeWidgetFrameShadow(((_d = (_c = record.size) === null || _c === void 0 ? void 0 : _c.frameAppearance) === null || _d === void 0 ? void 0 : _d.kind) === "page"
         ? record.size.frameAppearance.resolvedBoxShadow
@@ -108,9 +125,13 @@ function NativeViewPresentationFrame({ children, nativeViewComponent, record, tr
     };
     const targetStyles = {
         border: Object.assign(Object.assign(Object.assign(Object.assign({}, VIEW_FRAME_BORDER_OVERLAY_STYLE), cornerRadiusStyle), borderStyle), frameOverlayShadowStyle),
-        content: Object.assign(Object.assign({}, VIEW_FRAME_CONTENT_STYLE), cornerRadiusStyle),
+        content: Object.assign(Object.assign({}, (isNativeContent
+            ? { flexShrink: 1, overflow: "hidden" }
+            : VIEW_FRAME_CONTENT_STYLE)), cornerRadiusStyle),
         frame: hasMeasuredFrame
-            ? Object.assign(Object.assign(Object.assign(Object.assign({}, MEASURED_VIEW_FRAME_STYLE), cornerRadiusStyle), frameShadowStyle), { height: (_g = record.size) === null || _g === void 0 ? void 0 : _g.height, width: (_h = record.size) === null || _h === void 0 ? void 0 : _h.width }) : PREPARING_VIEW_FRAME_STYLE,
+            ? Object.assign(Object.assign(Object.assign(Object.assign({}, MEASURED_VIEW_FRAME_STYLE), cornerRadiusStyle), frameShadowStyle), { height: (_g = record.size) === null || _g === void 0 ? void 0 : _g.height, width: (_h = record.size) === null || _h === void 0 ? void 0 : _h.width }) : isNativeContent
+            ? NATIVE_CONTENT_FRAME_STYLE
+            : FILL_AVAILABLE_BOUNDS_STYLE,
     };
     const frame = hasMeasuredFrame && record.size
         ? {

package/dist/native-view-record-controller.d.ts

@@ -1,4 +1,5 @@
 import { type WidgetLayoutTransitionSchedule } from "@getuserfeedback/protocol/host";
+import { type NativeFlowInteraction, type NativeFlowProjection } from "@getuserfeedback/protocol/internal/native-flow-session";
 import type { BrowserNavigationAvailabilityPayload } from "@getuserfeedback/protocol/internal/navigation-rpc";
 import { type EventViewSize } from "@getuserfeedback/protocol/internal/view-host-control-messages";
 import type { OpenRequestDispatcher } from "@getuserfeedback/sdk/internal/open-request-dispatcher";
@@ -8,6 +9,11 @@ type NativeViewSizeReport = Omit<EventViewSize, "gen" | "t" | "viewId"> & {
     transitionSchedule?: WidgetLayoutTransitionSchedule;
 };
 export type NativeViewRecord = Readonly<{
+    nativeFlow?: Readonly<{
+        projection: NativeFlowProjection;
+        interaction: "idle" | "draft" | "action" | "draft-failed";
+        pending: boolean;
+    }>;
     allocationId: number;
     flowId: string | null;
     generation: number;
@@ -18,6 +24,21 @@ export type NativeViewRecord = Readonly<{
     viewId: string;
 }>;
 export type NativeViewRecordController = {
+    attachNativeContent(input: {
+        allocationId: number;
+        viewId: string;
+    }): NativeContentBinding | null;
+    interactNativeFlow(input: {
+        allocationId: number;
+        viewId: string;
+        projection: NativeFlowProjection;
+        intent: NativeFlowInteraction["intent"];
+        draft: NativeFlowInteraction["draft"];
+    }): boolean;
+    closeNativeFlow(input: {
+        allocationId: number;
+        viewId: string;
+    }): void;
     attachViewConnection(input: {
         allocationId: number;
         connection: ViewWebViewHostConnection;
@@ -41,6 +62,13 @@ export type NativeViewRecordController = {
     getSnapshot(): readonly NativeViewRecord[];
     subscribe(listener: () => void): () => void;
 };
+type NativeContentBinding = {
+    onLayout(size: {
+        width: number;
+        height: number;
+    }): void;
+    dispose(): void;
+};
 type NativeOpenRequestObserver = (payload: Parameters<OpenRequestDispatcher["dispatch"]>[0]) => ReturnType<OpenRequestDispatcher["dispatch"]>;
 export declare function createNativeViewRecordController(input: {
     coreConnection: CoreWebViewHostConnection;

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

@@ -1,9 +1,29 @@
 import { createWidgetLayoutTransitionSchedule, } from "@getuserfeedback/protocol/host";
 import { coreViewHostActionSchema, } from "@getuserfeedback/protocol/internal/core-view-host-actions-v3";
+import { actionPrerenderNativeFlowSchema, NATIVE_FLOW_SESSION_RPC_METHOD, nativeFlowInteractionSchema, nativeFlowProjectionSchema, } from "@getuserfeedback/protocol/internal/native-flow-session";
+import { createGeneration } from "@getuserfeedback/protocol/internal/v3-generation";
+import { buildRpcRequest, rpcRequestSchema, rpcResponseSchema, } from "@getuserfeedback/protocol/internal/v3-rpc-messages";
 import { actionRequestCloseViewSchema, actionViewConnectSchema, buildEventLayoutTransactionCommitted, buildEventViewSize, eventViewSizeSchema, } from "@getuserfeedback/protocol/internal/view-host-control-messages";
 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";
+// RPC IDs are UUIDs, unlike command IDs whose non-WebCrypto fallback is prefixed.
+// This is live request correlation, not an authentication token.
+function createNativeInteractionRpcId() {
+    var _a, _b;
+    if (typeof ((_a = globalThis.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === "function")
+        return globalThis.crypto.randomUUID();
+    const bytes = new Uint8Array(16);
+    if (typeof ((_b = globalThis.crypto) === null || _b === void 0 ? void 0 : _b.getRandomValues) === "function")
+        globalThis.crypto.getRandomValues(bytes);
+    else
+        for (let index = 0; index < bytes.length; index++)
+            bytes[index] = Math.floor(Math.random() * 256);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
 const createNativeViewReadinessRegistry = () => createViewPreparationReadinessRegistry();
 class NativeViewCleanupError extends Error {
     constructor(resourceErrors, observerErrors, viewId) {
@@ -63,6 +83,10 @@ export function createNativeViewRecordController(input) {
         if (entries.get(entry.viewId) !== entry) {
             return false;
         }
+        if (entry.nativeInteraction &&
+            entry.nativeInteraction.kind !== "draft-failed")
+            clearTimeout(entry.nativeInteraction.timeout);
+        entry.nativeInteraction = undefined;
         const detachViewConnection = entry.viewConnectionDetach;
         const resourceErrors = [];
         const observerErrors = [];
@@ -226,11 +250,18 @@ export function createNativeViewRecordController(input) {
     const handlePrerender = (action) => {
         var _a;
         var _b;
+        const srcdoc = action.t === "getuserfeedback:action:prerenderView" ? action.srcdoc : "";
+        if (srcdoc === undefined) {
+            failCoreConnection(new Error("Native prerenderView requires srcdoc; hosted URLs are unsupported"), "Unsupported native view document source");
+            return;
+        }
         const existing = entries.get(action.viewId);
         if (existing) {
             if (existing.generation !== action.gen ||
                 existing.instanceId !== action.instanceId ||
-                existing.flowRunId !== action.flowRunId) {
+                existing.flowRunId !== action.flowRunId ||
+                !!existing.nativeProjection !==
+                    (action.t === "getuserfeedback:action:prerenderNativeFlow")) {
                 failCoreConnection(new Error(`Conflicting native projection binding ${action.viewId}`), "Conflicting native projection binding");
             }
             return;
@@ -240,31 +271,11 @@ export function createNativeViewRecordController(input) {
             return;
         }
         nextAllocationId += 1;
-        const entry = {
-            allocationId: nextAllocationId,
-            flowId: ((_a = action.openRequest) === null || _a === void 0 ? void 0 : _a.source) === "command"
+        const entry = Object.assign(Object.assign({}, (action.t === "getuserfeedback:action:prerenderNativeFlow"
+            ? { nativeProjection: action.projection }
+            : {})), { allocationId: nextAllocationId, flowId: ((_a = action.openRequest) === null || _a === void 0 ? void 0 : _a.source) === "command"
                 ? ((_b = action.openRequest.flowId) !== null && _b !== void 0 ? _b : null)
-                : null,
-            generation: action.gen,
-            flowRunId: action.flowRunId,
-            instanceId: action.instanceId,
-            isActive: false,
-            isClosing: false,
-            isPreparationCommitted: false,
-            isPresentationAcknowledged: false,
-            isViewConnected: false,
-            isViewRelayDraining: false,
-            layoutReportRevision: 0,
-            pendingCoreToViewMessages: [],
-            preparation,
-            retainedSize: null,
-            size: null,
-            srcdoc: action.srcdoc,
-            committedLayoutReportOccurrence: null,
-            viewConnection: null,
-            viewConnectionDetach: null,
-            viewId: action.viewId,
-        };
+                : null, generation: action.gen, flowRunId: action.flowRunId, instanceId: action.instanceId, isActive: false, isClosing: false, isPreparationCommitted: false, isPresentationAcknowledged: false, isViewConnected: false, isViewRelayDraining: false, layoutReportRevision: 0, pendingCoreToViewMessages: [], preparation, retainedSize: null, size: null, srcdoc, committedLayoutReportOccurrence: null, viewConnection: null, viewConnectionDetach: null, viewId: action.viewId });
         entries.set(action.viewId, entry);
         try {
             preparation.addCleanup(() => {
@@ -383,6 +394,39 @@ export function createNativeViewRecordController(input) {
         if (coreConnectionFailed || disposed) {
             return;
         }
+        const nativeAction = actionPrerenderNativeFlowSchema.safeParse(value);
+        if (nativeAction.success &&
+            nativeAction.data.gen === input.coreConnection.generation) {
+            handlePrerender(nativeAction.data);
+            return;
+        }
+        const response = rpcResponseSchema.safeParse(value);
+        if (response.success &&
+            response.data.gen === input.coreConnection.generation &&
+            response.data.viewId) {
+            const entry = entries.get(response.data.viewId);
+            const interaction = entry === null || entry === void 0 ? void 0 : entry.nativeInteraction;
+            if (entry &&
+                interaction &&
+                interaction.kind !== "draft-failed" &&
+                interaction.rpcId === response.data.rpcId &&
+                entry.nativeProjection &&
+                !entry.isClosing &&
+                entry.isActive) {
+                const result = response.data.ok
+                    ? nativeFlowProjectionSchema.safeParse(response.data.result)
+                    : null;
+                if (!(result === null || result === void 0 ? void 0 : result.success)) {
+                    interaction.fail();
+                    return;
+                }
+                clearTimeout(interaction.timeout);
+                entry.nativeInteraction = undefined;
+                entry.nativeProjection = result.data;
+                notify();
+                return;
+            }
+        }
         const action = coreViewHostActionSchema.safeParse(value);
         if (action.success && action.data.gen === input.coreConnection.generation) {
             switch (action.data.t) {
@@ -403,12 +447,12 @@ export function createNativeViewRecordController(input) {
         });
         if (relay) {
             const entry = entries.get(relay.viewId);
-            if (entry) {
+            if (entry && !entry.nativeProjection) {
                 enqueueCoreToViewMessage(entry, relay.message);
             }
         }
     };
-    const completeConnectionReadiness = (entry, size) => {
+    const completePreparationReadiness = (entry, size) => {
         if (disposed || entries.get(entry.viewId) !== entry) {
             return;
         }
@@ -460,6 +504,144 @@ export function createNativeViewRecordController(input) {
     };
     const stopCoreTransport = input.coreConnection.transport.subscribe(handleCoreMessage);
     return {
+        attachNativeContent({ allocationId, viewId }) {
+            const entry = entries.get(viewId);
+            if (disposed ||
+                coreConnectionFailed ||
+                !(entry === null || entry === void 0 ? void 0 : entry.nativeProjection) ||
+                entry.allocationId !== allocationId ||
+                entry.isClosing)
+                return null;
+            const binding = {
+                onLayout(size) {
+                    var _a, _b;
+                    if (disposed ||
+                        coreConnectionFailed ||
+                        entries.get(viewId) !== entry ||
+                        entry.isClosing ||
+                        entry.nativeContentBinding !== binding)
+                        return;
+                    if (!Number.isFinite(size.width) ||
+                        !Number.isFinite(size.height) ||
+                        size.width <= 0 ||
+                        size.height <= 0 ||
+                        size.width > 4096 ||
+                        size.height > 4096)
+                        return;
+                    if (((_a = entry.size) === null || _a === void 0 ? void 0 : _a.width) === size.width &&
+                        ((_b = entry.size) === null || _b === void 0 ? void 0 : _b.height) === size.height)
+                        return;
+                    entry.size = Object.assign({}, size);
+                    entry.layoutReportRevision += 1;
+                    try {
+                        if (!entry.isPreparationCommitted)
+                            completePreparationReadiness(entry, entry.size);
+                        else
+                            input.coreConnection.transport.postMessage(buildEventViewSize(Object.assign({ gen: entry.generation, viewId }, entry.size)));
+                        notify();
+                    }
+                    catch (error) {
+                        if (entry.isPreparationCommitted)
+                            failCoreConnection(error, "Native content readiness failed");
+                        else
+                            failAllocation(entry, error);
+                    }
+                },
+                dispose() {
+                    if (entry.nativeContentBinding !== binding)
+                        return;
+                    entry.nativeContentBinding = undefined;
+                    entry.size = null;
+                    if (!disposed && entries.get(viewId) === entry)
+                        notify();
+                },
+            };
+            entry.nativeContentBinding = binding;
+            return binding;
+        },
+        interactNativeFlow({ allocationId, viewId, projection, intent, draft }) {
+            var _a, _b;
+            const entry = entries.get(viewId);
+            if (disposed ||
+                coreConnectionFailed ||
+                !entry ||
+                entry.allocationId !== allocationId ||
+                entry.isClosing ||
+                !entry.isActive ||
+                !entry.isPreparationCommitted ||
+                !entry.nativeContentBinding ||
+                !entry.nativeProjection ||
+                (intent === "draft"
+                    ? ((_a = entry.nativeInteraction) === null || _a === void 0 ? void 0 : _a.kind) === "action" ||
+                        entry.nativeProjection.nodeId !== projection.nodeId
+                    : entry.nativeInteraction !== undefined ||
+                        entry.nativeProjection !== projection))
+                return false;
+            const parsed = nativeFlowInteractionSchema.safeParse({
+                flowRunId: entry.flowRunId,
+                nodeId: projection.nodeId,
+                intent,
+                draft,
+            });
+            if (!parsed.success)
+                return false;
+            const rpcId = createNativeInteractionRpcId();
+            const currentProjection = entry.nativeProjection;
+            if (((_b = entry.nativeInteraction) === null || _b === void 0 ? void 0 : _b.kind) === "draft")
+                clearTimeout(entry.nativeInteraction.timeout);
+            // Match the ordinary RPC budget. Correlation already rejects late replies;
+            // Timeout or a failed reply restores editing for an explicit manual retry.
+            const settleFailure = () => {
+                var _a, _b;
+                if (disposed ||
+                    entries.get(viewId) !== entry ||
+                    ((_a = entry.nativeInteraction) === null || _a === void 0 ? void 0 : _a.kind) === "draft-failed" ||
+                    ((_b = entry.nativeInteraction) === null || _b === void 0 ? void 0 : _b.rpcId) !== rpcId)
+                    return;
+                clearTimeout(entry.nativeInteraction.timeout);
+                entry.nativeInteraction =
+                    intent === "draft" ? { kind: "draft-failed" } : undefined;
+                entry.nativeProjection = Object.assign(Object.assign({}, currentProjection), { answers: Object.assign(Object.assign({}, currentProjection.answers), parsed.data.draft), formErrors: ["Something went wrong. Please try again."] });
+                notify();
+            };
+            entry.nativeInteraction = {
+                kind: intent === "draft" ? "draft" : "action",
+                rpcId,
+                fail: settleFailure,
+                timeout: setTimeout(settleFailure, 10000),
+            };
+            try {
+                notify();
+                input.coreConnection.transport.postMessage(rpcRequestSchema.parse(buildRpcRequest({
+                    gen: entry.generation,
+                    viewId,
+                    rpcId,
+                    idemKey: rpcId,
+                    method: NATIVE_FLOW_SESSION_RPC_METHOD,
+                    params: parsed.data,
+                })));
+            }
+            catch (error) {
+                failCoreConnection(error, "Native interaction delivery failed");
+            }
+            return true;
+        },
+        closeNativeFlow({ allocationId, viewId }) {
+            var _a;
+            const entry = entries.get(viewId);
+            if (disposed ||
+                coreConnectionFailed ||
+                !entry ||
+                entry.allocationId !== allocationId ||
+                !((_a = entry.nativeProjection) === null || _a === void 0 ? void 0 : _a.canClose) ||
+                !entry.isActive)
+                return;
+            closeViewFromRequest(entry, {
+                t: "getuserfeedback:action:requestCloseView",
+                gen: createGeneration(input.coreConnection.generation),
+                viewId,
+            });
+        },
         failViewAllocation({ allocationId, error, viewId }) {
             const entry = entries.get(viewId);
             if (!entry || entry.allocationId !== allocationId) {
@@ -515,9 +697,11 @@ export function createNativeViewRecordController(input) {
                 entry.isClosing ||
                 !entry.isActive ||
                 !entry.isPreparationCommitted ||
-                !entry.isViewConnected ||
-                entry.viewConnection === null ||
-                entry.viewConnectionDetach === null ||
+                (entry.nativeProjection
+                    ? !entry.nativeContentBinding
+                    : !entry.isViewConnected ||
+                        entry.viewConnection === null ||
+                        entry.viewConnectionDetach === null) ||
                 entry.size === null ||
                 entry.isPresentationAcknowledged) {
                 return;
@@ -540,6 +724,7 @@ export function createNativeViewRecordController(input) {
             const { viewId } = connection;
             const entry = entries.get(viewId);
             if (!entry ||
+                entry.nativeProjection ||
                 entry.allocationId !== allocationId ||
                 connection.generation !== input.coreConnection.generation) {
                 return null;
@@ -584,7 +769,7 @@ export function createNativeViewRecordController(input) {
                     return;
                 }
                 try {
-                    completeConnectionReadiness(entry, size);
+                    completePreparationReadiness(entry, size);
                 }
                 catch (error) {
                     failCoreConnection(error, "Native view readiness delivery failed");
@@ -777,16 +962,18 @@ export function createNativeViewRecordController(input) {
     };
 }
 function toRecord(entry) {
-    return Object.freeze({
-        allocationId: entry.allocationId,
-        flowId: entry.flowId,
-        generation: entry.generation,
-        isActive: entry.isActive,
-        layoutReportRevision: entry.layoutReportRevision,
-        size: entry.size,
-        srcdoc: entry.srcdoc,
-        viewId: entry.viewId,
-    });
+    var _a, _b, _c;
+    var _d;
+    return Object.freeze(Object.assign(Object.assign({}, (entry.nativeProjection
+        ? {
+            nativeFlow: {
+                projection: entry.nativeProjection,
+                interaction: (_d = (_a = entry.nativeInteraction) === null || _a === void 0 ? void 0 : _a.kind) !== null && _d !== void 0 ? _d : "idle",
+                pending: ((_b = entry.nativeInteraction) === null || _b === void 0 ? void 0 : _b.kind) === "draft" ||
+                    ((_c = entry.nativeInteraction) === null || _c === void 0 ? void 0 : _c.kind) === "action",
+            },
+        }
+        : {})), { allocationId: entry.allocationId, flowId: entry.flowId, generation: entry.generation, isActive: entry.isActive, layoutReportRevision: entry.layoutReportRevision, size: entry.size, srcdoc: entry.srcdoc, viewId: entry.viewId }));
 }
 function toViewSizeReport(event, context) {
     var _a;

package/dist/provider-command-helpers.js

@@ -1,10 +1,12 @@
 import { createCommandRequestId, REACT_NATIVE_WEBVIEW_TRANSPORT_CAPABILITIES, } from "@getuserfeedback/protocol/host";
+import { NATIVE_FLOW_SESSION_PROTOCOL } from "@getuserfeedback/protocol/internal/native-flow-session";
 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: [
+        NATIVE_FLOW_SESSION_PROTOCOL,
         REACT_NATIVE_WEBVIEW_TRANSPORT_CAPABILITIES.LAYOUT_TRANSITION_POLICY,
         REACT_NATIVE_WEBVIEW_TRANSPORT_CAPABILITIES.LAYOUT_TRANSITION_SCHEDULE,
     ],
@@ -18,5 +20,15 @@ export function createProviderCommandEnvelope({ clientMeta, command, idempotency
     const resolvedIdempotencyKey = (idempotencyKey === null || idempotencyKey === void 0 ? void 0 : idempotencyKey.trim()) || resolvedRequestId;
     const resolvedCommand = clientMeta !== undefined
         ? Object.assign(Object.assign({}, command), { opts: Object.assign(Object.assign({}, command.opts), { clientMeta }) }) : command;
-    return Object.assign({ version: "1", command: resolvedCommand, idempotencyKey: resolvedIdempotencyKey, instanceId: resolvedInstanceId, requestId: resolvedRequestId }, (clientMeta === undefined ? {} : { clientMeta }));
+    const envelope = {
+        version: "1",
+        command: resolvedCommand,
+        idempotencyKey: resolvedIdempotencyKey,
+        instanceId: resolvedInstanceId,
+        requestId: resolvedRequestId,
+    };
+    if (clientMeta !== undefined) {
+        envelope.clientMeta = clientMeta;
+    }
+    return envelope;
 }

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "5.14.2",
+  "version": "5.15.3",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -54,8 +54,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^6.0.0",
-    "@getuserfeedback/sdk": "^0.19.1",
+    "@getuserfeedback/protocol": "^6.0.3",
+    "@getuserfeedback/sdk": "^0.19.4",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {