@getuserfeedback/react-native 3.0.71 → 3.0.73

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

@@ -1,10 +1,8 @@
 import { getFlowHandleFromSettlementDetail } from "@getuserfeedback/protocol/host";
 import { toCoreCommandPayload, } from "@getuserfeedback/protocol/internal/public-core-command";
-import { createFlowHandleCommandStateStore, planFlowHandleCommand, } from "./view-orchestration-runtime.js";
-// TODO(migration): Add native instance-wide command ordering and authoritative handle invalidation 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]
+// TODO(migration): Route reset, unscoped close, and 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]
 export function createNativeDirectCommandSession(input) {
-    const flowHandleCommandStateStore = createFlowHandleCommandStateStore();
     const dispatchToCore = (envelope, command) => {
         const coreEnvelope = Object.assign(Object.assign({}, envelope), { command: toCoreCommandPayload(command) });
         return input.coreSession.dispatch(coreEnvelope);
@@ -16,142 +14,41 @@ export function createNativeDirectCommandSession(input) {
             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)) {
-                    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;
+    const assertAllocationSettlement = (envelope, command, settlement) => {
+        assertSettlementMatches({
+            envelope,
+            expectedKind: command.kind,
+            settlement,
         });
+        const allocation = getFlowHandleFromSettlementDetail(settlement);
+        if (!(allocation === null || allocation === void 0 ? void 0 : allocation.flowRunId) ||
+            (command.flowHandleId !== undefined &&
+                allocation.flowHandleId !== command.flowHandleId)) {
+            throw new Error(command.flowHandleId === undefined
+                ? `Expected ${command.kind} settlement to include flowHandleId and flowRunId`
+                : `Expected ${command.kind} settlement to include matching flowHandleId and flowRunId`);
+        }
     };
     return {
-        dispatch: (envelope) => {
+        dispatch: async (envelope) => {
+            const settlement = await dispatchToCore(envelope, envelope.command);
+            if (!settlement.ok) {
+                return settlement;
+            }
             switch (envelope.command.kind) {
                 case "open":
                 case "prerender":
-                    return dispatchAllocation(envelope, envelope.command);
-                case "prefetch":
-                    return dispatchToCore(envelope, envelope.command);
+                    assertAllocationSettlement(envelope, envelope.command, settlement);
+                    break;
                 case "close":
-                    return dispatchHandleClose(envelope, envelope.command);
-                default:
-                    return dispatchToCore(envelope, envelope.command);
+                    assertSettlementMatches({
+                        envelope,
+                        expectedKind: "close",
+                        settlement,
+                    });
+                    break;
             }
+            return settlement;
         },
     };
 }

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

package/dist/view-orchestration-runtime.js

@@ -32,209 +32,6 @@ 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;
@@ -287,7 +84,7 @@ class PendingCommandTracker {
   }
 }
 // ../view-orchestration/src/view-activation-machine.ts
-import { createMachine as createMachine2, interpret as interpret2, state as state2, transition as transition2 } from "robot3";
+import { createMachine, interpret, state, transition } from "robot3";
 var VIEW_ACTIVATION_STATES = {
   idle: true,
   prerendering: true,
@@ -298,18 +95,18 @@ var VIEW_ACTIVATION_STATES = {
 };
 function createViewActivationMachine() {
   const states = {
-    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()
+    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()
   };
-  return createMachine2(states, () => ({}));
+  return createMachine(states, () => ({}));
 }
 function createViewActivationController() {
   const machine = createViewActivationMachine();
-  const service = interpret2(machine, () => {});
+  const service = interpret(machine, () => {});
   const getState = () => readViewActivationState(service.machine.current);
   const send = (event) => {
     service.send(event);
@@ -336,22 +133,22 @@ function readViewActivationState(value) {
 // ../view-orchestration/src/view-preparation-readiness-registry.ts
 function createViewPreparationReadinessRegistry() {
   const states = new Map;
-  const resolveReadySize = (state3) => {
-    if (!state3 || state3.status === "ready" || !state3.hostPrepared || state3.size === null) {
+  const resolveReadySize = (state2) => {
+    if (!state2 || state2.status === "ready" || !state2.hostPrepared || state2.size === null) {
       return null;
     }
-    state3.status = "ready";
-    return state3.size;
+    state2.status = "ready";
+    return state2.size;
   };
   return {
     begin(viewId) {
-      const state3 = {
+      const state2 = {
         hostPrepared: false,
         size: null,
         status: "pending"
       };
-      states.set(viewId, state3);
-      const getCurrentState = () => states.get(viewId) === state3 ? state3 : null;
+      states.set(viewId, state2);
+      const getCurrentState = () => states.get(viewId) === state2 ? state2 : null;
       return {
         markHostPrepared() {
           const current = getCurrentState();
@@ -469,12 +266,6 @@ function createViewPreparationRegistry() {
 function createPendingCommandTracker() {
   return new PendingCommandTracker;
 }
-function createFlowHandleCommandStateStore() {
-  return new FlowHandleCommandStateStore;
-}
-function planFlowHandleCommand2(input) {
-  return planFlowHandleCommand(input);
-}
 function createActiveViewSnapshotListController2() {
   return createActiveViewSnapshotListController();
 }
@@ -488,11 +279,9 @@ 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.71",
+  "version": "3.0.73",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",