@getuserfeedback/react-native 3.0.80 → 3.0.90

package/dist/index.js

@@ -9,10 +9,11 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementError, CommandSettlementTimeoutError, createFlowCommandHandleController, getFlowHandleFromSettlementDetail, getWidgetLayoutPlanNowMs, } from "@getuserfeedback/protocol/host";
+import { 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 { createNativeProviderClient, parseRequiredString, } from "./native-provider-client.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";
@@ -136,13 +137,6 @@ const normalizeOptionalString = (value) => {
     const normalized = value.trim();
     return normalized.length > 0 ? normalized : undefined;
 };
-const resolveRequiredString = (name, value) => {
-    const normalized = normalizeOptionalString(value);
-    if (normalized === undefined) {
-        throw new Error(`${name} must be a non-empty string`);
-    }
-    return normalized;
-};
 const toJsonKey = (value) => JSON.stringify(value);
 const toStableHash = (value) => {
     const json = toJsonKey(value);
@@ -171,33 +165,6 @@ function resolveReactNativeComponents() {
         };
     }
 }
-const toIdentifyCommandPayload = (identifyInput, traitsOrOptions, options) => {
-    if (typeof identifyInput === "string") {
-        assertNoSegmentExternalIdsInValueArgument({
-            argument: traitsOrOptions,
-            commandName: "identify",
-            valueArgumentName: "traits",
-            callShape: "identify(userId, traits, { externalIds })",
-        });
-        return {
-            kind: "identify",
-            userId: resolveRequiredString("userId", identifyInput),
-            traits: traitsOrOptions,
-            options,
-        };
-    }
-    assertNoSegmentExternalIdsInValueArgument({
-        argument: identifyInput,
-        commandName: "identify",
-        valueArgumentName: "traits",
-        callShape: "identify(traits, { externalIds })",
-    });
-    return {
-        kind: "identify",
-        traits: identifyInput,
-        options: options !== null && options !== void 0 ? options : traitsOrOptions,
-    };
-};
 export function GetUserFeedbackProvider({ autoInit = true, children, commandTimeoutMs = DEFAULT_COMMAND_TIMEOUT_MS, configureOptions, hostViewport, instanceId: instanceIdProp, initOptions, loaderUrl, onCommandError, onInvalidWebMessage, onWebMessage, source, webViewComponent, webViewProps, }) {
     var _a;
     const { View: NativeView } = useMemo(resolveReactNativeComponents, []);
@@ -383,7 +350,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         reportCommandError,
     };
     const flow = useCallback((flowId) => {
-        const normalizedFlowId = resolveRequiredString("flowId", flowId);
+        const normalizedFlowId = parseRequiredString("flowId", flowId);
         const existing = flowRunsRef.current.get(normalizedFlowId);
         if (existing) {
             return existing;
@@ -541,59 +508,32 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         disposeCommandTransport(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
     }, [disposeCommandTransport]);
     const getNativeMessages = useCallback(() => nativeMessagesRef.current, [nativeMessagesRef]);
-    const contextValue = useMemo(() => ({
-        instanceId,
-        get nativeMessages() {
-            return getNativeMessages();
-        },
-        enqueueCommand,
-        configure: (opts, options) => enqueueCommand({ kind: "configure", opts }, options),
-        identify: ((identifyInput, traitsOrOptions, options) => enqueueCommand(toIdentifyCommandPayload(identifyInput, traitsOrOptions, options))),
-        track: (eventName, properties, options) => {
-            assertNoSegmentExternalIdsInValueArgument({
-                argument: properties,
-                commandName: "track",
-                valueArgumentName: "properties",
-                callShape: "track(eventName, properties, { externalIds })",
-            });
-            return enqueueCommand(Object.assign(Object.assign({ kind: "track", origin: "customer", event: resolveRequiredString("eventName", eventName) }, (properties === undefined ? {} : { properties })), ((options === null || options === void 0 ? void 0 : options.externalIds) === undefined
-                ? {}
-                : { context: { externalIds: options.externalIds } })));
-        },
-        open: (flowId, options, commandOptions) => {
-            const normalizedFlowId = resolveRequiredString("flowId", flowId);
-            return enqueueCommand({
-                kind: "open",
-                flowId: normalizedFlowId,
-                hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
-            }, commandOptions);
-        },
-        prefetch: (flowId, options) => {
-            const normalizedFlowId = resolveRequiredString("flowId", flowId);
-            return enqueueCommand({
-                kind: "prefetch",
-                flowId: normalizedFlowId,
-            }, options);
-        },
-        prerender: (flowId, options, commandOptions) => {
-            const normalizedFlowId = resolveRequiredString("flowId", flowId);
-            return enqueueCommand({
-                kind: "prerender",
-                flowId: normalizedFlowId,
-                hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
-            }, commandOptions);
-        },
-        flow,
-        close: (flowHandleId, options) => enqueueCommand(Object.assign({ kind: "close" }, (flowHandleId === undefined
-            ? {}
-            : {
-                flowHandleId: resolveRequiredString("flowHandleId", flowHandleId),
-            })), options),
-        reset: (options) => enqueueCommand({ kind: "reset" }, options),
-        updateHostContext: (context, options) => enqueueCommand({ kind: "updateHostContext", context }, options),
-        emitHostSignal: (name, data, options) => enqueueCommand(Object.assign({ kind: "emitHostSignal", name: resolveRequiredString("name", name) }, (data === undefined ? {} : { data })), options),
-        handleWebMessage,
-    }), [enqueueCommand, flow, getNativeMessages, handleWebMessage, instanceId]);
+    const contextValue = useMemo(() => {
+        const client = createNativeProviderClient({
+            dispatchCommand: enqueueCommand,
+            flow,
+            instanceId,
+        });
+        return {
+            close: client.close,
+            configure: client.configure,
+            emitHostSignal: client.emitHostSignal,
+            enqueueCommand,
+            flow: client.flow,
+            handleWebMessage,
+            identify: client.identify,
+            instanceId: client.instanceId,
+            get nativeMessages() {
+                return getNativeMessages();
+            },
+            open: client.open,
+            prefetch: client.prefetch,
+            prerender: client.prerender,
+            reset: client.reset,
+            track: client.track,
+            updateHostContext: client.updateHostContext,
+        };
+    }, [enqueueCommand, flow, getNativeMessages, handleWebMessage, instanceId]);
     const previousSheetHostLayoutUpdateRef = useRef(undefined);
     const consumedTransitionPolicySequenceRef = useRef(undefined);
     useEffect(() => {

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

@@ -0,0 +1,9 @@
+import type { NativeDirectCommandSession } from "./native-direct-command-session.js";
+export type NativeDirectCommandSessionController = {
+    attach: (session: NativeDirectCommandSession) => void;
+    detach: (session: NativeDirectCommandSession) => void;
+    dispose: (error: Error) => void;
+    rejectUntilAttached: (error: Error) => void;
+    session: NativeDirectCommandSession;
+};
+export declare function createNativeDirectCommandSessionController(): NativeDirectCommandSessionController;

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

@@ -0,0 +1,78 @@
+export function createNativeDirectCommandSessionController() {
+    let attachedSession = null;
+    let disposed = false;
+    let disposalError;
+    let pendingCommands = [];
+    let unavailableError;
+    const dispatchThrough = (session, envelope) => {
+        try {
+            return Promise.resolve(session.dispatch(envelope));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    };
+    const session = {
+        dispatch: (envelope) => {
+            if (disposed) {
+                return Promise.reject(disposalError);
+            }
+            if (attachedSession !== null) {
+                return dispatchThrough(attachedSession, envelope);
+            }
+            if (unavailableError !== undefined) {
+                return Promise.reject(unavailableError);
+            }
+            return new Promise((resolve, reject) => {
+                pendingCommands.push({ envelope, reject, resolve });
+            });
+        },
+    };
+    const dispose = (error) => {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        disposalError = error;
+        attachedSession = null;
+        const queuedCommands = pendingCommands;
+        pendingCommands = [];
+        for (const command of queuedCommands) {
+            command.reject(error);
+        }
+    };
+    return {
+        attach: (nextSession) => {
+            if (disposed) {
+                return;
+            }
+            attachedSession = nextSession;
+            unavailableError = undefined;
+            const queuedCommands = pendingCommands;
+            pendingCommands = [];
+            for (const command of queuedCommands) {
+                if (disposed) {
+                    command.reject(disposalError);
+                    continue;
+                }
+                void dispatchThrough(nextSession, command.envelope).then(command.resolve, command.reject);
+            }
+        },
+        detach: (sessionToDetach) => {
+            if (attachedSession === sessionToDetach) {
+                attachedSession = null;
+            }
+        },
+        dispose,
+        rejectUntilAttached: (error) => {
+            attachedSession = null;
+            unavailableError = error;
+            const queuedCommands = pendingCommands;
+            pendingCommands = [];
+            for (const command of queuedCommands) {
+                command.reject(error);
+            }
+        },
+        session,
+    };
+}

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

@@ -1,7 +1,7 @@
 import { getFlowHandleFromSettlementDetail } from "@getuserfeedback/protocol/host";
 import { toCoreCommandPayload, } from "@getuserfeedback/protocol/internal/public-core-command";
-// TODO(migration): Route the public provider client through this core-ordered direct session.
-// [from=native-core-ordered-command-session] [to=native-provider-direct-session] [scope=slice] [principle=core-owned-flow-lifecycle] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=180]
+// TODO(migration): Route the public provider client through this core-ordered direct session after native per-view presentation is complete.
+// [from=native-view-presentation-behavior] [to=native-provider-direct-session] [scope=slice] [principle=core-owned-flow-lifecycle] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=190]
 export function createNativeDirectCommandSession(input) {
     const dispatchToCore = (envelope, command) => {
         const coreEnvelope = Object.assign(Object.assign({}, envelope), { command: toCoreCommandPayload(command) });

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

@@ -0,0 +1,64 @@
+import type { AppEventExternalId, AppEventJsonValue, PublicCommandPayload } from "@getuserfeedback/protocol";
+import type { ConfigureOptions } from "@getuserfeedback/sdk";
+type IdentifyTraits = Record<string, unknown>;
+type TrackProperties = Record<string, AppEventJsonValue>;
+type OpenCommand = Extract<PublicCommandPayload, {
+    kind: "open";
+}>;
+type PrerenderCommand = Extract<PublicCommandPayload, {
+    kind: "prerender";
+}>;
+type NativeProviderClientCommand = Exclude<Extract<PublicCommandPayload, {
+    kind: "configure" | "identify" | "track" | "open" | "prefetch" | "prerender" | "close" | "reset" | "updateHostContext" | "emitHostSignal";
+}>, OpenCommand> | (Omit<OpenCommand, "container"> & {
+    container?: never;
+});
+type IdentifyOptions = {
+    externalIds?: AppEventExternalId[];
+};
+type TrackOptions = {
+    externalIds?: AppEventExternalId[];
+};
+type OpenOptions = Pick<OpenCommand, "hideCloseButton">;
+type PrerenderOptions = Pick<PrerenderCommand, "hideCloseButton">;
+type OpenFlowOptions = Pick<OpenCommand, "hideCloseButton" | "metadata">;
+type PrerenderFlowOptions = Pick<PrerenderCommand, "hideCloseButton">;
+type HostContext = Extract<PublicCommandPayload, {
+    kind: "updateHostContext";
+}>["context"];
+interface NativeProviderCommandOptions {
+    idempotencyKey?: string;
+}
+export interface ReactNativeFlowRun {
+    readonly flowId: string;
+    open: (options?: OpenFlowOptions) => Promise<void>;
+    prefetch: () => Promise<void>;
+    prerender: (options?: PrerenderFlowOptions) => Promise<void>;
+    close: () => Promise<void>;
+}
+export interface NativeProviderClient<TResult> {
+    readonly instanceId: string;
+    configure: (opts: ConfigureOptions, options?: NativeProviderCommandOptions) => Promise<TResult>;
+    identify: {
+        (userId: string, traits?: IdentifyTraits, options?: IdentifyOptions): Promise<TResult>;
+        (traits: IdentifyTraits, placeholder: undefined, options?: IdentifyOptions): Promise<TResult>;
+        (traits: IdentifyTraits, options?: IdentifyOptions): Promise<TResult>;
+    };
+    track: (eventName: string, properties?: TrackProperties, options?: TrackOptions) => Promise<TResult>;
+    open: (flowId: string, options?: OpenOptions, commandOptions?: NativeProviderCommandOptions) => Promise<TResult>;
+    prefetch: (flowId: string, options?: NativeProviderCommandOptions) => Promise<TResult>;
+    prerender: (flowId: string, options?: PrerenderOptions, commandOptions?: NativeProviderCommandOptions) => Promise<TResult>;
+    flow: (flowId: string) => ReactNativeFlowRun;
+    close: (flowHandleId?: string, options?: NativeProviderCommandOptions) => Promise<TResult>;
+    reset: (options?: NativeProviderCommandOptions) => Promise<TResult>;
+    updateHostContext: (context: HostContext, options?: NativeProviderCommandOptions) => Promise<TResult>;
+    emitHostSignal: (name: string, data?: unknown, options?: NativeProviderCommandOptions) => Promise<TResult>;
+}
+type NativeProviderClientOptions<TResult> = {
+    dispatchCommand: (command: NativeProviderClientCommand, options?: NativeProviderCommandOptions) => Promise<TResult>;
+    flow: (flowId: string) => ReactNativeFlowRun;
+    instanceId: string;
+};
+export declare const parseRequiredString: (name: string, value?: string) => string;
+export declare function createNativeProviderClient<TResult>({ dispatchCommand, flow, instanceId, }: NativeProviderClientOptions<TResult>): NativeProviderClient<TResult>;
+export {};

package/dist/native-provider-client.js

@@ -0,0 +1,76 @@
+import { assertNoSegmentExternalIdsInValueArgument } from "@getuserfeedback/protocol/host";
+export const parseRequiredString = (name, value) => {
+    const normalized = value === null || value === void 0 ? void 0 : value.trim();
+    if (!normalized) {
+        throw new Error(`${name} must be a non-empty string`);
+    }
+    return normalized;
+};
+const toIdentifyCommandPayload = (identifyInput, traitsOrOptions, options) => {
+    if (typeof identifyInput === "string") {
+        assertNoSegmentExternalIdsInValueArgument({
+            argument: traitsOrOptions,
+            commandName: "identify",
+            valueArgumentName: "traits",
+            callShape: "identify(userId, traits, { externalIds })",
+        });
+        return {
+            kind: "identify",
+            userId: parseRequiredString("userId", identifyInput),
+            traits: traitsOrOptions,
+            options,
+        };
+    }
+    assertNoSegmentExternalIdsInValueArgument({
+        argument: identifyInput,
+        commandName: "identify",
+        valueArgumentName: "traits",
+        callShape: "identify(traits, { externalIds })",
+    });
+    return {
+        kind: "identify",
+        traits: identifyInput,
+        options: options !== null && options !== void 0 ? options : traitsOrOptions,
+    };
+};
+export function createNativeProviderClient({ dispatchCommand, flow, instanceId, }) {
+    return {
+        instanceId,
+        configure: (opts, options) => dispatchCommand({ kind: "configure", opts }, options),
+        identify: ((identifyInput, traitsOrOptions, options) => dispatchCommand(toIdentifyCommandPayload(identifyInput, traitsOrOptions, options))),
+        track: (eventName, properties, options) => {
+            assertNoSegmentExternalIdsInValueArgument({
+                argument: properties,
+                commandName: "track",
+                valueArgumentName: "properties",
+                callShape: "track(eventName, properties, { externalIds })",
+            });
+            return dispatchCommand(Object.assign(Object.assign({ kind: "track", origin: "customer", event: parseRequiredString("eventName", eventName) }, (properties === undefined ? {} : { properties })), ((options === null || options === void 0 ? void 0 : options.externalIds) === undefined
+                ? {}
+                : { context: { externalIds: options.externalIds } })));
+        },
+        open: (flowId, options, commandOptions) => dispatchCommand({
+            kind: "open",
+            flowId: parseRequiredString("flowId", flowId),
+            hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
+        }, commandOptions),
+        prefetch: (flowId, options) => dispatchCommand({
+            kind: "prefetch",
+            flowId: parseRequiredString("flowId", flowId),
+        }, options),
+        prerender: (flowId, options, commandOptions) => dispatchCommand({
+            kind: "prerender",
+            flowId: parseRequiredString("flowId", flowId),
+            hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
+        }, commandOptions),
+        flow,
+        close: (flowHandleId, options) => dispatchCommand(Object.assign({ kind: "close" }, (flowHandleId === undefined
+            ? {}
+            : {
+                flowHandleId: parseRequiredString("flowHandleId", flowHandleId),
+            })), options),
+        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-runtime-root.d.ts

@@ -13,7 +13,9 @@ export type NativeRuntimeRootProps = {
     onCommandSessionChange?: (session: NativeCoreCommandSession | null) => void;
     onError?: (error: Error) => void;
     onInvalidMessage?: (error: Error, value: unknown) => void;
+    onStartupTerminalError?: (error: Error) => void;
     startupCommandSettlementTimeoutMs?: number;
+    viewNativeViewComponent?: NativeViewHostProjectionProps["nativeViewComponent"];
     viewWebViewComponent?: NativeViewHostProjectionProps["webViewComponent"];
     viewWebViewProps?: NativeViewHostProjectionProps["webViewProps"];
 };
@@ -28,12 +30,12 @@ type NativeRuntimeConfigureCommand = Omit<CoreCommandEnvelope, "command"> & {
     }>;
 };
 type NativeRuntimeStartupCommands = readonly [NativeRuntimeInitCommand] | readonly [NativeRuntimeInitCommand, NativeRuntimeConfigureCommand];
-type NativeProviderRuntimeProps = Omit<NativeRuntimeRootProps, "onCommandSessionChange" | "startupCommands"> & {
+type NativeProviderRuntimeProps = Omit<NativeRuntimeRootProps, "onCommandSessionChange" | "onStartupTerminalError" | "startupCommands"> & {
     initialConfigureOptions?: ConfigureOptions;
     initOptions: InitOptions;
     instanceId: string;
     onCommandSessionChange?: (session: NativeDirectCommandSession | null) => void;
 };
-export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, startupCommandSettlementTimeoutMs, startupCommands, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;
-export declare function NativeProviderRuntime({ initOptions, initialConfigureOptions, instanceId, onCommandSessionChange, ...runtimeProps }: NativeProviderRuntimeProps): ReactElement;
+export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, onStartupTerminalError, startupCommandSettlementTimeoutMs, startupCommands, viewNativeViewComponent, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;
+export declare function NativeProviderRuntime({ initOptions, initialConfigureOptions, instanceId, onCommandSessionChange, onError, ...runtimeProps }: NativeProviderRuntimeProps): ReactElement;
 export {};

package/dist/native-runtime-root.js

@@ -18,6 +18,7 @@ import { createNativeDirectCommandSession, } from "./native-direct-command-sessi
 import { NativeViewHostProjection, } from "./native-view-host-projection.js";
 import { createNativeViewRecordController, } from "./native-view-record-controller.js";
 import { createProviderCommandEnvelope, REACT_NATIVE_CLIENT_META, } from "./provider-command-helpers.js";
+import { useNativeDirectCommandSessionController } from "./use-native-direct-command-session-controller.js";
 const DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS = 30000;
 function dispatchStartupCommand(input) {
     let timeoutId;
@@ -42,7 +43,7 @@ async function dispatchStartupCommands(input) {
         });
     }
 }
-export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, startupCommandSettlementTimeoutMs = DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS, startupCommands, viewWebViewComponent, viewWebViewProps, }) {
+export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, onStartupTerminalError, startupCommandSettlementTimeoutMs = DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS, startupCommands, viewNativeViewComponent, viewWebViewComponent, viewWebViewProps, }) {
     const [coreHostRevision, setCoreHostRevision] = useState(0);
     const [session, setSession] = useState(null);
     const sessionRef = useRef(null);
@@ -54,6 +55,8 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
     onCommandSessionChangeRef.current = onCommandSessionChange;
     const onInvalidMessageRef = useRef(onInvalidMessage);
     onInvalidMessageRef.current = onInvalidMessage;
+    const onStartupTerminalErrorRef = useRef(onStartupTerminalError);
+    onStartupTerminalErrorRef.current = onStartupTerminalError;
     const startupCommandsRef = useRef(startupCommands);
     startupCommandsRef.current = startupCommands;
     const reportError = useCallback((error) => {
@@ -124,6 +127,7 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
             })
                 .then(commitSession)
                 .catch((error) => {
+                var _a;
                 if (sessionRef.current !== nextSession) {
                     return;
                 }
@@ -131,11 +135,21 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
                 commandSessionOwner.dispose();
                 commandChannelOwner.dispose();
                 controller.dispose();
-                if (!(error instanceof CommandSettlementError) &&
-                    !startupRetryAttemptedRef.current) {
+                const shouldRetry = !(error instanceof CommandSettlementError) &&
+                    !startupRetryAttemptedRef.current;
+                if (shouldRetry) {
                     startupRetryAttemptedRef.current = true;
                     setCoreHostRevision((revision) => revision + 1);
                 }
+                else {
+                    startupRetryAttemptedRef.current = false;
+                    try {
+                        (_a = onStartupTerminalErrorRef.current) === null || _a === void 0 ? void 0 : _a.call(onStartupTerminalErrorRef, error instanceof Error ? error : new Error(String(error)));
+                    }
+                    catch (observerError) {
+                        reportError(observerError);
+                    }
+                }
                 reportError(error);
             });
             return;
@@ -199,17 +213,26 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
         : createElement(NativeViewHostProjection, {
             controller: session.controller,
             key: session.key,
+            nativeViewComponent: viewNativeViewComponent,
             onInvalidMessage,
             webViewComponent: viewWebViewComponent,
             webViewProps: viewWebViewProps,
         }));
 }
 export function NativeProviderRuntime(_a) {
-    var { initOptions, initialConfigureOptions, instanceId, onCommandSessionChange } = _a, runtimeProps = __rest(_a, ["initOptions", "initialConfigureOptions", "instanceId", "onCommandSessionChange"]);
+    var { initOptions, initialConfigureOptions, instanceId, onCommandSessionChange, onError } = _a, runtimeProps = __rest(_a, ["initOptions", "initialConfigureOptions", "instanceId", "onCommandSessionChange", "onError"]);
+    const directSessionController = useNativeDirectCommandSessionController();
     const directSessionRef = useRef(null);
+    const handleStartupTerminalError = useCallback((error) => {
+        directSessionController.rejectUntilAttached(error);
+    }, [directSessionController]);
     const handleCommandSessionChange = useCallback((session) => {
         var _a;
         if (session === null) {
+            if (directSessionRef.current !== null) {
+                directSessionController.detach(directSessionRef.current.directSession);
+                directSessionRef.current = null;
+            }
             onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(null);
             return;
         }
@@ -220,9 +243,10 @@ export function NativeProviderRuntime(_a) {
                     coreSession: session,
                 }),
             };
+            directSessionController.attach(directSessionRef.current.directSession);
         }
-        onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(directSessionRef.current.directSession);
-    }, [onCommandSessionChange]);
+        onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(directSessionController.session);
+    }, [directSessionController, onCommandSessionChange]);
     const startupCommands = useMemo(() => {
         const initCommand = createProviderCommandEnvelope({
             clientMeta: REACT_NATIVE_CLIENT_META,
@@ -240,5 +264,5 @@ export function NativeProviderRuntime(_a) {
             }),
         ];
     }, [initialConfigureOptions, initOptions, instanceId]);
-    return createElement(NativeRuntimeRoot, Object.assign(Object.assign({}, runtimeProps), { onCommandSessionChange: handleCommandSessionChange, startupCommands }));
+    return createElement(NativeRuntimeRoot, Object.assign(Object.assign({}, runtimeProps), { onCommandSessionChange: handleCommandSessionChange, onError, onStartupTerminalError: handleStartupTerminalError, startupCommands }));
 }

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

@@ -3,7 +3,8 @@ import type { NativeViewRecordController } from "./native-view-record-controller
 export type NativeViewHostProjectionProps = {
     controller: NativeViewRecordController;
     onInvalidMessage?: (error: Error, value: unknown) => void;
+    nativeViewComponent?: ComponentType<Record<string, unknown>>;
     webViewComponent?: ComponentType<Record<string, unknown>>;
     webViewProps?: Record<string, unknown>;
 };
-export declare function NativeViewHostProjection({ controller, onInvalidMessage, webViewComponent, webViewProps, }: NativeViewHostProjectionProps): ReactElement;
+export declare function NativeViewHostProjection({ controller, nativeViewComponent, onInvalidMessage, webViewComponent, webViewProps, }: NativeViewHostProjectionProps): ReactElement;

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

@@ -1,6 +1,7 @@
-import { createElement, Fragment, useCallback, useEffect, useRef, useSyncExternalStore, } from "react";
+import { createElement, Fragment, useCallback, useEffect, useMemo, useRef, useSyncExternalStore, } from "react";
+import { NativeViewPresentationSurface } from "./native-view-presentation-surface.js";
 import { ViewWebViewHost } from "./view-webview-host.js";
-function NativeViewHostProjectionEntry({ controller, onInvalidMessage, record, webViewComponent, webViewProps, }) {
+function NativeViewHostProjectionEntry({ controller, nativeViewComponent, onInvalidMessage, record, webViewComponent, webViewProps, }) {
     const detachConnectionRef = useRef(null);
     const detachConnection = useCallback(() => {
         const detach = detachConnectionRef.current;
@@ -8,15 +9,17 @@ function NativeViewHostProjectionEntry({ controller, onInvalidMessage, record, w
         detach === null || detach === void 0 ? void 0 : detach();
     }, []);
     const handleConnected = useCallback((connection) => {
-        detachConnection();
         const controllerDetach = controller.attachViewReadinessConnection({
             allocationId: record.allocationId,
             connection,
         });
-        detachConnectionRef.current = controllerDetach;
-    }, [controller, detachConnection, record.allocationId]);
+        if (controllerDetach) {
+            detachConnectionRef.current = controllerDetach;
+        }
+    }, [controller, record.allocationId]);
+    const presentedWebViewProps = useMemo(() => (Object.assign(Object.assign({}, webViewProps), { style: [webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.style, { flex: 1 }] })), [webViewProps]);
     useEffect(() => detachConnection, [detachConnection]);
-    return createElement(ViewWebViewHost, {
+    return createElement(NativeViewPresentationSurface, { nativeViewComponent, record }, createElement(ViewWebViewHost, {
         generation: record.generation,
         onConnected: handleConnected,
         onDisconnected: detachConnection,
@@ -24,13 +27,14 @@ function NativeViewHostProjectionEntry({ controller, onInvalidMessage, record, w
         srcdoc: record.srcdoc,
         viewId: record.viewId,
         webViewComponent,
-        webViewProps,
-    });
+        webViewProps: presentedWebViewProps,
+    }));
 }
-export function NativeViewHostProjection({ controller, onInvalidMessage, webViewComponent, webViewProps, }) {
+export function NativeViewHostProjection({ controller, nativeViewComponent, onInvalidMessage, webViewComponent, webViewProps, }) {
     const records = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
     return createElement(Fragment, null, records.map((record) => createElement(NativeViewHostProjectionEntry, {
         controller,
+        nativeViewComponent,
         onInvalidMessage,
         record,
         webViewComponent,

package/dist/native-view-presentation-surface.d.ts

@@ -0,0 +1,7 @@
+import { type ComponentType, type ReactElement, type ReactNode } from "react";
+import type { NativeViewRecord } from "./native-view-record-controller.js";
+export declare function NativeViewPresentationSurface({ children, nativeViewComponent, record, }: {
+    children?: ReactNode;
+    nativeViewComponent?: ComponentType<Record<string, unknown>>;
+    record: NativeViewRecord;
+}): ReactElement;