better-convex 0.6.3 → 0.7.0

package/dist/codegen-Cz1idI3-.mjs

@@ -0,0 +1,969 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { createJiti } from "jiti";
+
+//#region src/shared/meta-utils.ts
+/** Files to exclude from meta generation */
+const EXCLUDED_FILES = new Set([
+	"schema.ts",
+	"auth.ts",
+	"generated.ts",
+	"convex.config.ts",
+	"auth.config.ts"
+]);
+/**
+* Check if a file path should be included in meta generation.
+* Filters out private files/directories (prefixed with _) and config files.
+*/
+function isValidConvexFile(file) {
+	if (file.endsWith(".runtime.ts")) return false;
+	if (file.startsWith("generated/")) return false;
+	if (file.startsWith("_") || file.includes("/_")) return false;
+	const basename = file.split("/").pop() ?? "";
+	if (EXCLUDED_FILES.has(basename)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/cli/codegen.ts
+/** Valid JS identifier pattern for object keys */
+const VALID_IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+/** Valid JS identifier start pattern */
+const IDENTIFIER_START_RE = /^[a-zA-Z_$]/;
+/** Pattern to strip .ts extension */
+const TS_EXTENSION_RE = /\.ts$/;
+/** Pattern to detect default exports in auth contract files. */
+const DEFAULT_EXPORT_RE = /\bexport\s+default\b/;
+const RUNTIME_CALLER_RESERVED_EXPORTS = new Set(["actions", "schedule"]);
+const CODEGEN_SCOPES = new Set([
+	"all",
+	"auth",
+	"orm"
+]);
+function normalizeCodegenScope(scope) {
+	const normalized = scope ?? "all";
+	if (CODEGEN_SCOPES.has(normalized)) return normalized;
+	throw new Error(`Invalid codegen scope "${normalized}". Expected one of: all, auth, orm.`);
+}
+function shouldGenerateApi(scope) {
+	return scope === "all";
+}
+function shouldGenerateAuth(scope) {
+	return scope !== "orm";
+}
+function getGenerationLabel(generateApi, generateAuth) {
+	if (generateApi && generateAuth) return "all";
+	if (!generateApi && generateAuth) return "auth";
+	if (!generateApi && !generateAuth) return "orm";
+	return "api";
+}
+function resolveGenerationMode(options) {
+	const hasApiToggle = typeof options?.api === "boolean";
+	const hasAuthToggle = typeof options?.auth === "boolean";
+	if (hasApiToggle || hasAuthToggle) {
+		const generateApi = options?.api ?? true;
+		const generateAuth = options?.auth ?? true;
+		return {
+			generateApi,
+			generateAuth,
+			modeLabel: getGenerationLabel(generateApi, generateAuth)
+		};
+	}
+	const scope = normalizeCodegenScope(options?.scope);
+	return {
+		generateApi: shouldGenerateApi(scope),
+		generateAuth: shouldGenerateAuth(scope),
+		modeLabel: scope
+	};
+}
+const AUTH_RUNTIME_PROCEDURES = [
+	{
+		exportName: "create",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "deleteMany",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "deleteOne",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "findMany",
+		internal: true,
+		type: "query"
+	},
+	{
+		exportName: "findOne",
+		internal: true,
+		type: "query"
+	},
+	{
+		exportName: "getLatestJwks",
+		internal: true,
+		type: "action"
+	},
+	{
+		exportName: "rotateKeys",
+		internal: true,
+		type: "action"
+	},
+	{
+		exportName: "updateMany",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "updateOne",
+		internal: true,
+		type: "mutation"
+	}
+];
+const GENERATED_SERVER_RUNTIME_PROCEDURES = [
+	{
+		exportName: "scheduledMutationBatch",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "scheduledDelete",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "aggregateBackfill",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "aggregateBackfillChunk",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "aggregateBackfillStatus",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "resetChunk",
+		internal: true,
+		type: "mutation"
+	},
+	{
+		exportName: "reset",
+		internal: true,
+		type: "action"
+	}
+];
+function listFilesRecursive(cwd, relDir = "") {
+	const absDir = path.join(cwd, relDir);
+	const entries = fs.readdirSync(absDir, { withFileTypes: true });
+	const files = [];
+	for (const entry of entries) {
+		const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) {
+			files.push(...listFilesRecursive(cwd, relPath));
+			continue;
+		}
+		if (entry.isFile()) files.push(relPath);
+	}
+	return files;
+}
+function ensureRelativeImportPath(value) {
+	if (value.startsWith(".") || value.startsWith("/")) return value;
+	return `./${value}`;
+}
+function normalizeImportPath(value) {
+	return value.replace(/\\/g, "/");
+}
+function formatKey(key) {
+	return VALID_IDENTIFIER_RE.test(key) ? key : `'${key}'`;
+}
+function toPascalCaseToken(token) {
+	if (token.length === 0) return "";
+	return `${token[0]?.toUpperCase() ?? ""}${token.slice(1)}`;
+}
+function getModuleRuntimeExportBase(moduleName) {
+	const base = moduleName.split("/").filter(Boolean).flatMap((segment) => segment.split(/[^a-zA-Z0-9]+/g).filter(Boolean).map((token) => toPascalCaseToken(token))).join("");
+	if (base.length === 0) return "Module";
+	return IDENTIFIER_START_RE.test(base) ? base : `M${base}`;
+}
+function getModuleRuntimeExportNames(moduleName) {
+	if (moduleName === "generated/server") return {
+		callerExportName: "createServerCaller",
+		handlerExportName: "createServerHandler"
+	};
+	const base = getModuleRuntimeExportBase(moduleName);
+	return {
+		callerExportName: `create${base}Caller`,
+		handlerExportName: `create${base}Handler`
+	};
+}
+function getAccessPath(base, segments) {
+	return segments.reduce((acc, segment) => `${acc}[${JSON.stringify(segment)}]`, base);
+}
+function getModuleImportPath(outputFile, functionsDir, moduleName) {
+	const moduleFile = path.join(functionsDir, moduleName);
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), moduleFile)));
+}
+function getRuntimeApiImportPath(outputFile, functionsDir) {
+	const runtimeApiFile = path.join(functionsDir, "_generated", "api.js");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), runtimeApiFile)));
+}
+function getSchemaImportPath(outputFile, functionsDir) {
+	const schemaFile = path.join(functionsDir, "schema");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), schemaFile)));
+}
+function getServerTypesImportPath(outputFile, functionsDir) {
+	const serverTypesFile = path.join(functionsDir, "_generated", "server");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), serverTypesFile)));
+}
+function getDataModelImportPath(outputFile, functionsDir) {
+	const dataModelFile = path.join(functionsDir, "_generated", "dataModel");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), dataModelFile)));
+}
+function getHttpImportPath(outputFile, functionsDir) {
+	const httpFile = path.join(functionsDir, "http");
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), httpFile)));
+}
+const GENERATED_DIR = "generated";
+function getGeneratedServerOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "server.ts");
+}
+function getGeneratedAuthOutputFile(functionsDir) {
+	return path.join(functionsDir, GENERATED_DIR, "auth.ts");
+}
+function getLegacyGeneratedOutputFile(functionsDir) {
+	return path.join(functionsDir, "generated.ts");
+}
+function getModuleNameFromOutputFile(outputFile, functionsDir) {
+	return normalizeImportPath(path.relative(functionsDir, outputFile)).replace(TS_EXTENSION_RE, "");
+}
+function getGeneratedServerImportPath(outputFile, functionsDir) {
+	const generatedServerFile = getGeneratedServerOutputFile(functionsDir);
+	return ensureRelativeImportPath(normalizeImportPath(path.relative(path.dirname(outputFile), generatedServerFile)).replace(TS_EXTENSION_RE, ""));
+}
+function getGeneratedRuntimeOutputFile(functionsDir, moduleName) {
+	const runtimeModuleName = moduleName.startsWith(`${GENERATED_DIR}/`) ? moduleName.slice(10) : moduleName;
+	return path.join(functionsDir, GENERATED_DIR, `${runtimeModuleName}.runtime.ts`);
+}
+function emitGeneratedServerPlaceholderFile() {
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+import { initCRPC as baseInitCRPC } from 'better-convex/server';
+
+export type QueryCtx = unknown;
+export type MutationCtx = unknown;
+export type ActionCtx = unknown;
+export type GenericCtx = QueryCtx | MutationCtx | ActionCtx;
+export type OrmCtx<Ctx = QueryCtx> = Ctx;
+
+export const orm = {} as Record<string, unknown>;
+export const scheduledMutationBatch = undefined as unknown;
+export const scheduledDelete = undefined as unknown;
+export const initCRPC = baseInitCRPC;
+
+export function withOrm<Ctx>(ctx: Ctx): Ctx {
+  return ctx;
+}
+`;
+}
+function emitGeneratedAuthPlaceholderFile() {
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+export function defineAuth<TDefinition>(definition: TDefinition): TDefinition {
+  return definition;
+}
+
+export const authEnabled = false;
+export const authClient = {} as Record<string, unknown>;
+export const getAuth = () => ({} as Record<string, unknown>);
+export const auth = {} as Record<string, unknown>;
+`;
+}
+function ensureGeneratedSupportPlaceholders(functionsDir, options) {
+	const serverOutputFile = getGeneratedServerOutputFile(functionsDir);
+	const authOutputFile = getGeneratedAuthOutputFile(functionsDir);
+	const generatedDir = path.dirname(serverOutputFile);
+	fs.mkdirSync(generatedDir, { recursive: true });
+	const includeAuth = options?.includeAuth ?? true;
+	if (!fs.existsSync(serverOutputFile)) fs.writeFileSync(serverOutputFile, emitGeneratedServerPlaceholderFile());
+	if (includeAuth && !fs.existsSync(authOutputFile)) fs.writeFileSync(authOutputFile, emitGeneratedAuthPlaceholderFile());
+}
+function emitGeneratedRuntimePlaceholderFile(moduleName) {
+	const { callerExportName, handlerExportName } = getModuleRuntimeExportNames(moduleName);
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+export function ${callerExportName}(_ctx: unknown) {
+  throw new Error('[better-convex] Runtime caller is not generated yet. Run better-convex codegen.');
+}
+
+export function ${handlerExportName}(_ctx: unknown) {
+  throw new Error('[better-convex] Runtime handler is not generated yet. Run better-convex codegen.');
+}
+`;
+}
+function ensureGeneratedRuntimePlaceholders(functionsDir, moduleNames) {
+	const createdPlaceholderFiles = [];
+	for (const moduleName of moduleNames) {
+		const runtimeOutputFile = getGeneratedRuntimeOutputFile(functionsDir, moduleName);
+		if (fs.existsSync(runtimeOutputFile)) continue;
+		fs.mkdirSync(path.dirname(runtimeOutputFile), { recursive: true });
+		fs.writeFileSync(runtimeOutputFile, emitGeneratedRuntimePlaceholderFile(moduleName));
+		createdPlaceholderFiles.push(runtimeOutputFile);
+	}
+	return createdPlaceholderFiles;
+}
+function listGeneratedRuntimeFiles(functionsDir) {
+	const generatedDir = path.join(functionsDir, "generated");
+	if (!fs.existsSync(generatedDir)) return [];
+	return listFilesRecursive(generatedDir).filter((file) => file.endsWith(".runtime.ts")).map((file) => path.join(generatedDir, file));
+}
+function emitGeneratedServerFile(outputFile, functionsDir, hasRelationsExport, hasTriggersExport) {
+	const asSingleQuotedImport = (importPath) => `'${importPath.replaceAll("'", "\\'")}'`;
+	const serverTypesImportPath = getServerTypesImportPath(outputFile, functionsDir);
+	const dataModelImportPath = getDataModelImportPath(outputFile, functionsDir);
+	const runtimeApiImportPath = getRuntimeApiImportPath(outputFile, functionsDir);
+	const schemaImportPath = getSchemaImportPath(outputFile, functionsDir);
+	const serverTypesImportLiteral = asSingleQuotedImport(serverTypesImportPath);
+	const dataModelImportLiteral = asSingleQuotedImport(dataModelImportPath);
+	const runtimeApiImportLiteral = asSingleQuotedImport(runtimeApiImportPath);
+	const schemaImportLiteral = asSingleQuotedImport(schemaImportPath);
+	if (!hasRelationsExport) return `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+import { initCRPC as baseInitCRPC } from 'better-convex/server';
+import type { DataModel } from ${dataModelImportLiteral};
+import type {
+  ActionCtx as ServerActionCtx,
+  MutationCtx as ServerMutationCtx,
+  QueryCtx as ServerQueryCtx,
+} from ${serverTypesImportLiteral};
+
+export type QueryCtx = ServerQueryCtx;
+export type MutationCtx = ServerMutationCtx;
+export type ActionCtx = ServerActionCtx;
+export type GenericCtx = QueryCtx | MutationCtx | ActionCtx;
+export const initCRPC = baseInitCRPC.dataModel<DataModel>();
+`;
+	const ormFunctionsAccessor = getAccessPath("(internal as unknown as Record<string, any>)", getModuleNameFromOutputFile(outputFile, functionsDir).split("/").filter(Boolean));
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+import { createOrm, type GenericOrmCtx, type OrmFunctions } from 'better-convex/orm';
+import { initCRPC as baseInitCRPC } from 'better-convex/server';
+import { internal } from ${runtimeApiImportLiteral};
+import type { DataModel } from ${dataModelImportLiteral};
+import type {
+  ActionCtx as ServerActionCtx,
+  MutationCtx as ServerMutationCtx,
+  QueryCtx as ServerQueryCtx,
+} from ${serverTypesImportLiteral};
+import { internalMutation } from ${serverTypesImportLiteral};
+import schema, { ${hasTriggersExport ? "relations, triggers" : "relations"} } from ${schemaImportLiteral};
+
+const ormFunctions = ${ormFunctionsAccessor} as OrmFunctions;
+
+export const orm = createOrm({
+  schema: relations,
+${hasTriggersExport ? "  triggers,\n" : ""}  ormFunctions,
+  internalMutation,
+});
+
+export type OrmCtx<Ctx extends ServerQueryCtx | ServerMutationCtx = ServerQueryCtx> = GenericOrmCtx<Ctx, typeof relations>;
+export type QueryCtx = OrmCtx<ServerQueryCtx>;
+export type MutationCtx = OrmCtx<ServerMutationCtx>;
+export type ActionCtx = ServerActionCtx;
+export type GenericCtx = QueryCtx | MutationCtx | ActionCtx;
+
+export function withOrm<Ctx extends ServerQueryCtx | ServerMutationCtx>(ctx: Ctx) {
+  return orm.with(ctx) as OrmCtx<Ctx>;
+}
+
+export const initCRPC = baseInitCRPC.dataModel<DataModel>().context({
+  query: (ctx) => withOrm(ctx),
+  mutation: (ctx) => withOrm(ctx),
+});
+
+export const {
+  scheduledMutationBatch,
+  scheduledDelete,
+  aggregateBackfill,
+  aggregateBackfillChunk,
+  aggregateBackfillStatus,
+  resetChunk,
+  reset,
+} = orm.api();
+`;
+}
+function emitGeneratedAuthFile(outputFile, functionsDir, hasRelationsExport, authContract) {
+	const asSingleQuotedImport = (importPath) => `'${importPath.replaceAll("'", "\\'")}'`;
+	const runtimeApiImportPath = getRuntimeApiImportPath(outputFile, functionsDir);
+	const dataModelImportPath = getDataModelImportPath(outputFile, functionsDir);
+	const schemaImportPath = getSchemaImportPath(outputFile, functionsDir);
+	const serverImportPath = getGeneratedServerImportPath(outputFile, functionsDir);
+	const moduleNamespace = getModuleNameFromOutputFile(outputFile, functionsDir);
+	const authDefinitionImportPath = getModuleImportPath(outputFile, functionsDir, "auth");
+	const runtimeApiImportLiteral = asSingleQuotedImport(runtimeApiImportPath);
+	const dataModelImportLiteral = asSingleQuotedImport(dataModelImportPath);
+	const schemaImportLiteral = asSingleQuotedImport(schemaImportPath);
+	const serverImportLiteral = asSingleQuotedImport(serverImportPath);
+	const authDefinitionImportLiteral = asSingleQuotedImport(authDefinitionImportPath);
+	const hasAuthFile = authContract.hasAuthFile;
+	const hasAuthDefaultExport = authContract.hasAuthDefaultExport;
+	const disabledAuthReasonKind = hasAuthFile ? hasAuthDefaultExport ? "default_export_unavailable" : "missing_default_export" : "missing_auth_file";
+	const authRuntimeImports = `import {
+  ${[
+		"type BetterAuthOptionsWithoutDatabase",
+		"defineAuth as baseDefineAuth",
+		"createAuthRuntime",
+		"type GenericAuthDefinition",
+		"getGeneratedAuthDisabledReason",
+		hasAuthDefaultExport ? "resolveGeneratedAuthDefinition" : "createDisabledAuthRuntime"
+	].join(",\n  ")},
+} from 'better-convex/auth';`;
+	const authDefinitionImport = hasAuthDefaultExport ? `import * as authDefinitionModule from ${authDefinitionImportLiteral};` : "";
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+${authRuntimeImports}
+${hasAuthDefaultExport ? `import { internal } from ${runtimeApiImportLiteral};` : ""}
+import type { DataModel } from ${dataModelImportLiteral};
+import type { GenericCtx, MutationCtx } from ${serverImportLiteral};
+${hasRelationsExport && hasAuthDefaultExport ? `import { withOrm } from ${serverImportLiteral};` : ""}
+import schema from ${schemaImportLiteral};
+${authDefinitionImport}
+
+export function defineAuth<
+  AuthOptions extends BetterAuthOptionsWithoutDatabase = BetterAuthOptionsWithoutDatabase,
+>(
+  definition: GenericAuthDefinition<GenericCtx, DataModel, typeof schema, AuthOptions>
+) {
+  return baseDefineAuth(definition);
+}
+
+${hasAuthDefaultExport ? `type AuthDefinitionFromFile = Extract<
+  typeof authDefinitionModule extends { default: infer T } ? T : never,
+  (...args: unknown[]) => unknown
+>;
+
+const authDefinition = ((ctx: GenericCtx) =>
+  resolveGeneratedAuthDefinition<AuthDefinitionFromFile>(
+    authDefinitionModule,
+    getGeneratedAuthDisabledReason(${JSON.stringify(disabledAuthReasonKind)})
+  )(ctx)) as AuthDefinitionFromFile;
+` : ""}
+const authRuntime = ${hasAuthDefaultExport ? `createAuthRuntime<
+  DataModel,
+  typeof schema,
+  MutationCtx,
+  GenericCtx,
+  ReturnType<AuthDefinitionFromFile>
+>({
+  internal,
+  moduleName: ${JSON.stringify(moduleNamespace)},
+  schema,
+  auth: authDefinition,${hasRelationsExport ? "\n  context: withOrm," : ""}
+})` : `createDisabledAuthRuntime<DataModel, typeof schema, MutationCtx, GenericCtx>({
+  reason: getGeneratedAuthDisabledReason(${JSON.stringify(disabledAuthReasonKind)}),
+})`};
+
+export const {
+  authEnabled,
+  authClient,
+  getAuth,
+  auth,
+  create,
+  deleteMany,
+  deleteOne,
+  findMany,
+  findOne,
+  updateMany,
+  updateOne,
+  getLatestJwks,
+  rotateKeys,
+} = authRuntime;
+`;
+}
+function emitGeneratedModuleRuntimeFile(outputFile, functionsDir, moduleName, procedureEntries) {
+	const { callerExportName, handlerExportName } = getModuleRuntimeExportNames(moduleName);
+	const runtimeApiImportPath = getRuntimeApiImportPath(outputFile, functionsDir);
+	const generatedServerImportPath = getGeneratedServerImportPath(outputFile, functionsDir);
+	const { callerEntries, handlerEntries } = partitionRuntimeEntriesForEmission(procedureEntries);
+	const callerRegistryLines = emitProcedureRegistryEntries(callerEntries, outputFile, functionsDir, moduleName);
+	const callerRegistryBody = callerRegistryLines.length > 0 ? `\n${callerRegistryLines.join("\n")}\n` : "\n";
+	const hasHandlerRegistry = handlerEntries.length > 0;
+	const handlerRegistryLines = hasHandlerRegistry ? emitProcedureRegistryEntries(handlerEntries, outputFile, functionsDir, moduleName) : [];
+	const handlerRegistryBody = handlerRegistryLines.length > 0 ? `\n${handlerRegistryLines.join("\n")}\n` : "\n";
+	const allEntriesAreCrpc = callerEntries.length > 0 && callerEntries.length === handlerEntries.length;
+	const callerRegistryIdentifier = allEntriesAreCrpc ? "procedureRegistry" : "callerRegistry";
+	const handlerRegistryIdentifier = allEntriesAreCrpc ? "procedureRegistry" : "handlerRegistry";
+	const callerRegistryDeclaration = allEntriesAreCrpc ? `const procedureRegistry = {${callerRegistryBody}} as const;` : `const callerRegistry = {${callerRegistryBody}} as const;`;
+	return `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+import {
+  createGenericCallerFactory,${hasHandlerRegistry ? "\n  createGenericHandlerFactory," : ""}
+  typedProcedureResolver,
+  type ProcedureActionCallerFromRegistry,
+  type ProcedureCallerFromRegistry,
+  type ProcedureScheduleCallerFromRegistry,
+} from 'better-convex/server';
+import { api, internal } from '${runtimeApiImportPath}';
+import type { ActionCtx, MutationCtx, QueryCtx } from '${generatedServerImportPath}';
+
+${callerRegistryDeclaration}${hasHandlerRegistry && !allEntriesAreCrpc ? `\nconst handlerRegistry = {${handlerRegistryBody}} as const;\n` : ""}
+
+type ProcedureCallerContext = QueryCtx | MutationCtx | ActionCtx;
+type GeneratedProcedureCaller<
+  TCtx extends ProcedureCallerContext = ProcedureCallerContext,
+> = TCtx extends MutationCtx
+  ? ProcedureCallerFromRegistry<typeof ${callerRegistryIdentifier}, 'mutation'> & {
+      schedule: ProcedureScheduleCallerFromRegistry<typeof ${callerRegistryIdentifier}>;
+    }
+  : TCtx extends ActionCtx
+    ? ProcedureCallerFromRegistry<typeof ${callerRegistryIdentifier}, 'mutation'> & {
+        actions: ProcedureActionCallerFromRegistry<typeof ${callerRegistryIdentifier}>;
+        schedule: ProcedureScheduleCallerFromRegistry<typeof ${callerRegistryIdentifier}>;
+      }
+    : ProcedureCallerFromRegistry<typeof ${callerRegistryIdentifier}, 'query'>;
+${hasHandlerRegistry ? `
+type ProcedureHandlerContext = QueryCtx | MutationCtx;
+type GeneratedProcedureHandler<
+  TCtx extends ProcedureHandlerContext = ProcedureHandlerContext,
+> = TCtx extends MutationCtx
+  ? ProcedureCallerFromRegistry<typeof ${handlerRegistryIdentifier}, 'mutation'>
+  : ProcedureCallerFromRegistry<typeof ${handlerRegistryIdentifier}, 'query'>;
+` : ""}
+
+const createCallerFromRegistry = createGenericCallerFactory<
+  QueryCtx,
+  MutationCtx,
+  typeof ${callerRegistryIdentifier},
+  ActionCtx
+>(${callerRegistryIdentifier});${hasHandlerRegistry ? `
+const createHandlerFromRegistry = createGenericHandlerFactory<
+  QueryCtx,
+  MutationCtx,
+  typeof ${handlerRegistryIdentifier}
+>(${handlerRegistryIdentifier});
+` : ""}
+
+export function ${callerExportName}<TCtx extends ProcedureCallerContext>(
+  ctx: TCtx
+): GeneratedProcedureCaller<TCtx> {
+  return createCallerFromRegistry(ctx) as GeneratedProcedureCaller<TCtx>;
+}
+${hasHandlerRegistry ? `
+export function ${handlerExportName}<TCtx extends ProcedureHandlerContext>(
+  ctx: TCtx
+): GeneratedProcedureHandler<TCtx> {
+  return createHandlerFromRegistry(ctx) as GeneratedProcedureHandler<TCtx>;
+}
+` : ""}
+`;
+}
+function hasNamedExport(filePath, exportName) {
+	if (!fs.existsSync(filePath)) return false;
+	const source = fs.readFileSync(filePath, "utf-8");
+	if (new RegExp(`\\bexport\\s+(?:const|let|var|function|class|type|interface)\\s+${exportName}\\b`).test(source)) return true;
+	for (const match of source.matchAll(/\bexport\s*{([^}]*)}/g)) {
+		const exportList = match[1] ?? "";
+		if (new RegExp(`\\b${exportName}\\b`).test(exportList)) return true;
+	}
+	return false;
+}
+function hasDefaultExport(filePath) {
+	if (!fs.existsSync(filePath)) return false;
+	const source = fs.readFileSync(filePath, "utf-8");
+	return DEFAULT_EXPORT_RE.test(source);
+}
+function createApiTree(meta) {
+	const root = {
+		children: {},
+		functions: []
+	};
+	for (const [moduleName, fns] of Object.entries(meta)) {
+		const pathSegments = moduleName.split("/").filter(Boolean);
+		let node = root;
+		for (const segment of pathSegments) {
+			node.children[segment] ??= {
+				children: {},
+				functions: []
+			};
+			node = node.children[segment];
+		}
+		for (const fnName of Object.keys(fns).sort()) {
+			const fnMeta = fns[fnName] ?? {};
+			const type = fnMeta.type;
+			const fnType = type === "query" || type === "mutation" || type === "action" ? type : "query";
+			node.functions.push({
+				fnName,
+				fnType,
+				moduleName,
+				fnMeta: {
+					...fnMeta,
+					type: fnType
+				}
+			});
+		}
+	}
+	return root;
+}
+function formatMetaValue(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+	return null;
+}
+function emitFnMetaLiteral(fnMeta) {
+	const metaProps = [];
+	for (const [key, value] of Object.entries(fnMeta).sort(([a], [b]) => a.localeCompare(b))) {
+		if (value === void 0) continue;
+		const formatted = formatMetaValue(value);
+		if (formatted !== null) metaProps.push(`${key}: ${formatted}`);
+	}
+	return `{ ${metaProps.join(", ")} }`;
+}
+function emitHttpRoutes(dedupedRoutes, indentLevel) {
+	const indent = "  ".repeat(indentLevel);
+	const lines = [];
+	for (const [routeKey, route] of Object.entries(dedupedRoutes).sort(([a], [b]) => a.localeCompare(b))) lines.push(`${indent}${formatKey(routeKey)}: { path: ${JSON.stringify(route.path)}, method: ${JSON.stringify(route.method)} },`);
+	return lines;
+}
+function emitApiObject(tree, pathSegments, outputFile, functionsDir, indentLevel, dedupedRoutes, hasHttpRouterExport) {
+	const indent = "  ".repeat(indentLevel);
+	const lines = [];
+	const childKeys = Object.keys(tree.children).sort((a, b) => a.localeCompare(b));
+	const functionEntries = [...tree.functions].sort((a, b) => a.fnName.localeCompare(b.fnName));
+	const childSet = new Set(childKeys);
+	for (const entry of functionEntries) if (childSet.has(entry.fnName)) throw new Error(`Codegen conflict at ${pathSegments.join("/")}: export "${entry.fnName}" conflicts with directory of same name.`);
+	const mergedKeys = [...childKeys, ...functionEntries.map((entry) => entry.fnName)].sort((a, b) => a.localeCompare(b));
+	for (const key of mergedKeys) {
+		if (childSet.has(key)) {
+			const childNode = tree.children[key];
+			lines.push(`${indent}${formatKey(key)}: {`);
+			lines.push(...emitApiObject(childNode, [...pathSegments, key], outputFile, functionsDir, indentLevel + 1, dedupedRoutes, hasHttpRouterExport));
+			lines.push(`${indent}},`);
+			continue;
+		}
+		const fnEntry = functionEntries.find((entry) => entry.fnName === key);
+		if (!fnEntry) continue;
+		const runtimeAccess = getAccessPath("convexApi", [...pathSegments, key]);
+		const moduleImportPath = getModuleImportPath(outputFile, functionsDir, fnEntry.moduleName);
+		const fnMetaLiteral = emitFnMetaLiteral(fnEntry.fnMeta);
+		lines.push(`${indent}${formatKey(key)}: createApiLeaf<${JSON.stringify(fnEntry.fnType)}, typeof import(${JSON.stringify(moduleImportPath)}).${key}>(${runtimeAccess}, ${fnMetaLiteral}),`);
+	}
+	if (pathSegments.length === 0) {
+		if (hasHttpRouterExport) lines.push(`${indent}http: undefined as unknown as typeof httpRouter,`);
+		lines.push(`${indent}_http: {`);
+		lines.push(...emitHttpRoutes(dedupedRoutes, indentLevel + 1));
+		lines.push(`${indent}},`);
+	}
+	return lines;
+}
+function emitProcedureRegistryEntries(entries, outputFile, functionsDir, moduleName) {
+	return entries.map((entry) => {
+		const pathKey = entry.moduleName === moduleName ? entry.exportName : [...entry.moduleName.split("/"), entry.exportName].join(".");
+		const moduleImportPath = getModuleImportPath(outputFile, functionsDir, entry.moduleName);
+		const functionRefAccess = getAccessPath(entry.internal ? "internal" : "api", [...entry.moduleName.split("/"), entry.exportName]);
+		const resolver = `(require(${JSON.stringify(moduleImportPath)}) as Record<string, unknown>)[${JSON.stringify(entry.exportName)}]`;
+		return `  ${JSON.stringify(pathKey)}: [${JSON.stringify(entry.type)}, typedProcedureResolver(${functionRefAccess}, () => ${resolver})],`;
+	}).sort((a, b) => a.localeCompare(b));
+}
+function buildAuthRuntimeProcedureEntries(moduleName) {
+	return AUTH_RUNTIME_PROCEDURES.map((entry) => ({
+		...entry,
+		moduleName,
+		kind: "crpc"
+	}));
+}
+function buildGeneratedServerRuntimeProcedureEntries(moduleName) {
+	return GENERATED_SERVER_RUNTIME_PROCEDURES.map((entry) => ({
+		...entry,
+		moduleName,
+		kind: "dispatch"
+	}));
+}
+function partitionRuntimeEntriesForEmission(entries) {
+	return {
+		callerEntries: entries,
+		handlerEntries: entries.filter((entry) => entry.kind === "crpc")
+	};
+}
+function dedupeProcedureEntries(entries) {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of entries) {
+		const key = `${entry.moduleName}.${entry.exportName}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(entry);
+	}
+	return deduped;
+}
+function getConvexConfig(outputDir) {
+	const convexConfigPath = path.join(process.cwd(), "convex.json");
+	const functionsDir = (fs.existsSync(convexConfigPath) ? JSON.parse(fs.readFileSync(convexConfigPath, "utf-8")) : {}).functions || "convex";
+	return {
+		functionsDir: path.join(process.cwd(), functionsDir),
+		outputFile: path.join(process.cwd(), outputDir || "convex/shared", "api.ts")
+	};
+}
+/**
+* Check if a value is a CRPCHttpRouter (has _def.router === true)
+*/
+function isCRPCHttpRouter(value) {
+	return typeof value === "object" && value !== null && "_def" in value && value._def?.router === true;
+}
+/**
+* Import a module using jiti and extract cRPC metadata from exports.
+*/
+async function parseModuleRuntime(filePath, jitiInstance) {
+	const result = {};
+	const httpRoutes = {};
+	const procedures = [];
+	const isHttp = filePath.endsWith("http.ts");
+	const module = await jitiInstance.import(filePath);
+	if (!module || typeof module !== "object") {
+		if (isHttp) console.error("  http.ts: module is empty or not an object");
+		return {
+			meta: null,
+			httpRoutes: {},
+			procedures: []
+		};
+	}
+	for (const [name, value] of Object.entries(module)) {
+		if (name.startsWith("_")) continue;
+		const meta = value?._crpcMeta;
+		if (meta?.type) {
+			procedures.push({
+				exportName: name,
+				internal: Boolean(meta.internal),
+				type: meta.type
+			});
+			if (meta.internal) continue;
+			const fnMeta = { type: meta.type };
+			if (meta.auth) fnMeta.auth = meta.auth;
+			for (const [key, val] of Object.entries(meta)) if (key !== "type" && key !== "internal" && val !== void 0) fnMeta[key] = val;
+			result[name] = fnMeta;
+		}
+		const httpRoute = value?._crpcHttpRoute;
+		if (httpRoute?.path && httpRoute?.method) httpRoutes[name] = {
+			path: httpRoute.path,
+			method: httpRoute.method
+		};
+		if (isCRPCHttpRouter(value)) for (const [procPath, procedure] of Object.entries(value._def.procedures)) {
+			const route = procedure._crpcHttpRoute;
+			if (route?.path && route?.method) httpRoutes[procPath] = {
+				path: route.path,
+				method: route.method
+			};
+		}
+	}
+	return {
+		meta: Object.keys(result).length > 0 ? result : null,
+		httpRoutes,
+		procedures
+	};
+}
+async function generateMeta(outputDir, options) {
+	const startTime = Date.now();
+	const { functionsDir, outputFile } = getConvexConfig(outputDir);
+	const serverOutputFile = getGeneratedServerOutputFile(functionsDir);
+	const authOutputFile = getGeneratedAuthOutputFile(functionsDir);
+	const generatedAuthModuleName = getModuleNameFromOutputFile(authOutputFile, functionsDir);
+	const debug = options?.debug ?? false;
+	const silent = options?.silent ?? false;
+	const { generateApi, generateAuth, modeLabel } = resolveGenerationMode(options);
+	if (debug) if (generateApi) console.info("🔍 Scanning Convex functions for cRPC metadata...\n");
+	else console.info(`🔍 Running better-convex codegen (mode=${modeLabel})...\n`);
+	const meta = {};
+	const allHttpRoutes = {};
+	const procedureEntries = [];
+	let createdRuntimePlaceholders = [];
+	const runtimeFilesPreservedFromParseFailures = /* @__PURE__ */ new Set();
+	let totalFunctions = 0;
+	const authFilePath = path.join(functionsDir, "auth.ts");
+	const hasAuthFile = fs.existsSync(authFilePath);
+	const hasAuthDefaultExport = hasDefaultExport(authFilePath);
+	const authContract = {
+		hasAuthFile,
+		hasAuthDefaultExport
+	};
+	const hasRelationsExport = hasNamedExport(path.join(functionsDir, "schema.ts"), "relations");
+	const hasTriggersExport = hasNamedExport(path.join(functionsDir, "schema.ts"), "triggers");
+	if (hasTriggersExport && !hasRelationsExport) throw new Error("Codegen error: schema.ts exports 'triggers' but is missing 'relations'. Export `relations` and define triggers via `defineTriggers(relations, { ... })`.");
+	ensureGeneratedSupportPlaceholders(functionsDir, { includeAuth: generateAuth });
+	if (generateApi) {
+		const jitiInstance = createJiti(process.cwd(), {
+			interopDefault: true,
+			moduleCache: false
+		});
+		const files = listFilesRecursive(functionsDir).filter((file) => file.endsWith(".ts") && isValidConvexFile(file));
+		createdRuntimePlaceholders = ensureGeneratedRuntimePlaceholders(functionsDir, [...new Set([
+			...files.map((file) => file.replace(TS_EXTENSION_RE, "")),
+			...hasRelationsExport ? ["generated/server"] : [],
+			...generateAuth ? [generatedAuthModuleName] : []
+		])]);
+		for (const file of files) {
+			const filePath = path.join(functionsDir, file);
+			const moduleName = file.replace(TS_EXTENSION_RE, "");
+			try {
+				const { meta: moduleMeta, httpRoutes, procedures } = await parseModuleRuntime(filePath, jitiInstance);
+				if (moduleMeta) {
+					meta[moduleName] = moduleMeta;
+					const fnCount = Object.keys(moduleMeta).length;
+					totalFunctions += fnCount;
+					if (debug) console.info(`  ✓ ${moduleName}: ${fnCount} functions`);
+				}
+				if (Object.keys(httpRoutes).length > 0 && debug) console.info(`  ✓ ${moduleName}: ${Object.keys(httpRoutes).length} HTTP routes`);
+				Object.assign(allHttpRoutes, httpRoutes);
+				for (const procedure of procedures) procedureEntries.push({
+					moduleName,
+					exportName: procedure.exportName,
+					internal: procedure.internal,
+					type: procedure.type,
+					kind: "crpc"
+				});
+			} catch (error) {
+				runtimeFilesPreservedFromParseFailures.add(getGeneratedRuntimeOutputFile(functionsDir, moduleName));
+				if (debug || file === "http.ts") console.error(`  ⚠ Failed to parse ${file}:`, error);
+			}
+		}
+	}
+	if (generateApi) {
+		const routesByPath = /* @__PURE__ */ new Map();
+		for (const [key, route] of Object.entries(allHttpRoutes)) {
+			const pathKey = `${route.path}:${route.method}`;
+			const existing = routesByPath.get(pathKey) || [];
+			existing.push({
+				key,
+				route
+			});
+			routesByPath.set(pathKey, existing);
+		}
+		const dedupedRoutes = {};
+		for (const entries of routesByPath.values()) {
+			const best = entries.reduce((a, b) => a.key.length >= b.key.length ? a : b);
+			dedupedRoutes[best.key] = best.route;
+		}
+		const runtimeApiImportPath = getRuntimeApiImportPath(outputFile, functionsDir);
+		const schemaImportPath = getSchemaImportPath(outputFile, functionsDir);
+		const httpImportPath = getHttpImportPath(outputFile, functionsDir);
+		const hasTablesExport = hasNamedExport(path.join(functionsDir, "schema.ts"), "tables");
+		const hasHttpRouterExport = hasNamedExport(path.join(functionsDir, "http.ts"), "httpRouter");
+		const apiTree = createApiTree(meta);
+		if (Object.hasOwn(apiTree.children, "http") || apiTree.functions.some((entry) => entry.fnName === "http")) throw new Error("Codegen conflict: root \"http\" namespace is reserved for generated HTTP router types. Rename your Convex module/function.");
+		const apiObjectLines = emitApiObject(apiTree, [], outputFile, functionsDir, 1, dedupedRoutes, hasHttpRouterExport);
+		const apiObjectBody = apiObjectLines.length > 0 ? `\n${apiObjectLines.join("\n")}\n` : "\n";
+		const serverTypeImports = "import type { inferApiInputs, inferApiOutputs } from \"better-convex/server\";";
+		const ormTypeImports = [hasTablesExport ? "InferInsertModel" : null, hasTablesExport ? "InferSelectModel" : null].filter((item) => !!item);
+		const optionalImports = [
+			ormTypeImports.length > 0 ? `import type { ${ormTypeImports.join(", ")} } from "better-convex/orm";` : null,
+			hasHttpRouterExport ? `import type { httpRouter } from ${JSON.stringify(httpImportPath)};` : null,
+			hasTablesExport ? `import type { tables } from ${JSON.stringify(schemaImportPath)};` : null
+		].filter((line) => !!line).join("\n");
+		const apiTypeLine = "export type Api = typeof api;";
+		const optionalTypeExports = [hasTablesExport ? `
+export type TableName = keyof typeof tables;
+export type Select<T extends TableName> = InferSelectModel<(typeof tables)[T]>;
+export type Insert<T extends TableName> = InferInsertModel<(typeof tables)[T]>;` : null].filter((entry) => !!entry).join("\n");
+		const output = `// biome-ignore-all format: generated
+// This file is auto-generated by better-convex
+// Do not edit manually. Run \`better-convex codegen\` to regenerate.
+
+import { createApiLeaf } from "better-convex/server";
+${serverTypeImports}
+import { api as convexApi } from ${JSON.stringify(runtimeApiImportPath)};
+${optionalImports ? `\n${optionalImports}` : ""}
+
+export const api = {${apiObjectBody}} as const;
+
+${apiTypeLine}
+export type ApiInputs = inferApiInputs<Api>;
+export type ApiOutputs = inferApiOutputs<Api>;
+${optionalTypeExports}
+`;
+		const outputDirname = path.dirname(outputFile);
+		if (!fs.existsSync(outputDirname)) fs.mkdirSync(outputDirname, { recursive: true });
+		fs.writeFileSync(outputFile, output);
+	} else fs.rmSync(outputFile, { force: true });
+	const serverOutput = emitGeneratedServerFile(serverOutputFile, functionsDir, hasRelationsExport, hasTriggersExport);
+	const generatedOutputDirname = path.dirname(serverOutputFile);
+	if (!fs.existsSync(generatedOutputDirname)) fs.mkdirSync(generatedOutputDirname, { recursive: true });
+	fs.writeFileSync(serverOutputFile, serverOutput);
+	if (generateAuth) {
+		const authOutput = emitGeneratedAuthFile(authOutputFile, functionsDir, hasRelationsExport, authContract);
+		fs.writeFileSync(authOutputFile, authOutput);
+	} else fs.rmSync(authOutputFile, { force: true });
+	fs.rmSync(getLegacyGeneratedOutputFile(functionsDir), { force: true });
+	const mergedProcedureEntries = dedupeProcedureEntries([
+		...hasRelationsExport ? buildGeneratedServerRuntimeProcedureEntries("generated/server") : [],
+		...generateApi ? procedureEntries : [],
+		...generateAuth && hasAuthDefaultExport ? buildAuthRuntimeProcedureEntries(generatedAuthModuleName) : []
+	]);
+	const runtimeProcedureEntriesByModule = /* @__PURE__ */ new Map();
+	for (const entry of mergedProcedureEntries) {
+		if (RUNTIME_CALLER_RESERVED_EXPORTS.has(entry.exportName)) throw new Error(`Codegen conflict: "${entry.moduleName}.${entry.exportName}" uses reserved runtime caller namespace "${entry.exportName}". Rename the procedure export.`);
+		const existingEntries = runtimeProcedureEntriesByModule.get(entry.moduleName);
+		if (existingEntries) {
+			existingEntries.push(entry);
+			continue;
+		}
+		runtimeProcedureEntriesByModule.set(entry.moduleName, [entry]);
+	}
+	const runtimeOutputFiles = [];
+	for (const [moduleName, moduleEntries] of [...runtimeProcedureEntriesByModule].sort(([moduleA], [moduleB]) => moduleA.localeCompare(moduleB))) {
+		const runtimeOutputFile = getGeneratedRuntimeOutputFile(functionsDir, moduleName);
+		const runtimeOutput = emitGeneratedModuleRuntimeFile(runtimeOutputFile, functionsDir, moduleName, moduleEntries);
+		fs.mkdirSync(path.dirname(runtimeOutputFile), { recursive: true });
+		fs.writeFileSync(runtimeOutputFile, runtimeOutput);
+		runtimeOutputFiles.push(runtimeOutputFile);
+	}
+	const runtimeOutputFileSet = new Set(runtimeOutputFiles);
+	const existingRuntimeFiles = listGeneratedRuntimeFiles(functionsDir);
+	for (const existingRuntimeFile of existingRuntimeFiles) {
+		if (runtimeOutputFileSet.has(existingRuntimeFile) || runtimeFilesPreservedFromParseFailures.has(existingRuntimeFile)) continue;
+		fs.rmSync(existingRuntimeFile, { force: true });
+	}
+	for (const createdRuntimePlaceholder of createdRuntimePlaceholders) {
+		if (runtimeOutputFileSet.has(createdRuntimePlaceholder) || runtimeFilesPreservedFromParseFailures.has(createdRuntimePlaceholder)) continue;
+		fs.rmSync(createdRuntimePlaceholder, { force: true });
+	}
+	const elapsed = ((Date.now() - startTime) / 1e3).toFixed(2);
+	const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+		hour12: false,
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	});
+	if (!silent) if (debug) {
+		if (generateApi) console.info(`\n✅ Generated ${outputFile}`);
+		else console.info(`\n🧹 Removed ${outputFile}`);
+		console.info(`✅ Generated ${serverOutputFile}`);
+		if (generateAuth) console.info(`✅ Generated ${authOutputFile}`);
+		else console.info(`🧹 Removed ${authOutputFile}`);
+		for (const runtimeOutputFile of runtimeOutputFiles) console.info(`✅ Generated ${runtimeOutputFile}`);
+		if (generateApi) console.info(`   ${Object.keys(meta).length} modules, ${totalFunctions} functions`);
+		else console.info("   cRPC scan skipped for scoped generation");
+	} else console.info(`✔ ${time} Convex api ready! (${elapsed}s)`);
+}
+
+//#endregion
+export { getConvexConfig as n, generateMeta as t };