@novoagents/react 0.1.0-alpha.0 → 0.2.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.2.0-alpha.0 - 2026-07-14
+
+- Replaced the alpha store/transport hooks with effect-owned bindings over the
+  canonical `NovoRunController`.
+- Added `useNovoRunSelector` and controller-bound `useNovoInteractions`.
+- Fixed run-key/unmount leaks with stop + disposal and generation-fenced core
+  consumption.
+- Added client entry directives, `sideEffects: false`, React 18/19 peer range,
+  SSR snapshots, and Strict Mode lifecycle coverage.

package/README.md

@@ -1,31 +1,64 @@
 # @novoagents/react
 
-Headless React hooks for rendering Novo Agents runs in the browser. The hooks
-manage state and render nothing — bring your own components. This package
-never accepts an API key: it talks to **your** server routes, which proxy to
-`api.novoagents.ai` with the server-only `novoagents` SDK. Its only runtime
-dependency is the browser-safe `novoagents/browser` entry point.
-
-## Hooks
-
-- `useNovoRun({ transport })` — consumes the run stream through your proxy
-  routes and returns live UI state: `messages`, `status`,
-  `pendingInteractions`, `usage`, and `resume()`. One component instance keeps
-  exactly one store and one stream consumption, so an inline `transport`
-  object literal is safe across re-renders; pass a new `runKey` to
-  intentionally reset. Reconnects until the `data-novo-terminal` chunk (a
-  closed connection is not a finished run), with jittered exponential backoff
-  between unproductive reconnects.
-- `useNovoInteractions({ endpoint, run })` — sources pending
-  approvals/questions from the same stream state, POSTs the batch resolution
-  shape to your proxied resolve route, and calls the run's `resume()` after a
-  successful resolution so the parked stream picks back up from the last seen
-  event id.
-
-See the full guide with proxy routes and a working component:
-[Build a React run UI](https://novoagents.ai/docs/guides/build-a-react-run-ui).
+Headless React bindings for the canonical browser run controller in
+`novoagents/browser`. The package renders nothing, ships no CSS, and never
+accepts a Novo API key. Browser requests go only to your authenticated proxy
+routes.
+
+```tsx
+'use client';
+
+import { useNovoInteractions, useNovoRun } from '@novoagents/react';
+import {
+  createHttpInteractionResolveTransport,
+  createNovoHttpRunSource,
+  createNovoRunController,
+} from 'novoagents/browser';
+
+export function RunView({ runId }: { runId: string }) {
+  const run = useNovoRun({
+    runKey: runId,
+    createController: () =>
+      createNovoRunController({
+        source: createNovoHttpRunSource({
+          url: `/api/runs/${runId}/stream`,
+          pollUrl: `/api/runs/${runId}`,
+        }),
+        interactions: createHttpInteractionResolveTransport({
+          endpoint: `/api/runs/${runId}/interactions/resolve`,
+        }),
+      }),
+  });
+  const inbox = useNovoInteractions(run.controller);
+
+  return <main>{run.status} · {run.messages.length} messages · {inbox.interactions.length} pending</main>;
+}
+```
+
+`useNovoRun` creates its controller inside an effect, owns it for one `runKey`,
+and stops/disposes it on replacement or unmount. `useNovoRunSelector` provides
+concurrent-safe selected subscriptions. `useNovoInteractions` binds the
+controller's `interactions.pending` queue and resolution primitive.
+
+If your host persists interaction requests independently of the stream,
+configure `interactionDiscovery: { list, intervalMs? }` on the controller.
+Discovery is generation-fenced, runs while the SSE connection is idle, and
+reconciles DB-only requests into the same canonical pending queue.
+
+## Migrating from 0.1.0-alpha.0
+
+- `createNovoRunStore` → `createNovoRunController` from `novoagents/browser`.
+- `BrowserRunTransport` → `NovoRunEventSource`; use
+  `createNovoHttpRunSource` for fetch/SSE routes.
+- `useNovoRun({ transport })` →
+  `useNovoRun({ createController, runKey })`.
+- `useNovoInteractions({ endpoint, run })` → configure the controller's
+  interaction transport, then call `useNovoInteractions(run.controller)`.
+- `resolveNovoInteractions` → `createHttpInteractionResolveTransport`.
+
+There are no compatibility aliases for the alpha API.
 
 ## Publishing
 
-Publish with `pnpm publish` (not `npm publish`): the `workspace:*` dependency
-on `novoagents` is rewritten to the real version only by pnpm's pack step.
+Publish with `pnpm publish`: pnpm rewrites the `workspace:*` dependency on
+`novoagents` to the packed version.

package/dist/index.d.ts

@@ -1,2 +1,4 @@
-export { createNovoRunStore, useNovoRun, type NovoRunStore, type UseNovoRunOptions, type UseNovoRunResult, } from './useNovoRun.js';
-export { resolveNovoInteractions, useNovoInteractions, type NovoInteractionResolutionItem, type NovoInteractionResolutionOutcome, type NovoInteractionRunSource, type NovoPendingInteraction, } from './useNovoInteractions.js';
+export { NOVO_IDLE_RUN_STATE, useNovoRun, type UseNovoRunOptions, type UseNovoRunResult, } from './useNovoRun.js';
+export { useNovoRunSelector } from './useNovoRunSelector.js';
+export { useNovoInteractions, type NovoPendingInteraction, } from './useNovoInteractions.js';
+export type { NovoInteractionResolutionItem, NovoInteractionResolutionOutcome, NovoRunController, NovoRunControllerState, } from 'novoagents/browser';

package/dist/index.js

@@ -1,2 +1,4 @@
-export { createNovoRunStore, useNovoRun, } from './useNovoRun.js';
-export { resolveNovoInteractions, useNovoInteractions, } from './useNovoInteractions.js';
+'use client';
+export { NOVO_IDLE_RUN_STATE, useNovoRun, } from './useNovoRun.js';
+export { useNovoRunSelector } from './useNovoRunSelector.js';
+export { useNovoInteractions, } from './useNovoInteractions.js';

package/dist/useNovoInteractions.d.ts

@@ -1,48 +1,9 @@
-import type { NovoUiPendingInteraction } from 'novoagents/browser';
-export type NovoPendingInteraction = {
-    id: string;
-    kind: 'approval_request' | 'question';
-    status: 'pending' | 'resuming';
-} & Record<string, unknown>;
-export type NovoInteractionResolutionItem = {
-    id: string;
-    inputResponses?: Array<Record<string, unknown>>;
-    cancel?: boolean;
-    reason?: string;
+import type { NovoInteractionResolutionItem, NovoInteractionResolutionOutcome, NovoRunController, NovoUiPendingInteraction } from 'novoagents/browser';
+export type NovoPendingInteraction = NovoUiPendingInteraction & {
+    status: 'pending' | 'resolving';
 };
-export type NovoInteractionResolutionOutcome = {
-    id: string;
-    status: 'resolved' | 'already_resolved' | 'conflict' | 'not_found' | 'invalid_body';
-};
-/**
- * The slice of a `useNovoRun` result (or `NovoRunStore`-shaped object) that
- * interactions can be sourced from: the reducer's pending queue plus the
- * resume path invoked after a successful resolution.
- */
-export type NovoInteractionRunSource = {
-    pendingInteractions: readonly NovoUiPendingInteraction[];
-    resume?: () => Promise<void>;
-};
-export declare function resolveNovoInteractions(input: {
-    endpoint: string;
-    items: NovoInteractionResolutionItem[];
-    fetch?: typeof globalThis.fetch;
-}): Promise<NovoInteractionResolutionOutcome[]>;
-/**
- * Track and resolve the run's pending approvals/questions through your proxied
- * batch resolve route. Zero-config source: pass the `useNovoRun` result as
- * `run` and pending interactions come from the stream reducer, with the run's
- * `resume()` invoked automatically once a resolution lands. An explicit
- * `interactions` array (e.g. from your own discovery endpoint) overrides the
- * run source.
- */
-export declare function useNovoInteractions(input: {
-    endpoint: string;
-    run?: NovoInteractionRunSource;
-    interactions?: NovoPendingInteraction[];
-    fetch?: typeof globalThis.fetch;
-}): {
-    interactions: NovoPendingInteraction[];
-    resolve(items: NovoInteractionResolutionItem[]): Promise<NovoInteractionResolutionOutcome[]>;
+export declare function useNovoInteractions<TMetadata = unknown, TDataPart = unknown>(controller: NovoRunController<TMetadata, TDataPart> | undefined): {
+    interactions: readonly NovoPendingInteraction[];
+    resolve(items: readonly NovoInteractionResolutionItem[]): Promise<readonly NovoInteractionResolutionOutcome[]>;
     error: Error | undefined;
 };

package/dist/useNovoInteractions.js

@@ -1,68 +1,27 @@
-import { useCallback, useState } from 'react';
-export async function resolveNovoInteractions(input) {
-    const request = input.fetch ?? globalThis.fetch;
-    const response = await request(input.endpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ items: input.items }),
-    });
-    const body = (await response.json());
-    if (!response.ok) {
-        throw new Error(body.error?.message ?? `Interaction resolve failed (${response.status}).`);
-    }
-    return body.items ?? [];
-}
-/**
- * Track and resolve the run's pending approvals/questions through your proxied
- * batch resolve route. Zero-config source: pass the `useNovoRun` result as
- * `run` and pending interactions come from the stream reducer, with the run's
- * `resume()` invoked automatically once a resolution lands. An explicit
- * `interactions` array (e.g. from your own discovery endpoint) overrides the
- * run source.
- */
-export function useNovoInteractions(input) {
-    const [resolvedIds, setResolvedIds] = useState(() => new Set());
-    const [error, setError] = useState();
-    const resume = input.run?.resume;
-    const resolve = useCallback(async (items) => {
-        try {
-            const outcomes = await resolveNovoInteractions({
-                endpoint: input.endpoint,
-                items,
-                ...(input.fetch ? { fetch: input.fetch } : {}),
-            });
-            const resolved = new Set(outcomes
-                .filter((item) => item.status === 'resolved' ||
-                item.status === 'already_resolved')
-                .map((item) => item.id));
-            if (resolved.size > 0) {
-                setResolvedIds((current) => new Set([...current, ...resolved]));
-                // The run resumed (or will resume) server-side; restart stream
-                // consumption so the resolved chunk and subsequent output arrive.
-                void resume?.();
-            }
-            setError(undefined);
-            return outcomes;
-        }
-        catch (caught) {
-            const next = caught instanceof Error
-                ? caught
-                : new Error('Interaction resolve failed.');
-            setError(next);
-            throw next;
+'use client';
+import { useCallback } from 'react';
+import { useNovoRunSelector } from './useNovoRunSelector.js';
+export function useNovoInteractions(controller) {
+    const selected = useNovoRunSelector(controller, (state) => ({
+        pending: state.interactions.pending,
+        resolving: state.interactions.resolving,
+        error: state.interactions.error,
+    }), (left, right) => left.pending === right.pending &&
+        left.resolving === right.resolving &&
+        left.error === right.error);
+    const resolving = new Set(selected.resolving);
+    const resolve = useCallback((items) => {
+        if (!controller) {
+            return Promise.reject(new Error('No Novo run controller is mounted.'));
         }
-    }, [input.endpoint, input.fetch, resume]);
-    const sourced = input.interactions ??
-        (input.run?.pendingInteractions ?? []).map((interaction) => ({
-            ...interaction,
-            kind: interaction.request.kind,
-            status: 'pending',
-        }));
+        return controller.resolveInteractions(items);
+    }, [controller]);
     return {
-        // resolvedIds bridges the gap between the resolve acknowledgement and the
-        // stream's own data-novo-input-resolved chunk removing the entry.
-        interactions: sourced.filter((interaction) => !resolvedIds.has(interaction.id)),
+        interactions: selected.pending.map((interaction) => ({
+            ...interaction,
+            status: resolving.has(interaction.id) ? 'resolving' : 'pending',
+        })),
         resolve,
-        error,
+        error: selected.error,
     };
 }

package/dist/useNovoRun.d.ts

@@ -1,41 +1,23 @@
-import { type BrowserRunTransport, type NovoAgentEvent, type NovoRunUiState } from 'novoagents/browser';
-export type NovoRunStore = {
-    subscribe(listener: () => void): () => void;
-    getSnapshot(): NovoRunUiState;
-    /**
-     * Begin consuming the run stream. Idempotent: repeat calls return the
-     * in-flight (or last) consumption instead of starting another.
-     */
-    start(): Promise<void>;
-    /**
-     * Restart consumption from the last seen event id. No-op while consumption
-     * is active or after the terminal chunk; the restart path exists because a
-     * pause (`waiting_for_approval` / `waiting_for_input`) ends consumption —
-     * call this after resolving interactions so the resumed run streams again.
-     * Also retries after a stream failure.
-     */
-    resume(): Promise<void>;
-};
-export declare function createNovoRunStore(transport: BrowserRunTransport<NovoAgentEvent> | (() => BrowserRunTransport<NovoAgentEvent>)): NovoRunStore;
-export type UseNovoRunOptions = {
-    transport: BrowserRunTransport<NovoAgentEvent>;
+import type { NovoRunController, NovoRunControllerState } from 'novoagents/browser';
+export declare const NOVO_IDLE_RUN_STATE: NovoRunControllerState;
+export type UseNovoRunOptions<TMetadata = unknown, TDataPart = unknown> = {
+    /** A fresh controller factory. It is invoked only from the owning effect. */
+    createController: () => NovoRunController<TMetadata, TDataPart>;
     autoStart?: boolean;
-    /**
-     * Escape hatch for intentional resets: a new key discards the store and
-     * consumes the stream from scratch. The abandoned consumption is not
-     * cancelled — it stops at the run's next pause or terminal.
-     */
-    runKey?: string | number;
+    /** Changing this key stops/disposes the old controller and creates a new one. */
+    runKey?: string | number | null;
+    enabled?: boolean;
 };
-export type UseNovoRunResult = NovoRunUiState & {
-    /** See {@link NovoRunStore.resume}. */
-    resume(): Promise<void>;
-    store: NovoRunStore;
+export type UseNovoRunResult<TMetadata = unknown, TDataPart = unknown> = NovoRunControllerState<TMetadata, TDataPart> & {
+    controller: NovoRunController<TMetadata, TDataPart> | undefined;
+    start(): Promise<NovoRunControllerState<TMetadata, TDataPart>>;
+    resume(): Promise<NovoRunControllerState<TMetadata, TDataPart>>;
+    stop(): void;
+    cancelRun(): Promise<NovoRunControllerState<TMetadata, TDataPart>>;
 };
 /**
- * Consume a run stream through your proxy transport and expose the reduced UI
- * state. One store (one stream consumption) per component instance: passing an
- * inline `transport` object literal is safe across re-renders — the latest
- * transport is read through a ref without re-creating the store.
+ * Own exactly one controller per enabled `runKey`. Creation happens inside the
+ * effect so Strict Mode's mount/cleanup/remount cycle leaves no live transport
+ * behind; cleanup stops and permanently disposes the effect-owned controller.
  */
-export declare function useNovoRun(input: UseNovoRunOptions): UseNovoRunResult;
+export declare function useNovoRun<TMetadata = unknown, TDataPart = unknown>(options: UseNovoRunOptions<TMetadata, TDataPart>): UseNovoRunResult<TMetadata, TDataPart>;

package/dist/useNovoRun.js

@@ -1,107 +1,101 @@
-import { useEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
-import { consumeRunWithReconnect, createNovoRunUiReducer, } from 'novoagents/browser';
-export function createNovoRunStore(transport) {
-    const currentTransport = typeof transport === 'function' ? transport : () => transport;
-    const reducer = createNovoRunUiReducer();
+'use client';
+import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+export const NOVO_IDLE_RUN_STATE = Object.freeze({
+    messages: Object.freeze([]),
+    status: 'queued',
+    pendingInteractions: Object.freeze([]),
+    tasks: Object.freeze([]),
+    steps: Object.freeze([]),
+    browserSessions: Object.freeze([]),
+    warnings: Object.freeze([]),
+    warningCounts: Object.freeze({}),
+    connection: 'idle',
+    persistence: Object.freeze({ state: 'idle', pendingWrites: 0 }),
+    interactions: Object.freeze({
+        pending: Object.freeze([]),
+        resolving: Object.freeze([]),
+    }),
+});
+function createControllerSlot() {
     const listeners = new Set();
-    let state = reducer.getState();
-    let lastEventId;
-    let active;
-    let latest;
-    let reachedTerminal = false;
-    const publish = (next) => {
-        state = next;
+    let controller;
+    let unsubscribe;
+    const publish = () => {
         for (const listener of listeners)
             listener();
     };
-    const consume = () => {
-        const promise = consumeRunWithReconnect({
-            // Read the transport per call so the latest closure is always used.
-            transport: {
-                connect: (fromEventId) => currentTransport().connect(fromEventId),
-                pollRun: () => currentTransport().pollRun(),
-            },
-            ...(lastEventId !== undefined ? { initialLastEventId: lastEventId } : {}),
-            isTerminalEvent: (event) => event.type === 'data-novo-terminal',
-            onFrame: ({ id, event }) => {
-                if (id !== undefined)
-                    lastEventId = id;
-                if (event)
-                    publish(reducer.reduce(event));
-            },
-            onPoll: (run) => {
-                if (run.status === 'waiting_for_approval' ||
-                    run.status === 'waiting_for_input') {
-                    publish({ ...state, status: run.status });
-                }
-            },
-        })
-            .then((result) => {
-            if (result.reachedTerminal)
-                reachedTerminal = true;
-        }, (error) => {
-            publish({
-                ...state,
-                status: 'failed',
-                error: {
-                    type: 'api_error',
-                    code: 'stream_error',
-                    message: error instanceof Error ? error.message : 'Stream failed.',
-                },
-            });
-        })
-            .then(() => {
-            if (active === promise)
-                active = undefined;
-        });
-        active = promise;
-        latest = promise;
-        return promise;
-    };
     return {
         subscribe(listener) {
             listeners.add(listener);
             return () => listeners.delete(listener);
         },
-        getSnapshot: () => state,
-        start() {
-            return latest ?? consume();
-        },
-        resume() {
-            if (active)
-                return active;
-            if (reachedTerminal)
-                return latest ?? Promise.resolve();
-            return consume();
+        getSnapshot: () => controller?.getSnapshot() ??
+            NOVO_IDLE_RUN_STATE,
+        getController: () => controller,
+        setController(next) {
+            if (controller === next)
+                return;
+            unsubscribe?.();
+            controller = next;
+            unsubscribe = next?.subscribe(publish);
+            publish();
         },
     };
 }
 /**
- * Consume a run stream through your proxy transport and expose the reduced UI
- * state. One store (one stream consumption) per component instance: passing an
- * inline `transport` object literal is safe across re-renders — the latest
- * transport is read through a ref without re-creating the store.
+ * Own exactly one controller per enabled `runKey`. Creation happens inside the
+ * effect so Strict Mode's mount/cleanup/remount cycle leaves no live transport
+ * behind; cleanup stops and permanently disposes the effect-owned controller.
  */
-export function useNovoRun(input) {
-    const transportRef = useRef(input.transport);
-    const [entry, setEntry] = useState(() => ({
-        key: input.runKey,
-        store: createNovoRunStore(() => transportRef.current),
-    }));
-    if (!Object.is(entry.key, input.runKey)) {
-        setEntry({
-            key: input.runKey,
-            store: createNovoRunStore(() => transportRef.current),
-        });
-    }
-    const store = entry.store;
+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(() => {
-        transportRef.current = input.transport;
-    });
+        if (options.enabled === false) {
+            slot.setController(undefined);
+            return;
+        }
+        const controller = factoryRef.current();
+        ownedRunKeyRef.current = options.runKey ?? null;
+        slot.setController(controller);
+        return () => {
+            controller.stop();
+            controller.dispose();
+            if (ownedRunKeyRef.current === (options.runKey ?? null)) {
+                ownedRunKeyRef.current = UNOWNED_RUN_KEY;
+            }
+            if (slot.getController() === controller)
+                slot.setController(undefined);
+        };
+    }, [options.enabled, options.runKey, slot]);
     useEffect(() => {
-        if (input.autoStart !== false)
-            void store.start();
-    }, [input.autoStart, store]);
-    const state = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-    return useMemo(() => ({ ...state, resume: store.resume, store }), [state, store]);
+        if (options.enabled !== false &&
+            options.autoStart !== false &&
+            ownedRunKeyRef.current === (options.runKey ?? null)) {
+            void slot.getController()?.start();
+        }
+    }, [options.autoStart, options.enabled, options.runKey, slot]);
+    const observedState = useSyncExternalStore(slot.subscribe, slot.getSnapshot, () => NOVO_IDLE_RUN_STATE);
+    const ownsRenderedKey = options.enabled !== false &&
+        ownedRunKeyRef.current === (options.runKey ?? null);
+    const state = ownsRenderedKey
+        ? observedState
+        : NOVO_IDLE_RUN_STATE;
+    const controller = ownsRenderedKey ? slot.getController() : undefined;
+    return useMemo(() => ({
+        ...state,
+        controller,
+        start: () => controller?.start() ??
+            Promise.resolve(NOVO_IDLE_RUN_STATE),
+        resume: () => controller?.resume() ??
+            Promise.resolve(NOVO_IDLE_RUN_STATE),
+        stop: () => controller?.stop(),
+        cancelRun: () => controller?.cancelRun() ??
+            Promise.resolve(NOVO_IDLE_RUN_STATE),
+    }), [controller, state]);
 }
+const UNOWNED_RUN_KEY = Symbol('unowned Novo run key');

package/dist/useNovoRunSelector.d.ts

@@ -0,0 +1,3 @@
+import type { NovoRunController, NovoRunControllerState } from 'novoagents/browser';
+/** Concurrent-safe selector binding with selector/equality identity support. */
+export declare function useNovoRunSelector<T, TMetadata = unknown, TDataPart = unknown>(controller: NovoRunController<TMetadata, TDataPart> | undefined, selector: (state: NovoRunControllerState<TMetadata, TDataPart>) => T, isEqual?: (left: T, right: T) => boolean): T;

package/dist/useNovoRunSelector.js

@@ -0,0 +1,47 @@
+'use client';
+import { useCallback, useEffect, useMemo, useRef, 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 subscribe = useCallback((listener) => controller?.subscribe(listener) ?? (() => { }), [controller]);
+    const selection = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    useEffect(() => {
+        committedSelection.current = { hasValue: true, value: selection };
+    }, [selection]);
+    return selection;
+}

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "@novoagents/react",
-  "version": "0.1.0-alpha.0",
+  "version": "0.2.0-alpha.0",
   "description": "Browser-safe React hooks for Novo Agents streams and interactions.",
   "license": "UNLICENSED",
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "exports": {
     ".": {
@@ -21,10 +23,10 @@
     "access": "public"
   },
   "dependencies": {
-    "novoagents": "0.3.0-alpha.51"
+    "novoagents": "0.4.0-alpha.0"
   },
   "peerDependencies": {
-    "react": ">=18"
+    "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
     "@types/react": "19.2.17",
@@ -37,7 +39,7 @@
     "vitest": "5.0.0-beta.6"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node scripts/check-dist.mjs",
     "clean": "rm -rf dist",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit"