@opengeni/react 3.0.0-canary.0 → 3.3.2-canary.0

package/dist/session-ui.js

@@ -11,15 +11,15 @@ import {
   sessionChromeGoalPillLabel,
   sessionChromeGoalPillState,
   userMessageLikelyNeedsDisclosure
-} from "./chunk-HQVCKCLG.js";
+} from "./chunk-YG4QEQF5.js";
 import {
   createOlderHistoryLoadReceipt
-} from "./chunk-D3UIAJKY.js";
+} from "./chunk-JAQ5K7W6.js";
 import "./chunk-WSK7G5LE.js";
-import "./chunk-YFKJ7VZH.js";
+import "./chunk-7EAFGICR.js";
 import "./chunk-VZTQ73XT.js";
 import "./chunk-JVYQRRC4.js";
-import "./chunk-LAKLF4PA.js";
+import "./chunk-VTOREEXF.js";
 import "./chunk-22KP6LR5.js";
 export {
   BUILT_IN_TURN_SUMMARY_FACET_IDS,

package/dist/session.js

@@ -17,14 +17,14 @@ import {
   useSessionLineage,
   useSessionMcpApprovalPolicy,
   useTurnQueue
-} from "./chunk-YJFGAFBD.js";
+} from "./chunk-3AGBGTRT.js";
 import {
   FILE_ONLY_MESSAGE_TEXT,
   composeSendInput,
   shouldSteerOnKey,
   shouldSubmitOnKey,
   useComposer
-} from "./chunk-MZ2G2XBA.js";
+} from "./chunk-IOLVN74D.js";
 import {
   buildTimeline,
   createOlderHistoryLoadReceipt,
@@ -35,10 +35,10 @@ import {
   projectPendingHumanInputRequests,
   sessionStatusFromEvents,
   toolDisplayName
-} from "./chunk-D3UIAJKY.js";
+} from "./chunk-JAQ5K7W6.js";
 import "./chunk-KZ73RL76.js";
 import "./chunk-NEXLLTP4.js";
-import "./chunk-LAKLF4PA.js";
+import "./chunk-VTOREEXF.js";
 export {
   FILE_ONLY_MESSAGE_TEXT,
   approvalsFromRequiresAction,

package/dist/timeline/entrance.d.ts

@@ -1,4 +1,16 @@
-export declare const EntranceAnimationProvider: import("react").Provider<boolean>;
+import { type ReactNode } from "react";
+/**
+ * Freeze the mount-time gate for this subtree while publishing a separate live
+ * gate to activity rails that need later appends to animate after a bulk paint.
+ * MessageTimeline mounts one provider per durable group, so existing groups do
+ * not receive a context invalidation when a prepend toggles bulk mode and new
+ * groups still capture the value from the commit that created them.
+ */
+export declare function EntranceAnimationProvider({ value, liveValue, children, }: {
+    value: boolean;
+    liveValue?: boolean | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
 /**
  * Live entrance gate from the nearest provider. Prefer
  * {@link useEntranceAnimation} for elements that must freeze the decision at

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/react",
-  "version": "3.0.0-canary.0",
+  "version": "3.3.2-canary.0",
   "description": "React hooks and styled components for OpenGeni: live session streaming, chat composer, message timeline, session status, and fleet views — token-themed (CSS variables), dark-first, built on Tailwind v4 + Radix + Motion.",
   "license": "Apache-2.0",
   "repository": {
@@ -120,8 +120,9 @@
     "@dnd-kit/utilities": "3.2.2",
     "@fontsource-variable/noto-sans-arabic": "5.2.10",
     "@fontsource-variable/noto-sans-jp": "5.2.10",
-    "@opengeni/sdk": "^2.6.0-canary.0",
+    "@opengeni/sdk": "^3.3.2-canary.0",
     "clsx": "^2.1.1",
+    "dequal": "2.0.3",
     "lucide-react": "^1.8.0",
     "motion": "^12.0.0",
     "radix-ui": "^1.4.3",

package/src/accounts.tsx

@@ -197,6 +197,7 @@ export function BrowserAccountsProvider({
     expectedGeneration: string;
   } | null>(null);
   const pendingCommitSequenceRef = useRef<number | null>(null);
+  const pendingServerMutationSequenceRef = useRef<number | null>(null);
   const invalidatedDuringPendingCommitRef = useRef(false);
   const sequenceRef = useRef(0);
   const transitionAbortRef = useRef<AbortController | null>(null);
@@ -262,6 +263,7 @@ export function BrowserAccountsProvider({
       sequence: number,
       publish: boolean,
       authorityResetConfirmed = false,
+      initiatingSurfaceFenced = false,
     ): Promise<ManagedAuthSessionSetProjection | null> => {
       let source = from;
       let target = accepted;
@@ -272,7 +274,7 @@ export function BrowserAccountsProvider({
           throw new Error("Browser account response regressed the accepted actor epoch");
         }
       }
-      if (sameSelectedActor(source, target)) {
+      if (!initiatingSurfaceFenced && sameSelectedActor(source, target)) {
         setProjection(target);
         setPhase("ready");
         setError(null);
@@ -287,7 +289,13 @@ export function BrowserAccountsProvider({
         // and abort old-actor work throughout that entire window.
         if (publish) publishActorHint(target);
         setPhase("loading");
-        await onActorTransition({ kind, from: source, to: target, signal: controller.signal });
+        await onActorTransition({
+          kind,
+          from: initiatingSurfaceFenced ? null : source,
+          to: target,
+          signal: controller.signal,
+        });
+        initiatingSurfaceFenced = false;
         if (controller.signal.aborted || sequenceRef.current !== sequence) return null;
         if (!target) {
           setProjection(null);
@@ -393,21 +401,44 @@ export function BrowserAccountsProvider({
       pending.expectedGeneration = expectedGeneration;
       const sequence = ++sequenceRef.current;
       pendingCommitSequenceRef.current = sequence;
+      pendingServerMutationSequenceRef.current = null;
       invalidatedDuringPendingCommitRef.current = false;
       pendingRef.current = pending;
       setPhase("committing");
       setError(null);
       const changesActor = pending.changesActor(current);
-      if (changesActor) {
-        // Peers must hide and abort the old actor before this request can be
-        // accepted. Yielding one task after the secret-free hold lets queued
-        // BroadcastChannel delivery run before the network mutation starts;
-        // a peer that was already dispatching remains an ordinary pre-commit
-        // in-flight request and is still fenced by the server epoch.
-        publishActorHold(pending.operationId, current);
-        await yieldToCrossTabActorHold();
-      }
+      let initiatingActorFenced = false;
       try {
+        if (changesActor) {
+          // Every tab, including the initiator, must hide and abort the old actor
+          // before this request can be accepted. Otherwise a response-lost
+          // logout can leave the initiating route alive long enough for its
+          // event stream to reconnect with the newly revoked cookie.
+          publishActorHold(pending.operationId, current);
+          transitionAbortRef.current?.abort();
+          const controller = new AbortController();
+          transitionAbortRef.current = controller;
+          projectionRef.current = null;
+          setProjection(null);
+          setPhase("loading");
+          // The host can synchronously clear its actor surface before its
+          // transition promise later rejects. From this point on, every
+          // failure must reconcile and restore authority even though the
+          // account mutation has not started yet.
+          initiatingActorFenced = true;
+          await onActorTransition({
+            kind: pending.kind,
+            from: current,
+            to: null,
+            signal: controller.signal,
+          });
+          if (controller.signal.aborted || sequenceRef.current !== sequence) return false;
+          // Yield one task after the secret-free hold so queued BroadcastChannel
+          // delivery can fence peers before the network mutation starts.
+          await yieldToCrossTabActorHold();
+          if (controller.signal.aborted || sequenceRef.current !== sequence) return false;
+        }
+        pendingServerMutationSequenceRef.current = sequence;
         let accepted: ManagedAuthSessionSetProjection;
         try {
           accepted = await pending.execute(expectedGeneration);
@@ -429,7 +460,22 @@ export function BrowserAccountsProvider({
           if (sequenceRef.current !== sequence) return false;
         }
         pendingRef.current = null;
-        if (!authorityResetConfirmed && sameSelectedActor(current, accepted)) {
+        // The server response and any invalidation reconciliation are now
+        // authoritative. Release commit ownership before host settlement so a
+        // later invalidation starts its own reconciliation instead of relying
+        // on the already-consumed check above.
+        if (pendingServerMutationSequenceRef.current === sequence) {
+          pendingServerMutationSequenceRef.current = null;
+        }
+        if (pendingCommitSequenceRef.current === sequence) {
+          pendingCommitSequenceRef.current = null;
+          invalidatedDuringPendingCommitRef.current = false;
+        }
+        if (
+          !initiatingActorFenced &&
+          !authorityResetConfirmed &&
+          sameSelectedActor(current, accepted)
+        ) {
           setProjection(accepted);
           setPhase("ready");
           setError(null);
@@ -441,20 +487,62 @@ export function BrowserAccountsProvider({
             sequence,
             true,
             authorityResetConfirmed,
+            initiatingActorFenced,
           );
         }
         return true;
       } catch (caught) {
+        if (initiatingActorFenced) {
+          let authorityRestored = false;
+          try {
+            const restored = await client.reconcileSessionSetAuthority();
+            if (sequenceRef.current !== sequence) return false;
+            await settleActorTransition(
+              pending.kind,
+              current,
+              restored,
+              sequence,
+              false,
+              true,
+              true,
+            );
+            if (sequenceRef.current !== sequence) return false;
+            authorityRestored = true;
+          } catch {
+            // If authority itself cannot be reconciled, retain the existing
+            // fail-closed provider error path and its manual retry surface.
+          }
+          if (authorityRestored) {
+            // Restore transport provenance before retaining the existing
+            // fail-closed retry surface. The retry screen keeps tenant data
+            // hidden, while refresh can safely reveal this reconciled actor.
+            const restoredError = accountError(caught);
+            setError(restoredError);
+            setPhase("recoverable_error");
+            throw restoredError;
+          }
+        }
         return await fail(caught, pending.kind);
       } finally {
         if (changesActor) publishActorRelease(pending.operationId);
+        if (pendingServerMutationSequenceRef.current === sequence) {
+          pendingServerMutationSequenceRef.current = null;
+        }
         if (pendingCommitSequenceRef.current === sequence) {
           pendingCommitSequenceRef.current = null;
           invalidatedDuringPendingCommitRef.current = false;
         }
       }
     },
-    [client, fail, inspectBlockers, publishActorHold, publishActorRelease, settleActorTransition],
+    [
+      client,
+      fail,
+      inspectBlockers,
+      onActorTransition,
+      publishActorHold,
+      publishActorRelease,
+      settleActorTransition,
+    ],
   );
 
   const refresh = useCallback(async () => {
@@ -493,11 +581,25 @@ export function BrowserAccountsProvider({
   );
 
   const invalidateActor = useCallback(async () => {
-    if (pendingCommitSequenceRef.current !== null) {
+    const pendingCommitSequence = pendingCommitSequenceRef.current;
+    if (
+      pendingCommitSequence !== null &&
+      pendingServerMutationSequenceRef.current === pendingCommitSequence
+    ) {
       invalidatedDuringPendingCommitRef.current = true;
       await beginNeutralActorInvalidation(projectionRef.current);
       return null;
     }
+    // An authority hint that arrives while the initiating host fence is still
+    // pending supersedes the not-yet-dispatched mutation. Reconcile it here;
+    // otherwise aborting that fence makes executePending return early while no
+    // operation remains to restore the neutral actor surface.
+    if (pendingCommitSequence !== null) {
+      pendingCommitSequenceRef.current = null;
+      pendingServerMutationSequenceRef.current = null;
+      invalidatedDuringPendingCommitRef.current = false;
+      pendingRef.current = null;
+    }
     const sequence = ++sequenceRef.current;
     const before = projectionRef.current;
     try {

package/src/components/fleet-tile.tsx

@@ -1,13 +1,13 @@
-import type { Session } from "@opengeni/sdk";
+import { deriveSessionDisplayTitle, type Session } from "@opengeni/sdk";
 import { cn } from "../lib/cn";
 import { formatRelativeTime } from "../lib/format";
 import { SessionStatus } from "./session-status";
 
-const AUTOMATIC_SESSION_TITLE_FALLBACK = "New conversation";
+const SESSION_METADATA_TITLE_KEYS = ["title", "name"] as const;
 
 export type FleetTileProps = {
   session: Session;
-  /** Overrides the derived title (session title, metadata title/name, or safe fallback). */
+  /** Overrides the derived title (durable title, metadata, prompt preview, or safe fallback). */
   title?: string | undefined;
   /** Extra line under the title — e.g. "drift check" or the worker's task. */
   subtitle?: string | undefined;
@@ -17,18 +17,7 @@ export type FleetTileProps = {
 
 /** Best-effort display title for a session. */
 export function sessionDisplayTitle(session: Session): string {
-  // A set title (agent-generated or user-renamed) wins over metadata and the
-  // prompt-free fallback.
-  if (typeof session.title === "string" && session.title.trim().length > 0) {
-    return session.title;
-  }
-  for (const key of ["title", "name"] as const) {
-    const value = session.metadata[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return value;
-    }
-  }
-  return AUTOMATIC_SESSION_TITLE_FALLBACK;
+  return deriveSessionDisplayTitle(session, { metadataKeys: SESSION_METADATA_TITLE_KEYS });
 }
 
 /**