@getuserfeedback/react-native 3.0.67 → 3.0.72

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

@@ -1,9 +1,11 @@
 import { type CoreCommandEnvelope } from "@getuserfeedback/protocol";
+import { type EventHandleInvalidated } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
 import { type EventCommandSettled } from "@getuserfeedback/protocol/internal/core-host-command-settlement";
 import type { CoreWebViewHostConnection } from "./core-webview-host-controller.js";
 export type NativeCoreCommandChannel = {
     post: (envelope: CoreCommandEnvelope) => void;
     subscribe: (listener: (message: EventCommandSettled) => void) => () => void;
+    subscribeHandleInvalidated: (listener: (message: EventHandleInvalidated) => void) => () => void;
 };
 type OwnedNativeCoreCommandChannel = {
     channel: NativeCoreCommandChannel;

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

@@ -1,28 +1,47 @@
 import { coreCommandEnvelopeSchema, } from "@getuserfeedback/protocol";
+import { eventHandleInvalidatedSchema, } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
 import { eventCommandSettledSchema, } from "@getuserfeedback/protocol/internal/core-host-command-settlement";
 const DISPOSED_MESSAGE = "Core command channel is disposed";
 const isRecord = (value) => typeof value === "object" && value !== null;
 export function createNativeCoreCommandChannel(input) {
     const listeners = new Set();
+    const handleInvalidatedListeners = new Set();
     let disposed = false;
     const handleMessage = (value) => {
-        var _a;
-        if (disposed ||
-            !isRecord(value) ||
-            value.t !== "getuserfeedback:event:commandSettled") {
+        var _a, _b;
+        if (disposed || !isRecord(value)) {
             return;
         }
-        const parsed = eventCommandSettledSchema.safeParse(value);
+        if (value.t === "getuserfeedback:event:commandSettled") {
+            const parsed = eventCommandSettledSchema.safeParse(value);
+            if (!parsed.success) {
+                (_a = input.onInvalidMessage) === null || _a === void 0 ? void 0 : _a.call(input, parsed.error instanceof Error
+                    ? parsed.error
+                    : new Error("Invalid core command settlement message"), value);
+                return;
+            }
+            if (parsed.data.gen !== input.coreConnection.generation) {
+                return;
+            }
+            for (const listener of [...listeners]) {
+                listener(parsed.data);
+            }
+            return;
+        }
+        if (value.t !== "getuserfeedback:event:handleInvalidated") {
+            return;
+        }
+        const parsed = eventHandleInvalidatedSchema.safeParse(value);
         if (!parsed.success) {
-            (_a = input.onInvalidMessage) === null || _a === void 0 ? void 0 : _a.call(input, parsed.error instanceof Error
+            (_b = input.onInvalidMessage) === null || _b === void 0 ? void 0 : _b.call(input, parsed.error instanceof Error
                 ? parsed.error
-                : new Error("Invalid core command settlement message"), value);
+                : new Error("Invalid core handle invalidation message"), value);
             return;
         }
         if (parsed.data.gen !== input.coreConnection.generation) {
             return;
         }
-        for (const listener of [...listeners]) {
+        for (const listener of [...handleInvalidatedListeners]) {
             listener(parsed.data);
         }
     };
@@ -44,6 +63,15 @@ export function createNativeCoreCommandChannel(input) {
                 listeners.delete(listener);
             };
         },
+        subscribeHandleInvalidated: (listener) => {
+            if (disposed) {
+                return () => { };
+            }
+            handleInvalidatedListeners.add(listener);
+            return () => {
+                handleInvalidatedListeners.delete(listener);
+            };
+        },
     };
     return {
         channel,
@@ -54,6 +82,7 @@ export function createNativeCoreCommandChannel(input) {
             disposed = true;
             unsubscribeTransport();
             listeners.clear();
+            handleInvalidatedListeners.clear();
         },
     };
 }

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

@@ -1,8 +1,10 @@
 import { type CoreCommandEnvelope } from "@getuserfeedback/protocol";
 import { type CommandSettledDetail } from "@getuserfeedback/protocol/host";
+import type { EventHandleInvalidated } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
 import type { NativeCoreCommandChannel } from "./native-core-command-channel.js";
 export type NativeCoreCommandSession = {
     dispatch: (envelope: CoreCommandEnvelope) => Promise<CommandSettledDetail>;
+    subscribeHandleInvalidated: (listener: (message: EventHandleInvalidated) => void) => () => void;
 };
 type NativeCoreCommandSessionOwner = {
     dispose: () => void;

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

@@ -23,8 +23,9 @@ function toCommandSettledDetail(settlement) {
 }
 export function createNativeCoreCommandSession(input) {
     const pendingCommands = createPendingCommandTracker();
+    const handleInvalidatedListeners = new Set();
     let disposed = false;
-    const unsubscribe = input.channel.subscribe((settlement) => {
+    const unsubscribeSettlements = input.channel.subscribe((settlement) => {
         const detail = toCommandSettledDetail(settlement);
         if (detail.ok) {
             pendingCommands.resolve(detail.requestId, detail);
@@ -32,6 +33,11 @@ export function createNativeCoreCommandSession(input) {
         }
         pendingCommands.reject(detail.requestId, toCommandSettlementError(detail));
     });
+    const unsubscribeHandleInvalidated = input.channel.subscribeHandleInvalidated((message) => {
+        for (const listener of [...handleInvalidatedListeners]) {
+            listener(message);
+        }
+    });
     return {
         session: {
             dispatch: async (envelope) => {
@@ -48,13 +54,24 @@ export function createNativeCoreCommandSession(input) {
                 }
                 return settlement;
             },
+            subscribeHandleInvalidated: (listener) => {
+                if (disposed) {
+                    return () => { };
+                }
+                handleInvalidatedListeners.add(listener);
+                return () => {
+                    handleInvalidatedListeners.delete(listener);
+                };
+            },
         },
         dispose: () => {
             if (disposed) {
                 return;
             }
             disposed = true;
-            unsubscribe();
+            unsubscribeSettlements();
+            unsubscribeHandleInvalidated();
+            handleInvalidatedListeners.clear();
             pendingCommands.reset((requestId) => new NativeCoreCommandSessionClosedError(requestId));
         },
     };

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

@@ -1,13 +1,22 @@
 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";
+type NativeFlowAllocationCommand = (Omit<Extract<CoreTranslatablePublicCommandPayload, {
+    kind: "open";
+}>, "container"> & {
+    container?: never;
+}) | Extract<CoreTranslatablePublicCommandPayload, {
+    kind: "prefetch" | "prerender";
 }>;
+type NativeScopedCloseCommand = Extract<CoreTranslatablePublicCommandPayload, {
+    kind: "close";
+}> & {
+    flowHandleId: string;
+};
+/** Public commands accepted by the direct native provider session. */
+type NativeDirectCommandPayload = Exclude<CoreTranslatablePublicCommandPayload, {
+    kind: "init" | "open" | "prefetch" | "prerender" | "close" | "reset";
+}> | NativeFlowAllocationCommand | NativeScopedCloseCommand;
 /** Public command envelope accepted by the direct native provider session. */
 export type NativeDirectCommandEnvelope = Omit<CommandEnvelopeWithInstanceId, "command"> & {
     command: NativeDirectCommandPayload;
@@ -15,12 +24,6 @@ export type NativeDirectCommandEnvelope = Omit<CommandEnvelopeWithInstanceId, "c
 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;

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

@@ -1,15 +1,164 @@
+import { getFlowHandleFromSettlementDetail } from "@getuserfeedback/protocol/host";
 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.
- */
+import { createFlowHandleCommandStateStore, planFlowHandleCommand, } from "./view-orchestration-runtime.js";
+// TODO(migration): Add native instance-wide command ordering before routing reset, unscoped close, and the public provider client through this direct session.
+// [from=native-flow-handle-command-session] [to=native-instance-flow-command-session] [scope=slice] [principle=core-owned-flow-lifecycle] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=180]
 export function createNativeDirectCommandSession(input) {
+    const flowHandleCommandStateStore = createFlowHandleCommandStateStore();
+    // The direct session shares the core session lifetime; core-session disposal clears this listener.
+    input.coreSession.subscribeHandleInvalidated((message) => {
+        if (message.handleKind === "flow") {
+            flowHandleCommandStateStore.invalidate(message.handleId);
+        }
+    });
+    const dispatchToCore = (envelope, command) => {
+        const coreEnvelope = Object.assign(Object.assign({}, envelope), { command: toCoreCommandPayload(command) });
+        return input.coreSession.dispatch(coreEnvelope);
+    };
+    const assertSettlementMatches = (input) => {
+        if (input.settlement.requestId !== input.envelope.requestId ||
+            input.settlement.instanceId !== input.envelope.instanceId ||
+            input.settlement.kind !== input.expectedKind) {
+            throw new Error(`Expected ${input.expectedKind} settlement for requestId "${input.envelope.requestId}" and instanceId "${input.envelope.instanceId}"`);
+        }
+    };
+    const dispatchAllocation = async (envelope, command) => {
+        if (command.flowHandleId === undefined) {
+            const settlement = await dispatchToCore(envelope, command);
+            if (!settlement.ok) {
+                return settlement;
+            }
+            assertSettlementMatches({
+                envelope,
+                expectedKind: command.kind,
+                settlement,
+            });
+            const allocation = getFlowHandleFromSettlementDetail(settlement);
+            if (!(allocation === null || allocation === void 0 ? void 0 : allocation.flowRunId)) {
+                throw new Error(`Expected ${command.kind} settlement to include flowHandleId and flowRunId`);
+            }
+            const { flowHandleId, flowRunId } = allocation;
+            await flowHandleCommandStateStore.enqueue(flowHandleId, async (state) => {
+                state.runtime.bindAffinity({
+                    instanceId: envelope.instanceId,
+                    flowId: command.flowId,
+                });
+                state.runtime.bindFlowRun({
+                    flowRunId,
+                    activationPolicy: "never",
+                });
+            });
+            return settlement;
+        }
+        const flowHandleId = command.flowHandleId;
+        return flowHandleCommandStateStore.enqueue(flowHandleId, async (state) => {
+            const runtime = state.runtime.getSnapshot();
+            const decision = planFlowHandleCommand({
+                command: command.kind,
+                runtime,
+                instanceId: envelope.instanceId,
+                flowId: command.flowId,
+            });
+            if (decision === "forward-to-core") {
+                return dispatchToCore(envelope, Object.assign(Object.assign({}, command), { flowHandleId }));
+            }
+            if (decision !== "orchestrate") {
+                throw new Error(`Unexpected flow-handle command decision for ${command.kind}: ${decision}`);
+            }
+            state.runtime.bindAffinity({
+                instanceId: envelope.instanceId,
+                flowId: command.flowId,
+            });
+            const shouldResolveFlowRun = runtime.flowRunId === null;
+            if (shouldResolveFlowRun &&
+                !state.runtime.beginFlowRunResolution(envelope.requestId)) {
+                return dispatchToCore(envelope, Object.assign(Object.assign({}, command), { flowHandleId }));
+            }
+            try {
+                const settlement = await dispatchToCore(envelope, Object.assign(Object.assign({}, command), { flowHandleId }));
+                if (!settlement.ok) {
+                    if (shouldResolveFlowRun) {
+                        state.runtime.finishFlowRunResolution(envelope.requestId);
+                    }
+                    return settlement;
+                }
+                assertSettlementMatches({
+                    envelope,
+                    expectedKind: command.kind,
+                    settlement,
+                });
+                const allocation = getFlowHandleFromSettlementDetail(settlement);
+                if ((allocation === null || allocation === void 0 ? void 0 : allocation.flowHandleId) !== flowHandleId ||
+                    allocation.flowRunId === undefined) {
+                    throw new Error(`Expected ${command.kind} settlement to include matching flowHandleId and flowRunId`);
+                }
+                if (shouldResolveFlowRun &&
+                    !state.runtime.finishFlowRunResolution(envelope.requestId) &&
+                    state.runtime.getSnapshot().state !== "invalidated") {
+                    throw new Error(`Could not finish flow-run resolution for requestId "${envelope.requestId}"`);
+                }
+                state.runtime.bindFlowRun({
+                    flowRunId: allocation.flowRunId,
+                    activationPolicy: "never",
+                });
+                return settlement;
+            }
+            catch (error) {
+                if (shouldResolveFlowRun) {
+                    state.runtime.finishFlowRunResolution(envelope.requestId);
+                }
+                throw error;
+            }
+        });
+    };
+    const dispatchHandleClose = async (envelope, command) => {
+        const flowHandleId = command.flowHandleId;
+        return flowHandleCommandStateStore.enqueue(flowHandleId, async (state) => {
+            const decision = planFlowHandleCommand({
+                command: "close",
+                runtime: state.runtime.getSnapshot(),
+                instanceId: envelope.instanceId,
+            });
+            if (decision === "ignore") {
+                return {
+                    instanceId: envelope.instanceId,
+                    kind: "close",
+                    ok: true,
+                    requestId: envelope.requestId,
+                };
+            }
+            if (decision === "forward-to-core") {
+                return dispatchToCore(envelope, command);
+            }
+            if (decision !== "orchestrate") {
+                throw new Error(`Unexpected flow-handle command decision for close: ${decision}`);
+            }
+            state.runtime.bindAffinity({ instanceId: envelope.instanceId });
+            const settlement = await dispatchToCore(envelope, command);
+            if (settlement.ok) {
+                assertSettlementMatches({
+                    envelope,
+                    expectedKind: "close",
+                    settlement,
+                });
+                flowHandleCommandStateStore.invalidate(flowHandleId);
+            }
+            return settlement;
+        });
+    };
     return {
         dispatch: (envelope) => {
-            const coreEnvelope = Object.assign(Object.assign({}, envelope), { command: toCoreCommandPayload(envelope.command) });
-            return input.coreSession.dispatch(coreEnvelope);
+            switch (envelope.command.kind) {
+                case "open":
+                case "prerender":
+                    return dispatchAllocation(envelope, envelope.command);
+                case "prefetch":
+                    return dispatchToCore(envelope, envelope.command);
+                case "close":
+                    return dispatchHandleClose(envelope, envelope.command);
+                default:
+                    return dispatchToCore(envelope, envelope.command);
+            }
         },
     };
 }

package/dist/native-runtime-root.js

@@ -197,10 +197,22 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
 }
 export function NativeProviderRuntime(_a) {
     var { initOptions, instanceId, onCommandSessionChange } = _a, runtimeProps = __rest(_a, ["initOptions", "instanceId", "onCommandSessionChange"]);
+    const directSessionRef = useRef(null);
     const handleCommandSessionChange = useCallback((session) => {
-        onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(session === null
-            ? null
-            : createNativeDirectCommandSession({ coreSession: session }));
+        var _a;
+        if (session === null) {
+            onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(null);
+            return;
+        }
+        if (((_a = directSessionRef.current) === null || _a === void 0 ? void 0 : _a.coreSession) !== session) {
+            directSessionRef.current = {
+                coreSession: session,
+                directSession: createNativeDirectCommandSession({
+                    coreSession: session,
+                }),
+            };
+        }
+        onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(directSessionRef.current.directSession);
     }, [onCommandSessionChange]);
     const instanceRegistrationEnvelope = useMemo(() => createProviderCommandEnvelope({
         clientMeta: REACT_NATIVE_CLIENT_META,

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

package/dist/view-orchestration-runtime.js

@@ -32,6 +32,209 @@ function createActiveViewSnapshotListController() {
     }
   };
 }
+// ../view-orchestration/src/flow-handle-runtime-machine.ts
+import { createMachine, interpret, reduce, state, transition } from "robot3";
+var FLOW_HANDLE_RUNTIME_STATE_SET = {
+  active: true,
+  invalidated: true
+};
+var hasFlowHandleAffinityConflict = (input) => input.boundInstanceId !== undefined && input.boundInstanceId !== input.instanceId || input.flowId !== undefined && input.boundFlowId !== undefined && input.boundFlowId !== input.flowId;
+var assertAffinityCompatible = (input) => {
+  const { context, event } = input;
+  if (!hasFlowHandleAffinityConflict({
+    boundInstanceId: context.instanceId,
+    boundFlowId: context.flowId,
+    instanceId: event.instanceId,
+    flowId: event.flowId
+  })) {
+    return;
+  }
+  if (context.instanceId !== undefined && context.instanceId !== event.instanceId) {
+    throw new Error(`Flow handle affinity conflict: instanceId already bound to "${context.instanceId}" and cannot be rebound to "${event.instanceId}"`);
+  }
+  throw new Error(`Flow handle affinity conflict: flowId already bound to "${context.flowId}" and cannot be rebound to "${event.flowId}"`);
+};
+var bindAffinity = reduce((context, event) => {
+  assertAffinityCompatible({ context, event });
+  return {
+    ...context,
+    instanceId: event.instanceId,
+    flowId: event.flowId ?? context.flowId
+  };
+});
+var bindFlowRun = reduce((context, event) => {
+  if (context.instanceId === undefined) {
+    throw new Error("Cannot bind flowRunId before instance affinity is bound for flow handle runtime");
+  }
+  return {
+    ...context,
+    flowRunId: event.flowRunId
+  };
+});
+var beginFlowRunResolution = reduce((context, event) => {
+  if (context.instanceId === undefined) {
+    throw new Error("Cannot begin flowRun resolution before instance affinity is bound for flow handle runtime");
+  }
+  if (context.pendingFlowRunResolutionRequestId !== null && context.pendingFlowRunResolutionRequestId !== event.requestId) {
+    throw new Error(`Flow handle already has a pending flowRun resolution for requestId "${context.pendingFlowRunResolutionRequestId}"`);
+  }
+  return {
+    ...context,
+    pendingFlowRunResolutionRequestId: event.requestId
+  };
+});
+var clearFlowRunResolution = reduce((context, event) => context.pendingFlowRunResolutionRequestId === event.requestId ? { ...context, pendingFlowRunResolutionRequestId: null } : context);
+var setContainerMode = reduce((context, event) => {
+  if (context.containerMode !== undefined && context.containerMode !== event.mode) {
+    throw new Error(`Flow handle container mode conflict: already locked to "${context.containerMode}" and cannot switch to "${event.mode}"`);
+  }
+  return {
+    ...context,
+    containerMode: event.mode
+  };
+});
+var invalidateRuntime = reduce((context) => ({
+  ...context,
+  instanceId: undefined,
+  flowId: undefined,
+  flowRunId: null,
+  pendingFlowRunResolutionRequestId: null,
+  containerMode: undefined
+}));
+function createFlowHandleRuntimeMachine() {
+  const states = {
+    active: state(transition("bindAffinity", "active", bindAffinity), transition("bindFlowRun", "active", bindFlowRun), transition("beginFlowRunResolution", "active", beginFlowRunResolution), transition("finishFlowRunResolution", "active", clearFlowRunResolution), transition("setContainerMode", "active", setContainerMode), transition("invalidate", "invalidated", invalidateRuntime)),
+    invalidated: state()
+  };
+  return createMachine(states, () => ({
+    instanceId: undefined,
+    flowId: undefined,
+    flowRunId: null,
+    pendingFlowRunResolutionRequestId: null,
+    containerMode: undefined
+  }));
+}
+function createFlowHandleRuntimeController() {
+  const machine = createFlowHandleRuntimeMachine();
+  const service = interpret(machine, () => {});
+  const buildSnapshot = (svc) => {
+    const context = svc.context;
+    return {
+      state: readFlowHandleRuntimeState(svc.machine.current),
+      instanceId: context.instanceId,
+      flowId: context.flowId,
+      flowRunId: context.flowRunId,
+      pendingFlowRunResolutionRequestId: context.pendingFlowRunResolutionRequestId,
+      containerMode: context.containerMode
+    };
+  };
+  return {
+    getSnapshot: () => buildSnapshot(service),
+    bindAffinity: (input) => {
+      service.send({
+        type: "bindAffinity",
+        instanceId: input.instanceId,
+        ...input.flowId !== undefined ? { flowId: input.flowId } : {}
+      });
+    },
+    bindFlowRun: (input) => {
+      if (readFlowHandleRuntimeState(service.machine.current) === "invalidated") {
+        return "ignore";
+      }
+      const previousFlowRunId = service.context.flowRunId;
+      service.send({
+        type: "bindFlowRun",
+        flowRunId: input.flowRunId
+      });
+      if (input.activationPolicy === "always" || input.activationPolicy === "on-flow-run-change" && previousFlowRunId !== input.flowRunId) {
+        return "request-activation";
+      }
+      return "register";
+    },
+    beginFlowRunResolution: (requestId) => {
+      if (readFlowHandleRuntimeState(service.machine.current) === "invalidated") {
+        return false;
+      }
+      service.send({ type: "beginFlowRunResolution", requestId });
+      return true;
+    },
+    finishFlowRunResolution: (requestId) => {
+      if (readFlowHandleRuntimeState(service.machine.current) === "invalidated" || service.context.pendingFlowRunResolutionRequestId !== requestId) {
+        return false;
+      }
+      service.send({ type: "finishFlowRunResolution", requestId });
+      return true;
+    },
+    setContainerMode: (mode) => {
+      service.send({ type: "setContainerMode", mode });
+    },
+    invalidate: () => {
+      service.send({ type: "invalidate" });
+    }
+  };
+}
+function readFlowHandleRuntimeState(value) {
+  if (!isFlowHandleRuntimeState(value)) {
+    throw new Error(`Unknown flow-handle runtime state: ${String(value)}`);
+  }
+  return value;
+}
+function isFlowHandleRuntimeState(value) {
+  return typeof value === "string" && value in FLOW_HANDLE_RUNTIME_STATE_SET;
+}
+
+// ../view-orchestration/src/flow-handle-command-planner.ts
+var planFlowHandleCommand = (input) => {
+  if (input.runtime.state === "invalidated") {
+    return input.command === "open" || input.command === "prerender" ? "forward-to-core" : "ignore";
+  }
+  if (hasFlowHandleAffinityConflict({
+    boundInstanceId: input.runtime.instanceId,
+    boundFlowId: input.runtime.flowId,
+    instanceId: input.instanceId,
+    ...input.command === "open" || input.command === "prerender" ? { flowId: input.flowId } : {}
+  })) {
+    return input.command === "setContainer" ? "reject" : "forward-to-core";
+  }
+  return "orchestrate";
+};
+// ../view-orchestration/src/flow-handle-command-state-store.ts
+var createInitialFlowHandleCommandState = () => ({
+  runtime: createFlowHandleRuntimeController()
+});
+
+class FlowHandleCommandStateStore {
+  flowHandles = new Map;
+  getOrCreate(flowHandleId) {
+    const existing = this.flowHandles.get(flowHandleId);
+    if (existing) {
+      return existing;
+    }
+    const created = {
+      state: createInitialFlowHandleCommandState(),
+      tail: Promise.resolve()
+    };
+    this.flowHandles.set(flowHandleId, created);
+    return created;
+  }
+  enqueue(flowHandleId, task) {
+    const entry = this.getOrCreate(flowHandleId);
+    const nextTask = entry.tail.then(() => task(entry.state), () => task(entry.state));
+    entry.tail = nextTask.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return nextTask;
+  }
+  invalidate(flowHandleId) {
+    const state2 = this.getOrCreate(flowHandleId).state;
+    if (state2.runtime.getSnapshot().state !== "invalidated") {
+      state2.runtime.invalidate();
+    }
+    return state2;
+  }
+}
 // ../view-orchestration/src/pending-command-tracker.ts
 var createDeferred = () => {
   let resolve;
@@ -84,7 +287,7 @@ class PendingCommandTracker {
   }
 }
 // ../view-orchestration/src/view-activation-machine.ts
-import { createMachine, interpret, state, transition } from "robot3";
+import { createMachine as createMachine2, interpret as interpret2, state as state2, transition as transition2 } from "robot3";
 var VIEW_ACTIVATION_STATES = {
   idle: true,
   prerendering: true,
@@ -95,18 +298,18 @@ var VIEW_ACTIVATION_STATES = {
 };
 function createViewActivationMachine() {
   const states = {
-    idle: state(transition("startPrerender", "prerendering"), transition("requestActivation", "activation-requested")),
-    prerendering: state(transition("requestActivation", "prerendering-activation-requested"), transition("markPrerendered", "prerendered")),
-    "activation-requested": state(transition("startPrerender", "prerendering-activation-requested")),
-    "prerendering-activation-requested": state(transition("markPrerendered", "active")),
-    prerendered: state(transition("requestActivation", "active")),
-    active: state()
+    idle: state2(transition2("startPrerender", "prerendering"), transition2("requestActivation", "activation-requested")),
+    prerendering: state2(transition2("requestActivation", "prerendering-activation-requested"), transition2("markPrerendered", "prerendered")),
+    "activation-requested": state2(transition2("startPrerender", "prerendering-activation-requested")),
+    "prerendering-activation-requested": state2(transition2("markPrerendered", "active")),
+    prerendered: state2(transition2("requestActivation", "active")),
+    active: state2()
   };
-  return createMachine(states, () => ({}));
+  return createMachine2(states, () => ({}));
 }
 function createViewActivationController() {
   const machine = createViewActivationMachine();
-  const service = interpret(machine, () => {});
+  const service = interpret2(machine, () => {});
   const getState = () => readViewActivationState(service.machine.current);
   const send = (event) => {
     service.send(event);
@@ -133,22 +336,22 @@ function readViewActivationState(value) {
 // ../view-orchestration/src/view-preparation-readiness-registry.ts
 function createViewPreparationReadinessRegistry() {
   const states = new Map;
-  const resolveReadySize = (state2) => {
-    if (!state2 || state2.status === "ready" || !state2.hostPrepared || state2.size === null) {
+  const resolveReadySize = (state3) => {
+    if (!state3 || state3.status === "ready" || !state3.hostPrepared || state3.size === null) {
       return null;
     }
-    state2.status = "ready";
-    return state2.size;
+    state3.status = "ready";
+    return state3.size;
   };
   return {
     begin(viewId) {
-      const state2 = {
+      const state3 = {
         hostPrepared: false,
         size: null,
         status: "pending"
       };
-      states.set(viewId, state2);
-      const getCurrentState = () => states.get(viewId) === state2 ? state2 : null;
+      states.set(viewId, state3);
+      const getCurrentState = () => states.get(viewId) === state3 ? state3 : null;
       return {
         markHostPrepared() {
           const current = getCurrentState();
@@ -266,6 +469,12 @@ function createViewPreparationRegistry() {
 function createPendingCommandTracker() {
   return new PendingCommandTracker;
 }
+function createFlowHandleCommandStateStore() {
+  return new FlowHandleCommandStateStore;
+}
+function planFlowHandleCommand2(input) {
+  return planFlowHandleCommand(input);
+}
 function createActiveViewSnapshotListController2() {
   return createActiveViewSnapshotListController();
 }
@@ -279,9 +488,11 @@ function createViewPreparationReadinessRegistry2() {
   return createViewPreparationReadinessRegistry();
 }
 export {
+  planFlowHandleCommand2 as planFlowHandleCommand,
   createViewPreparationRegistry2 as createViewPreparationRegistry,
   createViewPreparationReadinessRegistry2 as createViewPreparationReadinessRegistry,
   createViewActivationController2 as createViewActivationController,
   createPendingCommandTracker,
+  createFlowHandleCommandStateStore,
   createActiveViewSnapshotListController2 as createActiveViewSnapshotListController
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "3.0.67",
+  "version": "3.0.72",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.18.1",
-    "@getuserfeedback/sdk": "^0.12.1",
+    "@getuserfeedback/protocol": "^3.18.3",
+    "@getuserfeedback/sdk": "^0.12.3",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {