@gaganref/confect-server 0.0.0-stage → 10.3.1-fork.1

package/dist/RegisteredFunction.d.ts

@@ -0,0 +1,143 @@
+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 { Value } from "convex/values";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import type * as EffectScheduler from "effect/Scheduler";
+import * as ActionCtx from "./ActionCtx";
+import * as Auth from "./Auth";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DataModel from "./DataModel";
+import * as ExecutionMetadata from "./ExecutionMetadata";
+import * as RequestMetadata from "./RequestMetadata";
+import * as MutationRunner from "./MutationRunner";
+import * as QueryRunner from "./QueryRunner";
+import type * as ResolvedMiddleware from "./ResolvedMiddleware";
+import * as Scheduler from "./Scheduler";
+import * as Storage from "./Storage";
+import * as StorageActionWriter from "./StorageActionWriter";
+import type * as StorageReader from "./StorageReader";
+import * as StorageWriter from "./StorageWriter";
+import * as VectorSearch from "./VectorSearch";
+import type * as Handler from "./Handler";
+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;
+export type RegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConvex> ? ConvexRegisteredFunction<FunctionSpec_> : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConfect> ? ConfectRegisteredFunction<FunctionSpec_> : never;
+/**
+ * Wrap a function's handler effect in its resolved middleware chain, per
+ * invocation, after args decode. Iterated innermost-first so that the
+ * first-attached (group-level, in attachment order) middleware ends up
+ * outermost and runs first. Erased types: the public safety story lives at the
+ * `MiddlewareSpec.MiddlewareImpl`/`MiddlewareImpl.make` signatures, and the
+ * composed effect's error channel is re-accounted by
+ * {@link combineErrorSchemas}.
+ */
+export declare const applyMiddleware: <A, E, R>(effect: Effect.Effect<A, E, R>, resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>, invocation: MiddlewareSpec.MiddlewareOptions["invocation"]) => Effect.Effect<A, any, R>;
+/**
+ * The error-schema allowlist for a function with middleware: the function's own
+ * declared `error` schema unioned with every covering middleware's error
+ * schema. `undefined` (⇒ every failure dies) only when neither declares
+ * 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;
+/**
+ * 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`:
+ *
+ * - 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.
+ *
+ * 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 `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.
+ */
+export declare const runHandlerPromise: (errorSchema: Schema.Codec<any, any> | undefined, runOptions?: {
+    readonly scheduler?: EffectScheduler.Scheduler | 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, }: {
+    name: string;
+    functionVisibility: FunctionVisibility;
+    args: Schema.Codec<Args, ConvexArgs>;
+    returns: Schema.Codec<Returns, ConvexReturns>;
+    error: Schema.Codec<Error, Value> | undefined;
+    handler: (a: Args) => Effect.Effect<Returns, E, R>;
+    resolvedMiddlewares?: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;
+    createLayer: (ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>) => Layer.Layer<R>;
+    scope?: IdScope.IdScope;
+}) => {
+    args: import("convex/values").PropertyValidators;
+    returns: import("convex/values").Validator<any, any, any>;
+    handler: (ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
+};
+export type ActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = Handler.ActionServices<DatabaseSchema_>;
+/**
+ * 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.
+ */
+export declare const baseActionLayer: <ConvexDataModel extends GenericDataModel>(ctx: GenericActionCtx<ConvexDataModel>) => Layer.Layer<Auth.Auth | ExecutionMetadata.ExecutionMetadata | GenericActionCtx<ConvexDataModel> | RequestMetadata.RequestMetadata | Storage.Storage | StorageActionWriter.StorageActionWriter | StorageReader.StorageReader | StorageWriter.StorageWriter | {
+    runAction: <Action extends import("@confect/core/Ref").AnyAction>(action: Action, ...args: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | Schema.SchemaError>;
+} | {
+    runMutation: {
+        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, ...args: [...import("@confect/core/Ref").OptionalArgs<Mutation>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError>;
+        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, args: import("@confect/core/Ref").Args<Mutation>, options: MutationRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError, import("./MutationTransactionContext").MutationTransactionContext>;
+    };
+} | {
+    runQuery: {
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, ...args: [...import("@confect/core/Ref").OptionalArgs<Query>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: (import("./QueryTransactionContext").Options & {
+            readonly useStaleSnapshot?: never;
+        }) | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./QueryTransactionContext").QueryTransactionContext>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options & {
+            readonly useStaleSnapshot: boolean;
+        }): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./MutationTransactionContext").MutationTransactionContext>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./QueryTransactionContext").QueryTransactionContext | import("./MutationTransactionContext").MutationTransactionContext>;
+    };
+} | {
+    cancel: (id: import("convex/values").GenericId<"_scheduled_functions">) => Effect.Effect<void, never, never>;
+    runAfter: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(delay: import("effect/Duration").Duration, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
+    runAt: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(dateTime: import("effect/DateTime").DateTime, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
+}, never, never>;
+export declare const actionLayer: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => Layer.Layer<ExecutionMetadata.ExecutionMetadata | RequestMetadata.RequestMetadata | Storage.Storage | VectorSearch.VectorSearchService<DataModel.FromSchema<DatabaseSchema_>> | {
+    runAction: <Action extends import("@confect/core/Ref").AnyAction>(action: Action, ...args: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | Schema.SchemaError>;
+} | {
+    runMutation: {
+        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, ...args: [...import("@confect/core/Ref").OptionalArgs<Mutation>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError>;
+        <Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, args: import("@confect/core/Ref").Args<Mutation>, options: MutationRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | Schema.SchemaError, import("./MutationTransactionContext").MutationTransactionContext>;
+    };
+} | {
+    runQuery: {
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, ...args: [...import("@confect/core/Ref").OptionalArgs<Query>, options?: undefined]): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: (import("./QueryTransactionContext").Options & {
+            readonly useStaleSnapshot?: never;
+        }) | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./QueryTransactionContext").QueryTransactionContext>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options & {
+            readonly useStaleSnapshot: boolean;
+        }): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./MutationTransactionContext").MutationTransactionContext>;
+        <Query extends import("@confect/core/Ref").AnyQuery>(query: Query, args: import("@confect/core/Ref").Args<Query>, options: QueryRunner.Options | undefined): Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | Schema.SchemaError, import("./QueryTransactionContext").QueryTransactionContext | import("./MutationTransactionContext").MutationTransactionContext>;
+    };
+} | 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

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

package/dist/RegisteredFunction.js

@@ -0,0 +1,125 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.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$7 } from "./ConvexLogger.js";
+import { layer as layer$8 } from "./Scheduler.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 * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { pipe } from "effect/Function";
+import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+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 Console from "effect/Console";
+//#region src/RegisteredFunction.ts
+var RegisteredFunction_exports = /* @__PURE__ */ __exportAll({
+	actionFunctionBase: () => actionFunctionBase,
+	actionLayer: () => actionLayer,
+	applyMiddleware: () => applyMiddleware,
+	baseActionLayer: () => baseActionLayer,
+	combineErrorSchemas: () => combineErrorSchemas,
+	runHandlerPromise: () => runHandlerPromise,
+	storageLayer: () => storageLayer
+});
+/**
+* Wrap a function's handler effect in its resolved middleware chain, per
+* invocation, after args decode. Iterated innermost-first so that the
+* first-attached (group-level, in attachment order) middleware ends up
+* outermost and runs first. Erased types: the public safety story lives at the
+* `MiddlewareSpec.MiddlewareImpl`/`MiddlewareImpl.make` signatures, and the
+* composed effect's error channel is re-accounted by
+* {@link combineErrorSchemas}.
+*/
+const applyMiddleware = (effect, resolvedMiddlewares, invocation) => {
+	return resolvedMiddlewares.reduceRight((wrapped, middleware) => {
+		const context = "options" in middleware.middlewareSpec ? {
+			options: middleware.options,
+			invocation
+		} : { invocation };
+		return middleware.middlewareImpl(wrapped, context);
+	}, effect);
+};
+/**
+* The error-schema allowlist for a function with middleware: the function's own
+* declared `error` schema unioned with every covering middleware's error
+* schema. `undefined` (⇒ every failure dies) only when neither declares
+* one—mirroring the ref-side union clients decode against.
+*/
+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);
+};
+/**
+* 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`:
+*
+* - 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.
+*
+* 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 `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.
+*/
+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({
+		onFailure: (error) => {
+			throw error;
+		},
+		onSuccess: (value) => value
+	}));
+};
+const actionFunctionBase = ({ name, functionVisibility, args, returns, error, handler, resolvedMiddlewares = [], createLayer, scope = IdScope.app }) => ({
+	args: compileArgsSchema(args, scope),
+	returns: compileReturnsSchema(returns, scope),
+	handler: (ctx, actualArgs) => Effect.gen(function* () {
+		const decodedArgs = yield* pipe(actualArgs, Schema.decodeUnknownEffect(args), Effect.catchTag("SchemaError", Effect.die));
+		const decodedReturns = yield* applyMiddleware(handler(decodedArgs), resolvedMiddlewares, {
+			name,
+			functionType: "action",
+			functionVisibility,
+			args: decodedArgs
+		}).pipe(Effect.provide(createLayer(ctx)));
+		return yield* pipe(decodedReturns, Schema.encodeEffect(returns), Effect.catchTag("SchemaError", Effect.die));
+	}).pipe(runHandlerPromise(combineErrorSchemas(error, resolvedMiddlewares)))
+});
+/**
+* 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);
+//#endregion
+export { RegisteredFunction_exports, actionFunctionBase, actionLayer, applyMiddleware, baseActionLayer, combineErrorSchemas, runHandlerPromise, storageLayer };
+
+//# sourceMappingURL=RegisteredFunction.js.map

package/dist/RegisteredFunction.js.map

@@ -0,0 +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\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport * as Auth from \"./Auth\";\nimport * as ConvexLogger from \"./ConvexLogger\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as ExecutionMetadata from \"./ExecutionMetadata\";\nimport * as RequestMetadata from \"./RequestMetadata\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport type * as ResolvedMiddleware from \"./ResolvedMiddleware\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as Storage from \"./Storage\";\nimport * as StorageActionWriter from \"./StorageActionWriter\";\nimport type * as StorageReader from \"./StorageReader\";\nimport * as StorageWriter from \"./StorageWriter\";\nimport * as VectorSearch from \"./VectorSearch\";\nimport type * as Handler from \"./Handler\";\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":"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"}

package/dist/RegisteredFunctions.d.ts

@@ -0,0 +1,57 @@
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as Spec from "@confect/core/Spec";
+import type { Layer, Types } from "effect";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as GroupImpl from "./GroupImpl";
+import type * as RegisteredFunction from "./RegisteredFunction";
+export type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> = Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
+type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
+    [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? RegisteredFunctionsForGroupSpec<Group> : never;
+};
+/**
+ * The `RegisteredFunction` record for a group's own declared functions.
+ */
+type RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = {
+    [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction.RegisteredFunction<FunctionSpec_> : never;
+};
+/**
+ * The registered-functions record for a single group, derived from the group's
+ * own `GroupSpec`: its declared functions, plus any nested subgroups it carries
+ * directly. This is the node that `buildForGroup` returns—computed from the
+ * leaf `GroupSpec` itself rather than by navigating the project-wide assembled
+ * `Spec` to a dot-path, so the per-group registry's type depends only on its
+ * own leaf. For the filesystem layout a leaf `GroupSpec` carries no subgroups
+ * (subdirectory children are assembled separately into `_generated/spec.ts`),
+ * so this resolves to just the leaf's functions.
+ */
+export type RegisteredFunctionsForGroupSpec<Group extends GroupSpec.AnyWithProps> = GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>> : RegisteredFunctionsOf<Group>;
+export interface AnyWithProps {
+    readonly [key: string]: RegisteredFunction.Any | AnyWithProps;
+}
+/**
+ * Build the registered Convex functions for a single group from its finalized
+ * `GroupImpl` layer.
+ *
+ * The `groupLayer` parameter requires `GroupImpl<"Finalized">`, so impls that
+ * were never piped through `GroupImpl.finalize` (and impls with unmet
+ * `FunctionImpl` requirements, which cannot be finalized) are rejected at the
+ * codegen boundary, not just deep inside Convex at runtime.
+ *
+ * The group layer is built with a fresh, isolated `Registry` (rather than the
+ * globally-cached default `Context.Reference`), so each `FunctionImpl.make`
+ * registers under its flat, single-segment function-name key without colliding
+ * with any other group built in the same process—the built registry holds
+ * exactly this group's functions at the top level.
+ *
+ * Only the runtime `databaseSchema` value is needed at runtime (it is forwarded
+ * to isolate registration to build each function's ctx services); the group's
+ * `GroupSpec` is supplied purely as the `Group` type parameter to shape the
+ * returned record. Generated isolate modules instead prepare definitions with
+ * `ConvexFunctionDefinitions.buildForGroup` and add local forwarding handlers
+ * before shared registration. Node groups use
+ * `RegisteredNodeFunction.buildForGroup` from the Node entry.
+ */
+export declare const buildForGroup: <Group extends GroupSpec.AnyWithProps>(databaseSchema: DatabaseSchema.AnyWithProps, groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>) => RegisteredFunctionsForGroupSpec<Group>;
+export {};
+//# sourceMappingURL=RegisteredFunctions.d.ts.map

package/dist/RegisteredFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredFunctions.d.ts","sourceRoot":"","sources":["../src/RegisteredFunctions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,KAAK,IAAI,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,KAAK,kBAAkB,MAAM,sBAAsB,CAAC;AAEhE,MAAM,MAAM,mBAAmB,CAAC,KAAK,SAAS,IAAI,CAAC,YAAY,IAC7D,KAAK,CAAC,QAAQ,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEhE,KAAK,yBAAyB,CAAC,MAAM,SAAS,SAAS,CAAC,YAAY,IAAI;KACrE,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,QAAQ,CACvD,MAAM,EACN,SAAS,CACV,SAAS,MAAM,KAAK,SAAS,SAAS,CAAC,YAAY,GAChD,+BAA+B,CAAC,KAAK,CAAC,GACtC,KAAK;CACV,CAAC;AAEF;;GAEG;AACH,KAAK,qBAAqB,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;KAE/D,YAAY,IAAI,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,GAC5D,YAAY,CAAC,QAAQ,CACtB,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,EAC1B,YAAY,CACb,SAAS,MAAM,aAAa,SAAS,YAAY,CAAC,YAAY,GAC3D,kBAAkB,CAAC,kBAAkB,CAAC,aAAa,CAAC,GACpD,KAAK;CACV,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,+BAA+B,CACzC,KAAK,SAAS,SAAS,CAAC,YAAY,IAEpC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,MAAM,SAAS,SAAS,SAAS,CAAC,YAAY,GAC1E,KAAK,CAAC,QAAQ,CACZ,yBAAyB,CAAC,SAAS,CAAC,GAAG,qBAAqB,CAAC,KAAK,CAAC,CACpE,GACD,qBAAqB,CAAC,KAAK,CAAC,CAAC;AAEnC,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAC,GAAG,GAAG,YAAY,CAAC;CAC/D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,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,+BAA+B,CAAC,KAAK,CAGrC,CAAC"}

package/dist/RegisteredFunctions.js

@@ -0,0 +1,32 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { buildForGroup as buildForGroup$1, register } from "./ConvexFunctionDefinitions.js";
+//#region src/RegisteredFunctions.ts
+var RegisteredFunctions_exports = /* @__PURE__ */ __exportAll({ buildForGroup: () => buildForGroup });
+/**
+* Build the registered Convex functions for a single group from its finalized
+* `GroupImpl` layer.
+*
+* The `groupLayer` parameter requires `GroupImpl<"Finalized">`, so impls that
+* were never piped through `GroupImpl.finalize` (and impls with unmet
+* `FunctionImpl` requirements, which cannot be finalized) are rejected at the
+* codegen boundary, not just deep inside Convex at runtime.
+*
+* The group layer is built with a fresh, isolated `Registry` (rather than the
+* globally-cached default `Context.Reference`), so each `FunctionImpl.make`
+* registers under its flat, single-segment function-name key without colliding
+* with any other group built in the same process—the built registry holds
+* exactly this group's functions at the top level.
+*
+* Only the runtime `databaseSchema` value is needed at runtime (it is forwarded
+* to isolate registration to build each function's ctx services); the group's
+* `GroupSpec` is supplied purely as the `Group` type parameter to shape the
+* returned record. Generated isolate modules instead prepare definitions with
+* `ConvexFunctionDefinitions.buildForGroup` and add local forwarding handlers
+* before shared registration. Node groups use
+* `RegisteredNodeFunction.buildForGroup` from the Node entry.
+*/
+const buildForGroup = (databaseSchema, groupLayer) => register(buildForGroup$1(databaseSchema, groupLayer));
+//#endregion
+export { RegisteredFunctions_exports, buildForGroup };
+
+//# sourceMappingURL=RegisteredFunctions.js.map

package/dist/RegisteredFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredFunctions.js","names":["ConvexFunctionDefinitions.register","ConvexFunctionDefinitions.buildForGroup"],"sources":["../src/RegisteredFunctions.ts"],"sourcesContent":["import * as ConvexFunctionDefinitions from \"./ConvexFunctionDefinitions\";\nimport type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as Spec from \"@confect/core/Spec\";\nimport type { Layer, Types } from \"effect\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as GroupImpl from \"./GroupImpl\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\n\nexport type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> =\n  Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;\n\ntype RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {\n  [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<\n    Groups,\n    GroupName\n  > extends infer Group extends GroupSpec.AnyWithProps\n    ? RegisteredFunctionsForGroupSpec<Group>\n    : never;\n};\n\n/**\n * The `RegisteredFunction` record for a group's own declared functions.\n */\ntype RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = {\n  [\n    FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>\n  ]: FunctionSpec.WithName<\n    GroupSpec.Functions<Group>,\n    FunctionName\n  > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps\n    ? RegisteredFunction.RegisteredFunction<FunctionSpec_>\n    : never;\n};\n\n/**\n * The registered-functions record for a single group, derived from the group's\n * own `GroupSpec`: its declared functions, plus any nested subgroups it carries\n * directly. This is the node that `buildForGroup` returns—computed from the\n * leaf `GroupSpec` itself rather than by navigating the project-wide assembled\n * `Spec` to a dot-path, so the per-group registry's type depends only on its\n * own leaf. For the filesystem layout a leaf `GroupSpec` carries no subgroups\n * (subdirectory children are assembled separately into `_generated/spec.ts`),\n * so this resolves to just the leaf's functions.\n */\nexport type RegisteredFunctionsForGroupSpec<\n  Group extends GroupSpec.AnyWithProps,\n> =\n  GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps\n    ? Types.Simplify<\n        RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>\n      >\n    : RegisteredFunctionsOf<Group>;\n\nexport interface AnyWithProps {\n  readonly [key: string]: RegisteredFunction.Any | AnyWithProps;\n}\n\n/**\n * Build the registered Convex functions for a single group from its finalized\n * `GroupImpl` layer.\n *\n * The `groupLayer` parameter requires `GroupImpl<\"Finalized\">`, so impls that\n * were never piped through `GroupImpl.finalize` (and impls with unmet\n * `FunctionImpl` requirements, which cannot be finalized) are rejected at the\n * codegen boundary, not just deep inside Convex at runtime.\n *\n * The group layer is built with a fresh, isolated `Registry` (rather than the\n * globally-cached default `Context.Reference`), so each `FunctionImpl.make`\n * registers under its flat, single-segment function-name key without colliding\n * with any other group built in the same process—the built registry holds\n * exactly this group's functions at the top level.\n *\n * Only the runtime `databaseSchema` value is needed at runtime (it is forwarded\n * to isolate registration to build each function's ctx services); the group's\n * `GroupSpec` is supplied purely as the `Group` type parameter to shape the\n * returned record. Generated isolate modules instead prepare definitions with\n * `ConvexFunctionDefinitions.buildForGroup` and add local forwarding handlers\n * before shared registration. Node groups use\n * `RegisteredNodeFunction.buildForGroup` from the Node entry.\n */\nexport const buildForGroup = <Group extends GroupSpec.AnyWithProps>(\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  groupLayer: Layer.Layer<GroupImpl.GroupImpl<\"Finalized\">>,\n): RegisteredFunctionsForGroupSpec<Group> =>\n  ConvexFunctionDefinitions.register<Group>(\n    ConvexFunctionDefinitions.buildForGroup(databaseSchema, groupLayer),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,MAAa,iBACX,gBACA,eAEAA,SACEC,gBAAwC,gBAAgB,UAAU,CACpE"}

package/dist/RegisteredNodeFunction.d.ts

@@ -0,0 +1,11 @@
+import * as Layer from "effect/Layer";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import * as RegisteredFunction from "./RegisteredFunction";
+import * as FunctionRegistryItem from "./FunctionRegistryItem";
+import * as ResolvedMiddleware from "./ResolvedMiddleware";
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as GroupImpl from "./GroupImpl";
+import type * as RegisteredFunctions from "./RegisteredFunctions";
+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;
+//# sourceMappingURL=RegisteredNodeFunction.d.ts.map

package/dist/RegisteredNodeFunction.d.ts.map

@@ -0,0 +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,kBAAkB,CAAC;AACxD,OAAO,KAAK,kBAAkB,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,oBAAoB,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,kBAAkB,MAAM,sBAAsB,CAAC;AAE3D,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAGlE,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"}

package/dist/RegisteredNodeFunction.js

@@ -0,0 +1,45 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.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";
+import * as NodeServices from "@effect/platform-node/NodeServices";
+//#region src/RegisteredNodeFunction.ts
+var RegisteredNodeFunction_exports = /* @__PURE__ */ __exportAll({
+	buildForGroup: () => buildForGroup,
+	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 make = (databaseSchema, item, resolvedMiddlewares = []) => {
+	return Match.value(item.functionVisibility).pipe(Match.when("public", () => actionGeneric), Match.when("internal", () => internalActionGeneric), Match.exhaustive)(nodeActionFunction(databaseSchema, {
+		name: item.name,
+		functionVisibility: item.functionVisibility,
+		args: item.args,
+		returns: item.returns,
+		error: item.error,
+		handler: item.handler,
+		resolvedMiddlewares
+	}));
+};
+const nodeActionFunction = (databaseSchema, { name, functionVisibility, args, returns, error, handler, resolvedMiddlewares }) => actionFunctionBase({
+	scope: databaseSchema.target.scope,
+	name,
+	functionVisibility,
+	args,
+	returns,
+	error,
+	handler,
+	resolvedMiddlewares,
+	createLayer: (ctx) => Layer.mergeAll(actionLayer(databaseSchema, ctx), NodeServices.layer)
+});
+//#endregion
+export { RegisteredNodeFunction_exports, buildForGroup, make };
+
+//# sourceMappingURL=RegisteredNodeFunction.js.map

package/dist/RegisteredNodeFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegisteredNodeFunction.js","names":["GroupRegistry.make","FunctionRegistryItem.isFunctionRegistryItem","ResolvedMiddleware.resolve","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredNodeFunction.ts"],"sourcesContent":["import * as NodeServices from \"@effect/platform-node/NodeServices\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  internalActionGeneric,\n} from \"convex/server\";\nimport type { Effect } from \"effect\";\nimport type { Schema } from \"effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Match from \"effect/Match\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport * as FunctionRegistryItem from \"./FunctionRegistryItem\";\nimport * as ResolvedMiddleware from \"./ResolvedMiddleware\";\nimport * as GroupRegistry from \"./GroupRegistry\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as GroupImpl from \"./GroupImpl\";\nimport type * as RegisteredFunctions from \"./RegisteredFunctions\";\nimport { mapLeaves } from \"./internal/utils\";\n\nexport const buildForGroup = <Group extends GroupSpec.AnyWithProps>(\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  groupLayer: Layer.Layer<GroupImpl.GroupImpl<\"Finalized\">>,\n): RegisteredFunctions.RegisteredFunctionsForGroupSpec<Group> => {\n  const { functionRegistryItems, middlewareRegistryItems } =\n    GroupRegistry.make(groupLayer);\n  return mapLeaves<FunctionRegistryItem.AnyWithProps, RegisteredFunction.Any>(\n    functionRegistryItems as {\n      [key: string]: FunctionRegistryItem.AnyWithProps;\n    },\n    FunctionRegistryItem.isFunctionRegistryItem,\n    (item) =>\n      Match.value(item).pipe(\n        Match.tag(\"Convex\", ({ handler }) => handler),\n        Match.tag(\"Confect\", (confect) =>\n          make(\n            databaseSchema,\n            confect,\n            ResolvedMiddleware.resolve(confect, middlewareRegistryItems),\n          ),\n        ),\n        Match.exhaustive,\n      ),\n  ) as RegisteredFunctions.RegisteredFunctionsForGroupSpec<Group>;\n};\n\nexport const make = (\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  item: FunctionRegistryItem.ConfectFunctionRegistryItem,\n  resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware> = [],\n): RegisteredFunction.Any => {\n  const genericFunction = Match.value(item.functionVisibility).pipe(\n    Match.when(\"public\", () => actionGeneric),\n    Match.when(\"internal\", () => internalActionGeneric),\n    Match.exhaustive,\n  );\n\n  return genericFunction(\n    nodeActionFunction(databaseSchema, {\n      name: item.name,\n      functionVisibility: item.functionVisibility,\n      args: item.args,\n      returns: item.returns,\n      error: item.error,\n      handler: item.handler,\n      resolvedMiddlewares,\n    }),\n  );\n};\n\nconst nodeActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  databaseSchema: DatabaseSchema_,\n  {\n    name,\n    functionVisibility,\n    args,\n    returns,\n    error,\n    handler,\n    resolvedMiddlewares,\n  }: {\n    name: string;\n    functionVisibility: FunctionVisibility;\n    args: Schema.Codec<Args, ConvexArgs>;\n    returns: Schema.Codec<Returns, ConvexReturns>;\n    error: Schema.Codec<any, any> | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      | RegisteredFunction.ActionServices<DatabaseSchema_>\n      | NodeServices.NodeServices\n    >;\n    resolvedMiddlewares: ReadonlyArray<ResolvedMiddleware.ResolvedMiddleware>;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    scope: databaseSchema.target.scope,\n    name,\n    functionVisibility,\n    args,\n    returns,\n    error,\n    handler,\n    resolvedMiddlewares,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(databaseSchema, ctx),\n        NodeServices.layer,\n      ),\n  });\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,MAAa,iBACX,gBACA,eAC+D;CAC/D,MAAM,EAAE,uBAAuB,4BAC7BA,OAAmB,UAAU;CAC/B,OAAO,UACL,uBAGAC,yBACC,SACC,MAAM,MAAM,IAAI,CAAC,CAAC,KAChB,MAAM,IAAI,WAAW,EAAE,cAAc,OAAO,GAC5C,MAAM,IAAI,YAAY,YACpB,KACE,gBACA,SACAC,QAA2B,SAAS,uBAAuB,CAC7D,CACF,GACA,MAAM,UACR,CACJ;AACF;AAEA,MAAa,QACX,gBACA,MACA,sBAA4E,CAAC,MAClD;CAO3B,OANwB,MAAM,MAAM,KAAK,kBAAkB,CAAC,CAAC,KAC3D,MAAM,KAAK,gBAAgB,aAAa,GACxC,MAAM,KAAK,kBAAkB,qBAAqB,GAClD,MAAM,UAGa,CAAC,CACpB,mBAAmB,gBAAgB;EACjC,MAAM,KAAK;EACX,oBAAoB,KAAK;EACzB,MAAM,KAAK;EACX,SAAS,KAAK;EACd,OAAO,KAAK;EACZ,SAAS,KAAK;EACd;CACF,CAAC,CACH;AACF;AAEA,MAAM,sBAQJ,gBACA,EACE,MACA,oBACA,MACA,SACA,OACA,SACA,0BAkBFC,mBAAsC;CACpC,OAAO,eAAe,OAAO;CAC7B;CACA;CACA;CACA;CACA;CACA;CACA;CACA,cAAc,QACZ,MAAM,SACJC,YAA+B,gBAAgB,GAAG,GAClD,aAAa,KACf;AACJ,CAAC"}

package/dist/Registry.d.ts

@@ -0,0 +1,12 @@
+import * as Context from "effect/Context";
+import * as Ref from "effect/Ref";
+import type { RegistryItems } from "./RegistryItems";
+/**
+ * Effect `Context.Reference` shared by everything that touches a group's
+ * registry—`FunctionImpl`/`MiddlewareImpl` initializers write to it,
+ * `RegisteredFunctions` reads it, and the CLI's impl validation inspects it—all
+ * through this one tag, without relying on Effect's global default-value cache
+ * to align separately-defined tags by string key.
+ */
+export declare const Registry: Context.Reference<Ref.Ref<RegistryItems>>;
+//# sourceMappingURL=Registry.d.ts.map

package/dist/Registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.d.ts","sourceRoot":"","sources":["../src/Registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,GAAG,MAAM,YAAY,CAAC;AAClC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,2CAKpB,CAAC"}

package/dist/Registry.js

@@ -0,0 +1,17 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Ref from "effect/Ref";
+//#region src/Registry.ts
+var Registry_exports = /* @__PURE__ */ __exportAll({ Registry: () => Registry });
+/**
+* Effect `Context.Reference` shared by everything that touches a group's
+* registry—`FunctionImpl`/`MiddlewareImpl` initializers write to it,
+* `RegisteredFunctions` reads it, and the CLI's impl validation inspects it—all
+* through this one tag, without relying on Effect's global default-value cache
+* to align separately-defined tags by string key.
+*/
+const Registry = Context.Reference("@confect/server/Registry", { defaultValue: () => Ref.makeUnsafe({}) });
+//#endregion
+export { Registry, Registry_exports };
+
+//# sourceMappingURL=Registry.js.map

package/dist/Registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.js","names":[],"sources":["../src/Registry.ts"],"sourcesContent":["import * as Context from \"effect/Context\";\nimport * as Ref from \"effect/Ref\";\nimport type { RegistryItems } from \"./RegistryItems\";\n\n/**\n * Effect `Context.Reference` shared by everything that touches a group's\n * registry—`FunctionImpl`/`MiddlewareImpl` initializers write to it,\n * `RegisteredFunctions` reads it, and the CLI's impl validation inspects it—all\n * through this one tag, without relying on Effect's global default-value cache\n * to align separately-defined tags by string key.\n */\nexport const Registry = Context.Reference<Ref.Ref<RegistryItems>>(\n  \"@confect/server/Registry\",\n  {\n    defaultValue: () => Ref.makeUnsafe<RegistryItems>({}),\n  },\n);\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,WAAW,QAAQ,UAC9B,4BACA,EACE,oBAAoB,IAAI,WAA0B,CAAC,CAAC,EACtD,CACF"}

package/dist/RegistryItems.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Runtime tree that mirrors a `Spec`'s group structure. Values remain unknown
+ * at this boundary so producers and consumers can narrow branches and registry
+ * items as needed.
+ */
+export interface RegistryItems {
+    readonly [key: string]: unknown;
+}
+/**
+ * The names of the function-shaped entries in a group's (flat, isolated)
+ * registry. `FunctionImpl.make` registers each function under a single-segment
+ * key, so the registry built for one group contains exactly that group's
+ * functions at the top level.
+ */
+export declare const functionNames: (items: RegistryItems) => ReadonlyArray<string>;
+/**
+ * The keys of the middleware implementations registered into a group's registry
+ * (stored under `middleware:<key>` entries by `MiddlewareImpl`).
+ */
+export declare const middlewareKeys: (items: RegistryItems) => ReadonlyArray<string>;
+//# sourceMappingURL=RegistryItems.d.ts.map

package/dist/RegistryItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegistryItems.d.ts","sourceRoot":"","sources":["../src/RegistryItems.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,UAAW,aAAa,KAAG,aAAa,CAAC,MAAM,CAOtE,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,cAAc,UAAW,aAAa,KAAG,aAAa,CAAC,MAAM,CAKvE,CAAC"}