convex 1.34.1 → 1.35.1

package/src/cli/lib/usage.ts

@@ -3,6 +3,7 @@ import { Context } from "../../bundler/context.js";
 import { logWarning } from "../../bundler/log.js";
 import { teamDashboardUrl } from "./dashboard.js";
 import { fetchTeamAndProject } from "./api.js";
+import { isAnonymousDeployment } from "./deployment.js";
 import { bigBrainAPI } from "./utils/utils.js";
 
 async function warn(
@@ -53,7 +54,8 @@ export async function usageStateWarning(
     auth === null ||
     auth.kind === "projectKey" ||
     auth.kind === "deploymentKey" ||
-    process.env.CONVEX_AGENT_MODE === "anonymous"
+    process.env.CONVEX_AGENT_MODE === "anonymous" ||
+    isAnonymousDeployment(targetDeployment)
   ) {
     return;
   }

package/src/cli/lib/utils/prompts.ts

@@ -30,12 +30,14 @@ export const promptString = async (
   options: {
     message: string;
     default?: string;
+    validate?: (value: string) => boolean | string | Promise<string | boolean>;
   },
 ): Promise<string> => {
   if (process.stdin.isTTY) {
     return input({
       message: options.message,
       ...(options.default !== undefined ? { default: options.default } : {}),
+      ...(options.validate !== undefined ? { validate: options.validate } : {}),
     }).catch(handlePromptError(ctx));
   } else {
     return ctx.crash({

package/src/cli/lib/utils/utils.test.ts

@@ -65,7 +65,7 @@ describe("bigBrainFetch", () => {
     const mockFetch = stubFetch();
     const ctx = makeContext(null);
 
-    const fetch = await bigBrainFetch(ctx);
+    const fetch = bigBrainFetch(ctx);
     await fetch("https://api.convex.dev/api/test", { method: "GET" });
 
     expect(mockFetch).toHaveBeenCalledOnce();
@@ -82,7 +82,7 @@ describe("bigBrainFetch", () => {
       accessToken: "test-token",
     });
 
-    const fetch = await bigBrainFetch(ctx);
+    const fetch = bigBrainFetch(ctx);
     await fetch("https://api.convex.dev/api/test", { method: "GET" });
 
     expect(mockFetch).toHaveBeenCalledOnce();
@@ -99,7 +99,7 @@ describe("bigBrainFetch", () => {
       accessToken: "original-token",
     });
 
-    const fetch = await bigBrainFetch(ctx);
+    const fetch = bigBrainFetch(ctx);
     await fetch("https://api.convex.dev/api/test", {
       method: "POST",
       headers: {
@@ -124,7 +124,7 @@ describe("bigBrainFetch", () => {
       headers: { "X-Custom-Header": "custom-value" },
     });
 
-    const fetch = await bigBrainFetch(ctx);
+    const fetch = bigBrainFetch(ctx);
     await fetch(request, undefined);
 
     expect(mockFetch).toHaveBeenCalledOnce();
@@ -143,7 +143,7 @@ describe("bigBrainFetch", () => {
       headers: { "X-Custom-Header": "from-request" },
     });
 
-    const fetch = await bigBrainFetch(ctx);
+    const fetch = bigBrainFetch(ctx);
     await fetch(request, {
       headers: { "X-Custom-Header": "from-options" },
     });
@@ -160,7 +160,7 @@ describe("bigBrainFetch", () => {
       method: "POST",
     });
 
-    const fetch = await bigBrainFetch(ctx);
+    const fetch = bigBrainFetch(ctx);
     await fetch(request);
 
     expect(mockFetch).toHaveBeenCalledOnce();

package/src/cli/lib/utils/utils.ts

@@ -1,3 +1,4 @@
+import { paths as PlatformDeploymentPaths } from "@convex-dev/platform/deploymentApi";
 import { paths as PlatformManagementPaths } from "@convex-dev/platform/managementApi";
 import { chalkStderr } from "chalk";
 import os from "os";
@@ -692,7 +693,7 @@ export function cacheDir() {
  *
  * This fetch() also has retries and throws if the response is not ok.
  */
-export async function bigBrainFetch(ctx: Context): Promise<typeof fetch> {
+export function bigBrainFetch(ctx: Context): typeof fetch {
   const authHeader = ctx.bigBrainAuth()?.header;
   const bigBrainHeaders: Record<string, string> = authHeader
     ? {
@@ -758,26 +759,25 @@ export async function bigBrainAPI<T = any>({
  *
  * Pass { throw: true } to throw ThrowingFetchErrors instead of exiting the process.
  */
-function typedBigBrainClientFactory<T>(baseUrl: string) {
+function typedApiClientFactory<T>(
+  baseUrl: string,
+  fetchBuilder: (ctx: Context) => typeof fetch,
+) {
   return (ctx: Context, options: { throw?: boolean } = {}) => {
     type Paths = T extends CliManagementPaths
       ? CliManagementPaths
       : T extends PlatformManagementPaths
         ? PlatformManagementPaths
-        : never;
-    const bigBrainClient = createClient<Paths>({
+        : T extends PlatformDeploymentPaths
+          ? PlatformDeploymentPaths
+          : never;
+    const client = createClient<Paths>({
       baseUrl,
-      fetch: async (
-        resource: Request,
-        options?: RequestInit,
-      ): Promise<Response> => {
-        const fetch = await bigBrainFetch(ctx);
-        return fetch(resource, options);
-      },
+      fetch: fetchBuilder(ctx),
     });
 
     // Wrap the client with error handling - go back to proxy since middleware doesn't catch parsing errors
-    return new Proxy(bigBrainClient, {
+    return new Proxy(client, {
       get(target, prop) {
         const originalMethod = target[prop as keyof typeof target];
 
@@ -810,13 +810,31 @@ function typedBigBrainClientFactory<T>(baseUrl: string) {
   };
 }
 
-export const typedBigBrainClient =
-  typedBigBrainClientFactory<CliManagementPaths>(BIG_BRAIN_URL);
+export const typedBigBrainClient = typedApiClientFactory<CliManagementPaths>(
+  BIG_BRAIN_URL,
+  bigBrainFetch,
+);
 export const typedPlatformClient =
-  typedBigBrainClientFactory<PlatformManagementPaths>(
+  typedApiClientFactory<PlatformManagementPaths>(
     PLATFORM_MANAGEMENT_API_URL,
+    bigBrainFetch,
   );
 
+export function typedDeploymentClient(
+  ctx: Context,
+  args: { deploymentUrl: string; adminKey: string },
+  options: { throw?: boolean } = {},
+) {
+  return typedApiClientFactory<PlatformDeploymentPaths>(
+    `${args.deploymentUrl}/api/v1`,
+    (ctx) =>
+      deploymentFetch(ctx, {
+        deploymentUrl: args.deploymentUrl,
+        adminKey: args.adminKey,
+      }),
+  )(ctx, options);
+}
+
 export async function bigBrainAPIMaybeThrows({
   ctx,
   method,
@@ -828,7 +846,7 @@ export async function bigBrainAPIMaybeThrows({
   path: string;
   data?: any;
 }): Promise<any> {
-  const fetch = await bigBrainFetch(ctx);
+  const fetch = bigBrainFetch(ctx);
   const dataString =
     data === undefined
       ? method === "POST"
@@ -894,19 +912,40 @@ export function waitUntilCalled(): [Promise<unknown>, () => void] {
   return [waitPromise, () => onCalled(null)];
 }
 
-// We can eventually switch to something like `filesize` for i18n and
-// more robust formatting, but let's keep our CLI bundle small for now.
+const BYTE_UNITS: [number, string][] = [
+  [1 << 30, "GiB"],
+  [1_000_000_000, "GB"],
+  [1 << 20, "MiB"],
+  [1_000_000, "MB"],
+  [1 << 10, "KiB"],
+  [1_000, "KB"],
+];
+
+/**
+ * Format a byte count into a human-friendly string.
+ *
+ * Picks the unit (binary or decimal) that divides most cleanly.
+ * Shows one decimal place only when it divides exactly (e.g. "4.1 MiB").
+ * Falls back to raw bytes when no unit divides cleanly.
+ */
 export function formatSize(n: number): string {
-  if (n < 1024) {
-    return `${n} B`;
+  if (n === 0) {
+    return "0 bytes";
   }
-  if (n < 1024 * 1024) {
-    return `${(n / 1024).toFixed(1)} KB`;
-  }
-  if (n < 1024 * 1024 * 1024) {
-    return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  for (const [unitSize, unitName] of BYTE_UNITS) {
+    if (n < unitSize) {
+      continue;
+    }
+    if (n % unitSize === 0) {
+      return `${n / unitSize} ${unitName}`;
+    }
+    if ((n * 10) % unitSize === 0) {
+      const whole = Math.floor(n / unitSize);
+      const frac = Math.floor((n * 10) / unitSize) % 10;
+      return `${whole}.${frac} ${unitName}`;
+    }
   }
-  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+  return `${n} bytes`;
 }
 
 export function formatDuration(ms: number): string {
@@ -1236,7 +1275,7 @@ export function deploymentFetch(
     adminKey: string;
     onError?: (err: any) => void;
   },
-): typeof throwingFetch {
+): typeof fetch {
   const { deploymentUrl, adminKey, onError } = options;
   const onErrorWithAttempt = (err: any, attempt: number) => {
     onError?.(err);

package/src/index.ts

@@ -1 +1 @@
-export const version = "1.34.1";
+export const version = "1.35.1";

package/src/react-clerk/ConvexProviderWithClerk.test.tsx

@@ -5,7 +5,7 @@ import { test } from "vitest";
 import React from "react";
 import { ConvexProviderWithClerk } from "./ConvexProviderWithClerk.js";
 import { ConvexReactClient } from "../react/index.js";
-import { useAuth } from "@clerk/clerk-react";
+import { useAuth } from "@clerk/react";
 
 test("Helpers are valid children", () => {
   const convex = new ConvexReactClient("https://localhost:3001");

package/src/react-clerk/ConvexProviderWithClerk.tsx

@@ -30,7 +30,7 @@ type UseAuth = () => {
  * authenticated with Clerk.
  *
  * It must be wrapped by a configured `ClerkProvider`, from
- * `@clerk/clerk-react`, `@clerk/clerk-expo`, `@clerk/nextjs` or
+ * `@clerk/react`, `@clerk/clerk-expo`, `@clerk/nextjs` or
  * another React-based Clerk client library and have the corresponding
  * `useAuth` hook passed in.
  *

package/src/server/components/definition.ts

@@ -45,6 +45,9 @@ export type ComponentDefinitionAnalysis = {
 };
 export type AppDefinitionAnalysis = {
   definitionType: AppDefinitionType;
+  // Top-level field (not inside definitionType) to match Rust's
+  // SerializedComponentDefinitionMetadata.http_prefix field.
+  httpPrefix?: string;
   childComponents: ComponentInstantiation[];
   httpMounts: Record<string, HttpMount>;
   exports: ComponentExport;

package/src/server/components/index.ts

@@ -94,6 +94,7 @@ export type ComponentDefinition<Exports extends ComponentExports = any> = {
     definition: Definition,
     options?: {
       name?: string;
+      httpPrefix?: string;
     },
   ): InstalledComponent<Definition>;
 
@@ -128,6 +129,7 @@ export type AppDefinition = {
     definition: Definition,
     options?: {
       name?: string;
+      httpPrefix?: string;
     },
   ): InstalledComponent<Definition>;
 };
@@ -143,6 +145,7 @@ type CommonDefinitionData = {
     string,
     ImportedComponentDefinition,
     Record<string, any> | null,
+    string | undefined,
   ][];
   _exportTree: ExportTree;
 };
@@ -152,7 +155,9 @@ type ComponentDefinitionData = CommonDefinitionData & {
   _name: string;
   _onInitCallbacks: Record<string, (argsStr: string) => string>;
 };
-type AppDefinitionData = CommonDefinitionData;
+type AppDefinitionData = CommonDefinitionData & {
+  _httpPrefix?: string;
+};
 
 /**
  * Used to refer to an already-installed component.
@@ -204,6 +209,7 @@ function use<Definition extends ComponentDefinition<any>>(
   definition: Definition,
   options?: {
     name?: string;
+    httpPrefix?: string;
   },
 ): InstalledComponent<Definition> {
   // At runtime an imported component will have this shape.
@@ -232,7 +238,21 @@ function use<Definition extends ComponentDefinition<any>>(
     throw new Error("Component name cannot be empty.");
   }
 
-  this._childComponents.push([name, importedComponentDefinition, {}]);
+  const httpPrefix = options?.httpPrefix;
+  if (httpPrefix !== undefined) {
+    if (!httpPrefix.startsWith("/")) {
+      throw new Error(
+        `httpPrefix must start with "/". Received: "${httpPrefix}"`,
+      );
+    }
+  }
+
+  this._childComponents.push([
+    name,
+    importedComponentDefinition,
+    {},
+    httpPrefix,
+  ]);
   return new InstalledComponent(definition, name);
 }
 
@@ -255,10 +275,14 @@ function exportAppForAnalysis(
 ): AppDefinitionAnalysis {
   const definitionType = { type: "app" as const };
   const childComponents = serializeChildComponents(this._childComponents);
+  const httpMounts = buildHttpMounts(this._childComponents);
   return {
     definitionType,
+    ...(this._httpPrefix !== undefined
+      ? { httpPrefix: normalizeHttpPrefix(this._httpPrefix) }
+      : {}),
     childComponents: childComponents as any,
-    httpMounts: {},
+    httpMounts,
     exports: serializeExportTree(this._exportTree),
   };
 }
@@ -277,11 +301,35 @@ function serializeExportTree(tree: ExportTree): any {
   return { type: "branch", branch };
 }
 
+function normalizeHttpPrefix(prefix: string): string {
+  // Ensure the prefix ends with "/" as required by HttpMountPath in Rust.
+  return prefix.endsWith("/") ? prefix : prefix + "/";
+}
+
+function buildHttpMounts(
+  childComponents: [
+    string,
+    ImportedComponentDefinition,
+    Record<string, any> | null,
+    string | undefined,
+  ][],
+): Record<string, string> {
+  const httpMounts: Record<string, string> = {};
+  for (const [name, , , httpPrefix] of childComponents) {
+    if (httpPrefix !== undefined) {
+      const normalized = normalizeHttpPrefix(httpPrefix);
+      httpMounts[normalized] = `_reference/childComponent/${name}`;
+    }
+  }
+  return httpMounts;
+}
+
 function serializeChildComponents(
   childComponents: [
     string,
     ImportedComponentDefinition,
     Record<string, any> | null,
+    string | undefined,
   ][],
 ): {
   name: string;
@@ -289,6 +337,7 @@ function serializeChildComponents(
   args: [string, { type: "value"; value: string }][] | null;
 }[] {
   return childComponents.map(([name, definition, p]) => {
+    // Note: httpPrefix (4th element) is used separately in buildHttpMounts()
     let args: [string, { type: "value"; value: string }][] | null = null;
     if (p !== null) {
       args = [];
@@ -335,11 +384,12 @@ function exportComponentForAnalysis(
     args,
   };
   const childComponents = serializeChildComponents(this._childComponents);
+  const httpMounts = buildHttpMounts(this._childComponents);
   return {
     name: this._name,
     definitionType,
     childComponents: childComponents as any,
-    httpMounts: {},
+    httpMounts,
     exports: serializeExportTree(this._exportTree),
   };
 }
@@ -394,11 +444,18 @@ export function defineComponent<Exports extends ComponentExports = any>(
  * This is a feature of components, which are in beta.
  * This API is unstable and may change in subsequent releases.
  */
-export function defineApp(): AppDefinition {
+export function defineApp(options?: { httpPrefix?: string }): AppDefinition {
+  const httpPrefix = options?.httpPrefix;
+  if (httpPrefix !== undefined && !httpPrefix.startsWith("/")) {
+    throw new Error(
+      `httpPrefix must start with "/". Received: "${httpPrefix}"`,
+    );
+  }
   const ret: RuntimeAppDefinition = {
     _isRoot: true,
     _childComponents: [],
     _exportTree: {},
+    ...(httpPrefix !== undefined ? { _httpPrefix: httpPrefix } : {}),
 
     export: exportAppForAnalysis,
     use,

package/src/server/data_model.ts

@@ -1,4 +1,5 @@
 import { Value } from "../values/index.js";
+import type { SystemIndexes } from "./system_fields.js";
 
 // Document Types  /////////////////////////////////////////////////////////////
 
@@ -262,7 +263,7 @@ export type AnyDataModel = {
   [tableName: string]: {
     document: any;
     fieldPaths: GenericFieldPaths;
-    indexes: {};
+    indexes: SystemIndexes;
     searchIndexes: {};
     vectorIndexes: {};
   };

package/src/server/impl/meta_impl.ts

@@ -0,0 +1,74 @@
+import { jsonToConvex } from "../../values/index.js";
+import {
+  ActionMeta,
+  MutationMeta,
+  QueryMeta,
+  FunctionMetadata,
+  TransactionMetrics,
+} from "../meta.js";
+import { performAsyncSyscall } from "./syscall.js";
+
+async function getTransactionMetrics(): Promise<TransactionMetrics> {
+  let syscallJSON;
+  try {
+    syscallJSON = await performAsyncSyscall("1.0/getTransactionMetrics", {});
+  } catch (e: any) {
+    if (e.message?.includes("Unknown async operation")) {
+      throw new Error(
+        "getTransactionMetrics() can only be called from a query or mutation. " +
+          "It is not available in actions or outside of a Convex function.",
+      );
+    }
+    throw e;
+  }
+  return jsonToConvex(syscallJSON) as any;
+}
+
+async function getFunctionMetadata(): Promise<{
+  name: string;
+  componentPath: string;
+}> {
+  const { name, componentPath } = await performAsyncSyscall(
+    "1.0/getFunctionMetadata",
+    {},
+  );
+  return { name, componentPath };
+}
+
+export function setupQueryMeta(
+  visibility: FunctionMetadata["visibility"],
+): QueryMeta {
+  return {
+    getFunctionMetadata: async () => ({
+      ...(await getFunctionMetadata()),
+      type: "query",
+      visibility,
+    }),
+    getTransactionMetrics,
+  };
+}
+
+export function setupMutationMeta(
+  visibility: FunctionMetadata["visibility"],
+): MutationMeta {
+  return {
+    getFunctionMetadata: async () => ({
+      ...(await getFunctionMetadata()),
+      type: "mutation",
+      visibility,
+    }),
+    getTransactionMetrics,
+  };
+}
+
+export function setupActionMeta(
+  visibility: FunctionMetadata["visibility"],
+): ActionMeta {
+  return {
+    getFunctionMetadata: async () => ({
+      ...(await getFunctionMetadata()),
+      type: "action",
+      visibility,
+    }),
+  };
+}

package/src/server/impl/registration_impl.ts

@@ -11,6 +11,7 @@ import { GenericDataModel } from "../data_model.js";
 import {
   ActionBuilder,
   DefaultFunctionArgs,
+  FunctionVisibility,
   GenericActionCtx,
   GenericMutationCtx,
   GenericQueryCtx,
@@ -39,10 +40,15 @@ import { parseArgs } from "../../common/index.js";
 import { performAsyncSyscall } from "./syscall.js";
 import { asObjectValidator } from "../../values/validator.js";
 import { getFunctionAddress } from "../components/paths.js";
+import {
+  setupQueryMeta,
+  setupMutationMeta,
+  setupActionMeta,
+} from "./meta_impl.js";
 
 async function invokeMutation<
   F extends (ctx: GenericMutationCtx<GenericDataModel>, ...args: any) => any,
->(func: F, argsStr: string) {
+>(func: F, argsStr: string, visibility: FunctionVisibility) {
   // TODO(presley): Change the function signature and propagate the requestId from Rust.
   // Ok, to mock it out for now, since queries are only running in V8.
   const requestId = "";
@@ -52,6 +58,7 @@ async function invokeMutation<
     auth: setupAuth(requestId),
     storage: setupStorageWriter(requestId),
     scheduler: setupMutationScheduler(),
+    meta: setupMutationMeta(visibility),
 
     runQuery: (reference: any, args?: any) => runUdf("query", reference, args),
     runMutation: (reference: any, args?: any) =>
@@ -247,7 +254,7 @@ export const mutationGeneric: MutationBuilder<any, "public"> = ((
   assertNotBrowser();
   func.isMutation = true;
   func.isPublic = true;
-  func.invokeMutation = (argsStr) => invokeMutation(handler, argsStr);
+  func.invokeMutation = (argsStr) => invokeMutation(handler, argsStr, "public");
   func.exportArgs = exportArgs(functionDefinition);
   func.exportReturns = exportReturns(functionDefinition);
   func._handler = handler;
@@ -308,7 +315,8 @@ export const internalMutationGeneric: MutationBuilder<any, "internal"> = ((
   assertNotBrowser();
   func.isMutation = true;
   func.isInternal = true;
-  func.invokeMutation = (argsStr) => invokeMutation(handler, argsStr);
+  func.invokeMutation = (argsStr) =>
+    invokeMutation(handler, argsStr, "internal");
   func.exportArgs = exportArgs(functionDefinition);
   func.exportReturns = exportReturns(functionDefinition);
   func._handler = handler;
@@ -317,7 +325,7 @@ export const internalMutationGeneric: MutationBuilder<any, "internal"> = ((
 
 async function invokeQuery<
   F extends (ctx: GenericQueryCtx<GenericDataModel>, ...args: any) => any,
->(func: F, argsStr: string) {
+>(func: F, argsStr: string, visibility: FunctionVisibility) {
   // TODO(presley): Change the function signature and propagate the requestId from Rust.
   // Ok, to mock it out for now, since queries are only running in V8.
   const requestId = "";
@@ -326,6 +334,7 @@ async function invokeQuery<
     db: setupReader(),
     auth: setupAuth(requestId),
     storage: setupStorageReader(requestId),
+    meta: setupQueryMeta(visibility),
     runQuery: (reference: any, args?: any) => runUdf("query", reference, args),
   };
   const result = await invokeFunction(func, queryCtx, args as any);
@@ -403,7 +412,7 @@ export const queryGeneric: QueryBuilder<any, "public"> = ((
   assertNotBrowser();
   func.isQuery = true;
   func.isPublic = true;
-  func.invokeQuery = (argsStr) => invokeQuery(handler, argsStr);
+  func.invokeQuery = (argsStr) => invokeQuery(handler, argsStr, "public");
   func.exportArgs = exportArgs(functionDefinition);
   func.exportReturns = exportReturns(functionDefinition);
   func._handler = handler;
@@ -470,7 +479,8 @@ export const internalQueryGeneric: QueryBuilder<any, "internal"> = ((
   assertNotBrowser();
   func.isQuery = true;
   func.isInternal = true;
-  func.invokeQuery = (argsStr) => invokeQuery(handler as any, argsStr);
+  func.invokeQuery = (argsStr) =>
+    invokeQuery(handler as any, argsStr, "internal");
   func.exportArgs = exportArgs(functionDefinition);
   func.exportReturns = exportReturns(functionDefinition);
   func._handler = handler;
@@ -479,7 +489,7 @@ export const internalQueryGeneric: QueryBuilder<any, "internal"> = ((
 
 async function invokeAction<
   F extends (ctx: GenericActionCtx<GenericDataModel>, ...args: any) => any,
->(func: F, requestId: string, argsStr: string) {
+>(func: F, requestId: string, argsStr: string, visibility: FunctionVisibility) {
   const args = jsonToConvex(JSON.parse(argsStr));
   const calls = setupActionCalls(requestId);
   const ctx = {
@@ -488,6 +498,7 @@ async function invokeAction<
     scheduler: setupActionScheduler(requestId),
     storage: setupStorageActionWriter(requestId),
     vectorSearch: setupActionVectorSearch(requestId) as any,
+    meta: setupActionMeta(visibility),
   };
   const result = await invokeFunction(func, ctx, args as any);
   return JSON.stringify(convexToJson(result === undefined ? null : result));
@@ -577,7 +588,7 @@ export const actionGeneric: ActionBuilder<any, "public"> = ((
   func.isAction = true;
   func.isPublic = true;
   func.invokeAction = (requestId, argsStr) =>
-    invokeAction(handler, requestId, argsStr);
+    invokeAction(handler, requestId, argsStr, "public");
   func.exportArgs = exportArgs(functionDefinition);
   func.exportReturns = exportReturns(functionDefinition);
   func._handler = handler;
@@ -650,7 +661,7 @@ export const internalActionGeneric: ActionBuilder<any, "internal"> = ((
   func.isAction = true;
   func.isInternal = true;
   func.invokeAction = (requestId, argsStr) =>
-    invokeAction(handler, requestId, argsStr);
+    invokeAction(handler, requestId, argsStr, "internal");
   func.exportArgs = exportArgs(functionDefinition);
   func.exportReturns = exportReturns(functionDefinition);
   func._handler = handler;
@@ -670,6 +681,7 @@ async function invokeHttpAction<
     storage: setupStorageActionWriter(requestId),
     scheduler: setupActionScheduler(requestId),
     vectorSearch: setupActionVectorSearch(requestId) as any,
+    meta: setupActionMeta("public"),
   };
   return await invokeFunction(func, ctx, [request]);
 }

package/src/server/index.ts

@@ -103,6 +103,14 @@ export {
   internalMutationGeneric,
   internalQueryGeneric,
 } from "./impl/registration_impl.js";
+export type {
+  TransactionMetric,
+  TransactionMetrics,
+  FunctionMetadata,
+  QueryMeta,
+  MutationMeta,
+  ActionMeta,
+} from "./meta.js";
 export type { IndexRange, IndexRangeBuilder } from "./index_range_builder.js";
 export * from "./pagination.js";
 export type { OrderedQuery, Query, QueryInitializer } from "./query.js";