@gaganref/confect-server 10.3.1-fork.9 → 10.3.1-fork.90

package/dist/RegisteredFunction.d.ts

@@ -1,9 +1,12 @@
+export { Forward } from "./internal/reservedArgument.js";
 import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
 import * as IdScope from "@confect/core/IdScope";
 import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
-import { type DefaultFunctionArgs, type FunctionVisibility, type GenericActionCtx, type GenericDataModel, type StorageReader as ConvexStorageReader, type RegisteredAction, type RegisteredMutation, type RegisteredQuery } from "convex/server";
+import { type DefaultFunctionArgs, type FunctionVisibility, type FunctionMetadata, type MutationMeta, type QueryMeta, type GenericActionCtx, type GenericDataModel, type StorageReader as ConvexStorageReader, type RegisteredAction, type RegisteredMutation, type RegisteredQuery } from "convex/server";
 import type { Value } from "convex/values";
+import * as Clock from "effect/Clock";
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
@@ -24,6 +27,17 @@ import type * as StorageReader from "./StorageReader.js";
 import * as StorageWriter from "./StorageWriter.js";
 import * as VectorSearch from "./VectorSearch.js";
 import type * as Handler from "./Handler.js";
+export interface ReceivedValue {
+    readonly value: unknown;
+    readonly requestId: string;
+    readonly deployment: string | undefined;
+    readonly visibility?: FunctionVisibility;
+}
+export declare const Received: Context.Reference<ReceivedValue | undefined>;
+export declare const invocationMetadata: (meta: Pick<MutationMeta, "getFunctionMetadata" | "getRequestMetadata">, args: DefaultFunctionArgs, reservedArgument?: string) => Effect.Effect<FunctionMetadata & {
+    readonly received?: ReceivedValue;
+}>;
+export declare const Observability: Context.Reference<Layer.Layer<never, never, never> | undefined>;
 export type Any = RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
 type ConfectRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends DefaultFunctionArgs ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : never : never;
 export type ConvexRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends FunctionSpec.AnyWithProps ? FunctionSpec.GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<infer Args_ extends DefaultFunctionArgs, infer Returns_> ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : never : never : never;
@@ -45,38 +59,50 @@ export declare const applyMiddleware: <A, E, R>(effect: Effect.Effect<A, E, R>,
  * one—mirroring the ref-side union clients decode against.
  */
 export declare const combineErrorSchemas: (error: Schema.Codec<any, any> | undefined, resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>) => Schema.Codec<any, any> | undefined;
+type InvocationMeta = Pick<QueryMeta, "getFunctionMetadata"> & Partial<Pick<MutationMeta, "getRequestMetadata">>;
+type InvocationFunctionType = "query" | "mutation" | "action";
 /**
- * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of
- * failures that may be surfaced to the client as a `ConvexError`:
+ * Run the `Effect` as a `Promise`. Inspect the complete `Exit` before encoding
+ * a declared error so a typed failure cannot hide a defect.
  *
- * - With a schema: typed errors are schema-encoded and wrapped in a
- *   `ConvexError`, then thrown so Convex surfaces the data to the client.
- *   `Effect.either` escapes the failure channel before `runPromise` so the
- *   thrown `ConvexError` retains its `Symbol.for("ConvexError")` identity
- *   instead of being wrapped in Effect's `FiberFailure`.
- * - Without a schema: every failure is converted to a defect via `Effect.orDie`,
- *   so nothing—not even a `ConvexError` the handler placed in its error
- *   channel—reaches the client as a `ConvexError`. The fiber dies and
- *   `runPromise` rejects with a generic failure.
+ * Any `Die` reason takes the defect path. Without a `Die`, the first `Fail` in
+ * cause order is schema-encoded and thrown as a `ConvexError` outside the
+ * Effect runtime so Convex surfaces its data to the client. Other failures and
+ * interruptions alongside that `Fail` are ignored. Without an error schema, the
+ * selected failure is treated as a defect.
  *
- * Either way, a `ConvexError` _defect_—thrown imperatively rather than placed
- * in the error channel, e.g. the pagination protocol's `InvalidCursor` signal
- * from `QueryStream.paginate`—is rethrown bare so it retains its identity and
- * Convex serializes its `data` to the client, matching how a thrown
- * `ConvexError` behaves in a plain Convex handler.
+ * A lone `ConvexError` defect or a selected undeclared `ConvexError` failure is
+ * rethrown bare so it keeps Convex's meaning. Pagination and Workpool rely on
+ * its data for their control signals. Other causes with a `Die`, interrupt-only
+ * or empty causes, and error-encoding failures reject with a plain `Error`
+ * whose message renders the complete cause and whose `cause` holds it for
+ * server diagnostics.
  *
  * A `scheduler` in `runOptions` must be passed here as a run option rather than
  * provided via `Effect.provideService` inside `effect`: the run option lands in
  * the fiber's root context, while a service provided within `effect` pops
- * before the `orDie`/`catch`/`result` wrappers this function adds. The fiber's
- * op counter survives context pops, so a cooperative yield can fire inside
- * those wrappers—only a root-context scheduler covers them.
+ * before the exit/encoding wrappers this function adds. The fiber's op counter
+ * survives context pops, so a cooperative yield can fire inside those wrappers.
+ * Only a root-context scheduler covers them.
+ *
+ * Under `@confect/test`, a handler reached from a bound test invocation starts
+ * with that invocation's services through `Effect.runPromiseWith`, on a fiber
+ * of its own. Every other handler starts with `Effect.runPromise`.
  */
 export declare const runHandlerPromise: (errorSchema: Schema.Codec<any, any> | undefined, runOptions?: {
     readonly scheduler?: EffectScheduler.Scheduler | undefined;
+    readonly clock?: Clock.Clock | undefined;
+    readonly invocation?: Effect.Effect<FunctionMetadata & {
+        readonly received?: ReceivedValue;
+    }> | undefined;
+    readonly observability?: Layer.Layer<never> | undefined;
+    readonly meta?: InvocationMeta | undefined;
+    readonly functionType?: InvocationFunctionType | undefined;
 }) => <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
-export declare const actionFunctionBase: <Schema extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E, R>({ name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, createLayer, scope, }: {
+export declare const domainArgs: (args: DefaultFunctionArgs, reservedArgument?: string) => DefaultFunctionArgs;
+export declare const actionFunctionBase: <Schema extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E, R>({ name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, createLayer, scope, observability, reservedArgument, }: {
     name: string;
+    reservedArgument?: string | undefined;
     functionVisibility: FunctionVisibility;
     args: Schema.Codec<Args, ConvexArgs>;
     returns: Schema.Codec<Returns, ConvexReturns>;
@@ -85,6 +111,7 @@ export declare const actionFunctionBase: <Schema extends DatabaseSchema.AnyWithP
     resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
     createLayer: (ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>) => Layer.Layer<R>;
     scope?: IdScope.IdScope;
+    observability?: Layer.Layer<never> | undefined;
 }) => {
     args: import("convex/values").PropertyValidators;
     returns: import("convex/values").Validator<any, any, any>;
@@ -139,5 +166,4 @@ export declare const actionLayer: <DatabaseSchema_ extends DatabaseSchema.AnyWit
     };
 } | ActionCtx.ActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>, DatabaseSchema.Scope<DatabaseSchema_>> | Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | StorageActionWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | StorageWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | Auth.ForTarget<DatabaseSchema_["target"]>, never, never>;
 export declare const storageLayer: <Scope extends IdScope.IdScope>(reader: ConvexStorageReader) => Layer.Layer<Storage.Storage | StorageReader.ForScope<Scope>>;
-export {};
 //# sourceMappingURL=RegisteredFunction.d.ts.map

package/dist/RegisteredFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.d.ts","sourceRoot":"","sources":["../src/RegisteredFunction.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"RegisteredFunction.d.ts","sourceRoot":"","sources":["../src/RegisteredFunction.ts"],"names":[],"mappings":"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"}

package/dist/RegisteredFunction.js

@@ -1,37 +1,71 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Forward } from "./internal/reservedArgument.js";
 import { ActionCtx, layer } from "./ActionCtx.js";
 import { layer as layer$1 } from "./ActionRunner.js";
-import { layer as layer$2, layerForTarget } from "./Auth.js";
-import { layer as layer$3 } from "./ExecutionMetadata.js";
-import { layer as layer$4 } from "./RequestMetadata.js";
-import { layer as layer$5 } from "./MutationRunner.js";
-import { layer as layer$6 } from "./QueryRunner.js";
+import { layer as layer$2 } from "./MutationRunner.js";
+import { layer as layer$3 } from "./QueryRunner.js";
+import { layer as layer$4 } from "./Scheduler.js";
+import { ActionCallAlreadyUsed, ActionCallNotUsed, NestedActionNotAllowed, SchedulingNotAllowed } from "./ActionCall.js";
+import { layer as layer$5, layerForTarget } from "./Auth.js";
+import { layer as layer$6 } from "./ConvexConfigProvider.js";
 import { layer as layer$7 } from "./ConvexLogger.js";
-import { layer as layer$8 } from "./Scheduler.js";
+import { layer as layer$8 } from "./ExecutionMetadata.js";
+import { layer as layer$9 } from "./RequestMetadata.js";
 import { StorageActionWriter } from "./StorageActionWriter.js";
 import { StorageWriter } from "./StorageWriter.js";
-import { layer as layer$9 } from "./Storage.js";
-import { layer as layer$10 } from "./VectorSearch.js";
-import * as Layer from "effect/Layer";
+import { layer as layer$10 } from "./Storage.js";
+import { memoized } from "./internal/observability.js";
+import { layer as layer$11 } from "./VectorSearch.js";
+import { ConvexError } from "convex/values";
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as Tracer from "effect/Tracer";
+import * as ActionCallSpec from "@confect/core/ActionCall";
+import * as Layer from "effect/Layer";
+import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
 import * as Schema from "effect/Schema";
 import { pipe } from "effect/Function";
-import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import * as Option from "effect/Option";
 import { compileArgsSchema, compileReturnsSchema } from "@confect/core/SchemaToValidator";
-import { ConvexError } from "convex/values";
 import * as Result from "effect/Result";
 import * as IdScope from "@confect/core/IdScope";
+import * as Config from "effect/Config";
+import * as Clock from "effect/Clock";
+import * as Cause from "effect/Cause";
 import * as Console from "effect/Console";
+import * as Exit from "effect/Exit";
 //#region src/RegisteredFunction.ts
 var RegisteredFunction_exports = /* @__PURE__ */ __exportAll({
+	Forward: () => Forward,
+	Observability: () => Observability,
+	Received: () => Received,
 	actionFunctionBase: () => actionFunctionBase,
 	actionLayer: () => actionLayer,
 	applyMiddleware: () => applyMiddleware,
 	baseActionLayer: () => baseActionLayer,
 	combineErrorSchemas: () => combineErrorSchemas,
+	domainArgs: () => domainArgs,
+	invocationMetadata: () => invocationMetadata,
 	runHandlerPromise: () => runHandlerPromise,
 	storageLayer: () => storageLayer
 });
+const Received = Context.Reference("@confect/server/RegisteredFunction/Received", { defaultValue: () => void 0 });
+const invocationMetadata = (meta, args, reservedArgument) => Effect.gen(function* () {
+	const metadata = yield* Effect.promise(() => meta.getFunctionMetadata());
+	if (reservedArgument === void 0) return metadata;
+	const { requestId } = yield* Effect.promise(() => meta.getRequestMetadata());
+	const deployment = yield* Config.String("CONVEX_CLOUD_URL").pipe(Config.option, Effect.map(Option.getOrUndefined), Effect.provide(layer$6), Effect.orDie);
+	return {
+		...metadata,
+		received: {
+			value: args[reservedArgument],
+			requestId,
+			deployment,
+			...metadata.visibility === void 0 ? {} : { visibility: metadata.visibility }
+		}
+	};
+});
+const Observability = Context.Reference("@confect/server/Observability", { defaultValue: () => void 0 });
 /**
 * Wrap a function's handler effect in its resolved middleware chain, per
 * invocation, after args decode. Iterated innermost-first so that the
@@ -60,66 +94,153 @@ const combineErrorSchemas = (error, resolvedMiddlewares) => {
 	const schemas = [...error !== void 0 ? [error] : [], ...MiddlewareSpec.errorSchemas(resolvedMiddlewares.map(({ middlewareSpec }) => middlewareSpec))];
 	return schemas.length === 0 ? void 0 : schemas.length === 1 ? schemas[0] : Schema.Union(schemas);
 };
+const testInvocation = Symbol.for("@confect/test/Invocation");
 /**
-* Run the `Effect` as a `Promise`. The error schema acts as an allowlist of
-* failures that may be surfaced to the client as a `ConvexError`:
+* Run the `Effect` as a `Promise`. Inspect the complete `Exit` before encoding
+* a declared error so a typed failure cannot hide a defect.
 *
-* - With a schema: typed errors are schema-encoded and wrapped in a
-*   `ConvexError`, then thrown so Convex surfaces the data to the client.
-*   `Effect.either` escapes the failure channel before `runPromise` so the
-*   thrown `ConvexError` retains its `Symbol.for("ConvexError")` identity
-*   instead of being wrapped in Effect's `FiberFailure`.
-* - Without a schema: every failure is converted to a defect via `Effect.orDie`,
-*   so nothing—not even a `ConvexError` the handler placed in its error
-*   channel—reaches the client as a `ConvexError`. The fiber dies and
-*   `runPromise` rejects with a generic failure.
+* Any `Die` reason takes the defect path. Without a `Die`, the first `Fail` in
+* cause order is schema-encoded and thrown as a `ConvexError` outside the
+* Effect runtime so Convex surfaces its data to the client. Other failures and
+* interruptions alongside that `Fail` are ignored. Without an error schema, the
+* selected failure is treated as a defect.
 *
-* Either way, a `ConvexError` _defect_—thrown imperatively rather than placed
-* in the error channel, e.g. the pagination protocol's `InvalidCursor` signal
-* from `QueryStream.paginate`—is rethrown bare so it retains its identity and
-* Convex serializes its `data` to the client, matching how a thrown
-* `ConvexError` behaves in a plain Convex handler.
+* A lone `ConvexError` defect or a selected undeclared `ConvexError` failure is
+* rethrown bare so it keeps Convex's meaning. Pagination and Workpool rely on
+* its data for their control signals. Other causes with a `Die`, interrupt-only
+* or empty causes, and error-encoding failures reject with a plain `Error`
+* whose message renders the complete cause and whose `cause` holds it for
+* server diagnostics.
 *
 * A `scheduler` in `runOptions` must be passed here as a run option rather than
 * provided via `Effect.provideService` inside `effect`: the run option lands in
 * the fiber's root context, while a service provided within `effect` pops
-* before the `orDie`/`catch`/`result` wrappers this function adds. The fiber's
-* op counter survives context pops, so a cooperative yield can fire inside
-* those wrappers—only a root-context scheduler covers them.
+* before the exit/encoding wrappers this function adds. The fiber's op counter
+* survives context pops, so a cooperative yield can fire inside those wrappers.
+* Only a root-context scheduler covers them.
+*
+* Under `@confect/test`, a handler reached from a bound test invocation starts
+* with that invocation's services through `Effect.runPromiseWith`, on a fiber
+* of its own. Every other handler starts with `Effect.runPromise`.
 */
 const runHandlerPromise = (errorSchema, runOptions) => (effect) => {
-	const rethrowConvexErrorDefects = Effect.catchDefect((defect) => defect instanceof ConvexError ? Effect.fail(defect) : Effect.die(defect));
-	const withConvexError = errorSchema === void 0 ? Effect.orDie(effect) : effect.pipe(Effect.catch((typedError) => pipe(Schema.encodeEffect(errorSchema)(typedError), Effect.catchTag("SchemaError", Effect.die), Effect.andThen((encodedError) => Effect.fail(new ConvexError(encodedError))))));
-	return Effect.runPromise(Effect.result(rethrowConvexErrorDefects(withConvexError)).pipe(Effect.provide(layer$7), Effect.provideService(Console.Console, globalThis.console)), runOptions).then(Result.match({
+	const { observability, invocation, clock, meta, functionType } = runOptions ?? {};
+	let encodedError;
+	let undeclared;
+	const observed = Effect.tapCause(effect, (cause) => Effect.gen(function* () {
+		const reason = cause.reasons.find(Cause.isDieReason) ?? cause.reasons.find(Cause.isFailReason);
+		if (reason?._tag === "Fail" && errorSchema !== void 0) {
+			encodedError = yield* Effect.exit(Schema.encodeEffect(errorSchema)(reason.error));
+			if (Exit.isFailure(encodedError)) {
+				const encoding = encodedError.cause;
+				return yield* Cause.squash(encoding) instanceof ConvexError ? Effect.die(new Error(Cause.pretty(encoding), { cause: encoding })) : Effect.orDie(encodedError);
+			}
+		}
+		if (reason?._tag === "Fail" && errorSchema === void 0 && !(reason.error instanceof ConvexError)) {
+			undeclared = { error: reason.error };
+			return yield* Effect.die(reason.error);
+		}
+	}));
+	const program = Effect.gen(function* () {
+		const exit = yield* Effect.exit(observability === void 0 || invocation === void 0 ? effect : Effect.flatMap(invocation, ({ name, type, componentPath, received }) => Effect.useSpan(name, {
+			root: true,
+			attributes: {
+				kind: type,
+				componentPath
+			}
+		}, (span) => Effect.provideService(observed, Tracer.ParentSpan, span)).pipe(Effect.provideService(Received, received))));
+		if (Exit.isSuccess(exit)) return Result.succeed(exit.value);
+		if (undeclared !== void 0) return yield* Effect.die(undeclared.error);
+		const cause = encodedError !== void 0 && Exit.isFailure(encodedError) ? encodedError.cause : exit.cause;
+		const reason = cause.reasons.find(Cause.isDieReason) ?? cause.reasons.find(Cause.isFailReason);
+		if (encodedError === void 0 && reason?._tag === "Die" && cause.reasons.length === 1 && reason.defect instanceof ConvexError) return Result.fail(reason.defect);
+		if (reason?._tag === "Fail") {
+			if (errorSchema === void 0) {
+				if (reason.error instanceof ConvexError) return Result.fail(reason.error);
+				return yield* Effect.die(reason.error);
+			}
+			const encoded = encodedError ?? (yield* Effect.exit(Schema.encodeEffect(errorSchema)(reason.error)));
+			if (Exit.isSuccess(encoded)) return Result.fail(new ConvexError(encoded.value));
+			return yield* Effect.die(new Error(Cause.pretty(encoded.cause), { cause: encoded.cause }));
+		}
+		return yield* Effect.die(new Error(Cause.pretty(cause), { cause }));
+	}).pipe(Effect.provide(observability === void 0 ? layer$7 : memoized(observability)), Effect.provideService(Console.Console, globalThis.console), clock === void 0 ? (self) => self : Effect.provideService(Clock.Clock, clock));
+	return ((meta === void 0 || functionType === void 0 ? void 0 : globalThis[testInvocation]?.start(meta, (services) => Effect.runPromiseWith(services)(program, runOptions), functionType)) ?? Effect.runPromise(program, runOptions)).then(Result.match({
 		onFailure: (error) => {
 			throw error;
 		},
 		onSuccess: (value) => value
 	}));
 };
-const actionFunctionBase = ({ name, functionVisibility, args, returns, error, handler, resolvedMiddlewares = [], createLayer, scope = IdScope.app }) => ({
-	args: compileArgsSchema(args, scope),
+const domainArgs = (args, reservedArgument) => reservedArgument === void 0 ? args : Object.fromEntries(Object.entries(args).filter(([key]) => key !== reservedArgument));
+const actionFunctionBase = ({ name, functionVisibility, args, returns, error, handler, resolvedMiddlewares = [], createLayer, scope = IdScope.app, observability, reservedArgument }) => ({
+	args: compileArgsSchema(args, scope, reservedArgument, name),
 	returns: compileReturnsSchema(returns, scope),
 	handler: (ctx, actualArgs) => Effect.gen(function* () {
-		const decodedArgs = yield* pipe(actualArgs, Schema.decodeUnknownEffect(args), Effect.catchTag("SchemaError", Effect.die));
+		const decodedArgs = yield* pipe(domainArgs(actualArgs, reservedArgument), Schema.decodeUnknownEffect(args), Effect.catchTag("SchemaError", Effect.die));
+		const restricted = resolvedMiddlewares.some(({ middlewareSpec }) => middlewareSpec.key === ActionCallSpec.Middleware.key) ? restrict(ctx) : void 0;
 		const decodedReturns = yield* applyMiddleware(handler(decodedArgs), resolvedMiddlewares, {
 			name,
 			functionType: "action",
 			functionVisibility,
 			args: decodedArgs
-		}).pipe(Effect.provide(createLayer(ctx)));
+		}).pipe(Effect.provide(createLayer(restricted?.ctx ?? ctx)));
+		if (restricted !== void 0) yield* restricted.check;
 		return yield* pipe(decodedReturns, Schema.encodeEffect(returns), Effect.catchTag("SchemaError", Effect.die));
-	}).pipe(runHandlerPromise(combineErrorSchemas(error, resolvedMiddlewares)))
+	}).pipe(runHandlerPromise(combineErrorSchemas(error, resolvedMiddlewares), {
+		invocation: invocationMetadata(ctx.meta, actualArgs, reservedArgument),
+		observability,
+		meta: ctx.meta,
+		functionType: "action"
+	}))
 });
 /**
 * The ctx-backed action services that don't depend on a Confect database
 * schema. {@link actionLayer} adds the schema-typed `VectorSearch` on top; the
 * HTTP API handler uses this base directly.
 */
-const baseActionLayer = (ctx) => Layer.mergeAll(layer$8(ctx.scheduler), layer$2(ctx.auth), layer$3(ctx.meta), layer$4(ctx.meta), layer$9(ctx.storage), StorageWriter.layer(ctx.storage), StorageActionWriter.layer(ctx.storage), layer$6(ctx.runQuery.bind(ctx)), layer$5(ctx.runMutation.bind(ctx)), layer$1(ctx.runAction.bind(ctx)), Layer.succeed(ActionCtx(), ctx));
-const actionLayer = (databaseSchema, ctx) => Layer.mergeAll(layer$8(ctx.scheduler, databaseSchema.target.scope), layerForTarget(databaseSchema.target, ctx.auth), layer$3(ctx.meta), layer$4(ctx.meta), storageLayer(ctx.storage), StorageWriter.layer(ctx.storage, databaseSchema.target.scope), StorageActionWriter.layer(ctx.storage, databaseSchema.target.scope), layer$6(ctx.runQuery.bind(ctx)), layer$5(ctx.runMutation.bind(ctx)), layer$1(ctx.runAction.bind(ctx)), layer(ctx, databaseSchema.target.scope), layer$10(ctx.vectorSearch.bind(ctx)));
-const storageLayer = (reader) => layer$9(reader);
+const baseActionLayer = (ctx) => Layer.mergeAll(layer$4(ctx.scheduler), layer$5(ctx.auth), layer$8(ctx.meta), layer$9(ctx.meta), layer$10(ctx.storage), StorageWriter.layer(ctx.storage), StorageActionWriter.layer(ctx.storage), layer$3(ctx.runQuery.bind(ctx)), layer$2(ctx.runMutation.bind(ctx)), layer$1(ctx.runAction.bind(ctx)), Layer.succeed(ActionCtx(), ctx));
+const actionLayer = (databaseSchema, ctx) => Layer.mergeAll(layer$4(ctx.scheduler, databaseSchema.target.scope), layerForTarget(databaseSchema.target, ctx.auth), layer$8(ctx.meta), layer$9(ctx.meta), storageLayer(ctx.storage), StorageWriter.layer(ctx.storage, databaseSchema.target.scope), StorageActionWriter.layer(ctx.storage, databaseSchema.target.scope), layer$3(ctx.runQuery.bind(ctx)), layer$2(ctx.runMutation.bind(ctx)), layer$1(ctx.runAction.bind(ctx)), layer(ctx, databaseSchema.target.scope), layer$11(ctx.vectorSearch.bind(ctx)));
+const storageLayer = (reader) => layer$10(reader);
+/**
+* Shares one dispatch budget across the entire middleware chain.
+*/
+const restrict = (ctx) => {
+	let dispatched = false;
+	const claim = () => {
+		if (dispatched) throw new ActionCallAlreadyUsed();
+		dispatched = true;
+	};
+	return {
+		ctx: {
+			...ctx,
+			scheduler: {
+				runAfter: () => {
+					throw new SchedulingNotAllowed();
+				},
+				runAt: () => {
+					throw new SchedulingNotAllowed();
+				},
+				cancel: () => {
+					throw new SchedulingNotAllowed();
+				}
+			},
+			runQuery: (...args) => {
+				claim();
+				return ctx.runQuery(...args);
+			},
+			runMutation: (...args) => {
+				claim();
+				return ctx.runMutation(...args);
+			},
+			runAction: () => {
+				throw new NestedActionNotAllowed();
+			}
+		},
+		check: Effect.suspend(() => dispatched ? Effect.void : Effect.die(new ActionCallNotUsed()))
+	};
+};
 //#endregion
-export { RegisteredFunction_exports, actionFunctionBase, actionLayer, applyMiddleware, baseActionLayer, combineErrorSchemas, runHandlerPromise, storageLayer };
+export { Forward, Observability, Received, RegisteredFunction_exports, actionFunctionBase, actionLayer, applyMiddleware, baseActionLayer, combineErrorSchemas, domainArgs, invocationMetadata, runHandlerPromise, storageLayer };
 
 //# sourceMappingURL=RegisteredFunction.js.map

package/dist/RegisteredFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.js","names":["ConvexLogger.layer","Scheduler.layer","Auth.layer","ExecutionMetadata.layer","RequestMetadata.layer","Storage.layer","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","ActionCtx.ActionCtx","Auth.layerForTarget","ActionCtx.layer","VectorSearch.layer"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["import type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport * as IdScope from \"@confect/core/IdScope\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport * as MiddlewareSpec from \"@confect/core/MiddlewareSpec\";\nimport {\n  compileArgsSchema,\n  compileReturnsSchema,\n} from \"@confect/core/SchemaToValidator\";\nimport {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type GenericDataModel,\n  type StorageReader as ConvexStorageReader,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { ConvexError } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Console from \"effect/Console\";\nimport * as Effect from \"effect/Effect\";\nimport * as Result from \"effect/Result\";\nimport * as Layer from \"effect/Layer\";\nimport * as Schema from \"effect/Schema\";\nimport type * as EffectScheduler from \"effect/Scheduler\";\nimport * as ActionCtx from \"./ActionCtx.js\";\nimport * as ActionRunner from \"./ActionRunner.js\";\nimport * as Auth from \"./Auth.js\";\nimport * as ConvexLogger from \"./ConvexLogger.js\";\nimport type * as DatabaseSchema from \"./DatabaseSchema.js\";\nimport type * as DataModel from \"./DataModel.js\";\nimport * as ExecutionMetadata from \"./ExecutionMetadata.js\";\nimport * as RequestMetadata from \"./RequestMetadata.js\";\nimport * as MutationRunner from \"./MutationRunner.js\";\nimport * as QueryRunner from \"./QueryRunner.js\";\nimport type * as ResolvedMiddleware from \"./ResolvedMiddleware.js\";\nimport * as Scheduler from \"./Scheduler.js\";\nimport * as Storage from \"./Storage.js\";\nimport * as StorageActionWriter from \"./StorageActionWriter.js\";\nimport type * as StorageReader from \"./StorageReader.js\";\nimport * as StorageWriter from \"./StorageWriter.js\";\nimport * as VectorSearch from \"./VectorSearch.js\";\nimport type * as Handler from \"./Handler.js\";\n\nexport type Any =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\ntype ConfectRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends\n    DefaultFunctionArgs\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n            >\n          : never\n    : never;\n\nexport type ConvexRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> = FunctionSpec_ extends FunctionSpec.AnyWithProps\n  ? FunctionSpec.GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<\n      infer Args_ extends DefaultFunctionArgs,\n      infer Returns_\n    >\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Returns_\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Returns_\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Returns_\n            >\n          : never\n    : never\n  : never;\n\nexport type RegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexRegisteredFunction<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectRegisteredFunction<FunctionSpec_>\n      : never;\n\n/**\n * Wrap a function's handler effect in its resolved middleware chain, per\n * invocation, after args decode. Iterated innermost-first so that the\n * first-attached (group-level, in attachment order) middleware ends up\n * outermost and runs first. Erased types: the public safety story lives at the\n * `MiddlewareSpec.MiddlewareImpl`/`MiddlewareImpl.make` signatures, and the\n * composed effect's error channel is re-accounted by\n * {@link combineErrorSchemas}.\n */\nexport const applyMiddleware = <A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>,\n  invocation: MiddlewareSpec.MiddlewareOptions[\"invocation\"],\n): Effect.Effect<A, any, R> => {\n  return resolvedMiddlewares.reduceRight<Effect.Effect<any, any, any>>(\n    // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- The erased middleware error remains intact so runHandlerPromise can validate it against the combined error schema.\n    (wrapped, middleware) => {\n      const context =\n        \"options\" in middleware.middlewareSpec\n          ? { options: middleware.options, invocation }\n          : { invocation };\n      // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- Resolved middleware is type-erased after its public implementation boundary; its error and service channels are restored by the surrounding function contract.\n      return middleware.middlewareImpl(wrapped, context);\n    },\n    effect,\n  );\n};\n\n/**\n * The error-schema allowlist for a function with middleware: the function's own\n * declared `error` schema unioned with every covering middleware's error\n * schema. `undefined` (⇒ every failure dies) only when neither declares\n * one—mirroring the ref-side union clients decode against.\n */\nexport const combineErrorSchemas = (\n  error: Schema.Codec<any, any> | undefined,\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>,\n): Schema.Codec<any, any> | undefined => {\n  const schemas = [\n    ...(error !== undefined ? [error] : []),\n    ...MiddlewareSpec.errorSchemas(\n      resolvedMiddlewares.map(({ middlewareSpec }) => middlewareSpec),\n    ),\n  ];\n  return schemas.length === 0\n    ? undefined\n    : schemas.length === 1\n      ? schemas[0]\n      : Schema.Union(schemas);\n};\n\n/**\n * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of\n * failures that may be surfaced to the client as a `ConvexError`:\n *\n * - With a schema: typed errors are schema-encoded and wrapped in a\n *   `ConvexError`, then thrown so Convex surfaces the data to the client.\n *   `Effect.either` escapes the failure channel before `runPromise` so the\n *   thrown `ConvexError` retains its `Symbol.for(\"ConvexError\")` identity\n *   instead of being wrapped in Effect's `FiberFailure`.\n * - Without a schema: every failure is converted to a defect via `Effect.orDie`,\n *   so nothing—not even a `ConvexError` the handler placed in its error\n *   channel—reaches the client as a `ConvexError`. The fiber dies and\n *   `runPromise` rejects with a generic failure.\n *\n * Either way, a `ConvexError` _defect_—thrown imperatively rather than placed\n * in the error channel, e.g. the pagination protocol's `InvalidCursor` signal\n * from `QueryStream.paginate`—is rethrown bare so it retains its identity and\n * Convex serializes its `data` to the client, matching how a thrown\n * `ConvexError` behaves in a plain Convex handler.\n *\n * A `scheduler` in `runOptions` must be passed here as a run option rather than\n * provided via `Effect.provideService` inside `effect`: the run option lands in\n * the fiber's root context, while a service provided within `effect` pops\n * before the `orDie`/`catch`/`result` wrappers this function adds. The fiber's\n * op counter survives context pops, so a cooperative yield can fire inside\n * those wrappers—only a root-context scheduler covers them.\n */\nexport const runHandlerPromise =\n  (\n    errorSchema: Schema.Codec<any, any> | undefined,\n    runOptions?: {\n      readonly scheduler?: EffectScheduler.Scheduler | undefined;\n    },\n  ) =>\n  <A, E>(effect: Effect.Effect<A, E>): Promise<A> => {\n    // A `ConvexError` defect escapes into the (escaped) failure channel so\n    // the `throw` below rethrows it with its identity intact.\n    const rethrowConvexErrorDefects = Effect.catchDefect(\n      (defect: unknown): Effect.Effect<never, ConvexError<any>> =>\n        defect instanceof ConvexError\n          ? Effect.fail(defect)\n          : Effect.die(defect),\n    );\n\n    const withConvexError =\n      errorSchema === undefined\n        ? Effect.orDie(effect)\n        : effect.pipe(\n            Effect.catch((typedError) =>\n              pipe(\n                Schema.encodeEffect(errorSchema)(typedError),\n                Effect.catchTag(\"SchemaError\", Effect.die),\n                Effect.andThen((encodedError) =>\n                  Effect.fail(new ConvexError(encodedError)),\n                ),\n              ),\n            ),\n          );\n    return Effect.runPromise(\n      Effect.result(rethrowConvexErrorDefects(withConvexError)).pipe(\n        Effect.provide(ConvexLogger.layer),\n        Effect.provideService(Console.Console, globalThis.console),\n      ),\n      runOptions,\n    ).then(\n      Result.match({\n        onFailure: (error) => {\n          throw error;\n        },\n        onSuccess: (value) => value,\n      }),\n    );\n  };\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  name,\n  functionVisibility,\n  args,\n  returns,\n  error,\n  handler,\n  resolvedMiddlewares = [],\n  createLayer,\n  scope = IdScope.app,\n}: {\n  name: string;\n  functionVisibility: FunctionVisibility;\n  args: Schema.Codec<Args, ConvexArgs>;\n  returns: Schema.Codec<Returns, ConvexReturns>;\n  error: Schema.Codec<Error, Value> | undefined;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\n  scope?: IdScope.IdScope;\n}) => ({\n  args: compileArgsSchema(args, scope),\n  returns: compileReturnsSchema(returns, scope),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decodeUnknownEffect(args),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n      // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- Middleware errors are intentionally erased here and validated by runHandlerPromise against the combined error schema below.\n      const decodedReturns = yield* applyMiddleware(\n        handler(decodedArgs),\n        resolvedMiddlewares,\n        {\n          name,\n          functionType: \"action\",\n          functionVisibility,\n          args: decodedArgs,\n        },\n      ).pipe(Effect.provide(createLayer(ctx)));\n      return yield* pipe(\n        decodedReturns,\n        Schema.encodeEffect(returns),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n    }).pipe(runHandlerPromise(combineErrorSchemas(error, resolvedMiddlewares))),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = Handler.ActionServices<DatabaseSchema_>;\n\n/**\n * The ctx-backed action services that don't depend on a Confect database\n * schema. {@link actionLayer} adds the schema-typed `VectorSearch` on top; the\n * HTTP API handler uses this base directly.\n */\nexport const baseActionLayer = <ConvexDataModel extends GenericDataModel>(\n  ctx: GenericActionCtx<ConvexDataModel>,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer(ctx.scheduler),\n    Auth.layer(ctx.auth),\n    ExecutionMetadata.layer(ctx.meta),\n    RequestMetadata.layer(ctx.meta),\n    Storage.layer(ctx.storage),\n    StorageWriter.StorageWriter.layer(ctx.storage),\n    StorageActionWriter.StorageActionWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery.bind(ctx)),\n    MutationRunner.layer(ctx.runMutation.bind(ctx)),\n    ActionRunner.layer(ctx.runAction.bind(ctx)),\n    Layer.succeed(ActionCtx.ActionCtx<ConvexDataModel>(), ctx),\n  );\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer<DatabaseSchema.Scope<DatabaseSchema_>>(\n      ctx.scheduler,\n      databaseSchema.target.scope,\n    ),\n    Auth.layerForTarget<DatabaseSchema_[\"target\"]>(\n      databaseSchema.target,\n      ctx.auth,\n    ),\n    ExecutionMetadata.layer(ctx.meta),\n    RequestMetadata.layer(ctx.meta),\n    storageLayer<DatabaseSchema.Scope<DatabaseSchema_>>(ctx.storage),\n    StorageWriter.StorageWriter.layer<DatabaseSchema.Scope<DatabaseSchema_>>(\n      ctx.storage,\n      databaseSchema.target.scope,\n    ),\n    StorageActionWriter.StorageActionWriter.layer<\n      DatabaseSchema.Scope<DatabaseSchema_>\n    >(ctx.storage, databaseSchema.target.scope),\n    QueryRunner.layer(ctx.runQuery.bind(ctx)),\n    MutationRunner.layer(ctx.runMutation.bind(ctx)),\n    ActionRunner.layer(ctx.runAction.bind(ctx)),\n    ActionCtx.layer<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,\n      DatabaseSchema.Scope<DatabaseSchema_>\n    >(ctx, databaseSchema.target.scope),\n    VectorSearch.layer(ctx.vectorSearch.bind(ctx)),\n  );\n\n// Scoped readers share the same runtime service and ID strings. Reuse the\n// reader supplied by Storage so both APIs keep the same reader instance.\nexport const storageLayer = <Scope extends IdScope.IdScope>(\n  reader: ConvexStorageReader,\n): Layer.Layer<Storage.Storage | StorageReader.ForScope<Scope>> =>\n  Storage.layer(reader) as Layer.Layer<\n    Storage.Storage | StorageReader.ForScope<Scope>\n  >;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8IA,MAAa,mBACX,QACA,qBACA,eAC6B;CAC7B,OAAO,oBAAoB,aAExB,SAAS,eAAe;EACvB,MAAM,UACJ,aAAa,WAAW,iBACpB;GAAE,SAAS,WAAW;GAAS;EAAW,IAC1C,EAAE,WAAW;EAEnB,OAAO,WAAW,eAAe,SAAS,OAAO;CACnD,GACA,MACF;AACF;;;;;;;AAQA,MAAa,uBACX,OACA,wBACuC;CACvC,MAAM,UAAU,CACd,GAAI,UAAU,KAAA,IAAY,CAAC,KAAK,IAAI,CAAC,GACrC,GAAG,eAAe,aAChB,oBAAoB,KAAK,EAAE,qBAAqB,cAAc,CAChE,CACF;CACA,OAAO,QAAQ,WAAW,IACtB,KAAA,IACA,QAAQ,WAAW,IACjB,QAAQ,KACR,OAAO,MAAM,OAAO;AAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,qBAET,aACA,gBAIK,WAA4C;CAGjD,MAAM,4BAA4B,OAAO,aACtC,WACC,kBAAkB,cACd,OAAO,KAAK,MAAM,IAClB,OAAO,IAAI,MAAM,CACzB;CAEA,MAAM,kBACJ,gBAAgB,KAAA,IACZ,OAAO,MAAM,MAAM,IACnB,OAAO,KACL,OAAO,OAAO,eACZ,KACE,OAAO,aAAa,WAAW,CAAC,CAAC,UAAU,GAC3C,OAAO,SAAS,eAAe,OAAO,GAAG,GACzC,OAAO,SAAS,iBACd,OAAO,KAAK,IAAI,YAAY,YAAY,CAAC,CAC3C,CACF,CACF,CACF;CACN,OAAO,OAAO,WACZ,OAAO,OAAO,0BAA0B,eAAe,CAAC,CAAC,CAAC,KACxD,OAAO,QAAQA,OAAkB,GACjC,OAAO,eAAe,QAAQ,SAAS,WAAW,OAAO,CAC3D,GACA,UACF,CAAC,CAAC,KACA,OAAO,MAAM;EACX,YAAY,UAAU;GACpB,MAAM;EACR;EACA,YAAY,UAAU;CACxB,CAAC,CACH;AACF;AAEF,MAAa,sBAQX,EACA,MACA,oBACA,MACA,SACA,OACA,SACA,sBAAsB,CAAC,GACvB,aACA,QAAQ,QAAQ,WAaX;CACL,MAAM,kBAAkB,MAAM,KAAK;CACnC,SAAS,qBAAqB,SAAS,KAAK;CAC5C,UACE,KACA,eAEA,OAAO,IAAI,aAAa;EACtB,MAAM,cAAc,OAAO,KACzB,YACA,OAAO,oBAAoB,IAAI,GAC/B,OAAO,SAAS,eAAe,OAAO,GAAG,CAC3C;EAEA,MAAM,iBAAiB,OAAO,gBAC5B,QAAQ,WAAW,GACnB,qBACA;GACE;GACA,cAAc;GACd;GACA,MAAM;EACR,CACF,CAAC,CAAC,KAAK,OAAO,QAAQ,YAAY,GAAG,CAAC,CAAC;EACvC,OAAO,OAAO,KACZ,gBACA,OAAO,aAAa,OAAO,GAC3B,OAAO,SAAS,eAAe,OAAO,GAAG,CAC3C;CACF,CAAC,CAAC,CAAC,KAAK,kBAAkB,oBAAoB,OAAO,mBAAmB,CAAC,CAAC;AAC9E;;;;;;AAWA,MAAa,mBACX,QAEA,MAAM,SACJC,QAAgB,IAAI,SAAS,GAC7BC,QAAW,IAAI,IAAI,GACnBC,QAAwB,IAAI,IAAI,GAChCC,QAAsB,IAAI,IAAI,GAC9BC,QAAc,IAAI,OAAO,GAAA,cACG,MAAM,IAAI,OAAO,GAAA,oBACL,MAAM,IAAI,OAAO,GACzDC,QAAkB,IAAI,SAAS,KAAK,GAAG,CAAC,GACxCC,QAAqB,IAAI,YAAY,KAAK,GAAG,CAAC,GAC9CC,QAAmB,IAAI,UAAU,KAAK,GAAG,CAAC,GAC1C,MAAM,QAAQC,UAAqC,GAAG,GAAG,CAC3D;AAEF,MAAa,eAGX,gBACA,QAIA,MAAM,SACJR,QACE,IAAI,WACJ,eAAe,OAAO,KACxB,GACAS,eACE,eAAe,QACf,IAAI,IACN,GACAP,QAAwB,IAAI,IAAI,GAChCC,QAAsB,IAAI,IAAI,GAC9B,aAAoD,IAAI,OAAO,GAAA,cACnC,MAC1B,IAAI,SACJ,eAAe,OAAO,KACxB,GAAA,oBACwC,MAEtC,IAAI,SAAS,eAAe,OAAO,KAAK,GAC1CE,QAAkB,IAAI,SAAS,KAAK,GAAG,CAAC,GACxCC,QAAqB,IAAI,YAAY,KAAK,GAAG,CAAC,GAC9CC,QAAmB,IAAI,UAAU,KAAK,GAAG,CAAC,GAC1CG,MAGE,KAAK,eAAe,OAAO,KAAK,GAClCC,SAAmB,IAAI,aAAa,KAAK,GAAG,CAAC,CAC/C;AAIF,MAAa,gBACX,WAEAP,QAAc,MAAM"}
+{"version":3,"file":"RegisteredFunction.js","names":["ConvexConfigProvider.layer","ConvexLogger.layer","ObservabilityRuntime.memoized","Scheduler.layer","Auth.layer","ExecutionMetadata.layer","RequestMetadata.layer","Storage.layer","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","ActionCtx.ActionCtx","Auth.layerForTarget","ActionCtx.layer","VectorSearch.layer","ActionCall.ActionCallAlreadyUsed","ActionCall.SchedulingNotAllowed","ActionCall.NestedActionNotAllowed","ActionCall.ActionCallNotUsed"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["export { Forward } from \"./internal/reservedArgument.js\";\nimport * as ActionCallSpec from \"@confect/core/ActionCall\";\nimport * as ActionCall from \"./ActionCall.js\";\nimport type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport * as IdScope from \"@confect/core/IdScope\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport * as MiddlewareSpec from \"@confect/core/MiddlewareSpec\";\nimport {\n  compileArgsSchema,\n  compileReturnsSchema,\n} from \"@confect/core/SchemaToValidator\";\nimport {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type FunctionMetadata,\n  type MutationMeta,\n  type QueryMeta,\n  type GenericActionCtx,\n  type GenericDataModel,\n  type StorageReader as ConvexStorageReader,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { ConvexError } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Config from \"effect/Config\";\nimport * as Option from \"effect/Option\";\nimport * as ConvexConfigProvider from \"./ConvexConfigProvider.js\";\nimport * as Clock from \"effect/Clock\";\nimport * as Cause from \"effect/Cause\";\nimport * as Console from \"effect/Console\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as Result from \"effect/Result\";\nimport * as Layer from \"effect/Layer\";\nimport * as Schema from \"effect/Schema\";\nimport type * as EffectScheduler from \"effect/Scheduler\";\nimport * as ActionCtx from \"./ActionCtx.js\";\nimport * as ActionRunner from \"./ActionRunner.js\";\nimport * as Auth from \"./Auth.js\";\nimport * as ConvexLogger from \"./ConvexLogger.js\";\nimport type * as DatabaseSchema from \"./DatabaseSchema.js\";\nimport type * as DataModel from \"./DataModel.js\";\nimport * as ExecutionMetadata from \"./ExecutionMetadata.js\";\nimport * as RequestMetadata from \"./RequestMetadata.js\";\nimport * as MutationRunner from \"./MutationRunner.js\";\nimport * as QueryRunner from \"./QueryRunner.js\";\nimport type * as ResolvedMiddleware from \"./ResolvedMiddleware.js\";\nimport * as Scheduler from \"./Scheduler.js\";\nimport * as Storage from \"./Storage.js\";\nimport * as StorageActionWriter from \"./StorageActionWriter.js\";\nimport type * as StorageReader from \"./StorageReader.js\";\nimport * as StorageWriter from \"./StorageWriter.js\";\nimport * as Tracer from \"effect/Tracer\";\nimport * as ObservabilityRuntime from \"./internal/observability.js\";\nimport * as VectorSearch from \"./VectorSearch.js\";\nimport type * as Handler from \"./Handler.js\";\n\nexport interface ReceivedValue {\n  readonly value: unknown;\n  readonly requestId: string;\n  readonly deployment: string | undefined;\n  readonly visibility?: FunctionVisibility;\n}\n\nexport const Received = Context.Reference<ReceivedValue | undefined>(\n  \"@confect/server/RegisteredFunction/Received\",\n  { defaultValue: () => undefined },\n);\n\nexport const invocationMetadata = (\n  meta: Pick<MutationMeta, \"getFunctionMetadata\" | \"getRequestMetadata\">,\n  args: DefaultFunctionArgs,\n  reservedArgument?: string,\n): Effect.Effect<FunctionMetadata & { readonly received?: ReceivedValue }> =>\n  Effect.gen(function* () {\n    const metadata = yield* Effect.promise(() => meta.getFunctionMetadata());\n    if (reservedArgument === undefined) return metadata;\n    const { requestId } = yield* Effect.promise(() =>\n      meta.getRequestMetadata(),\n    );\n    const deployment = yield* Config.String(\"CONVEX_CLOUD_URL\").pipe(\n      Config.option,\n      Effect.map(Option.getOrUndefined),\n      Effect.provide(ConvexConfigProvider.layer),\n      Effect.orDie,\n    );\n    return {\n      ...metadata,\n      received: {\n        value: args[reservedArgument],\n        requestId,\n        deployment,\n        ...(metadata.visibility === undefined\n          ? {}\n          : { visibility: metadata.visibility }),\n      },\n    };\n  });\n\nexport const Observability = Context.Reference<Layer.Layer<never> | undefined>(\n  \"@confect/server/Observability\",\n  { defaultValue: () => undefined },\n);\n\nexport type Any =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\ntype ConfectRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends\n    DefaultFunctionArgs\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n            >\n          : never\n    : never;\n\nexport type ConvexRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> = FunctionSpec_ extends FunctionSpec.AnyWithProps\n  ? FunctionSpec.GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<\n      infer Args_ extends DefaultFunctionArgs,\n      infer Returns_\n    >\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Returns_\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Returns_\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Returns_\n            >\n          : never\n    : never\n  : never;\n\nexport type RegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexRegisteredFunction<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectRegisteredFunction<FunctionSpec_>\n      : never;\n\n/**\n * Wrap a function's handler effect in its resolved middleware chain, per\n * invocation, after args decode. Iterated innermost-first so that the\n * first-attached (group-level, in attachment order) middleware ends up\n * outermost and runs first. Erased types: the public safety story lives at the\n * `MiddlewareSpec.MiddlewareImpl`/`MiddlewareImpl.make` signatures, and the\n * composed effect's error channel is re-accounted by\n * {@link combineErrorSchemas}.\n */\nexport const applyMiddleware = <A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>,\n  invocation: MiddlewareSpec.MiddlewareOptions[\"invocation\"],\n): Effect.Effect<A, any, R> => {\n  return resolvedMiddlewares.reduceRight<Effect.Effect<any, any, any>>(\n    // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- The erased middleware error remains intact so runHandlerPromise can validate it against the combined error schema.\n    (wrapped, middleware) => {\n      const context =\n        \"options\" in middleware.middlewareSpec\n          ? { options: middleware.options, invocation }\n          : { invocation };\n      // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- Resolved middleware is type-erased after its public implementation boundary; its error and service channels are restored by the surrounding function contract.\n      return middleware.middlewareImpl(wrapped, context);\n    },\n    effect,\n  );\n};\n\n/**\n * The error-schema allowlist for a function with middleware: the function's own\n * declared `error` schema unioned with every covering middleware's error\n * schema. `undefined` (⇒ every failure dies) only when neither declares\n * one—mirroring the ref-side union clients decode against.\n */\nexport const combineErrorSchemas = (\n  error: Schema.Codec<any, any> | undefined,\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>,\n): Schema.Codec<any, any> | undefined => {\n  const schemas = [\n    ...(error !== undefined ? [error] : []),\n    ...MiddlewareSpec.errorSchemas(\n      resolvedMiddlewares.map(({ middlewareSpec }) => middlewareSpec),\n    ),\n  ];\n  return schemas.length === 0\n    ? undefined\n    : schemas.length === 1\n      ? schemas[0]\n      : Schema.Union(schemas);\n};\n\ntype InvocationMeta = Pick<QueryMeta, \"getFunctionMetadata\"> &\n  Partial<Pick<MutationMeta, \"getRequestMetadata\">>;\n\ntype InvocationFunctionType = \"query\" | \"mutation\" | \"action\";\n\n/**\n * What `@confect/test` installs on `globalThis` under {@link testInvocation}.\n * `start` runs `run` with the services of the test invocation the handler\n * belongs to, with the handler's `Date`, `Math.random` and\n * `crypto.getRandomValues` pinned to that invocation, or answers `undefined`\n * when none is bound. `functionType` decides how `Date` reads: a query or\n * mutation keeps its start time, an action follows the clock. Production never\n * installs it.\n */\ntype TestInvocation = {\n  readonly start: <A>(\n    meta: InvocationMeta,\n    run: (services: Context.Context<never>) => Promise<A>,\n    functionType: InvocationFunctionType,\n  ) => Promise<A> | undefined;\n};\n\nconst testInvocation = Symbol.for(\"@confect/test/Invocation\");\n\n/**\n * Run the `Effect` as a `Promise`. Inspect the complete `Exit` before encoding\n * a declared error so a typed failure cannot hide a defect.\n *\n * Any `Die` reason takes the defect path. Without a `Die`, the first `Fail` in\n * cause order is schema-encoded and thrown as a `ConvexError` outside the\n * Effect runtime so Convex surfaces its data to the client. Other failures and\n * interruptions alongside that `Fail` are ignored. Without an error schema, the\n * selected failure is treated as a defect.\n *\n * A lone `ConvexError` defect or a selected undeclared `ConvexError` failure is\n * rethrown bare so it keeps Convex's meaning. Pagination and Workpool rely on\n * its data for their control signals. Other causes with a `Die`, interrupt-only\n * or empty causes, and error-encoding failures reject with a plain `Error`\n * whose message renders the complete cause and whose `cause` holds it for\n * server diagnostics.\n *\n * A `scheduler` in `runOptions` must be passed here as a run option rather than\n * provided via `Effect.provideService` inside `effect`: the run option lands in\n * the fiber's root context, while a service provided within `effect` pops\n * before the exit/encoding wrappers this function adds. The fiber's op counter\n * survives context pops, so a cooperative yield can fire inside those wrappers.\n * Only a root-context scheduler covers them.\n *\n * Under `@confect/test`, a handler reached from a bound test invocation starts\n * with that invocation's services through `Effect.runPromiseWith`, on a fiber\n * of its own. Every other handler starts with `Effect.runPromise`.\n */\nexport const runHandlerPromise =\n  (\n    errorSchema: Schema.Codec<any, any> | undefined,\n    runOptions?: {\n      readonly scheduler?: EffectScheduler.Scheduler | undefined;\n      readonly clock?: Clock.Clock | undefined;\n      readonly invocation?:\n        | Effect.Effect<\n            FunctionMetadata & { readonly received?: ReceivedValue }\n          >\n        | undefined;\n      readonly observability?: Layer.Layer<never> | undefined;\n      readonly meta?: InvocationMeta | undefined;\n      readonly functionType?: InvocationFunctionType | undefined;\n    },\n  ) =>\n  <A, E>(effect: Effect.Effect<A, E>): Promise<A> => {\n    const { observability, invocation, clock, meta, functionType } =\n      runOptions ?? {};\n    let encodedError: Exit.Exit<any, any> | undefined;\n    let undeclared: { readonly error: unknown } | undefined;\n    const observed = Effect.tapCause(effect, (cause) =>\n      Effect.gen(function* () {\n        const reason =\n          cause.reasons.find(Cause.isDieReason) ??\n          cause.reasons.find(Cause.isFailReason);\n        if (reason?._tag === \"Fail\" && errorSchema !== undefined) {\n          encodedError = yield* Effect.exit(\n            Schema.encodeEffect(errorSchema)(reason.error),\n          );\n          // An encoding failure is a defect, even when it dies with a ConvexError.\n          if (Exit.isFailure(encodedError)) {\n            const encoding = encodedError.cause;\n            return yield* Cause.squash(encoding) instanceof ConvexError\n              ? Effect.die(\n                  new Error(Cause.pretty(encoding), { cause: encoding }),\n                )\n              : Effect.orDie(encodedError);\n          }\n        }\n        // With no error schema a failure is a defect, so the root span ends as one.\n        if (\n          reason?._tag === \"Fail\" &&\n          errorSchema === undefined &&\n          !(reason.error instanceof ConvexError)\n        ) {\n          undeclared = { error: reason.error };\n          return yield* Effect.die(reason.error);\n        }\n      }),\n    );\n    const withConvexError: Effect.Effect<Result.Result<A, ConvexError<any>>> =\n      Effect.gen(function* () {\n        const exit = yield* Effect.exit(\n          observability === undefined || invocation === undefined\n            ? effect\n            : Effect.flatMap(\n                invocation,\n                ({ name, type, componentPath, received }) =>\n                  Effect.useSpan(\n                    name,\n                    {\n                      root: true,\n                      attributes: { kind: type, componentPath },\n                    },\n                    (span) =>\n                      Effect.provideService(observed, Tracer.ParentSpan, span),\n                  ).pipe(Effect.provideService(Received, received)),\n              ),\n        );\n        if (Exit.isSuccess(exit)) {\n          return Result.succeed(exit.value);\n        }\n        if (undeclared !== undefined)\n          return yield* Effect.die(undeclared.error);\n\n        const cause =\n          encodedError !== undefined && Exit.isFailure(encodedError)\n            ? encodedError.cause\n            : exit.cause;\n        const reason =\n          cause.reasons.find(Cause.isDieReason) ??\n          cause.reasons.find(Cause.isFailReason);\n        if (\n          encodedError === undefined &&\n          reason?._tag === \"Die\" &&\n          cause.reasons.length === 1 &&\n          reason.defect instanceof ConvexError\n        ) {\n          return Result.fail(reason.defect);\n        }\n\n        if (reason?._tag === \"Fail\") {\n          if (errorSchema === undefined) {\n            if (reason.error instanceof ConvexError) {\n              return Result.fail(reason.error);\n            }\n            return yield* Effect.die(reason.error);\n          }\n          const encoded =\n            encodedError ??\n            (yield* Effect.exit(\n              Schema.encodeEffect(errorSchema)(reason.error),\n            ));\n          if (Exit.isSuccess(encoded)) {\n            return Result.fail(new ConvexError(encoded.value));\n          }\n          return yield* Effect.die(\n            new Error(Cause.pretty(encoded.cause), { cause: encoded.cause }),\n          );\n        }\n        return yield* Effect.die(new Error(Cause.pretty(cause), { cause }));\n      });\n    const program = withConvexError.pipe(\n      Effect.provide(\n        observability === undefined\n          ? ConvexLogger.layer\n          : ObservabilityRuntime.memoized(observability),\n      ),\n      Effect.provideService(Console.Console, globalThis.console),\n      clock === undefined\n        ? (self) => self\n        : Effect.provideService(Clock.Clock, clock),\n    );\n    const started =\n      meta === undefined || functionType === undefined\n        ? undefined\n        : (globalThis as { [testInvocation]?: TestInvocation })[\n            testInvocation\n          ]?.start(\n            meta,\n            (services) => Effect.runPromiseWith(services)(program, runOptions),\n            functionType,\n          );\n    return (started ?? Effect.runPromise(program, runOptions)).then(\n      Result.match({\n        onFailure: (error) => {\n          throw error;\n        },\n        onSuccess: (value) => value,\n      }),\n    );\n  };\n\nexport const domainArgs = (\n  args: DefaultFunctionArgs,\n  reservedArgument?: string,\n): DefaultFunctionArgs =>\n  reservedArgument === undefined\n    ? args\n    : Object.fromEntries(\n        Object.entries(args).filter(([key]) => key !== reservedArgument),\n      );\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  name,\n  functionVisibility,\n  args,\n  returns,\n  error,\n  handler,\n  resolvedMiddlewares = [],\n  createLayer,\n  scope = IdScope.app,\n  observability,\n  reservedArgument,\n}: {\n  name: string;\n  reservedArgument?: string | undefined;\n  functionVisibility: FunctionVisibility;\n  args: Schema.Codec<Args, ConvexArgs>;\n  returns: Schema.Codec<Returns, ConvexReturns>;\n  error: Schema.Codec<Error, Value> | undefined;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\n  scope?: IdScope.IdScope;\n  observability?: Layer.Layer<never> | undefined;\n}) => ({\n  args: compileArgsSchema(args, scope, reservedArgument, name),\n  returns: compileReturnsSchema(returns, scope),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        domainArgs(actualArgs, reservedArgument),\n        Schema.decodeUnknownEffect(args),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n      const restricted = resolvedMiddlewares.some(\n        ({ middlewareSpec }) =>\n          middlewareSpec.key === ActionCallSpec.Middleware.key,\n      )\n        ? restrict(ctx)\n        : undefined;\n      // oxlint-disable-next-line effecttsgo/any-unknown-in-error-context -- Middleware errors are intentionally erased here and validated by runHandlerPromise against the combined error schema below.\n      const decodedReturns = yield* applyMiddleware(\n        handler(decodedArgs),\n        resolvedMiddlewares,\n        {\n          name,\n          functionType: \"action\",\n          functionVisibility,\n          args: decodedArgs,\n        },\n      ).pipe(Effect.provide(createLayer(restricted?.ctx ?? ctx)));\n      if (restricted !== undefined) yield* restricted.check;\n      return yield* pipe(\n        decodedReturns,\n        Schema.encodeEffect(returns),\n        Effect.catchTag(\"SchemaError\", Effect.die),\n      );\n    }).pipe(\n      runHandlerPromise(combineErrorSchemas(error, resolvedMiddlewares), {\n        invocation: invocationMetadata(ctx.meta, actualArgs, reservedArgument),\n        observability,\n        meta: ctx.meta,\n        functionType: \"action\",\n      }),\n    ),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> = Handler.ActionServices<DatabaseSchema_>;\n\n/**\n * The ctx-backed action services that don't depend on a Confect database\n * schema. {@link actionLayer} adds the schema-typed `VectorSearch` on top; the\n * HTTP API handler uses this base directly.\n */\nexport const baseActionLayer = <ConvexDataModel extends GenericDataModel>(\n  ctx: GenericActionCtx<ConvexDataModel>,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer(ctx.scheduler),\n    Auth.layer(ctx.auth),\n    ExecutionMetadata.layer(ctx.meta),\n    RequestMetadata.layer(ctx.meta),\n    Storage.layer(ctx.storage),\n    StorageWriter.StorageWriter.layer(ctx.storage),\n    StorageActionWriter.StorageActionWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery.bind(ctx)),\n    MutationRunner.layer(ctx.runMutation.bind(ctx)),\n    ActionRunner.layer(ctx.runAction.bind(ctx)),\n    Layer.succeed(ActionCtx.ActionCtx<ConvexDataModel>(), ctx),\n  );\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer<DatabaseSchema.Scope<DatabaseSchema_>>(\n      ctx.scheduler,\n      databaseSchema.target.scope,\n    ),\n    Auth.layerForTarget<DatabaseSchema_[\"target\"]>(\n      databaseSchema.target,\n      ctx.auth,\n    ),\n    ExecutionMetadata.layer(ctx.meta),\n    RequestMetadata.layer(ctx.meta),\n    storageLayer<DatabaseSchema.Scope<DatabaseSchema_>>(ctx.storage),\n    StorageWriter.StorageWriter.layer<DatabaseSchema.Scope<DatabaseSchema_>>(\n      ctx.storage,\n      databaseSchema.target.scope,\n    ),\n    StorageActionWriter.StorageActionWriter.layer<\n      DatabaseSchema.Scope<DatabaseSchema_>\n    >(ctx.storage, databaseSchema.target.scope),\n    QueryRunner.layer(ctx.runQuery.bind(ctx)),\n    MutationRunner.layer(ctx.runMutation.bind(ctx)),\n    ActionRunner.layer(ctx.runAction.bind(ctx)),\n    ActionCtx.layer<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,\n      DatabaseSchema.Scope<DatabaseSchema_>\n    >(ctx, databaseSchema.target.scope),\n    VectorSearch.layer(ctx.vectorSearch.bind(ctx)),\n  );\n\n// Scoped readers share the same runtime service and ID strings. Reuse the\n// reader supplied by Storage so both APIs keep the same reader instance.\nexport const storageLayer = <Scope extends IdScope.IdScope>(\n  reader: ConvexStorageReader,\n): Layer.Layer<Storage.Storage | StorageReader.ForScope<Scope>> =>\n  Storage.layer(reader) as Layer.Layer<\n    Storage.Storage | StorageReader.ForScope<Scope>\n  >;\n\n/**\n * Shares one dispatch budget across the entire middleware chain.\n */\nconst restrict = <Model extends GenericDataModel>(\n  ctx: GenericActionCtx<Model>,\n) => {\n  let dispatched = false;\n  const claim = () => {\n    if (dispatched) throw new ActionCall.ActionCallAlreadyUsed();\n    dispatched = true;\n  };\n  const restricted: GenericActionCtx<Model> = {\n    ...ctx,\n    scheduler: {\n      runAfter: () => {\n        throw new ActionCall.SchedulingNotAllowed();\n      },\n      runAt: () => {\n        throw new ActionCall.SchedulingNotAllowed();\n      },\n      cancel: () => {\n        throw new ActionCall.SchedulingNotAllowed();\n      },\n    },\n    runQuery: (...args) => {\n      claim();\n      return ctx.runQuery(...args);\n    },\n    runMutation: (...args) => {\n      claim();\n      return ctx.runMutation(...args);\n    },\n    runAction: () => {\n      throw new ActionCall.NestedActionNotAllowed();\n    },\n  };\n  return {\n    ctx: restricted,\n    check: Effect.suspend(() =>\n      dispatched ? Effect.void : Effect.die(new ActionCall.ActionCallNotUsed()),\n    ),\n  };\n};\n"],"mappings":"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"}

package/dist/RegisteredNodeFunction.d.ts

@@ -7,5 +7,5 @@ import type * as GroupSpec from "@confect/core/GroupSpec";
 import type * as GroupImpl from "./GroupImpl.js";
 import type * as RegisteredFunctions from "./RegisteredFunctions.js";
 export declare const buildForGroup: <Group extends GroupSpec.AnyWithProps>(databaseSchema: DatabaseSchema.AnyWithProps, groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>) => RegisteredFunctions.RegisteredFunctionsForGroupSpec<Group>;
-export declare const make: (databaseSchema: DatabaseSchema.AnyWithProps, item: FunctionRegistryItem.ConfectFunctionRegistryItem, resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>) => RegisteredFunction.Any;
+export declare const make: (databaseSchema: DatabaseSchema.AnyWithProps, item: FunctionRegistryItem.ConfectFunctionRegistryItem, resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>, observability?: Layer.Layer<never>) => RegisteredFunction.Any;
 //# sourceMappingURL=RegisteredNodeFunction.d.ts.map

package/dist/RegisteredNodeFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.d.ts","sourceRoot":"","sources":["../src/RegisteredNodeFunction.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,KAAK,cAAc,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,oBAAoB,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAC;AAE9D,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAGrE,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,SAAS,CAAC,YAAY,kBAChD,cAAc,CAAC,YAAY,cAC/B,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,KACxD,mBAAmB,CAAC,+BAA+B,CAAC,KAAK,CAqB3D,CAAC;AAEF,eAAO,MAAM,IAAI,mBACC,cAAc,CAAC,YAAY,QACrC,oBAAoB,CAAC,2BAA2B,wBACjC,aAAa,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,KACxE,kBAAkB,CAAC,GAkBrB,CAAC"}
+{"version":3,"file":"RegisteredNodeFunction.d.ts","sourceRoot":"","sources":["../src/RegisteredNodeFunction.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,KAAK,cAAc,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,oBAAoB,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAC;AAE9D,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAGrE,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,SAAS,CAAC,YAAY,kBAChD,cAAc,CAAC,YAAY,cAC/B,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,KACxD,mBAAmB,CAAC,+BAA+B,CAAC,KAAK,CAsB3D,CAAC;AAEF,eAAO,MAAM,IAAI,mBACC,cAAc,CAAC,YAAY,QACrC,oBAAoB,CAAC,2BAA2B,wBACjC,aAAa,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,kBACzD,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KACjC,kBAAkB,CAAC,GAoBrB,CAAC"}

package/dist/RegisteredNodeFunction.js

@@ -1,9 +1,9 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { mapLeaves } from "./internal/utils.js";
+import { actionFunctionBase, actionLayer } from "./RegisteredFunction.js";
 import { make as make$1 } from "./GroupRegistry.js";
 import { isFunctionRegistryItem } from "./FunctionRegistryItem.js";
-import { actionFunctionBase, actionLayer } from "./RegisteredFunction.js";
 import { resolve } from "./ResolvedMiddleware.js";
-import { mapLeaves } from "./internal/utils.js";
 import * as Layer from "effect/Layer";
 import { actionGeneric, internalActionGeneric } from "convex/server";
 import * as Match from "effect/Match";
@@ -14,12 +14,14 @@ var RegisteredNodeFunction_exports = /* @__PURE__ */ __exportAll({
 	make: () => make
 });
 const buildForGroup = (databaseSchema, groupLayer) => {
-	const { functionRegistryItems, middlewareRegistryItems } = make$1(groupLayer);
-	return mapLeaves(functionRegistryItems, isFunctionRegistryItem, (item) => Match.value(item).pipe(Match.tag("Convex", ({ handler }) => handler), Match.tag("Confect", (confect) => make(databaseSchema, confect, resolve(confect, middlewareRegistryItems))), Match.exhaustive));
+	const { functionRegistryItems, middlewareRegistryItems, observability } = make$1(groupLayer);
+	return mapLeaves(functionRegistryItems, isFunctionRegistryItem, (item) => Match.value(item).pipe(Match.tag("Convex", ({ handler }) => handler), Match.tag("Confect", (confect) => make(databaseSchema, confect, resolve(confect, middlewareRegistryItems), observability)), Match.exhaustive));
 };
-const make = (databaseSchema, item, resolvedMiddlewares = []) => {
+const make = (databaseSchema, item, resolvedMiddlewares = [], observability) => {
 	return Match.value(item.functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(databaseSchema, {
 		name: item.name,
+		reservedArgument: item.reservedArgument,
+		observability,
 		functionVisibility: item.functionVisibility,
 		args: item.args,
 		returns: item.returns,
@@ -28,7 +30,7 @@ const make = (databaseSchema, item, resolvedMiddlewares = []) => {
 		resolvedMiddlewares
 	}));
 };
-const nodeActionFunction = (databaseSchema, { name, functionVisibility, args, returns, error, handler, resolvedMiddlewares }) => actionFunctionBase({
+const nodeActionFunction = (databaseSchema, { name, functionVisibility, args, returns, error, handler, resolvedMiddlewares, observability, reservedArgument }) => actionFunctionBase({
 	scope: databaseSchema.target.scope,
 	name,
 	functionVisibility,
@@ -37,6 +39,8 @@ const nodeActionFunction = (databaseSchema, { name, functionVisibility, args, re
 	error,
 	handler,
 	resolvedMiddlewares,
+	observability,
+	reservedArgument,
 	createLayer: (ctx) => Layer.mergeAll(actionLayer(databaseSchema, ctx), NodeServices.layer)
 });
 //#endregion