@syncular/react 0.4.1 → 0.5.1

package/dist/use-mutation.d.ts

@@ -1,18 +1,28 @@
-/**
- * `useMutation` — submit local mutations (§6.1). Returns a stable `mutate`
- * that appends to the outbox and applies the optimistic overlay immediately
- * (§7.1); the referencing `useRawSql` re-runs on the resulting
- * invalidation batch, so optimistic writes appear without a manual refetch.
- * `mutate` resolves to the `clientCommitId` (track it against
- * `useConflicts`/status). `isPending`/`error` cover the (usually instant)
- * submit; server acceptance is observed through status + conflicts, not
- * here.
- */
 import type { MutationInput } from '@syncular/client';
+export interface SyncTableDescriptor<Row, Insert, Update, Id> {
+    readonly name: string;
+    readonly primaryKey: keyof Row & string;
+    readonly physicalPrimaryKey: string;
+    readonly __row?: Row;
+    readonly __insert?: Insert;
+    readonly __update?: Update;
+    readonly __id?: Id;
+}
+export interface UseMutationOptions {
+    readonly onSuccess?: (clientCommitId: string) => void;
+    readonly onError?: (error: Error) => void;
+}
 export interface UseMutationResult {
-    /** Submit mutations; resolves to the clientCommitId. */
     mutate: (mutations: readonly MutationInput[]) => Promise<string>;
+    readonly pendingCount: number;
     readonly isPending: boolean;
     readonly error: Error | undefined;
+    readonly resetError: () => void;
+}
+export interface UseTableMutationResult<Insert, Update, Id> extends UseMutationResult {
+    readonly upsert: (values: Insert, baseVersion?: number) => Promise<string>;
+    readonly patch: (id: Id, partial: Partial<Update>, baseVersion?: number) => Promise<string>;
+    readonly remove: (id: Id, baseVersion?: number) => Promise<string>;
 }
-export declare function useMutation(): UseMutationResult;
+export declare function useMutation(options?: UseMutationOptions): UseMutationResult;
+export declare function useMutation<Row, Insert, Update, Id>(table: SyncTableDescriptor<Row, Insert, Update, Id>, options?: UseMutationOptions): UseTableMutationResult<Insert, Update, Id>;

package/dist/use-mutation.js

@@ -1,34 +1,74 @@
-/**
- * `useMutation` — submit local mutations (§6.1). Returns a stable `mutate`
- * that appends to the outbox and applies the optimistic overlay immediately
- * (§7.1); the referencing `useRawSql` re-runs on the resulting
- * invalidation batch, so optimistic writes appear without a manual refetch.
- * `mutate` resolves to the `clientCommitId` (track it against
- * `useConflicts`/status). `isPending`/`error` cover the (usually instant)
- * submit; server acceptance is observed through status + conflicts, not
- * here.
- */
-import { useCallback, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 import { useSyncClient } from './use-client.js';
-export function useMutation() {
+export function useMutation(tableOrOptions, maybeOptions) {
     const client = useSyncClient();
-    const [isPending, setIsPending] = useState(false);
+    const table = tableOrOptions !== undefined && 'name' in tableOrOptions
+        ? tableOrOptions
+        : undefined;
+    const options = table === undefined
+        ? tableOrOptions
+        : maybeOptions;
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    const [pendingCount, setPendingCount] = useState(0);
     const [error, setError] = useState(undefined);
-    const mutate = useCallback(async (mutations) => {
-        setIsPending(true);
+    const resetError = useCallback(() => setError(undefined), []);
+    const run = useCallback(async (operation) => {
+        setPendingCount((count) => count + 1);
         setError(undefined);
         try {
-            const id = await client.mutate(mutations);
+            const id = await operation();
+            optionsRef.current?.onSuccess?.(id);
             return id;
         }
-        catch (err) {
-            const wrapped = err instanceof Error ? err : new Error(String(err));
+        catch (caught) {
+            const wrapped = caught instanceof Error ? caught : new Error(String(caught));
             setError(wrapped);
+            optionsRef.current?.onError?.(wrapped);
             throw wrapped;
         }
         finally {
-            setIsPending(false);
+            setPendingCount((count) => Math.max(0, count - 1));
         }
-    }, [client]);
-    return { mutate, isPending, error };
+    }, []);
+    const mutate = useCallback((mutations) => run(() => client.mutate(mutations)), [client, run]);
+    const base = {
+        mutate,
+        pendingCount,
+        isPending: pendingCount > 0,
+        error,
+        resetError,
+    };
+    const upsert = useCallback((values, baseVersion) => {
+        if (table === undefined)
+            throw new Error('table mutation descriptor missing');
+        return mutate([
+            {
+                table: table.name,
+                op: 'upsert',
+                values: values,
+                ...(baseVersion !== undefined ? { baseVersion } : {}),
+            },
+        ]);
+    }, [mutate, table]);
+    const patch = useCallback((id, partial, baseVersion) => {
+        if (table === undefined)
+            throw new Error('table mutation descriptor missing');
+        return run(() => client.patch(table.name, String(id), partial, baseVersion !== undefined ? { baseVersion } : undefined));
+    }, [client, run, table]);
+    const remove = useCallback((id, baseVersion) => {
+        if (table === undefined)
+            throw new Error('table mutation descriptor missing');
+        return mutate([
+            {
+                table: table.name,
+                op: 'delete',
+                rowId: String(id),
+                ...(baseVersion !== undefined ? { baseVersion } : {}),
+            },
+        ]);
+    }, [mutate, table]);
+    if (table === undefined)
+        return base;
+    return { ...base, upsert, patch, remove };
 }

package/dist/use-query.d.ts

@@ -18,10 +18,12 @@
  * (typegen emits its own `NamedQuery` type), so this hook depends only on the
  * descriptor's structural shape — no generated-file import coupling.
  */
-import type { SqlValue } from '@syncular/client';
+import type { QueryDependency, SqlValue, WindowCoverage } from '@syncular/client';
 import { type UseRawSqlOptions, type UseRawSqlResult } from './use-raw-sql.js';
 /** The structural shape typegen's `NamedQuery<Row, Params>` satisfies. */
 export interface NamedQueryDescriptor<Row, Params> {
+    readonly id: string;
+    readonly hasParams: boolean;
     readonly sql: string;
     readonly tables: readonly string[];
     readonly bind: (params: Params) => readonly SqlValue[];
@@ -29,10 +31,15 @@ export interface NamedQueryDescriptor<Row, Params> {
      * generate-time-checked allowlist (identifiers never come from runtime
      * input). Absent on knob-less queries — `sql` is the whole statement. */
     readonly sqlFor?: (params: Params) => string;
+    readonly dependencies: (params: Params) => readonly QueryDependency[];
+    readonly coverage: (params: Params) => readonly WindowCoverage[];
+    readonly rowKey?: (row: Row) => readonly SqlValue[];
     /** Phantom row carrier (never read at runtime). */
     readonly __row?: Row;
 }
+type NamedQueryOptions<Row> = Omit<UseRawSqlOptions<Row>, 'tables' | 'scopeKeys' | 'dependencies' | 'coverage' | 'rowKey' | 'id'>;
 /** Run a param-less named query live. */
-export declare function useQuery<Row>(query: NamedQueryDescriptor<Row, undefined>, options?: Omit<UseRawSqlOptions, 'tables'>): UseRawSqlResult<Row>;
+export declare function useQuery<Row>(query: NamedQueryDescriptor<Row, undefined>, options?: NamedQueryOptions<Row>): UseRawSqlResult<Row>;
 /** Run a named query live with its typed params. */
-export declare function useQuery<Row, Params>(query: NamedQueryDescriptor<Row, Params>, params: Params, options?: Omit<UseRawSqlOptions, 'tables'>): UseRawSqlResult<Row>;
+export declare function useQuery<Row, Params>(query: NamedQueryDescriptor<Row, Params>, params: Params, options?: NamedQueryOptions<Row>): UseRawSqlResult<Row>;
+export {};

package/dist/use-query.js

@@ -2,13 +2,18 @@ import { useRawSql, } from './use-raw-sql.js';
 export function useQuery(query, paramsOrOptions, maybeOptions) {
     // Overload disambiguation: a param-less query's second arg (if any) is the
     // options object; a parameterized query's second arg is the params.
-    const hasParams = query.bind.length > 0;
+    const hasParams = query.hasParams;
     const params = (hasParams ? paramsOrOptions : undefined);
     const options = (hasParams ? maybeOptions : paramsOrOptions);
     const bound = query.bind(params);
     const sql = query.sqlFor === undefined ? query.sql : query.sqlFor(params);
+    const dependencies = query.dependencies(params);
+    const coverage = query.coverage(params);
     return useRawSql(sql, bound, {
         ...options,
-        tables: query.tables,
+        id: query.id,
+        dependencies,
+        coverage,
+        ...(query.rowKey !== undefined ? { rowKey: query.rowKey } : {}),
     });
 }

package/dist/use-raw-sql.d.ts

@@ -1,39 +1,25 @@
-/**
- * `useRawSql` — a live local SQL query with fine-grained invalidation
- * (TODO 3.1 / DESIGN-eviction I1–I4). The query runs once on mount, then
- * re-runs ONLY when an invalidation event (one per apply batch, from the
- * web-client choke point) touches a table this query depends on — never
- * "re-run everything". Unrelated commits leave the result untouched (I4).
- *
- * Dependencies default to a conservative scan of the SQL text (FROM/JOIN
- * identifiers, {@link inferTables}); pass the explicit `tables` option to
- * override when the text cannot be read (dynamic SQL, views). `scopeKeys`
- * further narrows re-runs to specific §3.1 scope keys when supplied — but
- * a matching TABLE always re-runs (the table is the honest floor; a segment
- * apply carries no per-row scope keys, so table-level is the safe default).
- */
-import type { SqlRow, SqlValue } from '@syncular/client';
-export interface UseRawSqlOptions {
-    /**
-     * Tables this query depends on. Defaults to a conservative scan of `sql`.
-     * Pass explicitly to override the heuristic (the escape hatch).
-     */
+import { type LiveQueryPhase, type QueryDependency, type SqlRow, type SqlValue, type WindowCoverage } from '@syncular/client';
+export interface UseRawSqlOptions<Row = SqlRow> {
+    /** Legacy table list; prefer table-associated `dependencies`. */
     readonly tables?: readonly string[];
-    /**
-     * When set, re-run only if the invalidation event's touched table is a
-     * dependency AND (the event has no scope keys — table-level, e.g. a
-     * bootstrap — OR it touches one of these §3.1 `prefix:value` keys). Leave
-     * unset to re-run on any dependency-table touch.
-     */
+    /** Legacy narrowing applied to every table in `tables`. */
     readonly scopeKeys?: readonly string[];
-    /** Skip running the query (e.g. while inputs are not ready). */
+    readonly dependencies?: readonly QueryDependency[];
+    readonly coverage?: readonly WindowCoverage[];
+    readonly rowKey?: (row: Row) => readonly SqlValue[];
+    /** Generated coverage claims its windows by default. */
+    readonly claimCoverage?: boolean;
     readonly enabled?: boolean;
+    /** Stable identity override for a raw query cache entry. */
+    readonly id?: string;
 }
 export interface UseRawSqlResult<Row> {
     readonly rows: readonly Row[];
+    readonly phase: LiveQueryPhase;
+    readonly revision: bigint | undefined;
     readonly isLoading: boolean;
+    readonly isRefreshing: boolean;
     readonly error: Error | undefined;
-    /** Force a re-run (identity-stable). */
     readonly refresh: () => void;
 }
-export declare function useRawSql<Row = SqlRow>(sql: string, params?: readonly SqlValue[], options?: UseRawSqlOptions): UseRawSqlResult<Row>;
+export declare function useRawSql<Row = SqlRow>(sql: string, params?: readonly SqlValue[], options?: UseRawSqlOptions<Row>): UseRawSqlResult<Row>;

package/dist/use-raw-sql.js

@@ -1,191 +1,59 @@
-/**
- * `useRawSql` — a live local SQL query with fine-grained invalidation
- * (TODO 3.1 / DESIGN-eviction I1–I4). The query runs once on mount, then
- * re-runs ONLY when an invalidation event (one per apply batch, from the
- * web-client choke point) touches a table this query depends on — never
- * "re-run everything". Unrelated commits leave the result untouched (I4).
- *
- * Dependencies default to a conservative scan of the SQL text (FROM/JOIN
- * identifiers, {@link inferTables}); pass the explicit `tables` option to
- * override when the text cannot be read (dynamic SQL, views). `scopeKeys`
- * further narrows re-runs to specific §3.1 scope keys when supplied — but
- * a matching TABLE always re-runs (the table is the honest floor; a segment
- * apply carries no per-row scope keys, so table-level is the safe default).
- */
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { canonicalValue, } from '@syncular/client';
+import { useCallback, useMemo, useSyncExternalStore } from 'react';
 import { inferTables } from './infer-tables.js';
-import { FrameScheduler, reconcileRows } from './query-churn.js';
-import { useSyncClient } from './use-client.js';
-function paramsKey(params) {
-    if (params === undefined || params.length === 0)
-        return '';
-    // Stable identity for the params array so a new array with equal contents
-    // does not thrash the effect. Uint8Array is rare in query params; JSON of
-    // its byte view is stable enough for a dependency key.
-    return JSON.stringify(params.map((p) => (p instanceof Uint8Array ? [...p] : p)));
-}
-function eventMatches(event, tables, scopeKeys) {
-    let tableHit = false;
-    for (const table of event.tables) {
-        if (tables.has(table)) {
-            tableHit = true;
-            break;
-        }
-    }
-    if (!tableHit)
-        return false;
-    // Table matched. If the caller narrowed by scope keys, honor it — but a
-    // table-level event (no scope keys, e.g. a segment bootstrap or reset)
-    // always re-runs, because it carries no key to discriminate on.
-    if (scopeKeys === undefined || scopeKeys.length === 0)
-        return true;
-    if (event.scopeKeys.size === 0)
-        return true;
-    for (const key of scopeKeys) {
-        if (event.scopeKeys.has(key))
-            return true;
-    }
-    return false;
-}
+import { useReactiveStore } from './use-client.js';
+const DISABLED = {
+    rows: [],
+    phase: 'ready',
+    revision: undefined,
+    error: undefined,
+    isRefreshing: false,
+};
+const noSubscribe = () => () => { };
 export function useRawSql(sql, params, options) {
-    const client = useSyncClient();
+    const store = useReactiveStore();
     const enabled = options?.enabled ?? true;
-    const [rows, setRows] = useState([]);
-    const [isLoading, setIsLoading] = useState(enabled);
-    const [error, setError] = useState(undefined);
-    // The previous result plus its per-row content hashes, so a re-run can (a)
-    // skip setRows entirely when nothing changed (zero re-render) and (b) reuse
-    // unchanged row objects so memoized row components keep identity. Held in a
-    // ref — it is not render state; it's the reconcile baseline.
-    const prevRef = useRef(undefined);
-    // The effects depend on stable PRIMITIVE keys (strings), never on the
-    // array/object identities a caller may recreate each render. Latest
-    // sql/params/scopeKeys/dep-tables are read inside the effects via refs.
-    const explicitTables = options?.tables;
-    const scopeKeys = options?.scopeKeys;
-    const key = `${sql} ${paramsKey(params)}`;
-    const scopeKeysKey = scopeKeys?.join(',') ?? '';
-    const sqlRef = useRef(sql);
-    sqlRef.current = sql;
-    const paramsRef = useRef(params);
-    paramsRef.current = params;
-    const scopeKeysRef = useRef(scopeKeys);
-    scopeKeysRef.current = scopeKeys;
-    const depTablesRef = useRef(new Set());
-    depTablesRef.current =
-        explicitTables !== undefined ? new Set(explicitTables) : inferTables(sql);
-    // The single re-run routine, held in a ref so the scheduler and the
-    // subscription can call the LATEST closure without re-subscribing. It queries
-    // once, reconciles the fresh result against the previous, and only sets state
-    // when something actually changed (levers 1a/1b). A `cancelled` guard (reset
-    // per effect commit) makes a re-query from a stale mount a no-op.
-    const runRef = useRef();
-    const cancelledRef = useRef(false);
-    // `key`/`tick` are re-run triggers read via refs, not values used in the
-    // body — the pinned dep list re-runs the query on identity change.
-    const [tick, setTick] = useState(0);
-    const refresh = useCallback(() => setTick((n) => n + 1), []);
-    // One scheduler per hook instance, created lazily and re-run through the ref
-    // so a burst of invalidations coalesces to one query per frame (lever 2).
-    const schedulerRef = useRef();
-    if (schedulerRef.current === undefined) {
-        schedulerRef.current = new FrameScheduler(() => runRef.current?.());
-    }
-    // Latest committed loading/error, tracked in refs so the run can set state
-    // ONLY on a real transition. React does not reliably bail on a no-op
-    // `setState(sameValue)` when other setters fire in the same batch (it can
-    // still commit a render), so lever 1a — zero re-render on unchanged data —
-    // requires us to guard every setter, not just setRows.
-    const isLoadingValueRef = useRef(isLoading);
-    isLoadingValueRef.current = isLoading;
-    const errorValueRef = useRef(error);
-    errorValueRef.current = error;
-    const setLoadingIfChanged = (value) => {
-        if (isLoadingValueRef.current !== value) {
-            isLoadingValueRef.current = value;
-            setIsLoading(value);
-        }
-    };
-    const setErrorIfChanged = (value) => {
-        if (errorValueRef.current !== value) {
-            errorValueRef.current = value;
-            setError(value);
-        }
-    };
-    // Keep the run closure current every render (it closes over client via ref).
-    runRef.current = async () => {
-        if (cancelledRef.current)
-            return;
-        try {
-            const result = await client.query(sqlRef.current, paramsRef.current);
-            if (cancelledRef.current)
-                return;
-            const fresh = result;
-            const { next } = reconcileRows(prevRef.current, fresh);
-            if (next !== undefined) {
-                prevRef.current = next;
-                setRows(next.rows);
-            }
-            // next === undefined → whole result unchanged: NO setRows (zero re-render).
-            setErrorIfChanged(undefined);
-            setLoadingIfChanged(false);
-        }
-        catch (err) {
-            if (cancelledRef.current)
-                return;
-            setErrorIfChanged(err instanceof Error ? err : new Error(String(err)));
-            setLoadingIfChanged(false);
-        }
+    const inferred = options?.tables ?? [...inferTables(sql)];
+    const dependencies = options?.dependencies ??
+        inferred.map((table) => ({
+            table,
+            ...(options?.scopeKeys !== undefined
+                ? { scopeKeys: options.scopeKeys }
+                : {}),
+        }));
+    const coverage = options?.coverage ?? [];
+    const identity = canonicalValue({
+        sql,
+        params: params ?? [],
+        dependencies,
+        coverage,
+        ...(options?.id !== undefined ? { id: options.id } : {}),
+    });
+    // `identity` canonically contains every value-shaped input. Depending on
+    // the caller's array/object references would defeat value-stable query
+    // identity; executable rowKey intentionally follows function identity.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: canonical value identity is the dependency
+    const entry = useMemo(() => store.query({
+        id: options?.id ?? `raw:${identity}`,
+        sql,
+        ...(params !== undefined ? { params } : {}),
+        dependencies,
+        ...(coverage.length > 0 ? { coverage } : {}),
+        ...(options?.rowKey !== undefined ? { rowKey: options.rowKey } : {}),
+        claimCoverage: options?.claimCoverage ?? true,
+    }), [store, identity, options?.rowKey]);
+    const snapshot = useSyncExternalStore(enabled ? entry.subscribe : noSubscribe, enabled ? entry.getSnapshot : () => DISABLED, enabled ? entry.getSnapshot : () => DISABLED);
+    const refresh = useCallback(() => {
+        if (enabled)
+            entry.refresh();
+    }, [enabled, entry]);
+    return {
+        rows: snapshot.rows,
+        phase: snapshot.phase,
+        revision: snapshot.revision,
+        isLoading: snapshot.phase === 'loading',
+        isRefreshing: snapshot.isRefreshing,
+        error: snapshot.error,
+        refresh,
     };
-    // Mount / query-identity / refresh: run immediately (not frame-coalesced —
-    // the caller changed the query, so it must reflect at once). Invalidations go
-    // through the scheduler instead.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: key/tick are intentional re-run triggers
-    useEffect(() => {
-        cancelledRef.current = false;
-        if (!enabled) {
-            setLoadingIfChanged(false);
-            return;
-        }
-        // A query-identity change invalidates the reconcile baseline (a different
-        // query's rows are not comparable to this one's), so reset it.
-        prevRef.current = undefined;
-        setLoadingIfChanged(true);
-        void runRef.current?.();
-        return () => {
-            cancelledRef.current = true;
-        };
-    }, [client, key, enabled, tick]);
-    // Subscribe once per client/enabled/query identity; a matching event asks the
-    // scheduler for a run (coalesced). `key`/`scopeKeysKey` re-key the sub. The
-    // scheduler is read from the ref AT EVENT TIME (never captured at effect
-    // setup): the lifecycle effect below may replace it on a remount, and a
-    // captured disposed instance would swallow every schedule() silently.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: key/scopeKeysKey re-key the subscription intentionally
-    useEffect(() => {
-        if (!enabled)
-            return;
-        const unsubscribe = client.onInvalidate((event) => {
-            if (eventMatches(event, depTablesRef.current, scopeKeysRef.current)) {
-                schedulerRef.current?.schedule();
-            }
-        });
-        return unsubscribe;
-    }, [client, enabled, key, scopeKeysKey]);
-    // Scheduler lifecycle. Under StrictMode (and any future fiber remount)
-    // React runs mount → cleanup → mount on the SAME hook instance: the cleanup
-    // disposes the scheduler, so the setup must RE-CREATE it — the render-time
-    // lazy init above never runs again (the ref is non-undefined), and a
-    // disposed scheduler turns every later invalidation into a silent no-op
-    // that freezes the live query forever.
-    useEffect(() => {
-        if (schedulerRef.current === undefined) {
-            schedulerRef.current = new FrameScheduler(() => runRef.current?.());
-        }
-        return () => {
-            schedulerRef.current?.dispose();
-            schedulerRef.current = undefined;
-        };
-    }, []);
-    return { rows, isLoading, error, refresh };
 }

package/dist/use-sync-status.d.ts

@@ -1,29 +1,12 @@
-/**
- * `useSyncStatus` — the client's operational status: outbox depth,
- * upgrading (§7.4.5), leaseState (§7.3.5), schemaFloor (§1.6), and
- * syncNeeded (§8.4). Status is derived by polling the normalized accessors
- * after every apply batch (invalidation is the natural "something changed"
- * signal) plus an initial read; `refresh()` re-reads on demand.
- *
- * `online` is not a protocol concept the client exposes directly (§1.3
- * transport-owned), so it is reported as `undefined` unless a future
- * accessor lands — the hook surfaces what the core actually knows, never a
- * guessed value.
- */
 import type { LeaseState, SchemaFloor } from '@syncular/client';
 export interface SyncStatus {
-    /** Pending outbox commits (unpushed local writes). */
     readonly outbox: number;
-    /** §7.4.5: a schema-bump reset + first re-bootstrap is in flight. */
     readonly upgrading: boolean;
-    /** §7.3.5: opaque auth-lease state, or undefined. */
     readonly leaseState: LeaseState | undefined;
-    /** §1.6: server-declared schema floor (syncing stopped), or undefined. */
     readonly schemaFloor: SchemaFloor | undefined;
-    /** §8.4: the host loop should run a pull soon. */
     readonly syncNeeded: boolean;
-    /** True until the first status read resolves. */
     readonly isLoading: boolean;
+    readonly error: Error | undefined;
     readonly refresh: () => void;
 }
 export declare function useSyncStatus(): SyncStatus;

package/dist/use-sync-status.js

@@ -1,67 +1,17 @@
-/**
- * `useSyncStatus` — the client's operational status: outbox depth,
- * upgrading (§7.4.5), leaseState (§7.3.5), schemaFloor (§1.6), and
- * syncNeeded (§8.4). Status is derived by polling the normalized accessors
- * after every apply batch (invalidation is the natural "something changed"
- * signal) plus an initial read; `refresh()` re-reads on demand.
- *
- * `online` is not a protocol concept the client exposes directly (§1.3
- * transport-owned), so it is reported as `undefined` unless a future
- * accessor lands — the hook surfaces what the core actually knows, never a
- * guessed value.
- */
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { useSyncClient } from './use-client.js';
-const INITIAL = {
-    outbox: 0,
-    upgrading: false,
-    leaseState: undefined,
-    schemaFloor: undefined,
-    syncNeeded: false,
-    isLoading: true,
-};
+import { useCallback, useSyncExternalStore } from 'react';
+import { useReactiveStore } from './use-client.js';
 export function useSyncStatus() {
-    const client = useSyncClient();
-    const [state, setState] = useState(INITIAL);
-    // `refresh` re-reads through a ref set by the effect (identity-stable, no
-    // tick state — biome-clean deps).
-    const readRef = useRef(() => { });
-    const refresh = useCallback(() => readRef.current(), []);
-    useEffect(() => {
-        let cancelled = false;
-        const read = () => {
-            Promise.all([
-                client.pendingCommits(),
-                client.upgrading(),
-                client.leaseState(),
-                client.schemaFloor(),
-                client.syncNeeded(),
-            ])
-                .then(([pending, upgrading, leaseState, schemaFloor, syncNeeded]) => {
-                if (cancelled)
-                    return;
-                setState({
-                    outbox: pending.length,
-                    upgrading,
-                    leaseState,
-                    schemaFloor,
-                    syncNeeded,
-                    isLoading: false,
-                });
-            })
-                .catch(() => {
-                if (!cancelled)
-                    setState((s) => ({ ...s, isLoading: false }));
-            });
-        };
-        readRef.current = read;
-        read();
-        // Re-read on every apply batch — the "state changed" edge.
-        const unsubscribe = client.onInvalidate(read);
-        return () => {
-            cancelled = true;
-            unsubscribe();
-        };
-    }, [client]);
-    return { ...state, refresh };
+    const entry = useReactiveStore().status;
+    const snapshot = useSyncExternalStore(entry.subscribe, entry.getSnapshot, entry.getSnapshot);
+    const refresh = useCallback(() => entry.refresh(), [entry]);
+    return {
+        outbox: snapshot.status?.outbox ?? 0,
+        upgrading: snapshot.status?.upgrading ?? false,
+        leaseState: snapshot.status?.leaseState,
+        schemaFloor: snapshot.status?.schemaFloor,
+        syncNeeded: snapshot.status?.syncNeeded ?? false,
+        isLoading: snapshot.isLoading,
+        error: snapshot.error,
+        refresh,
+    };
 }