@atlasauth/convex 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @atlasauth/convex changelog
+
+## 0.1.1 — 2026-11-12
+
+- Picks up `@atlasauth/design` 0.4.0 (zod 4, fixes a zod 3 memory-exhaustion advisory). No API change.
+
+## 0.1.0 — 2026-10-23
+- First release: `atlasAuthConfig()` / `atlasAuthProvider()` for `convex/auth.config.ts`, and
+  `<ConvexProviderWithAtlas>` / `useAtlasConvexAuth()` from `@atlasauth/convex/react`.

package/README.md

@@ -1,3 +1,37 @@
-# Temporary Holding Version
+# @atlasauth/convex
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Sign users in with [Atlas](https://atlasauth.net) and authenticate them in [Convex](https://convex.dev).
+
+```bash
+npm install @atlasauth/convex @atlasauth/react convex
+```
+
+1. Create a JWT template named `convex` with its audience set to `convex`.
+2. Tell Convex to trust Atlas:
+
+```ts
+// convex/auth.config.ts
+import { atlasAuthConfig } from '@atlasauth/convex';
+
+export default atlasAuthConfig({
+  issuer: process.env.ATLAS_ISSUER!,         // https://auth.example.com, or https://atlasauth.net
+  instanceId: process.env.ATLAS_INSTANCE_ID, // ins_… (needed on the shared atlasauth.net host)
+});
+```
+
+3. Swap `ConvexProvider` for `ConvexProviderWithAtlas`, inside `AtlasProvider`:
+
+```tsx
+import { AtlasProvider } from '@atlasauth/react';
+import { ConvexProviderWithAtlas } from '@atlasauth/convex/react';
+
+<AtlasProvider publishableKey="pk_live_…">
+  <ConvexProviderWithAtlas client={convex}>
+    <App />
+  </ConvexProviderWithAtlas>
+</AtlasProvider>;
+```
+
+In Convex functions, `await ctx.auth.getUserIdentity()` returns the signed-in Atlas user (`subject` is the Atlas user id).
+
+Full guide: https://atlasauth.net/docs/convex

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `@atlasauth/convex` — the Convex side of Atlas sign-in.
+ *
+ * Convex verifies the JWT your client hands it against the providers listed in
+ * `convex/auth.config.ts`. An Atlas instance on its own custom frontend domain
+ * is a plain OpenID Connect issuer, so Convex can discover its keys from the
+ * issuer. An instance on the shared Atlas host signs with a per-instance key
+ * that lives at a per-instance JWKS URL, so it is declared as a Convex
+ * "custom JWT" provider pointing at that URL instead.
+ *
+ * ```ts
+ * // convex/auth.config.ts
+ * import { atlasAuthConfig } from '@atlasauth/convex';
+ * export default atlasAuthConfig({ issuer: process.env.ATLAS_ISSUER!, instanceId: process.env.ATLAS_INSTANCE_ID });
+ * ```
+ *
+ * This module has no runtime dependency (Convex loads the auth config in its
+ * own runtime); the React provider lives in `@atlasauth/convex/react`.
+ */
+/** The JWT template the client asks Atlas for, and the `aud` it pins by default. */
+export declare const DEFAULT_CONVEX_TEMPLATE = "convex";
+export declare const DEFAULT_APPLICATION_ID = "convex";
+/** The shared Atlas frontend host. Tokens issued there are verified per instance. */
+export declare const SHARED_ATLAS_ISSUER = "https://atlasauth.net";
+/** Where the per-instance keys of a shared-host instance are published. */
+export declare const SHARED_ATLAS_API = "https://api.atlasauth.net";
+/** A Convex OIDC provider: keys discovered from `<domain>/.well-known/openid-configuration`. */
+export interface ConvexOidcProvider {
+    domain: string;
+    applicationID: string;
+}
+/** A Convex custom-JWT provider: the issuer and JWKS URL are given explicitly. */
+export interface ConvexCustomJwtProvider {
+    type: 'customJwt';
+    issuer: string;
+    jwks: string;
+    algorithm: 'RS256';
+    applicationID?: string;
+}
+export type ConvexAuthProvider = ConvexOidcProvider | ConvexCustomJwtProvider;
+export interface AtlasConvexOptions {
+    /**
+     * The `iss` of your Atlas tokens: your custom frontend domain (for example
+     * `https://auth.example.com`), or `https://atlasauth.net` on the shared host.
+     */
+    issuer: string;
+    /**
+     * Your instance id (`ins_…`). Required on the shared host, where the
+     * per-instance JWKS URL is built from it. Ignored on a custom domain.
+     */
+    instanceId?: string;
+    /**
+     * The `aud` your Convex template pins (its `audience` setting). Convex
+     * rejects a token whose `aud` differs. Default `convex`. Pass `null` for a
+     * template with no audience (shared-host instances only: Convex's OIDC
+     * provider type always checks `aud`).
+     */
+    applicationID?: string | null;
+    /** Override the JWKS URL (rarely needed). */
+    jwks?: string;
+}
+/** Is this the shared Atlas host (whose keys are per instance)? */
+export declare function isSharedAtlasIssuer(issuer: string): boolean;
+/** The per-instance JWKS URL of a shared-host instance. */
+export declare function sharedInstanceJwksUrl(instanceId: string): string;
+/** One Convex auth provider entry for an Atlas instance. */
+export declare function atlasAuthProvider(options: AtlasConvexOptions): ConvexAuthProvider;
+/** The whole `convex/auth.config.ts` default export for one Atlas instance. */
+export declare function atlasAuthConfig(options: AtlasConvexOptions): {
+    providers: ConvexAuthProvider[];
+};

package/dist/index.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * `@atlasauth/convex` — the Convex side of Atlas sign-in.
+ *
+ * Convex verifies the JWT your client hands it against the providers listed in
+ * `convex/auth.config.ts`. An Atlas instance on its own custom frontend domain
+ * is a plain OpenID Connect issuer, so Convex can discover its keys from the
+ * issuer. An instance on the shared Atlas host signs with a per-instance key
+ * that lives at a per-instance JWKS URL, so it is declared as a Convex
+ * "custom JWT" provider pointing at that URL instead.
+ *
+ * ```ts
+ * // convex/auth.config.ts
+ * import { atlasAuthConfig } from '@atlasauth/convex';
+ * export default atlasAuthConfig({ issuer: process.env.ATLAS_ISSUER!, instanceId: process.env.ATLAS_INSTANCE_ID });
+ * ```
+ *
+ * This module has no runtime dependency (Convex loads the auth config in its
+ * own runtime); the React provider lives in `@atlasauth/convex/react`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHARED_ATLAS_API = exports.SHARED_ATLAS_ISSUER = exports.DEFAULT_APPLICATION_ID = exports.DEFAULT_CONVEX_TEMPLATE = void 0;
+exports.isSharedAtlasIssuer = isSharedAtlasIssuer;
+exports.sharedInstanceJwksUrl = sharedInstanceJwksUrl;
+exports.atlasAuthProvider = atlasAuthProvider;
+exports.atlasAuthConfig = atlasAuthConfig;
+/** The JWT template the client asks Atlas for, and the `aud` it pins by default. */
+exports.DEFAULT_CONVEX_TEMPLATE = 'convex';
+exports.DEFAULT_APPLICATION_ID = 'convex';
+/** The shared Atlas frontend host. Tokens issued there are verified per instance. */
+exports.SHARED_ATLAS_ISSUER = 'https://atlasauth.net';
+/** Where the per-instance keys of a shared-host instance are published. */
+exports.SHARED_ATLAS_API = 'https://api.atlasauth.net';
+function normaliseIssuer(issuer) {
+    let url;
+    try {
+        url = new URL(issuer);
+    }
+    catch {
+        throw new Error(`@atlasauth/convex: issuer must be an absolute URL, got "${issuer}".`);
+    }
+    if (url.protocol !== 'https:' && url.hostname !== 'localhost' && url.hostname !== '127.0.0.1') {
+        throw new Error('@atlasauth/convex: issuer must use https.');
+    }
+    return `${url.protocol}//${url.host}${url.pathname.replace(/\/+$/, '')}`;
+}
+/** Is this the shared Atlas host (whose keys are per instance)? */
+function isSharedAtlasIssuer(issuer) {
+    return normaliseIssuer(issuer) === exports.SHARED_ATLAS_ISSUER;
+}
+/** The per-instance JWKS URL of a shared-host instance. */
+function sharedInstanceJwksUrl(instanceId) {
+    if (!/^ins_[A-Za-z0-9]+$/.test(instanceId)) {
+        throw new Error(`@atlasauth/convex: instanceId must look like "ins_…", got "${instanceId}".`);
+    }
+    return `${exports.SHARED_ATLAS_API}/instances/${instanceId}/.well-known/jwks.json`;
+}
+/** One Convex auth provider entry for an Atlas instance. */
+function atlasAuthProvider(options) {
+    const issuer = normaliseIssuer(options.issuer);
+    const applicationID = options.applicationID === undefined ? exports.DEFAULT_APPLICATION_ID : options.applicationID;
+    if (issuer === exports.SHARED_ATLAS_ISSUER || options.jwks) {
+        let jwks = options.jwks;
+        if (!jwks) {
+            if (!options.instanceId) {
+                throw new Error('@atlasauth/convex: on the shared Atlas host, pass instanceId so Convex can find your instance\'s signing keys.');
+            }
+            jwks = sharedInstanceJwksUrl(options.instanceId);
+        }
+        return {
+            type: 'customJwt',
+            issuer,
+            jwks,
+            algorithm: 'RS256',
+            ...(applicationID ? { applicationID } : {}),
+        };
+    }
+    if (!applicationID) {
+        throw new Error('@atlasauth/convex: an issuer on a custom domain is checked as an OIDC provider, which needs an applicationID (the template audience).');
+    }
+    return { domain: issuer, applicationID };
+}
+/** The whole `convex/auth.config.ts` default export for one Atlas instance. */
+function atlasAuthConfig(options) {
+    return { providers: [atlasAuthProvider(options)] };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAgEH,kDAEC;AAGD,sDAKC;AAGD,8CA6BC;AAGD,0CAEC;AA7GD,oFAAoF;AACvE,QAAA,uBAAuB,GAAG,QAAQ,CAAC;AACnC,QAAA,sBAAsB,GAAG,QAAQ,CAAC;AAE/C,qFAAqF;AACxE,QAAA,mBAAmB,GAAG,uBAAuB,CAAC;AAC3D,2EAA2E;AAC9D,QAAA,gBAAgB,GAAG,2BAA2B,CAAC;AAyC5D,SAAS,eAAe,CAAC,MAAc;IACrC,IAAI,GAAQ,CAAC;IACb,IAAI,CAAC;QACH,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;IACxB,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,KAAK,CAAC,2DAA2D,MAAM,IAAI,CAAC,CAAC;IACzF,CAAC;IACD,IAAI,GAAG,CAAC,QAAQ,KAAK,QAAQ,IAAI,GAAG,CAAC,QAAQ,KAAK,WAAW,IAAI,GAAG,CAAC,QAAQ,KAAK,WAAW,EAAE,CAAC;QAC9F,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,GAAG,GAAG,CAAC,QAAQ,KAAK,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;AAC3E,CAAC;AAED,mEAAmE;AACnE,SAAgB,mBAAmB,CAAC,MAAc;IAChD,OAAO,eAAe,CAAC,MAAM,CAAC,KAAK,2BAAmB,CAAC;AACzD,CAAC;AAED,2DAA2D;AAC3D,SAAgB,qBAAqB,CAAC,UAAkB;IACtD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,8DAA8D,UAAU,IAAI,CAAC,CAAC;IAChG,CAAC;IACD,OAAO,GAAG,wBAAgB,cAAc,UAAU,wBAAwB,CAAC;AAC7E,CAAC;AAED,4DAA4D;AAC5D,SAAgB,iBAAiB,CAAC,OAA2B;IAC3D,MAAM,MAAM,GAAG,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,8BAAsB,CAAC,CAAC,CAAC,OAAO,CAAC,aAAa,CAAC;IAE3G,IAAI,MAAM,KAAK,2BAAmB,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACnD,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;gBACxB,MAAM,IAAI,KAAK,CACb,gHAAgH,CACjH,CAAC;YACJ,CAAC;YACD,IAAI,GAAG,qBAAqB,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QACnD,CAAC;QACD,OAAO;YACL,IAAI,EAAE,WAAW;YACjB,MAAM;YACN,IAAI;YACJ,SAAS,EAAE,OAAO;YAClB,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC5C,CAAC;IACJ,CAAC;IAED,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CACb,uIAAuI,CACxI,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;AAC3C,CAAC;AAED,+EAA+E;AAC/E,SAAgB,eAAe,CAAC,OAA2B;IACzD,OAAO,EAAE,SAAS,EAAE,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;AACrD,CAAC"}

package/dist/react.d.ts

@@ -0,0 +1,54 @@
+import { type ReactNode } from 'react';
+import { type ConvexReactClient } from 'convex/react';
+/**
+ * `@atlasauth/convex/react` — authenticate Convex with the Atlas session.
+ *
+ * ```tsx
+ * <AtlasProvider publishableKey={…}>
+ *   <ConvexProviderWithAtlas client={convex}>
+ *     <App />
+ *   </ConvexProviderWithAtlas>
+ * </AtlasProvider>
+ * ```
+ *
+ * Convex asks for a token whenever it (re)connects; the provider answers with a
+ * fresh token minted from the `convex` JWT template of the signed-in session.
+ */
+/** The shape Convex's `ConvexProviderWithAuth` expects from its `useAuth` prop. */
+export interface ConvexAuthState {
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    fetchAccessToken(args: {
+        forceRefreshToken: boolean;
+    }): Promise<string | null>;
+}
+/** The part of Atlas's `useAuth()` the bridge reads. */
+export interface AtlasAuthLike {
+    isLoaded: boolean;
+    isSignedIn: boolean;
+    getToken(options?: {
+        template?: string;
+    }): Promise<string | null>;
+}
+/**
+ * The pure projection: Atlas auth state → Convex auth state. A token fetch that
+ * fails resolves `null` (Convex then treats the client as signed out) instead of
+ * throwing into Convex's reconnect loop.
+ */
+export declare function convexAuthFromAtlas(auth: AtlasAuthLike, template?: string): ConvexAuthState;
+/**
+ * Convex's `useAuth` contract backed by Atlas. `template` is the JWT template
+ * to mint (default `convex`). Memoised so Convex only re-authenticates when the
+ * sign-in state actually changes.
+ */
+export declare function useAtlasConvexAuth(template?: string): ConvexAuthState;
+/**
+ * Drop-in for Convex's `ConvexProvider` when the app signs in with Atlas. Must
+ * sit inside `<AtlasProvider>`.
+ */
+export declare function ConvexProviderWithAtlas({ client, children, template, }: {
+    client: ConvexReactClient;
+    children: ReactNode;
+    /** The JWT template Convex tokens are minted from. Default `convex`. */
+    template?: string;
+}): import("react").JSX.Element;

package/dist/react.js

@@ -0,0 +1,55 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convexAuthFromAtlas = convexAuthFromAtlas;
+exports.useAtlasConvexAuth = useAtlasConvexAuth;
+exports.ConvexProviderWithAtlas = ConvexProviderWithAtlas;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_2 = require("convex/react");
+const react_3 = require("@atlasauth/react");
+const index_1 = require("./index");
+/**
+ * The pure projection: Atlas auth state → Convex auth state. A token fetch that
+ * fails resolves `null` (Convex then treats the client as signed out) instead of
+ * throwing into Convex's reconnect loop.
+ */
+function convexAuthFromAtlas(auth, template = index_1.DEFAULT_CONVEX_TEMPLATE) {
+    return {
+        isLoading: !auth.isLoaded,
+        isAuthenticated: auth.isLoaded && auth.isSignedIn,
+        fetchAccessToken: async () => {
+            if (!auth.isSignedIn)
+                return null;
+            try {
+                return await auth.getToken({ template });
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+/**
+ * Convex's `useAuth` contract backed by Atlas. `template` is the JWT template
+ * to mint (default `convex`). Memoised so Convex only re-authenticates when the
+ * sign-in state actually changes.
+ */
+function useAtlasConvexAuth(template = index_1.DEFAULT_CONVEX_TEMPLATE) {
+    const { isLoaded, isSignedIn, getToken } = (0, react_3.useAuth)();
+    const fetchAccessToken = (0, react_1.useCallback)((args) => convexAuthFromAtlas({ isLoaded, isSignedIn, getToken }, template).fetchAccessToken(args), 
+    // getToken is stable per provider; isSignedIn flips on sign-in / sign-out.
+    [isLoaded, isSignedIn, getToken, template]);
+    return (0, react_1.useMemo)(() => ({ isLoading: !isLoaded, isAuthenticated: isLoaded && isSignedIn, fetchAccessToken }), [isLoaded, isSignedIn, fetchAccessToken]);
+}
+/**
+ * Drop-in for Convex's `ConvexProvider` when the app signs in with Atlas. Must
+ * sit inside `<AtlasProvider>`.
+ */
+function ConvexProviderWithAtlas({ client, children, template = index_1.DEFAULT_CONVEX_TEMPLATE, }) {
+    const useAuthFromAtlas = (0, react_1.useMemo)(() => function useAuthFromAtlas() {
+        return useAtlasConvexAuth(template);
+    }, [template]);
+    return ((0, jsx_runtime_1.jsx)(react_2.ConvexProviderWithAuth, { client: client, useAuth: useAuthFromAtlas, children: children }));
+}
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","sourceRoot":"","sources":["../src/react.tsx"],"names":[],"mappings":";AAAA,YAAY,CAAC;;AAyCb,kDAaC;AAOD,gDAYC;AAMD,0DAsBC;;AAnGD,iCAA6D;AAC7D,wCAA8E;AAC9E,4CAA2C;AAC3C,mCAAkD;AA+BlD;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,IAAmB,EAAE,WAAmB,+BAAuB;IACjG,OAAO;QACL,SAAS,EAAE,CAAC,IAAI,CAAC,QAAQ;QACzB,eAAe,EAAE,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU;QACjD,gBAAgB,EAAE,KAAK,IAAI,EAAE;YAC3B,IAAI,CAAC,IAAI,CAAC,UAAU;gBAAE,OAAO,IAAI,CAAC;YAClC,IAAI,CAAC;gBACH,OAAO,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC3C,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,WAAmB,+BAAuB;IAC3E,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,IAAA,eAAO,GAAE,CAAC;IACrD,MAAM,gBAAgB,GAAG,IAAA,mBAAW,EAClC,CAAC,IAAoC,EAAE,EAAE,CACvC,mBAAmB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC;IAC1F,2EAA2E;IAC3E,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAC3C,CAAC;IACF,OAAO,IAAA,eAAO,EACZ,GAAG,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,QAAQ,EAAE,eAAe,EAAE,QAAQ,IAAI,UAAU,EAAE,gBAAgB,EAAE,CAAC,EAC3F,CAAC,QAAQ,EAAE,UAAU,EAAE,gBAAgB,CAAC,CACzC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,QAAQ,EACR,QAAQ,GAAG,+BAAuB,GAMnC;IACC,MAAM,gBAAgB,GAAG,IAAA,eAAO,EAC9B,GAAG,EAAE,CACH,SAAS,gBAAgB;QACvB,OAAO,kBAAkB,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC,EACH,CAAC,QAAQ,CAAC,CACX,CAAC;IACF,OAAO,CACL,uBAAC,8BAAsB,IAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,YAC9D,QAAQ,GACc,CAC1B,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@atlasauth/convex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Use Atlas sign-in with Convex: the Convex auth config for Atlas tokens and <ConvexProviderWithAtlas>.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@atlasauth/react": "^0.34.1"
+  },
+  "peerDependencies": {
+    "convex": ">=1.13",
+    "react": ">=18"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "convex": "^1.17.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "typescript": "^5.6.3",
+    "vitest": "^3.2.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "!dist/*.tsbuildinfo",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsgo -p tsconfig.json --noEmit --module preserve --moduleResolution bundler --incremental --tsBuildInfoFile node_modules/.cache/typecheck.tsbuildinfo",
+    "test": "vitest run"
+  }
 }