@novoagents/react 0.3.0-alpha.34 → 0.3.0-alpha.36

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.3.0-alpha.36 - 2026-09-01
+
+Companion release for `novoagents` 0.5.0-alpha.32.
+
+- Controller ownership now rides the external-store snapshot (run key and
+  controller travel with the subscribed state), so an abandoned concurrent
+  render can no longer strand ownership in a render-written ref. Selector
+  readers isolate speculative renders while preserving equal object identity
+  across inline selector changes: the committed selection lives in a
+  `useState`-held cell that is still read during render, by design, mirroring
+  React's own `useSyncExternalStoreWithSelector` shim. Behavior is unchanged
+  across React 18 and 19, and the package now passes the canonical hooks lint
+  rules.
+
+## 0.3.0-alpha.35 - 2026-08-26
+
+- Companion release for `novoagents` 0.5.0-alpha.31. GitHub connection and
+  agent repository grants now carry exact immutable repository identities
+  end to end; an explicit empty agent selection grants no repositories.
+
 ## 0.3.0-alpha.34 - 2026-08-26
 
 - Companion release for `novoagents` 0.5.0-alpha.30. The React runtime is

package/dist/useNovoRun.js

@@ -1,5 +1,5 @@
 'use client';
-import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
 export const NOVO_IDLE_RUN_STATE = Object.freeze({
     messages: Object.freeze([]),
     status: 'queued',
@@ -22,7 +22,17 @@ function createControllerSlot() {
     const listeners = new Set();
     let controller;
     let unsubscribe;
+    let snapshot = {
+        controller: undefined,
+        runKey: UNOWNED_RUN_KEY,
+        state: NOVO_IDLE_RUN_STATE,
+    };
     const publish = () => {
+        snapshot = {
+            ...snapshot,
+            state: controller?.getSnapshot() ??
+                NOVO_IDLE_RUN_STATE,
+        };
         for (const listener of listeners)
             listener();
     };
@@ -31,15 +41,20 @@ function createControllerSlot() {
             listeners.add(listener);
             return () => listeners.delete(listener);
         },
-        getSnapshot: () => controller?.getSnapshot() ??
-            NOVO_IDLE_RUN_STATE,
+        getSnapshot: () => snapshot,
         getController: () => controller,
-        setController(next) {
-            if (controller === next)
+        setController(next, runKey = UNOWNED_RUN_KEY) {
+            if (controller === next && snapshot.runKey === runKey)
                 return;
             unsubscribe?.();
             controller = next;
             unsubscribe = next?.subscribe(publish);
+            snapshot = {
+                controller: next,
+                runKey,
+                state: next?.getSnapshot() ??
+                    NOVO_IDLE_RUN_STATE,
+            };
             publish();
         },
     };
@@ -51,11 +66,10 @@ function createControllerSlot() {
  */
 export function useNovoRun(options) {
     const factoryRef = useRef(options.createController);
-    factoryRef.current = options.createController;
-    const slotRef = useRef(undefined);
-    slotRef.current ??= createControllerSlot();
-    const slot = slotRef.current;
-    const ownedRunKeyRef = useRef(UNOWNED_RUN_KEY);
+    useEffect(() => {
+        factoryRef.current = options.createController;
+    }, [options.createController]);
+    const [slot] = useState(() => createControllerSlot());
     // Normalize before any dependency array: `enabled: undefined <-> true` and
     // `runKey: undefined <-> null` toggles are identity changes and must not
     // dispose and recreate a live controller.
@@ -67,14 +81,10 @@ export function useNovoRun(options) {
             return;
         }
         const controller = factoryRef.current();
-        ownedRunKeyRef.current = runKey;
-        slot.setController(controller);
+        slot.setController(controller, runKey);
         return () => {
             controller.stop();
             controller.dispose();
-            if (ownedRunKeyRef.current === runKey) {
-                ownedRunKeyRef.current = UNOWNED_RUN_KEY;
-            }
             if (slot.getController() === controller)
                 slot.setController(undefined);
         };
@@ -82,16 +92,16 @@ export function useNovoRun(options) {
     useEffect(() => {
         if (enabled &&
             options.autoStart !== false &&
-            ownedRunKeyRef.current === runKey) {
+            slot.getSnapshot().runKey === runKey) {
             void slot.getController()?.start();
         }
     }, [options.autoStart, enabled, runKey, slot]);
-    const observedState = useSyncExternalStore(slot.subscribe, slot.getSnapshot, () => NOVO_IDLE_RUN_STATE);
-    const ownsRenderedKey = enabled && ownedRunKeyRef.current === runKey;
+    const observed = useSyncExternalStore(slot.subscribe, slot.getSnapshot, () => IDLE_SLOT_SNAPSHOT);
+    const ownsRenderedKey = enabled && observed.runKey === runKey;
     const state = ownsRenderedKey
-        ? observedState
+        ? observed.state
         : NOVO_IDLE_RUN_STATE;
-    const controller = ownsRenderedKey ? slot.getController() : undefined;
+    const controller = ownsRenderedKey ? observed.controller : undefined;
     return useMemo(() => ({
         ...state,
         controller,
@@ -105,3 +115,8 @@ export function useNovoRun(options) {
     }), [controller, state]);
 }
 const UNOWNED_RUN_KEY = Symbol('unowned Novo run key');
+const IDLE_SLOT_SNAPSHOT = Object.freeze({
+    controller: undefined,
+    runKey: UNOWNED_RUN_KEY,
+    state: NOVO_IDLE_RUN_STATE,
+});

package/dist/useNovoRunSelector.js

@@ -1,47 +1,67 @@
 'use client';
-import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
+import { useCallback, useEffect, useMemo, useState, useSyncExternalStore, } from 'react';
 import { NOVO_IDLE_RUN_STATE } from './useNovoRun.js';
 /** Concurrent-safe selector binding with selector/equality identity support. */
 export function useNovoRunSelector(controller, selector, isEqual = Object.is) {
-    const committedSelection = useRef({
-        hasValue: false,
-    });
-    const idleState = NOVO_IDLE_RUN_STATE;
-    const [getSnapshot, getServerSnapshot] = useMemo(() => {
-        let hasMemo = false;
-        let memoizedState;
-        let memoizedSelection;
-        const select = (state) => {
-            if (!hasMemo) {
-                hasMemo = true;
-                memoizedState = state;
-                const nextSelection = selector(state);
-                const committed = committedSelection.current;
-                memoizedSelection =
-                    committed.hasValue && isEqual(committed.value, nextSelection)
-                        ? committed.value
-                        : nextSelection;
-                return memoizedSelection;
-            }
-            if (Object.is(memoizedState, state))
-                return memoizedSelection;
-            const nextSelection = selector(state);
-            memoizedState = state;
-            if (isEqual(memoizedSelection, nextSelection))
-                return memoizedSelection;
-            memoizedSelection = nextSelection;
-            return memoizedSelection;
-        };
-        const serverSelection = select(idleState);
-        return [
-            () => select(controller?.getSnapshot() ?? idleState),
-            () => serverSelection,
-        ];
-    }, [controller, isEqual, selector]);
+    const [committedSelection] = useState(() => createCommittedSelection());
+    const [getSnapshot, getServerSnapshot] = useMemo(() => createSelectionReader(controller, selector, isEqual, NOVO_IDLE_RUN_STATE, committedSelection), [committedSelection, controller, isEqual, selector]);
     const subscribe = useCallback((listener) => controller?.subscribe(listener) ?? (() => { }), [controller]);
     const selection = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
     useEffect(() => {
-        committedSelection.current = { hasValue: true, value: selection };
-    }, [selection]);
+        committedSelection.write(selection);
+    }, [committedSelection, selection]);
     return selection;
 }
+// Deliberately a mutable cell read during render (via getSnapshot) and
+// written from the commit effect, mirroring React's own
+// useSyncExternalStoreWithSelector shim. The hooks lint layer cannot see a
+// closure-held cell; do not "fix" this back into a ref, which it would flag.
+function createCommittedSelection() {
+    let committed = {
+        hasValue: false,
+    };
+    return {
+        read: () => committed,
+        write: (value) => {
+            committed = { hasValue: true, value };
+        },
+    };
+}
+function createSelectionReader(controller, selector, isEqual, idleState, committedSelection) {
+    let hasValue = false;
+    let value;
+    let memoizedState;
+    let hasServerValue = false;
+    let serverValue;
+    const select = (state) => {
+        if (Object.is(memoizedState, state) && hasValue)
+            return value;
+        const next = selector(state);
+        memoizedState = state;
+        if (!hasValue) {
+            hasValue = true;
+            const committed = committedSelection.read();
+            value =
+                committed.hasValue && isEqual(committed.value, next)
+                    ? committed.value
+                    : next;
+        }
+        else if (!isEqual(value, next)) {
+            value = next;
+        }
+        return value;
+    };
+    const selectServer = () => {
+        if (hasServerValue)
+            return serverValue;
+        const next = selector(idleState);
+        const committed = committedSelection.read();
+        serverValue =
+            committed.hasValue && isEqual(committed.value, next)
+                ? committed.value
+                : next;
+        hasServerValue = true;
+        return serverValue;
+    };
+    return [() => select(controller?.getSnapshot() ?? idleState), selectServer];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@novoagents/react",
-  "version": "0.3.0-alpha.34",
+  "version": "0.3.0-alpha.36",
   "description": "Browser-safe React hooks for Novo Agents streams and interactions.",
   "license": "UNLICENSED",
   "type": "module",
@@ -23,14 +23,14 @@
     "access": "public"
   },
   "peerDependencies": {
-    "novoagents": "0.5.0-alpha.30",
+    "novoagents": "0.5.0-alpha.32",
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "@types/react": "19.2.18",
     "@types/react-dom": "19.2.4",
     "happy-dom": "20.11.6",
-    "novoagents": "0.5.0-alpha.30",
+    "novoagents": "0.5.0-alpha.32",
     "react": "19.2.8",
     "react-dom": "19.2.8",
     "typescript": "6.0.3",