@convex-localfirst/react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fanzzzd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,28 @@
+# @convex-localfirst/react
+
+Convex-compatible React hooks for local-first, offline-capable apps. Keep writing
+`useQuery` / `useMutation` — local-first tables read and write optimistically, work
+offline, and sync in the background, with Convex as the source of truth.
+
+```bash
+npm install @convex-localfirst/react
+```
+
+```tsx
+import { useMutation, useQuery, useSyncStatus } from "@convex-localfirst/react";
+import { api } from "../convex/_generated/api";
+
+export function Todos({ listId }: { listId: string }) {
+  const todos = useQuery(api.todos.list, { listId }, { initial: [] });
+  const create = useMutation(api.todos.create);
+  const sync = useSyncStatus();
+
+  return (
+    <button disabled={sync.blockedBySchemaMismatch} onClick={() => create({ listId, text: "Ship it" })}>
+      Add {todos.length} todos
+    </button>
+  );
+}
+```
+
+Peer dependencies: `convex`, `react`. MIT

package/dist/index.d.ts

@@ -0,0 +1,114 @@
+import React from "react";
+import * as ConvexReact from "convex/react";
+import type { FunctionArgs, FunctionReference, FunctionReturnType } from "convex/server";
+import { collection, many, manyToMany, one, type FunctionNameResolver, type LocalFirstManifest, type LocalFirstMutationCall, type LocalQueryPlan, type LocalStore, type RelationSpec, type RowValue, type SyncStatus, type SyncTransport } from "@convex-localfirst/core";
+import { LocalFirstEngine } from "@convex-localfirst/core/internal";
+export { collection, many, manyToMany, one };
+export type { LocalQueryPlan, RelationSpec };
+export declare const ConvexReactClient: typeof ConvexReact.ConvexReactClient;
+export declare const Authenticated: typeof ConvexReact.Authenticated;
+export declare const Unauthenticated: typeof ConvexReact.Unauthenticated;
+export declare const AuthLoading: typeof ConvexReact.AuthLoading;
+export declare const useConvex: typeof ConvexReact.useConvex;
+export declare const useConvexAuth: typeof ConvexReact.useConvexAuth;
+export type LocalFirstProviderConfig = {
+    readonly manifest: LocalFirstManifest;
+    readonly transport?: SyncTransport;
+    /** Local store. Defaults to an in-memory store; pass an IndexedDbStore in the browser. */
+    readonly store?: LocalStore;
+    readonly clientId?: string;
+    readonly userId?: string | null;
+    readonly nameOf?: FunctionNameResolver;
+};
+/**
+ * The convex-aware name resolver (`api.todos.list` → `"todos:list"`) the provider and the
+ * headless factory wire by default. Exported so an imperative consumer building its own
+ * engine doesn't have to inject one.
+ */
+export declare const convexFunctionName: FunctionNameResolver;
+/**
+ * The engine from createConvexLocalFirst, with convex-typed `mutate`/`query`: args and
+ * result infer from the function reference, like the hooks — so headless consumers get the
+ * same inference instead of core's backend-agnostic `reference: unknown`. Core stays
+ * convex-free; the typing lives here in the adapter.
+ */
+export type ConvexLocalFirstEngine = Omit<LocalFirstEngine, "mutate" | "query"> & {
+    mutate<Mutation extends FunctionReference<"mutation">>(reference: Mutation, args: FunctionArgs<Mutation>): LocalFirstMutationCall<FunctionReturnType<Mutation>>;
+    query<Query extends FunctionReference<"query">>(reference: Query, args: FunctionArgs<Query>): Promise<FunctionReturnType<Query> | undefined>;
+};
+export type CreateConvexLocalFirstOptions = {
+    readonly manifest: LocalFirstManifest;
+    /** Pass a Convex client, or a `url` to construct a (reactive) ConvexReactClient. */
+    readonly client?: InstanceType<typeof ConvexReact.ConvexReactClient>;
+    readonly url?: string;
+    readonly userId?: string | null;
+    readonly clientId?: string;
+    /** Local store. Defaults to IndexedDb in the browser, in-memory elsewhere. */
+    readonly store?: LocalStore;
+    /** Names for the default browser IndexedDb store. */
+    readonly databaseName?: string;
+    readonly namespace?: string;
+    /** Sync function refs. Default to the conventional `sync:push` / `sync:pull`. */
+    readonly sync?: {
+        readonly push?: FunctionReference<"mutation">;
+        readonly pull?: FunctionReference<"query">;
+    };
+};
+/**
+ * One-call headless setup for an imperative (non-hook) consumer — a service layer, store,
+ * or Node script. Wires the Convex transport, name resolver, a browser/Node store default,
+ * and a client id (the provider's plumbing minus the React lifecycle). Returns the engine
+ * plus the Convex client (for server-only, non-local-first functions).
+ */
+export declare function createConvexLocalFirst(options: CreateConvexLocalFirstOptions): {
+    readonly engine: ConvexLocalFirstEngine;
+    readonly client: InstanceType<typeof ConvexReact.ConvexReactClient>;
+};
+export declare function ConvexProvider(props: {
+    readonly client: InstanceType<typeof ConvexReact.ConvexReactClient>;
+    readonly children: React.ReactNode;
+    readonly localFirst?: LocalFirstProviderConfig;
+}): React.JSX.Element;
+export type UseLocalFirstQueryOptions<TResult> = {
+    readonly initial?: TResult;
+    /** `"auto"` (default): pull from the server on mount + subscribe to live changes.
+     *  `"off"`: read local data only, never sync this query. (No silent middle ground —
+     *  a "manual" mode with no trigger API would just behave as "auto", so it isn't offered.) */
+    readonly sync?: "auto" | "off";
+};
+/**
+ * Convex-compatible useQuery. Args and result type are inferred from the Convex
+ * function reference (drop-in, no explicit generics — exactly like `convex/react`).
+ * Local-first functions read from the engine and subscribe to local changes;
+ * everything else falls through to Convex.
+ *
+ * All hooks below run unconditionally on every render (no rules-of-hooks
+ * violation): the Convex hook is fed "skip" for local-first functions, and the
+ * local subscription is inert when there is no engine/local definition.
+ */
+export declare function useQuery<Query extends FunctionReference<"query">>(reference: Query, args?: FunctionArgs<Query> | "skip", options?: UseLocalFirstQueryOptions<FunctionReturnType<Query>>): FunctionReturnType<Query> | undefined;
+/**
+ * Reactive local-first query for the chainable `collection(...)` builder. Re-renders on
+ * local data change and refines the derived view with where/order/limit on the client.
+ * The query is rebuilt inline each render, so effects key on the stable (table, scope)
+ * identity, never the per-render object — keeping dynamic predicates live without resubscribing.
+ */
+export type UseLiveQueryOptions = {
+    /**
+     * Real-time FALLBACK for non-reactive transports only. A reactive transport (the default
+     * ConvexReactClient) pushes changes and ignores this; an HTTP client re-pulls the scope
+     * every N ms while mounted. Leave unset for normal data.
+     */
+    readonly pollMs?: number;
+};
+export declare function useLiveQuery<Row extends Record<string, unknown> = RowValue, Rel = unknown>(query: LocalQueryPlan<Row, Rel> | "skip", options?: UseLiveQueryOptions): Array<Row & Rel> | undefined;
+/** Mutators always return the hybrid call shape (await it like Convex, or use .local/.server). */
+export type LocalFirstMutator<TArgs, TResult> = (args: TArgs) => LocalFirstMutationCall<TResult>;
+/**
+ * Convex-compatible useMutation. Args and result type are inferred from the
+ * function reference (no explicit generics). The returned mutator yields the
+ * hybrid call: `await it` resolves to the server result (Convex-identical), and
+ * `.local` / `.server` are separately awaitable.
+ */
+export declare function useMutation<Mutation extends FunctionReference<"mutation">>(reference: Mutation): LocalFirstMutator<FunctionArgs<Mutation>, FunctionReturnType<Mutation>>;
+export declare function useSyncStatus(): SyncStatus;

package/dist/index.js

@@ -0,0 +1,320 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+import * as ConvexReact from "convex/react";
+import { getFunctionName, makeFunctionReference } from "convex/server";
+import { IndexedDbStore, MemoryLocalStore, collection, createClientId, createConvexTransport, createLocalFirstEngine, many, manyToMany, one } from "@convex-localfirst/core";
+// Engine + low-level helpers are INTERNAL (I13): imported from the internal subpath,
+// never re-exported to app authors. See @convex-localfirst/core/internal.
+import { LocalFirstEngine, coordinationName, createFallbackMutationCall, createMultiTabSync, defaultFunctionName } from "@convex-localfirst/core/internal";
+export { collection, many, manyToMany, one };
+export const ConvexReactClient = ConvexReact.ConvexReactClient;
+export const Authenticated = ConvexReact.Authenticated;
+export const Unauthenticated = ConvexReact.Unauthenticated;
+export const AuthLoading = ConvexReact.AuthLoading;
+export const useConvex = ConvexReact.useConvex;
+export const useConvexAuth = ConvexReact.useConvexAuth;
+const EMPTY_STATUS = {
+    online: true,
+    syncing: false,
+    pendingMutations: 0,
+    lastPushAt: null,
+    lastPullAt: null,
+    lastError: null,
+    blockedBySchemaMismatch: false,
+    partial: false
+};
+const LocalFirstReactContext = createContext(null);
+/**
+ * Default name resolver: use Convex's getFunctionName for real function
+ * references (api.todos.list -> "todos:list"); fall back to the core resolver
+ * for plain strings/objects (used in tests).
+ */
+function reactDefaultFunctionName(reference) {
+    try {
+        return getFunctionName(reference);
+    }
+    catch {
+        return defaultFunctionName(reference);
+    }
+}
+/**
+ * The convex-aware name resolver (`api.todos.list` → `"todos:list"`) the provider and the
+ * headless factory wire by default. Exported so an imperative consumer building its own
+ * engine doesn't have to inject one.
+ */
+export const convexFunctionName = reactDefaultFunctionName;
+/**
+ * One-call headless setup for an imperative (non-hook) consumer — a service layer, store,
+ * or Node script. Wires the Convex transport, name resolver, a browser/Node store default,
+ * and a client id (the provider's plumbing minus the React lifecycle). Returns the engine
+ * plus the Convex client (for server-only, non-local-first functions).
+ */
+export function createConvexLocalFirst(options) {
+    const client = options.client ??
+        new ConvexReact.ConvexReactClient(options.url ?? raise("createConvexLocalFirst: pass either `client` or `url`."));
+    const clientId = options.clientId ?? createClientId();
+    const userId = options.userId ?? null;
+    const store = options.store ??
+        (typeof indexedDB !== "undefined"
+            ? new IndexedDbStore({
+                databaseName: options.databaseName ?? "convex-localfirst",
+                namespace: options.namespace ?? userId ?? "default"
+            })
+            : new MemoryLocalStore());
+    const transport = createConvexTransport({
+        client,
+        push: options.sync?.push ?? makeFunctionReference("sync:push"),
+        pull: options.sync?.pull ?? makeFunctionReference("sync:pull"),
+        clientId,
+        // The transport envelope wants a string; an anonymous (null-userId) engine sends
+        // "" — the server resolves the real identity from auth and ignores this anyway.
+        userId: userId ?? ""
+    });
+    const engine = createLocalFirstEngine({
+        manifest: options.manifest,
+        store,
+        transport,
+        clientId,
+        userId,
+        nameOf: convexFunctionName
+    });
+    // Runtime is core's engine; the cast only adds the convex-typed mutate/query overloads
+    // (same methods, inferred arg/return types). Sound: the runtime signatures are wider.
+    return { engine: engine, client };
+}
+function raise(message) {
+    throw new Error(message);
+}
+export function ConvexProvider(props) {
+    if (!props.localFirst) {
+        return _jsx(ConvexReact.ConvexProvider, { client: props.client, children: props.children });
+    }
+    return (_jsx(ConvexReact.ConvexProvider, { client: props.client, children: _jsx(LocalFirstProvider, { ...props.localFirst, children: props.children }) }));
+}
+// Internal: the explicit-config provider. Users mount the local-first layer via
+// the public `ConvexProvider` (drop-in name) + its `localFirst` prop.
+function LocalFirstProvider(props) {
+    // Resolve the store ONCE per provider instance, with the SAME deps as the engine, so
+    // (a) an app that inlines a fresh store object each render doesn't thrash the engine,
+    // and (b) the multi-tab coordination key below is derived from the EXACT store the
+    // engine holds — never an old-engine-under-a-new-store-namespace mismatch.
+    const store = useMemo(() => props.store ?? new MemoryLocalStore(), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [props.manifest, props.userId, props.transport, props.nameOf]);
+    const engine = useMemo(() => {
+        return new LocalFirstEngine({
+            manifest: props.manifest,
+            store,
+            clientId: props.clientId ?? createClientId(),
+            userId: props.userId ?? null,
+            transport: props.transport,
+            nameOf: props.nameOf ?? reactDefaultFunctionName
+        });
+        // clientId is intentionally captured once; store moves in lockstep (same deps).
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.manifest, props.userId, props.transport, props.nameOf, store]);
+    // The engine self-wires browser connectivity in its constructor — reflecting
+    // navigator.onLine into the sync status and flushing the offline outbox on reconnect
+    // (see LocalFirstEngine.wireConnectivity). The provider used to duplicate that here;
+    // it doesn't anymore. We only need to dispose the engine-owned listeners when the engine
+    // is replaced (manifest/user/transport/store change) or the provider unmounts, so they
+    // don't leak across recreations.
+    useEffect(() => () => engine.dispose(), [engine]);
+    // Multi-tab coordination: elect one leader (only it runs the background batch push)
+    // and poke other tabs to re-read the shared IndexedDB after a pull. Engaged only with
+    // the crash-safe Web Locks primitive present (every modern browser); without it — SSR,
+    // jsdom tests, old browsers — every tab syncs independently exactly as before.
+    const userId = props.userId ?? null;
+    useEffect(() => {
+        if (typeof window === "undefined" || !("locks" in navigator)) {
+            return;
+        }
+        // Coordinate on the SHARED-data boundary (the store the engine actually holds), not
+        // just the user — see coordinationName. engine + store move in lockstep, so this can
+        // never key an engine under another store's namespace.
+        const dispose = createMultiTabSync(engine, { name: coordinationName(store, userId), id: engine.clientId });
+        return dispose;
+    }, [engine, userId, store]);
+    const value = useMemo(() => ({ engine }), [engine]);
+    return _jsx(LocalFirstReactContext.Provider, { value: value, children: props.children });
+}
+// Internal: the engine never appears in the public type surface (GOAL §6/I13).
+function useLocalFirstEngine() {
+    return useContext(LocalFirstReactContext)?.engine ?? null;
+}
+/**
+ * Convex-compatible useQuery. Args and result type are inferred from the Convex
+ * function reference (drop-in, no explicit generics — exactly like `convex/react`).
+ * Local-first functions read from the engine and subscribe to local changes;
+ * everything else falls through to Convex.
+ *
+ * All hooks below run unconditionally on every render (no rules-of-hooks
+ * violation): the Convex hook is fed "skip" for local-first functions, and the
+ * local subscription is inert when there is no engine/local definition.
+ */
+export function useQuery(reference, args, options) {
+    const engine = useLocalFirstEngine();
+    const isLocal = engine !== null && engine.hasLocalQuery(reference);
+    const resolvedArgs = (args ?? {});
+    const convexResult = ConvexReact.useQuery(reference, (isLocal ? "skip" : resolvedArgs));
+    const localResult = useLocalQuery(isLocal ? engine : null, reference, resolvedArgs, options);
+    return isLocal ? localResult : convexResult;
+}
+function useLocalQuery(engine, reference, args, options) {
+    const [value, setValue] = useState(options?.initial);
+    const argsKey = useMemo(() => JSON.stringify(args), [args]);
+    // Key the effect on the resolved function NAME, not the reference object:
+    // Convex's `api` proxy returns a fresh object per access, so using the object
+    // identity would re-run this effect every render (an infinite sync loop).
+    const refKey = useMemo(() => (engine ? engine.functionName(reference) : null), [engine, reference]);
+    useEffect(() => {
+        if (!engine || args === "skip") {
+            // "skip" must read as no data (Convex returns undefined), not the last
+            // value from before the query was skipped.
+            setValue(options?.initial);
+            return;
+        }
+        let alive = true;
+        const run = () => {
+            void engine.query(reference, args).then((result) => {
+                if (alive) {
+                    setValue(result ?? options?.initial);
+                }
+            });
+        };
+        run();
+        const unsubscribe = engine.subscribe(run);
+        let unwatch = null;
+        if (options?.sync !== "off") {
+            void engine.refreshQuery(reference, args);
+            // Reactive like convex/react: a reactive transport pushes server changes, which
+            // drain into the store and fire `run` via the local subscription above. Falls
+            // back to mount + local-change pulls when the transport isn't reactive.
+            unwatch = engine.watchQuery(reference, args);
+        }
+        return () => {
+            alive = false;
+            unsubscribe();
+            unwatch?.();
+        };
+        // refKey/argsKey are the stable identity of (function, args); reference and
+        // options are read at effect time. eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [engine, refKey, argsKey]);
+    // "skip" must read as no data SYNCHRONOUSLY (Convex returns undefined): the
+    // effect's clear runs after render, so returning `value` here would surface the
+    // previous result for one render.
+    if (args === "skip") {
+        return options?.initial;
+    }
+    return value;
+}
+export function useLiveQuery(query, options) {
+    const engine = useLocalFirstEngine();
+    const [rowsByTable, setRowsByTable] = useState(undefined);
+    const lastResult = useRef(undefined);
+    // The tables this query reads: its base table + any relation targets/join
+    // tables. A stable sorted key so an inline-rebuilt query object (or added
+    // relations) re-subscribes only when the table SET actually changes.
+    const tables = query === "skip" || !engine ? [] : engine.tablesForPlan(query);
+    const tablesKey = tables.length ? [...tables].sort().join(",") : null;
+    // Subscribe to every read table's live rows; re-pull all on any local change.
+    useEffect(() => {
+        if (!engine || query === "skip") {
+            setRowsByTable(undefined);
+            return;
+        }
+        const wanted = engine.tablesForPlan(query);
+        let alive = true;
+        const pull = () => {
+            void Promise.all(wanted.map((t) => engine.tableRows(t).then((rows) => [t, rows]))).then((entries) => {
+                if (alive) {
+                    setRowsByTable(Object.fromEntries(entries));
+                }
+            });
+        };
+        pull();
+        const unsubscribe = engine.subscribe(pull);
+        return () => {
+            alive = false;
+            unsubscribe();
+        };
+        // query is read at effect time; tablesKey is the stable identity of its read set.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [engine, tablesKey]);
+    // Background sync for this query's scope (push pending + pull). Keyed on the
+    // scope values + read set, not the per-render query object.
+    const scopeKey = query === "skip" ? null : JSON.stringify(query.scopeValues ?? null);
+    const pollMs = options?.pollMs;
+    useEffect(() => {
+        if (!engine || query === "skip") {
+            return;
+        }
+        void engine.refreshPlan(query);
+        // Prefer true server-push: a reactive transport drains this scope the instant
+        // the server has a change — no idle polling, instant cross-client updates.
+        const unwatch = engine.watchPlan(query);
+        if (unwatch) {
+            return unwatch;
+        }
+        // Fallback for a non-reactive transport (e.g. the HTTP client, or tests): poll
+        // the scope when the caller opted in. refreshPlan never throws and pulls only
+        // changes after the cursor, so an idle poll is cheap.
+        if (!pollMs) {
+            return;
+        }
+        const timer = setInterval(() => {
+            void engine.refreshPlan(query);
+        }, pollMs);
+        return () => clearInterval(timer);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [engine, tablesKey, scopeKey, pollMs]);
+    if (query === "skip" || rowsByTable === undefined || !engine) {
+        lastResult.current = undefined;
+        return undefined;
+    }
+    // Route through the engine (not query.run directly) so the scoped fail-closed
+    // guard + relation attach are enforced. Return a stable array reference when the
+    // result is unchanged (no-relation case), so it's safe in downstream deps.
+    const next = engine.applyLocalQuery(query, rowsByTable);
+    const prev = lastResult.current;
+    if (prev && prev.length === next.length && prev.every((row, i) => row === next[i])) {
+        return prev;
+    }
+    lastResult.current = next;
+    return next;
+}
+/**
+ * Convex-compatible useMutation. Args and result type are inferred from the
+ * function reference (no explicit generics). The returned mutator yields the
+ * hybrid call: `await it` resolves to the server result (Convex-identical), and
+ * `.local` / `.server` are separately awaitable.
+ */
+export function useMutation(reference) {
+    const engine = useLocalFirstEngine();
+    const convexMutation = ConvexReact.useMutation(reference);
+    const isLocal = engine !== null && engine.hasLocalMutation(reference);
+    // Stable function NAME, not the per-access `api` proxy object — otherwise the
+    // returned mutator changes every render and re-runs any effect that depends on it.
+    const refKey = useMemo(() => (engine ? engine.functionName(reference) : null), [engine, reference]);
+    return useMemo(() => {
+        if (isLocal && engine) {
+            return (args) => engine.mutate(reference, args);
+        }
+        // Fallback to Convex, but keep the uniform return type so .local/.server work.
+        return (args) => createFallbackMutationCall(convexMutation(args));
+        // reference is read at call time; refKey is its stable identity.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [engine, convexMutation, isLocal, refKey]);
+}
+export function useSyncStatus() {
+    const engine = useLocalFirstEngine();
+    const [status, setStatus] = useState(() => engine?.getStatus() ?? EMPTY_STATUS);
+    useEffect(() => {
+        if (!engine) {
+            return;
+        }
+        setStatus(engine.getStatus());
+        return engine.subscribeStatus(() => setStatus(engine.getStatus()));
+    }, [engine]);
+    return status;
+}

package/dist/shadow.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist/shadow.js

@@ -0,0 +1 @@
+export * from "./index.js";

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@convex-localfirst/react",
+  "version": "0.1.0",
+  "description": "Convex-compatible React hooks (useQuery/useMutation/useSyncStatus) for local-first, offline-capable apps.",
+  "license": "MIT",
+  "keywords": [
+    "convex",
+    "local-first",
+    "offline",
+    "react",
+    "hooks"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./shadow": {
+      "types": "./dist/shadow.d.ts",
+      "import": "./dist/shadow.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "convex": ">=1.0.0",
+    "react": ">=18.0.0"
+  },
+  "dependencies": {
+    "@convex-localfirst/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "fake-indexeddb": "^6.2.5",
+    "jsdom": "^29.1.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json --noEmit false --emitDeclarationOnly false",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}