@robelest/convex-auth 0.0.4-preview.27 → 0.0.4-preview.28

package/dist/core/index.d.ts

@@ -0,0 +1,380 @@
+import { ComponentCtx, ComponentReadCtx } from "../server/componentContext.js";
+import { AuthAuthorizationConfig, ConvexAuthConfig, KeyDoc, KeyScope, ScopeChecker, UserOrderBy, UserWhere } from "../server/types.js";
+import { AuthProfile } from "../server/payloads.js";
+import { AuthConfig, AuthContext, AuthContextConfig, AuthContextFactory as AuthContextFactory$1, AuthContextResolver as AuthContextResolver$1, OptionalAuthContext, UserDoc } from "../server/auth-context.js";
+import "../component/index.js";
+import * as convex_values0 from "convex/values";
+import * as convex_server0 from "convex/server";
+import * as fluent_convex0 from "fluent-convex";
+
+//#region src/core/index.d.ts
+type AuthContextResolver = AuthContextResolver$1;
+type AuthContextFactory = AuthContextFactory$1;
+/**
+ * Create a lightweight auth context object.
+ *
+ * Returns the same `user`, `session`, `member`, `group`, `account`,
+ * `invite`, `key`, `context`, and `ctx` APIs as `createAuth`, but
+ * without `signIn`, `signOut`, `store`, `http`, or provider logic.
+ *
+ * Use this in query/mutation files that only need to resolve the
+ * current user — it avoids loading provider, OAuth, and crypto code.
+ *
+ * @example
+ * ```ts
+ * // convex/auth-core.ts
+ * import { createAuthContext } from "@robelest/convex-auth/core";
+ * import { components } from "./_generated/api";
+ *
+ * export const auth = createAuthContext(components.auth);
+ *
+ * // convex/functions.ts
+ * import { auth } from "./auth-core";
+ * export const authQuery = customQuery(query, auth.ctx());
+ * ```
+ */
+declare function createAuthContext(component: ConvexAuthConfig["component"], config?: Omit<AuthConfig, "providers"> & {
+  authorization?: AuthAuthorizationConfig;
+}): {
+  user: {
+    get: (ctx: ComponentReadCtx, userId: string) => Promise<any>;
+    list: (ctx: ComponentReadCtx, opts?: {
+      where?: UserWhere;
+      limit?: number;
+      cursor?: string | null;
+      orderBy?: UserOrderBy;
+      order?: "asc" | "desc";
+    }) => Promise<any>;
+    viewer: (ctx: ComponentReadCtx & {
+      auth: convex_server0.Auth;
+    }) => Promise<any>;
+    update: (ctx: ComponentCtx, userId: string, data: Record<string, unknown>) => Promise<{
+      userId: string;
+    }>;
+    setActiveGroup: (ctx: ComponentCtx, opts: {
+      userId: string;
+      groupId: string | null;
+    }) => Promise<{
+      userId: string;
+      groupId: null;
+    } | {
+      userId: string;
+      groupId: string;
+    }>;
+    getActiveGroup: (ctx: ComponentReadCtx, opts: {
+      userId: string;
+    }) => Promise<string | null>;
+    delete: (ctx: ComponentCtx, userId: string, opts?: {
+      cascade?: boolean;
+    }) => Promise<{
+      userId: string;
+    }>;
+  };
+  session: {
+    current: (ctx: {
+      auth: convex_server0.Auth;
+    }) => Promise<convex_values0.GenericId<"Session"> | null>;
+    invalidate: <DataModel extends fluent_convex0.GenericDataModel>(ctx: convex_server0.GenericActionCtx<DataModel>, args: {
+      userId: convex_values0.GenericId<"User">;
+      except?: convex_values0.GenericId<"Session">[];
+    }) => Promise<{
+      userId: convex_values0.GenericId<"User">;
+      except: convex_values0.GenericId<"Session">[];
+    }>;
+    get: (ctx: ComponentReadCtx, sessionId: string) => Promise<any>;
+    list: (ctx: ComponentReadCtx, opts: {
+      userId: string;
+    }) => Promise<any>;
+  };
+  account: {
+    create: <DataModel extends fluent_convex0.GenericDataModel>(ctx: convex_server0.GenericActionCtx<DataModel>, args: {
+      provider: string;
+      account: {
+        id: string;
+        secret?: string;
+      };
+      profile: AuthProfile;
+      shouldLinkViaEmail?: boolean;
+      shouldLinkViaPhone?: boolean;
+    }) => Promise<{
+      account: {
+        _id: string;
+        userId: string;
+        secret?: string | null;
+      };
+      user: Record<string, unknown>;
+    }>;
+    get: <DataModel extends fluent_convex0.GenericDataModel>(ctx: convex_server0.GenericActionCtx<DataModel>, args: {
+      provider: string;
+      account: {
+        id: string;
+        secret?: string;
+      };
+    }) => Promise<{
+      account: {
+        _id: string;
+        userId: string;
+        secret?: string | null;
+      };
+      user: Record<string, unknown>;
+    } | null>;
+    update: <DataModel extends fluent_convex0.GenericDataModel>(ctx: convex_server0.GenericActionCtx<DataModel>, args: {
+      provider: string;
+      account: {
+        id: string;
+        secret: string;
+      };
+    }) => Promise<{
+      accountId: string;
+    }>;
+    delete: (ctx: ComponentCtx, accountId: string) => Promise<{
+      accountId: string;
+    }>;
+    listPasskeys: (ctx: ComponentReadCtx, opts: {
+      userId: string;
+    }) => Promise<any>;
+    renamePasskey: (ctx: ComponentCtx, passkeyId: string, name: string) => Promise<{
+      passkeyId: string;
+    }>;
+    deletePasskey: (ctx: ComponentCtx, passkeyId: string) => Promise<{
+      passkeyId: string;
+    }>;
+    listTotps: (ctx: ComponentReadCtx, opts: {
+      userId: string;
+    }) => Promise<any>;
+    deleteTotp: (ctx: ComponentCtx, totpId: string) => Promise<{
+      totpId: string;
+    }>;
+  };
+  group: {
+    create: (ctx: ComponentCtx, data: {
+      name: string;
+      slug?: string;
+      type?: string;
+      parentGroupId?: string;
+      tags?: Array<{
+        key: string;
+        value: string;
+      }>;
+      extend?: Record<string, unknown>;
+    }) => Promise<{
+      groupId: string;
+    }>;
+    get: (ctx: ComponentReadCtx, groupId: string) => Promise<any>;
+    list: (ctx: ComponentReadCtx, opts?: {
+      where?: {
+        slug?: string;
+        type?: string;
+        parentGroupId?: string;
+        name?: string;
+        isRoot?: boolean;
+        tagsAll?: Array<{
+          key: string;
+          value: string;
+        }>;
+        tagsAny?: Array<{
+          key: string;
+          value: string;
+        }>;
+      };
+      limit?: number;
+      cursor?: string | null;
+      orderBy?: "_creationTime" | "name" | "slug" | "type";
+      order?: "asc" | "desc";
+    }) => Promise<any>;
+    update: (ctx: ComponentCtx, groupId: string, data: Record<string, unknown>) => Promise<{
+      groupId: string;
+    }>;
+    delete: (ctx: ComponentCtx, groupId: string) => Promise<{
+      groupId: string;
+    }>;
+    ancestors: (ctx: ComponentReadCtx, opts: {
+      groupId: string;
+      maxDepth?: number;
+      includeSelf?: boolean;
+    }) => Promise<{
+      ancestors: Record<string, unknown>[];
+      cycleDetected: boolean;
+      maxDepthReached: boolean;
+    }>;
+  };
+  member: {
+    create: (ctx: ComponentCtx, data: {
+      groupId: string;
+      userId: string;
+      roleIds?: string[];
+      status?: string;
+      extend?: Record<string, unknown>;
+    }) => Promise<{
+      memberId: string;
+    }>;
+    get: (ctx: ComponentReadCtx, memberId: string) => Promise<any>;
+    list: (ctx: ComponentReadCtx, opts?: {
+      where?: {
+        groupId?: string;
+        userId?: string;
+        roleId?: string;
+        status?: string;
+      };
+      limit?: number;
+      cursor?: string | null;
+      orderBy?: "_creationTime" | "status";
+      order?: "asc" | "desc";
+    }) => Promise<any>;
+    delete: (ctx: ComponentCtx, memberId: string) => Promise<{
+      memberId: string;
+    }>;
+    update: (ctx: ComponentCtx, memberId: string, data: Record<string, unknown>) => Promise<{
+      memberId: string;
+    }>;
+    inspect: (ctx: ComponentReadCtx, opts: {
+      userId: string;
+      groupId: string;
+      ancestry?: boolean;
+      maxDepth?: number;
+    }) => Promise<{
+      membership: null;
+      roleIds: string[];
+      grants: string[];
+    } | {
+      membership: {
+        _id: string;
+        _creationTime: number;
+        groupId: string;
+        userId: string;
+        role?: string;
+        roleIds?: string[];
+        status?: string;
+        extend?: Record<string, unknown>;
+      };
+      roleIds: string[];
+      grants: string[];
+    }>;
+    require: (ctx: ComponentReadCtx, opts: {
+      userId: string;
+      groupId: string;
+      ancestry?: boolean;
+      roleIds?: string[];
+      grants?: string[];
+      maxDepth?: number;
+    }) => Promise<{
+      membership: {
+        _id: string;
+        _creationTime: number;
+        groupId: string;
+        userId: string;
+        role?: string;
+        roleIds?: string[];
+        status?: string;
+        extend?: Record<string, unknown>;
+      };
+      roleIds: string[];
+      grants: string[];
+    }>;
+  };
+  invite: {
+    create: (ctx: ComponentCtx, data: {
+      groupId?: string;
+      invitedByUserId?: string;
+      email?: string;
+      roleIds?: string[];
+      expiresTime?: number;
+      extend?: Record<string, unknown>;
+    }) => Promise<{
+      inviteId: string;
+      token: string;
+    }>;
+    get: (ctx: ComponentReadCtx, inviteId: string) => Promise<any>;
+    token: {
+      get: (ctx: ComponentReadCtx, token: string) => Promise<any>;
+      accept: (ctx: ComponentCtx, args: {
+        token: string;
+        acceptedByUserId: string;
+      }) => Promise<any>;
+    };
+    list: (ctx: ComponentReadCtx, opts?: {
+      where?: {
+        tokenHash?: string;
+        groupId?: string;
+        status?: "pending" | "accepted" | "revoked" | "expired";
+        email?: string;
+        invitedByUserId?: string;
+        roleId?: string;
+        acceptedByUserId?: string;
+      };
+      limit?: number;
+      cursor?: string | null;
+      orderBy?: "_creationTime" | "status" | "email" | "expiresTime" | "acceptedTime";
+      order?: "asc" | "desc";
+    }) => Promise<any>;
+    accept: (ctx: ComponentCtx, inviteId: string, acceptedByUserId?: string) => Promise<{
+      inviteId: string;
+      acceptedByUserId: string | null;
+    }>;
+    revoke: (ctx: ComponentCtx, inviteId: string) => Promise<{
+      inviteId: string;
+    }>;
+  };
+  key: {
+    create: (ctx: ComponentCtx, opts: {
+      userId: string;
+      name: string;
+      scopes: KeyScope[];
+      rateLimit?: {
+        maxRequests: number;
+        windowMs: number;
+      };
+      expiresAt?: number;
+      metadata?: Record<string, unknown>;
+    }) => Promise<{
+      keyId: string;
+      secret: string;
+    }>;
+    verify: (ctx: ComponentCtx, rawKey: string) => Promise<{
+      userId: string;
+      keyId: string;
+      scopes: ScopeChecker;
+    }>;
+    list: (ctx: ComponentReadCtx, opts?: {
+      where?: {
+        userId?: string;
+        revoked?: boolean;
+        name?: string;
+        prefix?: string;
+      };
+      limit?: number;
+      cursor?: string | null;
+      orderBy?: "_creationTime" | "name" | "lastUsedAt" | "expiresAt" | "revoked";
+      order?: "asc" | "desc";
+    }) => Promise<any>;
+    get: (ctx: ComponentReadCtx, keyId: string) => Promise<KeyDoc | null>;
+    update: (ctx: ComponentCtx, keyId: string, data: {
+      name?: string;
+      scopes?: KeyScope[];
+      rateLimit?: {
+        maxRequests: number;
+        windowMs: number;
+      };
+    }) => Promise<{
+      keyId: string;
+    }>;
+    revoke: (ctx: ComponentCtx, keyId: string) => Promise<{
+      keyId: string;
+    }>;
+    delete: (ctx: ComponentCtx, keyId: string) => Promise<{
+      keyId: string;
+    }>;
+    rotate: (ctx: ComponentCtx, keyId: string, opts?: {
+      name?: string;
+      expiresAt?: number;
+    }) => Promise<{
+      keyId: string;
+      secret: string;
+    }>;
+  };
+  context: AuthContextResolver;
+  ctx: AuthContextFactory;
+};
+//#endregion
+export { type AuthContext, type AuthContextConfig, type OptionalAuthContext, type UserDoc, createAuthContext };
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -0,0 +1,83 @@
+import { assertAuthResolverContext, createAuthContextCustomization, createPublicAuthContext } from "../server/auth-context.js";
+import { configDefaults } from "../server/config.js";
+import { createCoreDomains } from "../server/core.js";
+import { callModifyAccount } from "../server/mutations/account.js";
+import { callInvalidateSessions } from "../server/mutations/invalidate.js";
+import { callCreateAccountFromCredentials } from "../server/mutations/register.js";
+import { callRetrieveAccountWithCredentials } from "../server/mutations/retrieve.js";
+
+//#region src/core/index.ts
+/**
+* Lightweight auth context entry point for `@robelest/convex-auth/core`.
+*
+* Provides auth context resolution, user/session/member/group lookups,
+* and authorization helpers without pulling in provider implementations,
+* OAuth, crypto, or sign-in logic.
+*
+* @module
+*/
+/**
+* Create a lightweight auth context object.
+*
+* Returns the same `user`, `session`, `member`, `group`, `account`,
+* `invite`, `key`, `context`, and `ctx` APIs as `createAuth`, but
+* without `signIn`, `signOut`, `store`, `http`, or provider logic.
+*
+* Use this in query/mutation files that only need to resolve the
+* current user — it avoids loading provider, OAuth, and crypto code.
+*
+* @example
+* ```ts
+* // convex/auth-core.ts
+* import { createAuthContext } from "@robelest/convex-auth/core";
+* import { components } from "./_generated/api";
+*
+* export const auth = createAuthContext(components.auth);
+*
+* // convex/functions.ts
+* import { auth } from "./auth-core";
+* export const authQuery = customQuery(query, auth.ctx());
+* ```
+*/
+function createAuthContext(component, config) {
+	const fullConfig = configDefaults({
+		component,
+		providers: [],
+		...config
+	});
+	const INVITE_TOKEN_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	const INVITE_TOKEN_LENGTH = 48;
+	const enrichCtx = (ctx) => ctx;
+	const domains = createCoreDomains({
+		config: fullConfig,
+		callInvalidateSessions,
+		callCreateAccountFromCredentials,
+		callRetrieveAccountWithCredentials,
+		callModifyAccount,
+		getEnrichCtx: () => enrichCtx,
+		inviteTokenAlphabet: INVITE_TOKEN_ALPHABET,
+		inviteTokenLength: INVITE_TOKEN_LENGTH
+	});
+	const authLike = {
+		user: domains.user,
+		member: domains.member
+	};
+	return {
+		user: domains.user,
+		session: domains.session,
+		account: domains.account,
+		group: domains.group,
+		member: domains.member,
+		invite: domains.invite,
+		key: domains.key,
+		context: ((ctx, config$1) => {
+			assertAuthResolverContext(ctx);
+			return createPublicAuthContext(authLike, ctx, config$1);
+		}),
+		ctx: ((config$1) => createAuthContextCustomization(authLike, config$1))
+	};
+}
+
+//#endregion
+export { createAuthContext };
+//# sourceMappingURL=index.js.map

package/dist/otel.d.ts

@@ -1,6 +1,6 @@
-import * as _effect_opentelemetry_Resource0 from "@effect/opentelemetry/Resource";
-import * as effect_Layer0 from "effect/Layer";
 import { Attributes } from "@opentelemetry/api";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
 import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
 import { MetricReader } from "@opentelemetry/sdk-metrics";
 import { SpanProcessor, TracerConfig } from "@opentelemetry/sdk-trace-base";
@@ -10,7 +10,7 @@ import { SpanProcessor, TracerConfig } from "@opentelemetry/sdk-trace-base";
  * Consumer-provided telemetry configuration for Convex Auth spans.
  *
  * The host application decides the service name, exporters, processors, and
- * readers. Convex Auth only turns this configuration into an Effect layer.
+ * readers.
  */
 type TelemetryConfig = {
   /** Service name reported to the telemetry backend. */serviceName: string; /** Optional service version reported alongside the service name. */
@@ -22,52 +22,48 @@ type TelemetryConfig = {
   logRecordProcessor?: LogRecordProcessor | ReadonlyArray<LogRecordProcessor>;
 };
 /**
- * Build a Node.js OpenTelemetry layer for an app using Convex Auth.
+ * Build a Node.js OpenTelemetry tracer provider for an app using Convex Auth.
  *
- * Convex Auth does not install this layer automatically. Provide it from your
+ * Convex Auth does not install this provider automatically. Provide it from your
  * application runtime when you want server-side spans, metrics, or logs to be
  * exported.
  *
  * @param config - Telemetry configuration supplied by the host application.
- * @returns An Effect layer that installs the Node OpenTelemetry SDK.
+ * @returns A registered {@link NodeTracerProvider}.
  *
  * @example
  * ```ts
- * import { NodeRuntime } from "@effect/platform-node";
  * import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
  * import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
  * import { nodeTelemetry } from "@robelest/convex-auth/otel";
- * import { Effect } from "effect";
  *
- * const telemetry = nodeTelemetry({
+ * const provider = nodeTelemetry({
  *   serviceName: "my-app",
  *   spanProcessor: new BatchSpanProcessor(new OTLPTraceExporter()),
  * });
- *
- * Effect.log("ready").pipe(Effect.provide(telemetry), NodeRuntime.runMain);
  * ```
  */
-declare function nodeTelemetry(config: TelemetryConfig): effect_Layer0.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
+declare function nodeTelemetry(config: TelemetryConfig): NodeTracerProvider;
 /**
- * Build a browser OpenTelemetry layer for an app using Convex Auth.
+ * Build a browser OpenTelemetry tracer provider for an app using Convex Auth.
  *
- * Convex Auth does not install this layer automatically. Provide it from your
+ * Convex Auth does not install this provider automatically. Provide it from your
  * browser runtime when you want client-side Convex Auth spans to be exported.
  *
  * @param config - Telemetry configuration supplied by the host application.
- * @returns An Effect layer that installs the browser OpenTelemetry SDK.
+ * @returns A registered {@link WebTracerProvider}.
  *
  * @example
  * ```ts
  * import { browserTelemetry } from "@robelest/convex-auth/otel";
  *
- * const telemetry = browserTelemetry({
+ * const provider = browserTelemetry({
  *   serviceName: "my-web-app",
  *   attributes: { deployment: "production" },
  * });
  * ```
  */
-declare function browserTelemetry(config: TelemetryConfig): effect_Layer0.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
+declare function browserTelemetry(config: TelemetryConfig): WebTracerProvider;
 //#endregion
 export { TelemetryConfig, browserTelemetry, nodeTelemetry };
 //# sourceMappingURL=otel.d.ts.map

package/dist/otel.js

@@ -1,90 +1,80 @@
-import { Effect } from "effect";
-import * as NodeSdk from "@effect/opentelemetry/NodeSdk";
-import * as WebSdk from "@effect/opentelemetry/WebSdk";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
 
 //#region src/otel.ts
+function resolveProcessors(input) {
+	if (input === void 0) return [];
+	if (Array.isArray(input)) return [...input];
+	return [input];
+}
 /**
-* OpenTelemetry integration helpers for Convex Auth.
-*
-* @module
-*
-* Convex Auth exposes tracing hooks through Effect spans, but it does not
-* automatically install OpenTelemetry exporters or boot a telemetry runtime for
-* consumers. The application using Convex Auth owns telemetry setup.
-*
-* Use the helpers in this module when you want Convex Auth spans to participate
-* in your app's existing OpenTelemetry pipeline.
-*/
-/**
-* Build a Node.js OpenTelemetry layer for an app using Convex Auth.
+* Build a Node.js OpenTelemetry tracer provider for an app using Convex Auth.
 *
-* Convex Auth does not install this layer automatically. Provide it from your
+* Convex Auth does not install this provider automatically. Provide it from your
 * application runtime when you want server-side spans, metrics, or logs to be
 * exported.
 *
 * @param config - Telemetry configuration supplied by the host application.
-* @returns An Effect layer that installs the Node OpenTelemetry SDK.
+* @returns A registered {@link NodeTracerProvider}.
 *
 * @example
 * ```ts
-* import { NodeRuntime } from "@effect/platform-node";
 * import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 * import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 * import { nodeTelemetry } from "@robelest/convex-auth/otel";
-* import { Effect } from "effect";
 *
-* const telemetry = nodeTelemetry({
+* const provider = nodeTelemetry({
 *   serviceName: "my-app",
 *   spanProcessor: new BatchSpanProcessor(new OTLPTraceExporter()),
 * });
-*
-* Effect.log("ready").pipe(Effect.provide(telemetry), NodeRuntime.runMain);
 * ```
 */
 function nodeTelemetry(config) {
-	return NodeSdk.layer(Effect.sync(() => ({
-		resource: {
-			serviceName: config.serviceName,
-			serviceVersion: config.serviceVersion,
-			attributes: config.attributes
-		},
-		spanProcessor: config.spanProcessor,
-		tracerConfig: config.tracerConfig,
-		metricReader: config.metricReader,
-		logRecordProcessor: config.logRecordProcessor
-	})));
+	const provider = new NodeTracerProvider({
+		resource: resourceFromAttributes({
+			[ATTR_SERVICE_NAME]: config.serviceName,
+			...config.serviceVersion ? { [ATTR_SERVICE_VERSION]: config.serviceVersion } : {},
+			...config.attributes
+		}),
+		spanProcessors: resolveProcessors(config.spanProcessor),
+		...config.tracerConfig
+	});
+	provider.register();
+	return provider;
 }
 /**
-* Build a browser OpenTelemetry layer for an app using Convex Auth.
+* Build a browser OpenTelemetry tracer provider for an app using Convex Auth.
 *
-* Convex Auth does not install this layer automatically. Provide it from your
+* Convex Auth does not install this provider automatically. Provide it from your
 * browser runtime when you want client-side Convex Auth spans to be exported.
 *
 * @param config - Telemetry configuration supplied by the host application.
-* @returns An Effect layer that installs the browser OpenTelemetry SDK.
+* @returns A registered {@link WebTracerProvider}.
 *
 * @example
 * ```ts
 * import { browserTelemetry } from "@robelest/convex-auth/otel";
 *
-* const telemetry = browserTelemetry({
+* const provider = browserTelemetry({
 *   serviceName: "my-web-app",
 *   attributes: { deployment: "production" },
 * });
 * ```
 */
 function browserTelemetry(config) {
-	return WebSdk.layer(Effect.sync(() => ({
-		resource: {
-			serviceName: config.serviceName,
-			serviceVersion: config.serviceVersion,
-			attributes: config.attributes
-		},
-		spanProcessor: config.spanProcessor,
-		tracerConfig: config.tracerConfig,
-		metricReader: config.metricReader,
-		logRecordProcessor: config.logRecordProcessor
-	})));
+	const provider = new WebTracerProvider({
+		resource: resourceFromAttributes({
+			[ATTR_SERVICE_NAME]: config.serviceName,
+			...config.serviceVersion ? { [ATTR_SERVICE_VERSION]: config.serviceVersion } : {},
+			...config.attributes
+		}),
+		spanProcessors: resolveProcessors(config.spanProcessor),
+		...config.tracerConfig
+	});
+	provider.register();
+	return provider;
 }
 
 //#endregion

package/dist/providers/email.d.ts

@@ -1,5 +1,5 @@
 import { EmailConfig } from "../server/types.js";
-import { GenericActionCtx, GenericDataModel } from "convex/server";
+import { AnyDataModel, GenericActionCtx } from "convex/server";
 
 //#region src/providers/email.d.ts
 /** Configuration for the {@link email} provider. */
@@ -7,7 +7,7 @@ interface EmailProviderConfig {
   /** Sender address used for outgoing verification emails. */
   from: string;
   /** Delivery callback that actually sends the rendered verification email. */
-  send: (ctx: GenericActionCtx<GenericDataModel>, opts: {
+  send: (ctx: GenericActionCtx<AnyDataModel>, opts: {
     from: string;
     to: string;
     subject: string;