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

package/dist/Document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Document.js","names":[],"sources":["../src/Document.ts"],"sourcesContent":["import type { ReadonlyValue } from \"@confect/core/SchemaToValidator\";\nimport { pipe } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Function from \"effect/Function\";\nimport * as Schema from \"effect/Schema\";\nimport type { ReadonlyRecord } from \"effect/Record\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport type * as TableInfo from \"./TableInfo\";\nimport type * as Table from \"./Table\";\n\nexport type Document<\n  Schema_ extends DatabaseSchema.AnyWithProps,\n  TableName extends DatabaseSchema.TableNames<Schema_>,\n> = DataModel.DocumentByName<DataModel.FromSchema<Schema_>, TableName>;\n\nexport type WithoutSystemFields<Doc> = Doc extends unknown\n  ? Omit<Doc, \"_creationTime\" | \"_id\">\n  : never;\n\nexport type Any = any;\nexport type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;\n\nexport const decode = Function.dual<\n  <Table_ extends Table.AnyWithProps>(\n    table: Table_,\n  ) => (\n    self: TableInfo.TableInfo<Table_>[\"convexDocument\"],\n  ) => Effect.Effect<\n    TableInfo.TableInfo<Table_>[\"document\"],\n    DocumentDecodeError\n  >,\n  <Table_ extends Table.AnyWithProps>(\n    self: TableInfo.TableInfo<Table_>[\"convexDocument\"],\n    table: Table_,\n  ) => Effect.Effect<\n    TableInfo.TableInfo<Table_>[\"document\"],\n    DocumentDecodeError\n  >\n>(\n  2,\n  <Table_ extends Table.AnyWithProps>(\n    self: TableInfo.TableInfo<Table_>[\"convexDocument\"],\n    table: Table_,\n  ): Effect.Effect<\n    TableInfo.TableInfo<Table_>[\"document\"],\n    DocumentDecodeError\n  > =>\n    pipe(\n      self,\n      Schema.decodeUnknownEffect(table.Doc),\n      Effect.catchIf(Schema.isSchemaError, (schemaError) =>\n        Effect.fail(\n          new DocumentDecodeError({\n            tableName: table.tableName,\n            id: self._id,\n            parseError: schemaError.message,\n          }),\n        ),\n      ),\n    ),\n);\n\nexport const encode = Function.dual<\n  <Table_ extends Table.AnyWithProps>(\n    table: Table_,\n  ) => (\n    self: Schema.Schema.Type<Table.Fields<Table_>>,\n  ) => Effect.Effect<\n    Schema.Codec.Encoded<Table.Fields<Table_>>,\n    DocumentEncodeError\n  >,\n  <Table_ extends Table.AnyWithProps>(\n    self: Schema.Schema.Type<Table.Fields<Table_>>,\n    table: Table_,\n  ) => Effect.Effect<\n    Schema.Codec.Encoded<Table.Fields<Table_>>,\n    DocumentEncodeError\n  >\n>(\n  2,\n  <Table_ extends Table.AnyWithProps>(\n    self: Schema.Schema.Type<Table.Fields<Table_>>,\n    table: Table_,\n  ): Effect.Effect<\n    Schema.Codec.Encoded<Table.Fields<Table_>>,\n    DocumentEncodeError\n  > =>\n    pipe(\n      self,\n      Schema.encodeEffect(table.Fields),\n      Effect.catchIf(Schema.isSchemaError, (schemaError) =>\n        Effect.fail(\n          new DocumentEncodeError({\n            tableName: table.tableName,\n            id: self._id,\n            parseError: schemaError.message,\n          }),\n        ),\n      ),\n    ),\n);\n\nexport class DocumentDecodeError extends Schema.TaggedError<DocumentDecodeError>()(\n  \"DocumentDecodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be decoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport class DocumentEncodeError extends Schema.TaggedError<DocumentEncodeError>()(\n  \"DocumentEncodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be encoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport const documentErrorMessage = ({\n  id,\n  tableName,\n  message,\n}: {\n  id: string;\n  tableName: string;\n  message: string;\n}) => `Document with ID '${id}' in table '${tableName}' ${message}`;\n"],"mappings":";;;;;;;;;;;;;AAuBA,MAAa,SAAS,SAAS,KAiB7B,IAEE,MACA,UAKA,KACE,MACA,OAAO,oBAAoB,MAAM,GAAG,GACpC,OAAO,QAAQ,OAAO,gBAAgB,gBACpC,OAAO,KACL,IAAI,oBAAoB;CACtB,WAAW,MAAM;CACjB,IAAI,KAAK;CACT,YAAY,YAAY;AAC1B,CAAC,CACH,CACF,CACF,CACJ;AAEA,MAAa,SAAS,SAAS,KAiB7B,IAEE,MACA,UAKA,KACE,MACA,OAAO,aAAa,MAAM,MAAM,GAChC,OAAO,QAAQ,OAAO,gBAAgB,gBACpC,OAAO,KACL,IAAI,oBAAoB;CACtB,WAAW,MAAM;CACjB,IAAI,KAAK;CACT,YAAY,YAAY;AAC1B,CAAC,CACH,CACF,CACF,CACJ;AAEA,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;AACrB,CACF,CAAC,CAAC;CACA,IAAa,UAAkB;EAC7B,OAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;EAC5C,CAAC;CACH;AACF;AAEA,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;AACrB,CACF,CAAC,CAAC;CACA,IAAa,UAAkB;EAC7B,OAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;EAC5C,CAAC;CACH;AACF;AAEA,MAAa,wBAAwB,EACnC,IACA,WACA,cAKI,qBAAqB,GAAG,cAAc,UAAU,IAAI"}

package/dist/ExecutionMetadata.d.ts

@@ -0,0 +1,13 @@
+import type { QueryMeta } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+export type { DeploymentMetadata, FunctionMetadata } from "convex/server";
+declare const ExecutionMetadata_base: Context.ServiceClass<ExecutionMetadata, "@confect/server/ExecutionMetadata", {
+    getFunction: () => Effect.Effect<import("convex/server").FunctionMetadata, never, never>;
+    getDeployment: () => Effect.Effect<import("convex/server").DeploymentMetadata, never, never>;
+}>;
+export declare class ExecutionMetadata extends ExecutionMetadata_base {
+}
+export declare const layer: (meta: Pick<QueryMeta, "getFunctionMetadata" | "getDeploymentMetadata">) => Layer.Layer<ExecutionMetadata, never, never>;
+//# sourceMappingURL=ExecutionMetadata.d.ts.map

package/dist/ExecutionMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionMetadata.d.ts","sourceRoot":"","sources":["../src/ExecutionMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;;;;;AAa1E,qBAAa,iBAAkB,SAAQ,sBAGC;CAAG;AAE3C,eAAO,MAAM,KAAK,SACV,IAAI,CAAC,SAAS,EAAE,qBAAqB,GAAG,uBAAuB,CAAC,iDACvB,CAAC"}

package/dist/ExecutionMetadata.js

@@ -0,0 +1,19 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+//#region src/ExecutionMetadata.ts
+var ExecutionMetadata_exports = /* @__PURE__ */ __exportAll({
+	ExecutionMetadata: () => ExecutionMetadata,
+	layer: () => layer
+});
+const make = (meta) => ({
+	getFunction: Effect.fn("ExecutionMetadata.getFunction")(() => Effect.promise(() => meta.getFunctionMetadata())),
+	getDeployment: Effect.fn("ExecutionMetadata.getDeployment")(() => Effect.promise(() => meta.getDeploymentMetadata()))
+});
+var ExecutionMetadata = class extends Context.Service()("@confect/server/ExecutionMetadata") {};
+const layer = (meta) => Layer.succeed(ExecutionMetadata, make(meta));
+//#endregion
+export { ExecutionMetadata, ExecutionMetadata_exports, layer };
+
+//# sourceMappingURL=ExecutionMetadata.js.map

package/dist/ExecutionMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionMetadata.js","names":[],"sources":["../src/ExecutionMetadata.ts"],"sourcesContent":["import type { QueryMeta } from \"convex/server\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\n\nexport type { DeploymentMetadata, FunctionMetadata } from \"convex/server\";\n\nconst make = (\n  meta: Pick<QueryMeta, \"getFunctionMetadata\" | \"getDeploymentMetadata\">,\n) => ({\n  getFunction: Effect.fn(\"ExecutionMetadata.getFunction\")(() =>\n    Effect.promise(() => meta.getFunctionMetadata()),\n  ),\n  getDeployment: Effect.fn(\"ExecutionMetadata.getDeployment\")(() =>\n    Effect.promise(() => meta.getDeploymentMetadata()),\n  ),\n});\n\nexport class ExecutionMetadata extends Context.Service<\n  ExecutionMetadata,\n  ReturnType<typeof make>\n>()(\"@confect/server/ExecutionMetadata\") {}\n\nexport const layer = (\n  meta: Pick<QueryMeta, \"getFunctionMetadata\" | \"getDeploymentMetadata\">,\n) => Layer.succeed(ExecutionMetadata, make(meta));\n"],"mappings":";;;;;;;;;AAOA,MAAM,QACJ,UACI;CACJ,aAAa,OAAO,GAAG,+BAA+B,CAAC,OACrD,OAAO,cAAc,KAAK,oBAAoB,CAAC,CACjD;CACA,eAAe,OAAO,GAAG,iCAAiC,CAAC,OACzD,OAAO,cAAc,KAAK,sBAAsB,CAAC,CACnD;AACF;AAEA,IAAa,oBAAb,cAAuC,QAAQ,QAG7C,CAAC,CAAC,mCAAmC,CAAC,CAAC,CAAC;AAE1C,MAAa,SACX,SACG,MAAM,QAAQ,mBAAmB,KAAK,IAAI,CAAC"}

package/dist/FunctionImpl.d.ts

@@ -0,0 +1,39 @@
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Handler from "./Handler";
+export interface FunctionImpl<Name_ extends string> {
+    readonly name: Name_;
+}
+export declare const FunctionImpl: <Name_ extends string>({ name }: {
+    name: Name_;
+}) => Context.Service<FunctionImpl<Name_>, FunctionImpl<Name_>>;
+/**
+ * Register a single function's implementation into the group's `Registry`.
+ *
+ * The function is registered under a flat, single-segment key (its own `name`),
+ * not a project-wide dot-path. Each group's impl layer is built in
+ * isolation—`RegisteredFunctions.buildForGroup` (and the CLI's `validateImpl`)
+ * provide a fresh `Registry` per group—so function names only need to be unique
+ * within their own group.
+ *
+ * `databaseSchema` is retained purely as a type-level carrier: the handler's
+ * ctx-service requirements (`DatabaseReader`, `QueryCtx<DataModel>`, …) are
+ * derived from it via `Handler.WithName`. It is not read at runtime—the
+ * generated per-group registry forwards the schema value to the function
+ * builders—so impls depend on `_generated/schema` (table schemas) rather than
+ * `_generated/api` (which transitively imports every function spec).
+ */
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Group extends GroupSpec.AnyWithProps, const Name_ extends FunctionSpec.Name<GroupSpec.Functions<Group>>>(_databaseSchema: DatabaseSchema_, group: Group, name: Name_, handler: Handler.WithName<DatabaseSchema_, GroupSpec.Functions<Group>, Name_, MiddlewareSpec.Provides<GroupSpec.MiddlewareSpecs<Group> | FunctionSpec.MiddlewareSpecs<FunctionSpec.WithName<GroupSpec.Functions<Group>, Name_>>>>) => Layer.Layer<FunctionImpl<Name_>>;
+/**
+ * Get the function implementation service type for a specific function name.
+ */
+export type ForFunction<Name_ extends string> = FunctionImpl<Name_>;
+/**
+ * Get all function implementation services required for a group spec.
+ */
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionSpec.Name<GroupSpec.Functions<Group>> extends infer FunctionNames extends string ? FunctionNames extends string ? FunctionImpl<FunctionNames> : never : never;
+//# sourceMappingURL=FunctionImpl.d.ts.map

package/dist/FunctionImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionImpl.d.ts","sourceRoot":"","sources":["../src/FunctionImpl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,KAAK,cAAc,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,CAAC;AAI1C,MAAM,WAAW,YAAY,CAAC,KAAK,SAAS,MAAM;IAChD,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,GAAI,KAAK,SAAS,MAAM,YAAY;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,8DACE,CAAC;AAE/E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GACf,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,KAAK,SAAS,SAAS,CAAC,YAAY,EACpC,KAAK,CAAC,KAAK,SAAS,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,mBAEhD,eAAe,SACzB,KAAK,QACN,KAAK,WACF,OAAO,CAAC,QAAQ,CACvB,eAAe,EACf,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,EAC1B,KAAK,EACL,cAAc,CAAC,QAAQ,CACnB,SAAS,CAAC,eAAe,CAAC,KAAK,CAAC,GAChC,YAAY,CAAC,eAAe,CAC1B,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CACzD,CACJ,CACF,KACA,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAuBjC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,KAAK,SAAS,MAAM,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAC5D,YAAY,CAAC,IAAI,CACf,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAC3B,SAAS,MAAM,aAAa,SAAS,MAAM,GACxC,aAAa,SAAS,MAAM,GAC1B,YAAY,CAAC,aAAa,CAAC,GAC3B,KAAK,GACP,KAAK,CAAC"}

package/dist/FunctionImpl.js

@@ -0,0 +1,46 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Registry } from "./Registry.js";
+import { make as make$1 } from "./FunctionRegistryItem.js";
+import { setNestedProperty } from "./internal/utils.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/FunctionImpl.ts
+var FunctionImpl_exports = /* @__PURE__ */ __exportAll({
+	FunctionImpl: () => FunctionImpl,
+	make: () => make
+});
+const FunctionImpl = ({ name }) => Context.Service(`@confect/server/FunctionImpl/${name}`);
+/**
+* Register a single function's implementation into the group's `Registry`.
+*
+* The function is registered under a flat, single-segment key (its own `name`),
+* not a project-wide dot-path. Each group's impl layer is built in
+* isolation—`RegisteredFunctions.buildForGroup` (and the CLI's `validateImpl`)
+* provide a fresh `Registry` per group—so function names only need to be unique
+* within their own group.
+*
+* `databaseSchema` is retained purely as a type-level carrier: the handler's
+* ctx-service requirements (`DatabaseReader`, `QueryCtx<DataModel>`, …) are
+* derived from it via `Handler.WithName`. It is not read at runtime—the
+* generated per-group registry forwards the schema value to the function
+* builders—so impls depend on `_generated/schema` (table schemas) rather than
+* `_generated/api` (which transitively imports every function spec).
+*/
+const make = (_databaseSchema, group, name, handler) => {
+	const functionSpec = group.functions[name];
+	return Layer.effect(FunctionImpl({ name }), Effect.gen(function* () {
+		const registry = yield* Registry;
+		yield* Ref.update(registry, (registryItems) => setNestedProperty(registryItems, [name], make$1({
+			functionSpec,
+			groupMiddlewareAttachments: group.middlewareAttachments,
+			handler
+		})));
+		return { name };
+	}));
+};
+//#endregion
+export { FunctionImpl, FunctionImpl_exports, make };
+
+//# sourceMappingURL=FunctionImpl.js.map

package/dist/FunctionImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionImpl.js","names":["Registry.Registry","FunctionRegistryItem.make"],"sources":["../src/FunctionImpl.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as MiddlewareSpec from \"@confect/core/MiddlewareSpec\";\nimport * as Registry from \"./Registry\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Ref from \"effect/Ref\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as Handler from \"./Handler\";\nimport { setNestedProperty } from \"./internal/utils\";\nimport * as FunctionRegistryItem from \"./FunctionRegistryItem\";\n\nexport interface FunctionImpl<Name_ extends string> {\n  readonly name: Name_;\n}\n\nexport const FunctionImpl = <Name_ extends string>({ name }: { name: Name_ }) =>\n  Context.Service<FunctionImpl<Name_>>(`@confect/server/FunctionImpl/${name}`);\n\n/**\n * Register a single function's implementation into the group's `Registry`.\n *\n * The function is registered under a flat, single-segment key (its own `name`),\n * not a project-wide dot-path. Each group's impl layer is built in\n * isolation—`RegisteredFunctions.buildForGroup` (and the CLI's `validateImpl`)\n * provide a fresh `Registry` per group—so function names only need to be unique\n * within their own group.\n *\n * `databaseSchema` is retained purely as a type-level carrier: the handler's\n * ctx-service requirements (`DatabaseReader`, `QueryCtx<DataModel>`, …) are\n * derived from it via `Handler.WithName`. It is not read at runtime—the\n * generated per-group registry forwards the schema value to the function\n * builders—so impls depend on `_generated/schema` (table schemas) rather than\n * `_generated/api` (which transitively imports every function spec).\n */\nexport const make = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Group extends GroupSpec.AnyWithProps,\n  const Name_ extends FunctionSpec.Name<GroupSpec.Functions<Group>>,\n>(\n  _databaseSchema: DatabaseSchema_,\n  group: Group,\n  name: Name_,\n  handler: Handler.WithName<\n    DatabaseSchema_,\n    GroupSpec.Functions<Group>,\n    Name_,\n    MiddlewareSpec.Provides<\n      | GroupSpec.MiddlewareSpecs<Group>\n      | FunctionSpec.MiddlewareSpecs<\n          FunctionSpec.WithName<GroupSpec.Functions<Group>, Name_>\n        >\n    >\n  >,\n): Layer.Layer<FunctionImpl<Name_>> => {\n  const functionSpec = group.functions[name]!;\n\n  return Layer.effect(\n    FunctionImpl<Name_>({ name }),\n    Effect.gen(function* () {\n      const registry = yield* Registry.Registry;\n\n      yield* Ref.update(registry, (registryItems) =>\n        setNestedProperty(\n          registryItems,\n          [name],\n          FunctionRegistryItem.make({\n            functionSpec,\n            groupMiddlewareAttachments: group.middlewareAttachments,\n            handler,\n          }),\n        ),\n      );\n\n      return { name };\n    }),\n  );\n};\n\n/**\n * Get the function implementation service type for a specific function name.\n */\nexport type ForFunction<Name_ extends string> = FunctionImpl<Name_>;\n\n/**\n * Get all function implementation services required for a group spec.\n */\nexport type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =\n  FunctionSpec.Name<\n    GroupSpec.Functions<Group>\n  > extends infer FunctionNames extends string\n    ? FunctionNames extends string\n      ? FunctionImpl<FunctionNames>\n      : never\n    : never;\n"],"mappings":";;;;;;;;;;;;;AAiBA,MAAa,gBAAsC,EAAE,WACnD,QAAQ,QAA6B,gCAAgC,MAAM;;;;;;;;;;;;;;;;;AAkB7E,MAAa,QAKX,iBACA,OACA,MACA,YAWqC;CACrC,MAAM,eAAe,MAAM,UAAU;CAErC,OAAO,MAAM,OACX,aAAoB,EAAE,KAAK,CAAC,GAC5B,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,OAAOA;EAExB,OAAO,IAAI,OAAO,WAAW,kBAC3B,kBACE,eACA,CAAC,IAAI,GACLC,OAA0B;GACxB;GACA,4BAA4B,MAAM;GAClC;EACF,CAAC,CACH,CACF;EAEA,OAAO,EAAE,KAAK;CAChB,CAAC,CACH;AACF"}

package/dist/FunctionRegistryItem.d.ts

@@ -0,0 +1,36 @@
+import type * as MiddlewareAttachment from "@confect/core/MiddlewareAttachment";
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type { FunctionType, FunctionVisibility } from "convex/server";
+import type * as Schema from "effect/Schema";
+import type * as Handler from "./Handler";
+export declare const TypeId = "~@confect/server/FunctionRegistryItem";
+export type TypeId = typeof TypeId;
+export declare const isFunctionRegistryItem: (value: unknown) => value is AnyWithProps;
+/**
+ * A function registered by `FunctionImpl.make`, one of two shapes keyed by the
+ * spec's provenance.
+ */
+export type AnyWithProps = ConfectFunctionRegistryItem | ConvexFunctionRegistryItem;
+export interface ConfectFunctionRegistryItem {
+    readonly [TypeId]: TypeId;
+    readonly _tag: "Confect";
+    readonly name: string;
+    readonly functionVisibility: FunctionVisibility;
+    readonly functionType: FunctionType;
+    readonly args: Schema.Codec<any, any>;
+    readonly returns: Schema.Codec<any, any>;
+    readonly error?: Schema.Codec<any, any>;
+    readonly middlewareAttachments: ReadonlyArray<MiddlewareAttachment.MiddlewareAttachment>;
+    readonly handler: Handler.AnyConfectProvenance;
+}
+export interface ConvexFunctionRegistryItem {
+    readonly [TypeId]: TypeId;
+    readonly _tag: "Convex";
+    readonly handler: Handler.AnyConvexProvenance;
+}
+export declare const make: ({ functionSpec, groupMiddlewareAttachments, handler, }: {
+    functionSpec: FunctionSpec.AnyWithProps;
+    groupMiddlewareAttachments: ReadonlyArray<MiddlewareAttachment.MiddlewareAttachment>;
+    handler: Handler.Any;
+}) => AnyWithProps;
+//# sourceMappingURL=FunctionRegistryItem.d.ts.map

package/dist/FunctionRegistryItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionRegistryItem.d.ts","sourceRoot":"","sources":["../src/FunctionRegistryItem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,oBAAoB,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGtE,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,CAAC;AAE1C,eAAO,MAAM,MAAM,0CAA0C,CAAC;AAC9D,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,eAAO,MAAM,sBAAsB,UAAW,OAAO,KAAG,KAAK,IAAI,YAC3B,CAAC;AAMvC;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB,2BAA2B,GAC3B,0BAA0B,CAAC;AAE/B,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAChD,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACzC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACxC,QAAQ,CAAC,qBAAqB,EAAE,aAAa,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;IACzF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;CAChD;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,mBAAmB,CAAC;CAC/C;AAED,eAAO,MAAM,IAAI,2DAId;IACD,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC;IACxC,0BAA0B,EAAE,aAAa,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,CAAC;IACrF,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC;CACtB,KAAG,YA8BD,CAAC"}

package/dist/FunctionRegistryItem.js

@@ -0,0 +1,34 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Match from "effect/Match";
+import * as Predicate from "effect/Predicate";
+import * as Lazy from "@confect/core/Lazy";
+//#region src/FunctionRegistryItem.ts
+var FunctionRegistryItem_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	isFunctionRegistryItem: () => isFunctionRegistryItem,
+	make: () => make
+});
+const TypeId = "~@confect/server/FunctionRegistryItem";
+const isFunctionRegistryItem = (value) => Predicate.hasProperty(value, TypeId);
+const FunctionRegistryItemProto = { [TypeId]: TypeId };
+const make = ({ functionSpec, groupMiddlewareAttachments, handler }) => Match.value(functionSpec.functionProvenance).pipe(Match.tag("Convex", () => Object.assign(Object.create(FunctionRegistryItemProto), {
+	_tag: "Convex",
+	handler
+})), Match.tag("Confect", (provenance) => {
+	const item = Object.assign(Object.create(FunctionRegistryItemProto), {
+		_tag: "Confect",
+		name: functionSpec.name,
+		functionVisibility: functionSpec.functionVisibility,
+		functionType: functionSpec.runtimeAndFunctionType.functionType,
+		middlewareAttachments: [...groupMiddlewareAttachments, ...functionSpec.middlewareAttachments],
+		handler
+	});
+	Lazy.defineProperty(item, "args", () => provenance.args);
+	Lazy.defineProperty(item, "returns", () => provenance.returns);
+	if ("error" in provenance) Lazy.defineProperty(item, "error", () => provenance.error);
+	return item;
+}), Match.exhaustive);
+//#endregion
+export { FunctionRegistryItem_exports, TypeId, isFunctionRegistryItem, make };
+
+//# sourceMappingURL=FunctionRegistryItem.js.map

package/dist/FunctionRegistryItem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionRegistryItem.js","names":[],"sources":["../src/FunctionRegistryItem.ts"],"sourcesContent":["import type * as MiddlewareAttachment from \"@confect/core/MiddlewareAttachment\";\nimport type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport * as Lazy from \"@confect/core/Lazy\";\nimport type { FunctionType, FunctionVisibility } from \"convex/server\";\nimport * as Match from \"effect/Match\";\nimport * as Predicate from \"effect/Predicate\";\nimport type * as Schema from \"effect/Schema\";\nimport type * as Handler from \"./Handler\";\n\nexport const TypeId = \"~@confect/server/FunctionRegistryItem\";\nexport type TypeId = typeof TypeId;\n\nexport const isFunctionRegistryItem = (value: unknown): value is AnyWithProps =>\n  Predicate.hasProperty(value, TypeId);\n\nconst FunctionRegistryItemProto = {\n  [TypeId]: TypeId,\n};\n\n/**\n * A function registered by `FunctionImpl.make`, one of two shapes keyed by the\n * spec's provenance.\n */\nexport type AnyWithProps =\n  | ConfectFunctionRegistryItem\n  | ConvexFunctionRegistryItem;\n\nexport interface ConfectFunctionRegistryItem {\n  readonly [TypeId]: TypeId;\n  readonly _tag: \"Confect\";\n  readonly name: string;\n  readonly functionVisibility: FunctionVisibility;\n  readonly functionType: FunctionType;\n  readonly args: Schema.Codec<any, any>;\n  readonly returns: Schema.Codec<any, any>;\n  readonly error?: Schema.Codec<any, any>;\n  readonly middlewareAttachments: ReadonlyArray<MiddlewareAttachment.MiddlewareAttachment>;\n  readonly handler: Handler.AnyConfectProvenance;\n}\n\nexport interface ConvexFunctionRegistryItem {\n  readonly [TypeId]: TypeId;\n  readonly _tag: \"Convex\";\n  readonly handler: Handler.AnyConvexProvenance;\n}\n\nexport const make = ({\n  functionSpec,\n  groupMiddlewareAttachments,\n  handler,\n}: {\n  functionSpec: FunctionSpec.AnyWithProps;\n  groupMiddlewareAttachments: ReadonlyArray<MiddlewareAttachment.MiddlewareAttachment>;\n  handler: Handler.Any;\n}): AnyWithProps =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", (): AnyWithProps =>\n      Object.assign(Object.create(FunctionRegistryItemProto), {\n        _tag: \"Convex\" as const,\n        handler: handler as Handler.AnyConvexProvenance,\n      }),\n    ),\n    Match.tag(\"Confect\", (provenance): AnyWithProps => {\n      const item = Object.assign(Object.create(FunctionRegistryItemProto), {\n        _tag: \"Confect\" as const,\n        name: functionSpec.name,\n        functionVisibility: functionSpec.functionVisibility,\n        functionType: functionSpec.runtimeAndFunctionType.functionType,\n        middlewareAttachments: [\n          ...groupMiddlewareAttachments,\n          ...functionSpec.middlewareAttachments,\n        ],\n        handler: handler as Handler.AnyConfectProvenance,\n      });\n\n      Lazy.defineProperty(item, \"args\", () => provenance.args);\n      Lazy.defineProperty(item, \"returns\", () => provenance.returns);\n      if (\"error\" in provenance) {\n        Lazy.defineProperty(item, \"error\", () => provenance.error);\n      }\n\n      return item as AnyWithProps;\n    }),\n    Match.exhaustive,\n  );\n"],"mappings":";;;;;;;;;;AASA,MAAa,SAAS;AAGtB,MAAa,0BAA0B,UACrC,UAAU,YAAY,OAAO,MAAM;AAErC,MAAM,4BAA4B,GAC/B,SAAS,OACZ;AA6BA,MAAa,QAAQ,EACnB,cACA,4BACA,cAMA,MAAM,MAAM,aAAa,kBAAkB,CAAC,CAAC,KAC3C,MAAM,IAAI,gBACR,OAAO,OAAO,OAAO,OAAO,yBAAyB,GAAG;CACtD,MAAM;CACG;AACX,CAAC,CACH,GACA,MAAM,IAAI,YAAY,eAA6B;CACjD,MAAM,OAAO,OAAO,OAAO,OAAO,OAAO,yBAAyB,GAAG;EACnE,MAAM;EACN,MAAM,aAAa;EACnB,oBAAoB,aAAa;EACjC,cAAc,aAAa,uBAAuB;EAClD,uBAAuB,CACrB,GAAG,4BACH,GAAG,aAAa,qBAClB;EACS;CACX,CAAC;CAED,KAAK,eAAe,MAAM,cAAc,WAAW,IAAI;CACvD,KAAK,eAAe,MAAM,iBAAiB,WAAW,OAAO;CAC7D,IAAI,WAAW,YACb,KAAK,eAAe,MAAM,eAAe,WAAW,KAAK;CAG3D,OAAO;AACT,CAAC,GACD,MAAM,UACR"}

package/dist/GroupImpl.d.ts

@@ -0,0 +1,77 @@
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as FunctionImpl from "./FunctionImpl";
+import type * as MiddlewareImpl from "./MiddlewareImpl";
+export declare const TypeId = "~@confect/server/GroupImpl";
+export type TypeId = typeof TypeId;
+export type FinalizationStatus = "Unfinalized" | "Finalized";
+export interface GroupImpl<FinalizationStatus_ extends FinalizationStatus = "Unfinalized"> {
+    readonly [TypeId]: TypeId;
+    readonly finalizationStatus: FinalizationStatus_;
+    /**
+     * Names of every function registered into this group's layer scope by
+     * `FunctionImpl.make`. Authoritative only when `finalizationStatus` is
+     * `"Finalized"`; the `"Unfinalized"` value is set to `[]` at `make`-time
+     * since the list is only known once `finalize` snapshots the registry.
+     */
+    readonly registeredFunctionNames: ReadonlyArray<string>;
+    /**
+     * Keys of every middleware whose implementation registered into this group's
+     * layer scope via `MiddlewareImpl.make` (and friends). Same authoritativeness
+     * caveat as `registeredFunctionNames`. Lets consumers (the CLI's
+     * `validateImpl`) verify middleware-impl completeness against a `GroupSpec`'s
+     * attached middleware without inspecting the `Registry`.
+     */
+    readonly registeredMiddlewareKeys: ReadonlyArray<string>;
+}
+export interface Any extends GroupImpl<FinalizationStatus> {
+}
+export declare const isGroupImpl: (u: unknown) => u is Any;
+export interface AnyFinalized extends GroupImpl<"Finalized"> {
+}
+export interface AnyUnfinalized extends GroupImpl<"Unfinalized"> {
+}
+export declare const isFinalizedGroupImpl: (u: unknown) => u is AnyFinalized;
+export declare const isUnfinalizedGroupImpl: (u: unknown) => u is AnyUnfinalized;
+/**
+ * Build the runtime tag for a `GroupImpl` service. The finalization status is
+ * embedded in the tag string so that `Unfinalized` and `Finalized` are distinct
+ * services at runtime; consumers of a finalized layer (the server's
+ * `RegisteredFunctions.buildForGroup` and the CLI's `validateImpl`) retrieve
+ * the typed `Finalized` service directly rather than scanning the context.
+ *
+ * The tag is keyed only by finalization status—no group path—because each
+ * group's impl layer is built in its own isolated scope
+ * (`buildForGroup`/`validateImpl` each provide a fresh `Registry`), so at most
+ * one `GroupImpl` service of each status exists per build.
+ */
+export declare const GroupImpl: <FinalizationStatus_ extends FinalizationStatus>({ finalizationStatus, }: {
+    finalizationStatus: FinalizationStatus_;
+}) => Context.Service<GroupImpl<FinalizationStatus_>, GroupImpl<FinalizationStatus_>>;
+/**
+ * Begin a group's impl layer. `databaseSchema` and `group` are retained only as
+ * type-level carriers (`group` drives the required `FunctionImpl` services via
+ * `FromGroupSpec<Group>`; `databaseSchema` keeps the impl's dependency on
+ * `_generated/schema` symmetric with `FunctionImpl.make`). Neither is read at
+ * runtime.
+ */
+export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps, Group extends GroupSpec.AnyWithProps>(_databaseSchema: DatabaseSchema_, _group: Group & MiddlewareSpec.ValidateImplRequires<GroupSpec.Functions<Group>, GroupSpec.MiddlewareSpecs<Group>>) => Layer.Layer<GroupImpl<"Unfinalized">, never, FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>>;
+/**
+ * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
+ * `RIn = never`, so passing a layer that still requires any `FunctionImpl`
+ * service produces a type error at the impl author's site. The codegen boundary
+ * requires the resulting `"Finalized"` brand, so omitting this call is also
+ * rejected downstream.
+ *
+ * As a side effect of finalization, the names of every `FunctionImpl` that
+ * registered into this group's scope are snapshotted onto the produced service
+ * value's `registeredFunctionNames` field, so consumers can verify impl
+ * completeness against a `GroupSpec`'s expected functions without having to
+ * inspect the `Registry` themselves.
+ */
+export declare const finalize: (group: Layer.Layer<GroupImpl<"Unfinalized">>) => Layer.Layer<GroupImpl<"Finalized">>;
+export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>;
+//# sourceMappingURL=GroupImpl.d.ts.map

package/dist/GroupImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupImpl.d.ts","sourceRoot":"","sources":["../src/GroupImpl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,KAAK,cAAc,MAAM,8BAA8B,CAAC;AAIpE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,YAAY,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AAExD,eAAO,MAAM,MAAM,+BAA+B,CAAC;AACnD,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG,WAAW,CAAC;AAE7D,MAAM,WAAW,SAAS,CACxB,mBAAmB,SAAS,kBAAkB,GAAG,aAAa;IAE9D,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,mBAAmB,CAAC;IACjD;;;;;OAKG;IACH,QAAQ,CAAC,uBAAuB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxD;;;;;;OAMG;IACH,QAAQ,CAAC,wBAAwB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,GAAI,SAAQ,SAAS,CAAC,kBAAkB,CAAC;CAAG;AAE7D,eAAO,MAAM,WAAW,MAAO,OAAO,KAAG,CAAC,IAAI,GACZ,CAAC;AAEnC,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,WAAW,CAAC;CAAG;AAC/D,MAAM,WAAW,cAAe,SAAQ,SAAS,CAAC,aAAa,CAAC;CAAG;AAEnE,eAAO,MAAM,oBAAoB,MAAO,OAAO,KAAG,CAAC,IAAI,YACC,CAAC;AAEzD,eAAO,MAAM,sBAAsB,MAAO,OAAO,KAAG,CAAC,IAAI,cACC,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,GAAI,mBAAmB,SAAS,kBAAkB,2BAErE;IACD,kBAAkB,EAAE,mBAAmB,CAAC;CACzC,oFAGE,CAAC;AAEJ;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GACf,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,KAAK,SAAS,SAAS,CAAC,YAAY,mBAEnB,eAAe,UACxB,KAAK,GACX,cAAc,CAAC,oBAAoB,CACjC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,EAC1B,SAAS,CAAC,eAAe,CAAC,KAAK,CAAC,CACjC,KACF,KAAK,CAAC,KAAK,CACZ,SAAS,CAAC,aAAa,CAAC,EACxB,KAAK,EACL,YAAY,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,cAAc,CAAC,aAAa,CAAC,KAAK,CAAC,CActE,CAAC;AAOJ;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,UACZ,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,KAC3C,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CA6BlC,CAAC;AAEJ,MAAM,MAAM,aAAa,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAC1D,YAAY,CAAC,aAAa,CAAC,KAAK,CAAC,GACjC,cAAc,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC"}

package/dist/GroupImpl.js

@@ -0,0 +1,81 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { Registry } from "./Registry.js";
+import { functionNames, middlewareKeys } from "./RegistryItems.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Array from "effect/Array";
+import * as Predicate from "effect/Predicate";
+import * as Ref from "effect/Ref";
+//#region src/GroupImpl.ts
+var GroupImpl_exports = /* @__PURE__ */ __exportAll({
+	GroupImpl: () => GroupImpl,
+	TypeId: () => TypeId,
+	finalize: () => finalize,
+	isFinalizedGroupImpl: () => isFinalizedGroupImpl,
+	isGroupImpl: () => isGroupImpl,
+	isUnfinalizedGroupImpl: () => isUnfinalizedGroupImpl,
+	make: () => make
+});
+const TypeId = "~@confect/server/GroupImpl";
+const isGroupImpl = (u) => Predicate.hasProperty(u, TypeId);
+const isFinalizedGroupImpl = (u) => isGroupImpl(u) && u.finalizationStatus === "Finalized";
+const isUnfinalizedGroupImpl = (u) => isGroupImpl(u) && u.finalizationStatus === "Unfinalized";
+/**
+* Build the runtime tag for a `GroupImpl` service. The finalization status is
+* embedded in the tag string so that `Unfinalized` and `Finalized` are distinct
+* services at runtime; consumers of a finalized layer (the server's
+* `RegisteredFunctions.buildForGroup` and the CLI's `validateImpl`) retrieve
+* the typed `Finalized` service directly rather than scanning the context.
+*
+* The tag is keyed only by finalization status—no group path—because each
+* group's impl layer is built in its own isolated scope
+* (`buildForGroup`/`validateImpl` each provide a fresh `Registry`), so at most
+* one `GroupImpl` service of each status exists per build.
+*/
+const GroupImpl = ({ finalizationStatus }) => Context.Service(`@confect/server/GroupImpl/${finalizationStatus}`);
+/**
+* Begin a group's impl layer. `databaseSchema` and `group` are retained only as
+* type-level carriers (`group` drives the required `FunctionImpl` services via
+* `FromGroupSpec<Group>`; `databaseSchema` keeps the impl's dependency on
+* `_generated/schema` symmetric with `FunctionImpl.make`). Neither is read at
+* runtime.
+*/
+const make = (_databaseSchema, _group) => Layer.succeed(GroupImpl({ finalizationStatus: "Unfinalized" }), {
+	[TypeId]: TypeId,
+	finalizationStatus: "Unfinalized",
+	registeredFunctionNames: [],
+	registeredMiddlewareKeys: []
+});
+const findUnfinalizedGroupImpl = (context) => Array.findFirst(context.mapUnsafe.values(), isUnfinalizedGroupImpl);
+/**
+* Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
+* `RIn = never`, so passing a layer that still requires any `FunctionImpl`
+* service produces a type error at the impl author's site. The codegen boundary
+* requires the resulting `"Finalized"` brand, so omitting this call is also
+* rejected downstream.
+*
+* As a side effect of finalization, the names of every `FunctionImpl` that
+* registered into this group's scope are snapshotted onto the produced service
+* value's `registeredFunctionNames` field, so consumers can verify impl
+* completeness against a `GroupSpec`'s expected functions without having to
+* inspect the `Registry` themselves.
+*/
+const finalize = (group) => Layer.flatMap(group, (context) => findUnfinalizedGroupImpl(context).pipe(Option.match({
+	onNone: () => Layer.effect(GroupImpl({ finalizationStatus: "Finalized" }), Effect.die(/* @__PURE__ */ new Error("GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context."))),
+	onSome: () => Layer.effect(GroupImpl({ finalizationStatus: "Finalized" }), Effect.gen(function* () {
+		const registry = yield* Registry;
+		const items = yield* Ref.get(registry);
+		return {
+			[TypeId]: TypeId,
+			finalizationStatus: "Finalized",
+			registeredFunctionNames: functionNames(items),
+			registeredMiddlewareKeys: middlewareKeys(items)
+		};
+	}))
+})));
+//#endregion
+export { GroupImpl, GroupImpl_exports, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
+
+//# sourceMappingURL=GroupImpl.js.map

package/dist/GroupImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupImpl.js","names":["Registry.Registry","RegistryItems.functionNames","RegistryItems.middlewareKeys"],"sources":["../src/GroupImpl.ts"],"sourcesContent":["import type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as MiddlewareSpec from \"@confect/core/MiddlewareSpec\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItems from \"./RegistryItems\";\nimport * as Array from \"effect/Array\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Option from \"effect/Option\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Ref from \"effect/Ref\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as FunctionImpl from \"./FunctionImpl\";\nimport type * as MiddlewareImpl from \"./MiddlewareImpl\";\n\nexport const TypeId = \"~@confect/server/GroupImpl\";\nexport type TypeId = typeof TypeId;\n\nexport type FinalizationStatus = \"Unfinalized\" | \"Finalized\";\n\nexport interface GroupImpl<\n  FinalizationStatus_ extends FinalizationStatus = \"Unfinalized\",\n> {\n  readonly [TypeId]: TypeId;\n  readonly finalizationStatus: FinalizationStatus_;\n  /**\n   * Names of every function registered into this group's layer scope by\n   * `FunctionImpl.make`. Authoritative only when `finalizationStatus` is\n   * `\"Finalized\"`; the `\"Unfinalized\"` value is set to `[]` at `make`-time\n   * since the list is only known once `finalize` snapshots the registry.\n   */\n  readonly registeredFunctionNames: ReadonlyArray<string>;\n  /**\n   * Keys of every middleware whose implementation registered into this group's\n   * layer scope via `MiddlewareImpl.make` (and friends). Same authoritativeness\n   * caveat as `registeredFunctionNames`. Lets consumers (the CLI's\n   * `validateImpl`) verify middleware-impl completeness against a `GroupSpec`'s\n   * attached middleware without inspecting the `Registry`.\n   */\n  readonly registeredMiddlewareKeys: ReadonlyArray<string>;\n}\n\nexport interface Any extends GroupImpl<FinalizationStatus> {}\n\nexport const isGroupImpl = (u: unknown): u is Any =>\n  Predicate.hasProperty(u, TypeId);\n\nexport interface AnyFinalized extends GroupImpl<\"Finalized\"> {}\nexport interface AnyUnfinalized extends GroupImpl<\"Unfinalized\"> {}\n\nexport const isFinalizedGroupImpl = (u: unknown): u is AnyFinalized =>\n  isGroupImpl(u) && u.finalizationStatus === \"Finalized\";\n\nexport const isUnfinalizedGroupImpl = (u: unknown): u is AnyUnfinalized =>\n  isGroupImpl(u) && u.finalizationStatus === \"Unfinalized\";\n\n/**\n * Build the runtime tag for a `GroupImpl` service. The finalization status is\n * embedded in the tag string so that `Unfinalized` and `Finalized` are distinct\n * services at runtime; consumers of a finalized layer (the server's\n * `RegisteredFunctions.buildForGroup` and the CLI's `validateImpl`) retrieve\n * the typed `Finalized` service directly rather than scanning the context.\n *\n * The tag is keyed only by finalization status—no group path—because each\n * group's impl layer is built in its own isolated scope\n * (`buildForGroup`/`validateImpl` each provide a fresh `Registry`), so at most\n * one `GroupImpl` service of each status exists per build.\n */\nexport const GroupImpl = <FinalizationStatus_ extends FinalizationStatus>({\n  finalizationStatus,\n}: {\n  finalizationStatus: FinalizationStatus_;\n}) =>\n  Context.Service<GroupImpl<FinalizationStatus_>>(\n    `@confect/server/GroupImpl/${finalizationStatus}`,\n  );\n\n/**\n * Begin a group's impl layer. `databaseSchema` and `group` are retained only as\n * type-level carriers (`group` drives the required `FunctionImpl` services via\n * `FromGroupSpec<Group>`; `databaseSchema` keeps the impl's dependency on\n * `_generated/schema` symmetric with `FunctionImpl.make`). Neither is read at\n * runtime.\n */\nexport const make = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Group extends GroupSpec.AnyWithProps,\n>(\n  _databaseSchema: DatabaseSchema_,\n  _group: Group &\n    MiddlewareSpec.ValidateImplRequires<\n      GroupSpec.Functions<Group>,\n      GroupSpec.MiddlewareSpecs<Group>\n    >,\n): Layer.Layer<\n  GroupImpl<\"Unfinalized\">,\n  never,\n  FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>\n> =>\n  Layer.succeed(\n    GroupImpl<\"Unfinalized\">({ finalizationStatus: \"Unfinalized\" }),\n    {\n      [TypeId]: TypeId,\n      finalizationStatus: \"Unfinalized\" as const,\n      registeredFunctionNames: [],\n      registeredMiddlewareKeys: [],\n    },\n  ) as Layer.Layer<\n    GroupImpl<\"Unfinalized\">,\n    never,\n    FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>\n  >;\n\nconst findUnfinalizedGroupImpl = <S>(\n  context: Context.Context<S>,\n): Option.Option<AnyUnfinalized> =>\n  Array.findFirst(context.mapUnsafe.values(), isUnfinalizedGroupImpl);\n\n/**\n * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults\n * `RIn = never`, so passing a layer that still requires any `FunctionImpl`\n * service produces a type error at the impl author's site. The codegen boundary\n * requires the resulting `\"Finalized\"` brand, so omitting this call is also\n * rejected downstream.\n *\n * As a side effect of finalization, the names of every `FunctionImpl` that\n * registered into this group's scope are snapshotted onto the produced service\n * value's `registeredFunctionNames` field, so consumers can verify impl\n * completeness against a `GroupSpec`'s expected functions without having to\n * inspect the `Registry` themselves.\n */\nexport const finalize = (\n  group: Layer.Layer<GroupImpl<\"Unfinalized\">>,\n): Layer.Layer<GroupImpl<\"Finalized\">> =>\n  Layer.flatMap(group, (context): Layer.Layer<GroupImpl<\"Finalized\">> =>\n    findUnfinalizedGroupImpl(context).pipe(\n      Option.match({\n        onNone: () =>\n          Layer.effect(\n            GroupImpl<\"Finalized\">({ finalizationStatus: \"Finalized\" }),\n            Effect.die(\n              new Error(\n                \"GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.\",\n              ),\n            ),\n          ),\n        onSome: () =>\n          Layer.effect(\n            GroupImpl<\"Finalized\">({ finalizationStatus: \"Finalized\" }),\n            Effect.gen(function* () {\n              const registry = yield* Registry.Registry;\n              const items = yield* Ref.get(registry);\n              return {\n                [TypeId]: TypeId,\n                finalizationStatus: \"Finalized\" as const,\n                registeredFunctionNames: RegistryItems.functionNames(items),\n                registeredMiddlewareKeys: RegistryItems.middlewareKeys(items),\n              };\n            }),\n          ),\n      }),\n    ),\n  );\n\nexport type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =\n  | FunctionImpl.FromGroupSpec<Group>\n  | MiddlewareImpl.FromGroupSpec<Group>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAeA,MAAa,SAAS;AA6BtB,MAAa,eAAe,MAC1B,UAAU,YAAY,GAAG,MAAM;AAKjC,MAAa,wBAAwB,MACnC,YAAY,CAAC,KAAK,EAAE,uBAAuB;AAE7C,MAAa,0BAA0B,MACrC,YAAY,CAAC,KAAK,EAAE,uBAAuB;;;;;;;;;;;;;AAc7C,MAAa,aAA6D,EACxE,yBAIA,QAAQ,QACN,6BAA6B,oBAC/B;;;;;;;;AASF,MAAa,QAIX,iBACA,WAUA,MAAM,QACJ,UAAyB,EAAE,oBAAoB,cAAc,CAAC,GAC9D;EACG,SAAS;CACV,oBAAoB;CACpB,yBAAyB,CAAC;CAC1B,0BAA0B,CAAC;AAC7B,CACF;AAMF,MAAM,4BACJ,YAEA,MAAM,UAAU,QAAQ,UAAU,OAAO,GAAG,sBAAsB;;;;;;;;;;;;;;AAepE,MAAa,YACX,UAEA,MAAM,QAAQ,QAAQ,YACpB,yBAAyB,OAAO,CAAC,CAAC,KAChC,OAAO,MAAM;CACX,cACE,MAAM,OACJ,UAAuB,EAAE,oBAAoB,YAAY,CAAC,GAC1D,OAAO,oBACL,IAAI,MACF,wFACF,CACF,CACF;CACF,cACE,MAAM,OACJ,UAAuB,EAAE,oBAAoB,YAAY,CAAC,GAC1D,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,OAAOA;EACxB,MAAM,QAAQ,OAAO,IAAI,IAAI,QAAQ;EACrC,OAAO;IACJ,SAAS;GACV,oBAAoB;GACpB,yBAAyBC,cAA4B,KAAK;GAC1D,0BAA0BC,eAA6B,KAAK;EAC9D;CACF,CAAC,CACH;AACJ,CAAC,CACH,CACF"}

package/dist/GroupRegistry.d.ts

@@ -0,0 +1,8 @@
+import type * as Layer from "effect/Layer";
+import type * as GroupImpl from "./GroupImpl";
+import * as MiddlewareRegistryItem from "./MiddlewareRegistryItem";
+export declare const make: (groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>) => {
+    functionRegistryItems: Record<string, unknown>;
+    middlewareRegistryItems: Map<string, MiddlewareRegistryItem.MiddlewareRegistryItem>;
+};
+//# sourceMappingURL=GroupRegistry.d.ts.map

package/dist/GroupRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupRegistry.d.ts","sourceRoot":"","sources":["../src/GroupRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAI3C,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,sBAAsB,MAAM,0BAA0B,CAAC;AAEnE,eAAO,MAAM,IAAI,eACH,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;;;CAe1D,CAAC"}

package/dist/GroupRegistry.js

@@ -0,0 +1,26 @@
+import { Registry } from "./Registry.js";
+import { isMiddlewareRegistryItem } from "./MiddlewareRegistryItem.js";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+//#region src/GroupRegistry.ts
+const make = (groupLayer) => {
+	const registryItems = Effect.gen(function* () {
+		const registry = yield* Registry;
+		return yield* Ref.get(registry);
+	}).pipe(Effect.provide(groupLayer), Effect.provideService(Registry, Ref.makeUnsafe({})), Effect.runSync);
+	return partitionRegistryItems(registryItems);
+};
+const partitionRegistryItems = (registryItems) => {
+	const middlewareRegistryItems = /* @__PURE__ */ new Map();
+	const functionRegistryItems = {};
+	for (const [key, value] of Object.entries(registryItems)) if (isMiddlewareRegistryItem(value)) middlewareRegistryItems.set(value.middlewareSpec.key, value);
+	else functionRegistryItems[key] = value;
+	return {
+		functionRegistryItems,
+		middlewareRegistryItems
+	};
+};
+//#endregion
+export { make };
+
+//# sourceMappingURL=GroupRegistry.js.map

package/dist/GroupRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupRegistry.js","names":["Registry.Registry","MiddlewareRegistryItem.isMiddlewareRegistryItem"],"sources":["../src/GroupRegistry.ts"],"sourcesContent":["import * as Effect from \"effect/Effect\";\nimport type * as Layer from \"effect/Layer\";\nimport * as Ref from \"effect/Ref\";\nimport * as Registry from \"./Registry\";\nimport type * as RegistryItems from \"./RegistryItems\";\nimport type * as GroupImpl from \"./GroupImpl\";\nimport * as MiddlewareRegistryItem from \"./MiddlewareRegistryItem\";\n\nexport const make = (\n  groupLayer: Layer.Layer<GroupImpl.GroupImpl<\"Finalized\">>,\n) => {\n  const registryItems = Effect.gen(function* () {\n    const registry = yield* Registry.Registry;\n    return yield* Ref.get(registry);\n  }).pipe(\n    Effect.provide(groupLayer),\n    Effect.provideService(\n      Registry.Registry,\n      Ref.makeUnsafe<RegistryItems.RegistryItems>({}),\n    ),\n    Effect.runSync,\n  );\n\n  return partitionRegistryItems(registryItems);\n};\n\nconst partitionRegistryItems = (registryItems: RegistryItems.RegistryItems) => {\n  const middlewareRegistryItems = new Map<\n    string,\n    MiddlewareRegistryItem.MiddlewareRegistryItem\n  >();\n  const functionRegistryItems: Record<string, unknown> = {};\n  for (const [key, value] of Object.entries(registryItems)) {\n    if (MiddlewareRegistryItem.isMiddlewareRegistryItem(value)) {\n      middlewareRegistryItems.set(value.middlewareSpec.key, value);\n    } else {\n      functionRegistryItems[key] = value;\n    }\n  }\n  return { functionRegistryItems, middlewareRegistryItems };\n};\n"],"mappings":";;;;;AAQA,MAAa,QACX,eACG;CACH,MAAM,gBAAgB,OAAO,IAAI,aAAa;EAC5C,MAAM,WAAW,OAAOA;EACxB,OAAO,OAAO,IAAI,IAAI,QAAQ;CAChC,CAAC,CAAC,CAAC,KACD,OAAO,QAAQ,UAAU,GACzB,OAAO,eACLA,UACA,IAAI,WAAwC,CAAC,CAAC,CAChD,GACA,OAAO,OACT;CAEA,OAAO,uBAAuB,aAAa;AAC7C;AAEA,MAAM,0BAA0B,kBAA+C;CAC7E,MAAM,0CAA0B,IAAI,IAGlC;CACF,MAAM,wBAAiD,CAAC;CACxD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,aAAa,GACrD,IAAIC,yBAAgD,KAAK,GACvD,wBAAwB,IAAI,MAAM,eAAe,KAAK,KAAK;MAE3D,sBAAsB,OAAO;CAGjC,OAAO;EAAE;EAAuB;CAAwB;AAC1D"}

package/dist/Handler.d.ts

@@ -0,0 +1,47 @@
+import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
+import type * as NodeServices from "@effect/platform-node/NodeServices";
+import type { Effect } from "effect";
+import type * as ActionCtx from "./ActionCtx";
+import type * as ActionRunner from "./ActionRunner";
+import type * as Auth from "./Auth";
+import type * as DatabaseReader from "./DatabaseReader";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DatabaseWriter from "./DatabaseWriter";
+import type * as DataModel from "./DataModel";
+import type { ExecutionMetadata } from "./ExecutionMetadata";
+import type { RequestMetadata } from "./RequestMetadata";
+import type { TransactionMetadata } from "./TransactionMetadata";
+import type * as MutationCtx from "./MutationCtx";
+import type * as MutationRunner from "./MutationRunner";
+import type { MutationTransactionContext } from "./MutationTransactionContext";
+import type * as QueryCtx from "./QueryCtx";
+import type * as QueryRunner from "./QueryRunner";
+import type { QueryTransactionContext } from "./QueryTransactionContext";
+import type * as RegisteredFunction from "./RegisteredFunction";
+import type * as Scheduler from "./Scheduler";
+import type { Storage } from "./Storage";
+import type * as StorageActionWriter from "./StorageActionWriter";
+import type * as StorageReader from "./StorageReader";
+import type * as StorageWriter from "./StorageWriter";
+import type * as VectorSearch from "./VectorSearch";
+export type Handler<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithProps, R = never> = FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConvex> ? ConvexProvenanceHandler<FunctionSpec_> : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConfect> ? ConfectProvenanceHandler<DatabaseSchema_, FunctionSpec_, R> : never;
+type ConvexProvenanceHandler<FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConvex>> = RegisteredFunction.ConvexRegisteredFunction<FunctionSpec_>;
+type ConfectProvenanceHandler<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConfect>, R = never> = FunctionSpec_ extends FunctionSpec.WithFunctionType<FunctionSpec_, "query"> ? ConfectProvenanceQuery<DatabaseSchema_, FunctionSpec_, R> : FunctionSpec_ extends FunctionSpec.WithFunctionType<FunctionSpec_, "mutation"> ? ConfectProvenanceMutation<DatabaseSchema_, FunctionSpec_, R> : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<FunctionSpec_, RuntimeAndFunctionType.ConvexAction> ? ConvexRuntimeAction<DatabaseSchema_, FunctionSpec_, R> : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<FunctionSpec_, RuntimeAndFunctionType.NodeAction> ? NodeRuntimeAction<DatabaseSchema_, FunctionSpec_, R> : never;
+export type QueryServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = DatabaseReader.DatabaseReader<DatabaseSchema_> | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Auth.Auth) | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | ExecutionMetadata | TransactionMetadata | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Storage) | QueryRunner.QueryRunner | QueryTransactionContext | QueryCtx.QueryCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>, DatabaseSchema.Scope<DatabaseSchema_>>;
+export type MutationServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = DatabaseReader.DatabaseReader<DatabaseSchema_> | DatabaseWriter.DatabaseWriter<DatabaseSchema_> | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Auth.Auth) | Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | StorageWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | ExecutionMetadata | TransactionMetadata | RequestMetadata | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Storage) | QueryRunner.QueryRunner | MutationRunner.MutationRunner | QueryTransactionContext | MutationTransactionContext | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>, DatabaseSchema.Scope<DatabaseSchema_>>;
+/**
+ * Shared by both action runtimes.
+ */
+export type ActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Auth.Auth) | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | StorageWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | StorageActionWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>> | ExecutionMetadata | RequestMetadata | (DatabaseSchema_["target"]["kind"] extends "component" ? never : Storage) | QueryRunner.QueryRunner | MutationRunner.MutationRunner | ActionRunner.ActionRunner | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>> | ActionCtx.ActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>, DatabaseSchema.Scope<DatabaseSchema_>>;
+export type ConfectProvenanceQuery<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyQuery>, R = never> = Base<FunctionSpec_, QueryServices<DatabaseSchema_> | R>;
+export type ConfectProvenanceMutation<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyMutation>, R = never> = Base<FunctionSpec_, MutationServices<DatabaseSchema_> | R>;
+export type ConvexRuntimeAction<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyAction>, R = never> = Base<FunctionSpec_, ActionServices<DatabaseSchema_> | R>;
+export type NodeRuntimeAction<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.NodeAction>, R = never> = Base<FunctionSpec_, ActionServices<DatabaseSchema_> | NodeServices.NodeServices | R>;
+type Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (args: FunctionSpec.Args<FunctionSpec_>) => Effect.Effect<FunctionSpec.Returns<FunctionSpec_>, FunctionSpec.Error<FunctionSpec_>, R>;
+export type Any = AnyConfectProvenance | AnyConvexProvenance;
+export type AnyConfectProvenance = Base<FunctionSpec.AnyConfect, any>;
+export type AnyConvexProvenance = RegisteredFunction.Any;
+export type WithName<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithProps, FunctionName extends string, R = never> = Handler<DatabaseSchema_, FunctionSpec.WithName<FunctionSpec_, FunctionName>, R>;
+export {};
+//# sourceMappingURL=Handler.d.ts.map

package/dist/Handler.d.ts.map

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

package/dist/Handler.js

@@ -0,0 +1,7 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/Handler.ts
+var Handler_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+export { Handler_exports };
+
+//# sourceMappingURL=Handler.js.map

package/dist/Handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Handler.js","names":[],"sources":["../src/Handler.ts"],"sourcesContent":["import type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport type * as NodeServices from \"@effect/platform-node/NodeServices\";\nimport type { Effect } from \"effect\";\nimport type * as ActionCtx from \"./ActionCtx\";\nimport type * as ActionRunner from \"./ActionRunner\";\nimport type * as Auth from \"./Auth\";\nimport type * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport type { ExecutionMetadata } from \"./ExecutionMetadata\";\nimport type { RequestMetadata } from \"./RequestMetadata\";\nimport type { TransactionMetadata } from \"./TransactionMetadata\";\nimport type * as MutationCtx from \"./MutationCtx\";\nimport type * as MutationRunner from \"./MutationRunner\";\nimport type { MutationTransactionContext } from \"./MutationTransactionContext\";\nimport type * as QueryCtx from \"./QueryCtx\";\nimport type * as QueryRunner from \"./QueryRunner\";\nimport type { QueryTransactionContext } from \"./QueryTransactionContext\";\nimport type * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as Scheduler from \"./Scheduler\";\nimport type { Storage } from \"./Storage\";\nimport type * as StorageActionWriter from \"./StorageActionWriter\";\nimport type * as StorageReader from \"./StorageReader\";\nimport type * as StorageWriter from \"./StorageWriter\";\nimport type * as VectorSearch from \"./VectorSearch\";\n\nexport type Handler<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n  R = never,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexProvenanceHandler<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectProvenanceHandler<DatabaseSchema_, FunctionSpec_, R>\n      : never;\n\ntype ConvexProvenanceHandler<\n  FunctionSpec_ extends\n    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConvex>,\n> = RegisteredFunction.ConvexRegisteredFunction<FunctionSpec_>;\n\ntype ConfectProvenanceHandler<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends\n    FunctionSpec.AnyWithPropsWithFunctionProvenance<FunctionProvenance.AnyConfect>,\n  R = never,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionType<FunctionSpec_, \"query\">\n    ? ConfectProvenanceQuery<DatabaseSchema_, FunctionSpec_, R>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionType<\n          FunctionSpec_,\n          \"mutation\"\n        >\n      ? ConfectProvenanceMutation<DatabaseSchema_, FunctionSpec_, R>\n      : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<\n            FunctionSpec_,\n            RuntimeAndFunctionType.ConvexAction\n          >\n        ? ConvexRuntimeAction<DatabaseSchema_, FunctionSpec_, R>\n        : FunctionSpec_ extends FunctionSpec.WithRuntimeAndFunctionType<\n              FunctionSpec_,\n              RuntimeAndFunctionType.NodeAction\n            >\n          ? NodeRuntimeAction<DatabaseSchema_, FunctionSpec_, R>\n          : never;\n\nexport type QueryServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | DatabaseReader.DatabaseReader<DatabaseSchema_>\n  | (DatabaseSchema_[\"target\"][\"kind\"] extends \"component\" ? never : Auth.Auth)\n  | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | ExecutionMetadata\n  | TransactionMetadata\n  | (DatabaseSchema_[\"target\"][\"kind\"] extends \"component\" ? never : Storage)\n  | QueryRunner.QueryRunner\n  | QueryTransactionContext\n  | QueryCtx.QueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,\n      DatabaseSchema.Scope<DatabaseSchema_>\n    >;\n\nexport type MutationServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | DatabaseReader.DatabaseReader<DatabaseSchema_>\n  | DatabaseWriter.DatabaseWriter<DatabaseSchema_>\n  | (DatabaseSchema_[\"target\"][\"kind\"] extends \"component\" ? never : Auth.Auth)\n  | Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | StorageWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | ExecutionMetadata\n  | TransactionMetadata\n  | RequestMetadata\n  | (DatabaseSchema_[\"target\"][\"kind\"] extends \"component\" ? never : Storage)\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | QueryTransactionContext\n  | MutationTransactionContext\n  | MutationCtx.MutationCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,\n      DatabaseSchema.Scope<DatabaseSchema_>\n    >;\n\n/**\n * Shared by both action runtimes.\n */\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | Scheduler.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | (DatabaseSchema_[\"target\"][\"kind\"] extends \"component\" ? never : Auth.Auth)\n  | StorageReader.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | StorageWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | StorageActionWriter.ForScope<DatabaseSchema.Scope<DatabaseSchema_>>\n  | ExecutionMetadata\n  | RequestMetadata\n  | (DatabaseSchema_[\"target\"][\"kind\"] extends \"component\" ? never : Storage)\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | ActionRunner.ActionRunner\n  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>\n  | ActionCtx.ActionCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>,\n      DatabaseSchema.Scope<DatabaseSchema_>\n    >;\n\nexport type ConfectProvenanceQuery<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends\n    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyQuery>,\n  R = never,\n> = Base<FunctionSpec_, QueryServices<DatabaseSchema_> | R>;\n\nexport type ConfectProvenanceMutation<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends\n    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyMutation>,\n  R = never,\n> = Base<FunctionSpec_, MutationServices<DatabaseSchema_> | R>;\n\nexport type ConvexRuntimeAction<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends\n    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.AnyAction>,\n  R = never,\n> = Base<FunctionSpec_, ActionServices<DatabaseSchema_> | R>;\n\nexport type NodeRuntimeAction<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends\n    FunctionSpec.AnyWithPropsWithFunctionType<RuntimeAndFunctionType.NodeAction>,\n  R = never,\n> = Base<\n  FunctionSpec_,\n  ActionServices<DatabaseSchema_> | NodeServices.NodeServices | R\n>;\n\ntype Base<FunctionSpec_ extends FunctionSpec.AnyWithProps, R> = (\n  args: FunctionSpec.Args<FunctionSpec_>,\n) => Effect.Effect<\n  FunctionSpec.Returns<FunctionSpec_>,\n  FunctionSpec.Error<FunctionSpec_>,\n  R\n>;\n\nexport type Any = AnyConfectProvenance | AnyConvexProvenance;\n\nexport type AnyConfectProvenance = Base<FunctionSpec.AnyConfect, any>;\n\nexport type AnyConvexProvenance = RegisteredFunction.Any;\n\nexport type WithName<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n  FunctionName extends string,\n  R = never,\n> = Handler<\n  DatabaseSchema_,\n  FunctionSpec.WithName<FunctionSpec_, FunctionName>,\n  R\n>;\n"],"mappings":""}