@gaganref/confect-server 10.3.1-fork.17 → 10.3.1-fork.19

package/dist/GroupImpl.d.ts

@@ -1,5 +1,6 @@
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import type * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import * as RegistryItems from "./RegistryItems.js";
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
 import type * as DatabaseSchema from "./DatabaseSchema.js";
@@ -59,6 +60,15 @@ export declare const GroupImpl: <FinalizationStatus_ extends FinalizationStatus>
  * 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>>;
+declare const MissingRequiredMiddlewareError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "MissingRequiredMiddlewareError";
+} & Readonly<A>;
+export declare class MissingRequiredMiddlewareError extends MissingRequiredMiddlewareError_base<{
+    readonly missing: ReadonlyArray<RegistryItems.MissingMiddleware>;
+}> {
+    get message(): string;
+}
+type Finalizable = Layer.Layer<AnyUnfinalized> | Layer.Layer<AnyFinalized>;
 /**
  * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
  * `RIn = never`, so passing a layer that still requires any `FunctionImpl`
@@ -70,8 +80,17 @@ export declare const make: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
  * 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.
+ * inspect the `Registry` themselves. Pass `{ required }` to check every
+ * registered function's middleware at layer build, including internal
+ * functions. This form also accepts a finalized layer so generated registration
+ * can enforce the backend declaration without changing authored impls. Pass
+ * `groupPath` to qualify uncovered function names in the diagnostic.
  */
-export declare const finalize: (group: Layer.Layer<GroupImpl<"Unfinalized">>) => Layer.Layer<GroupImpl<"Finalized">>;
+export declare function finalize(options: {
+    readonly groupPath?: string;
+    readonly required: ReadonlyArray<Pick<MiddlewareSpec.AnyMiddlewareSpec, "key">>;
+}): (group: Finalizable) => Layer.Layer<GroupImpl<"Finalized">>;
+export declare function finalize(group: Layer.Layer<GroupImpl<"Unfinalized">>): Layer.Layer<GroupImpl<"Finalized">>;
 export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>;
+export {};
 //# sourceMappingURL=GroupImpl.d.ts.map

package/dist/GroupImpl.d.ts.map

@@ -1 +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,qBAAqB,CAAC;AAC3D,OAAO,KAAK,KAAK,YAAY,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,KAAK,cAAc,MAAM,qBAAqB,CAAC;AAE3D,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"}
+{"version":3,"file":"GroupImpl.d.ts","sourceRoot":"","sources":["../src/GroupImpl.ts"],"names":[],"mappings":"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"}

package/dist/GroupImpl.js

@@ -1,6 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { Registry } from "./Registry.js";
-import { functionNames, middlewareKeys } from "./RegistryItems.js";
+import { functionNames, middlewareKeys, missingRequired } from "./RegistryItems.js";
 import * as Context from "effect/Context";
 import * as Layer from "effect/Layer";
 import * as Effect from "effect/Effect";
@@ -8,9 +8,11 @@ import * as Option from "effect/Option";
 import * as Array from "effect/Array";
 import * as Predicate from "effect/Predicate";
 import * as Ref from "effect/Ref";
+import * as Data from "effect/Data";
 //#region src/GroupImpl.ts
 var GroupImpl_exports = /* @__PURE__ */ __exportAll({
 	GroupImpl: () => GroupImpl,
+	MissingRequiredMiddlewareError: () => MissingRequiredMiddlewareError,
 	TypeId: () => TypeId,
 	finalize: () => finalize,
 	isFinalizedGroupImpl: () => isFinalizedGroupImpl,
@@ -48,25 +50,22 @@ const make = (_databaseSchema, _group) => Layer.succeed(GroupImpl({ finalization
 	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."))),
+const findGroupImpl = (context) => Array.findFirst(context.mapUnsafe.values(), isGroupImpl);
+var MissingRequiredMiddlewareError = class extends Data.TaggedError("MissingRequiredMiddlewareError") {
+	get message() {
+		return `GroupImpl.finalize: ${this.missing.map(({ functionName, middlewareKey }) => `${functionName} requires middleware "${middlewareKey}"`).join("\n")}`;
+	}
+};
+function finalize(input) {
+	return "required" in input ? (group) => finalizeWith(group, input.required, input.groupPath) : finalizeWith(input, []);
+}
+const finalizeWith = (group, required, groupPath = "") => Layer.flatMap(group, (context) => findGroupImpl(context).pipe(Option.match({
+	onNone: () => Layer.effect(GroupImpl({ finalizationStatus: "Finalized" }), Effect.die(/* @__PURE__ */ new Error("GroupImpl.finalize: no 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);
+		const missing = missingRequired(items, required, groupPath);
+		if (missing.length > 0) return yield* Effect.die(new MissingRequiredMiddlewareError({ missing }));
 		return {
 			[TypeId]: TypeId,
 			finalizationStatus: "Finalized",
@@ -76,6 +75,6 @@ const finalize = (group) => Layer.flatMap(group, (context) => findUnfinalizedGro
 	}))
 })));
 //#endregion
-export { GroupImpl, GroupImpl_exports, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
+export { GroupImpl, GroupImpl_exports, MissingRequiredMiddlewareError, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
 
 //# sourceMappingURL=GroupImpl.js.map

package/dist/GroupImpl.js.map

@@ -1 +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.js\";\nimport * as RegistryItems from \"./RegistryItems.js\";\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.js\";\nimport type * as FunctionImpl from \"./FunctionImpl.js\";\nimport type * as MiddlewareImpl from \"./MiddlewareImpl.js\";\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"}
+{"version":3,"file":"GroupImpl.js","names":["Registry.Registry","RegistryItems.missingRequired","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.js\";\nimport * as RegistryItems from \"./RegistryItems.js\";\nimport * as Array from \"effect/Array\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Data from \"effect/Data\";\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.js\";\nimport type * as FunctionImpl from \"./FunctionImpl.js\";\nimport type * as MiddlewareImpl from \"./MiddlewareImpl.js\";\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 findGroupImpl = <S>(context: Context.Context<S>): Option.Option<Any> =>\n  Array.findFirst(context.mapUnsafe.values(), isGroupImpl);\n\nexport class MissingRequiredMiddlewareError extends Data.TaggedError(\n  \"MissingRequiredMiddlewareError\",\n)<{\n  readonly missing: ReadonlyArray<RegistryItems.MissingMiddleware>;\n}> {\n  override get message(): string {\n    return `GroupImpl.finalize: ${this.missing.map(({ functionName, middlewareKey }) => `${functionName} requires middleware \"${middlewareKey}\"`).join(\"\\n\")}`;\n  }\n}\n\ntype Finalizable = Layer.Layer<AnyUnfinalized> | Layer.Layer<AnyFinalized>;\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. Pass `{ required }` to check every\n * registered function's middleware at layer build, including internal\n * functions. This form also accepts a finalized layer so generated registration\n * can enforce the backend declaration without changing authored impls. Pass\n * `groupPath` to qualify uncovered function names in the diagnostic.\n */\nexport function finalize(options: {\n  readonly groupPath?: string;\n  readonly required: ReadonlyArray<\n    Pick<MiddlewareSpec.AnyMiddlewareSpec, \"key\">\n  >;\n}): (group: Finalizable) => Layer.Layer<GroupImpl<\"Finalized\">>;\nexport function finalize(\n  group: Layer.Layer<GroupImpl<\"Unfinalized\">>,\n): Layer.Layer<GroupImpl<\"Finalized\">>;\nexport function finalize(\n  input:\n    | Finalizable\n    | {\n        readonly groupPath?: string;\n        readonly required: ReadonlyArray<\n          Pick<MiddlewareSpec.AnyMiddlewareSpec, \"key\">\n        >;\n      },\n):\n  | Layer.Layer<GroupImpl<\"Finalized\">>\n  | ((group: Finalizable) => Layer.Layer<GroupImpl<\"Finalized\">>) {\n  return \"required\" in input\n    ? (group) => finalizeWith(group, input.required, input.groupPath)\n    : finalizeWith(input, []);\n}\n\nconst finalizeWith = (\n  group: Layer.Layer<never>,\n  required: ReadonlyArray<Pick<MiddlewareSpec.AnyMiddlewareSpec, \"key\">>,\n  groupPath = \"\",\n): Layer.Layer<GroupImpl<\"Finalized\">> =>\n  Layer.flatMap(group, (context): Layer.Layer<GroupImpl<\"Finalized\">> =>\n    findGroupImpl(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 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              const missing = RegistryItems.missingRequired(\n                items,\n                required,\n                groupPath,\n              );\n              if (missing.length > 0) {\n                return yield* Effect.die(\n                  new MissingRequiredMiddlewareError({ missing }),\n                );\n              }\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":";;;;;;;;;;;;;;;;;;;;;;AAgBA,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,iBAAoB,YACxB,MAAM,UAAU,QAAQ,UAAU,OAAO,GAAG,WAAW;AAEzD,IAAa,iCAAb,cAAoD,KAAK,YACvD,gCACF,CAAC,CAEE;CACD,IAAa,UAAkB;EAC7B,OAAO,uBAAuB,KAAK,QAAQ,KAAK,EAAE,cAAc,oBAAoB,GAAG,aAAa,wBAAwB,cAAc,EAAE,CAAC,CAAC,KAAK,IAAI;CACzJ;AACF;AA8BA,SAAgB,SACd,OAUgE;CAChE,OAAO,cAAc,SAChB,UAAU,aAAa,OAAO,MAAM,UAAU,MAAM,SAAS,IAC9D,aAAa,OAAO,CAAC,CAAC;AAC5B;AAEA,MAAM,gBACJ,OACA,UACA,YAAY,OAEZ,MAAM,QAAQ,QAAQ,YACpB,cAAc,OAAO,CAAC,CAAC,KACrB,OAAO,MAAM;CACX,cACE,MAAM,OACJ,UAAuB,EAAE,oBAAoB,YAAY,CAAC,GAC1D,OAAO,oBACL,IAAI,MACF,4EACF,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,MAAM,UAAUC,gBACd,OACA,UACA,SACF;EACA,IAAI,QAAQ,SAAS,GACnB,OAAO,OAAO,OAAO,IACnB,IAAI,+BAA+B,EAAE,QAAQ,CAAC,CAChD;EAEF,OAAO;IACJ,SAAS;GACV,oBAAoB;GACpB,yBAAyBC,cAA4B,KAAK;GAC1D,0BAA0BC,eAA6B,KAAK;EAC9D;CACF,CAAC,CACH;AACJ,CAAC,CACH,CACF"}

package/dist/RegistryItems.d.ts

@@ -18,4 +18,11 @@ export declare const functionNames: (items: RegistryItems) => ReadonlyArray<stri
  * (stored under `middleware:<key>` entries by `MiddlewareImpl`).
  */
 export declare const middlewareKeys: (items: RegistryItems) => ReadonlyArray<string>;
+export interface MissingMiddleware {
+    readonly functionName: string;
+    readonly middlewareKey: string;
+}
+export declare const missingRequired: (items: RegistryItems, required: ReadonlyArray<{
+    readonly key: string;
+}>, groupPath?: string) => ReadonlyArray<MissingMiddleware>;
 //# sourceMappingURL=RegistryItems.d.ts.map

package/dist/RegistryItems.d.ts.map

@@ -1 +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"}
+{"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;AAEJ,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,eAAe,UACnB,aAAa,YACV,aAAa,CAAC;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,yBAEhD,aAAa,CAAC,iBAAiB,CAoB7B,CAAC"}

package/dist/RegistryItems.js

@@ -7,7 +7,8 @@ import * as Record from "effect/Record";
 //#region src/RegistryItems.ts
 var RegistryItems_exports = /* @__PURE__ */ __exportAll({
 	functionNames: () => functionNames,
-	middlewareKeys: () => middlewareKeys
+	middlewareKeys: () => middlewareKeys,
+	missingRequired: () => missingRequired
 });
 /**
 * The names of the function-shaped entries in a group's (flat, isolated)
@@ -21,7 +22,11 @@ const functionNames = (items) => pipe(Record.toEntries(items), Array.filter(([,
 * (stored under `middleware:<key>` entries by `MiddlewareImpl`).
 */
 const middlewareKeys = (items) => pipe(Record.values(items), Array.filter(isMiddlewareRegistryItem), Array.map((item) => item.middlewareSpec.key));
+const missingRequired = (items, required, groupPath = "") => Object.entries(items).sort(([left], [right]) => left.localeCompare(right)).flatMap(([functionName, value]) => isFunctionRegistryItem(value) ? required.flatMap(({ key }) => value._tag === "Confect" && value.middlewareAttachments.some(({ spec }) => spec.key === key) ? [] : [{
+	functionName: groupPath === "" ? functionName : `${groupPath}.${functionName}`,
+	middlewareKey: key
+}]) : []);
 //#endregion
-export { RegistryItems_exports, functionNames, middlewareKeys };
+export { RegistryItems_exports, functionNames, middlewareKeys, missingRequired };
 
 //# sourceMappingURL=RegistryItems.js.map

package/dist/RegistryItems.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegistryItems.js","names":["FunctionRegistryItem.isFunctionRegistryItem","MiddlewareRegistryItem.isMiddlewareRegistryItem"],"sources":["../src/RegistryItems.ts"],"sourcesContent":["import * as Array from \"effect/Array\";\nimport { pipe } from \"effect/Function\";\nimport * as Record from \"effect/Record\";\nimport * as FunctionRegistryItem from \"./FunctionRegistryItem.js\";\nimport * as MiddlewareRegistryItem from \"./MiddlewareRegistryItem.js\";\n\n/**\n * Runtime tree that mirrors a `Spec`'s group structure. Values remain unknown\n * at this boundary so producers and consumers can narrow branches and registry\n * items as needed.\n */\nexport interface RegistryItems {\n  readonly [key: string]: unknown;\n}\n\n/**\n * The names of the function-shaped entries in a group's (flat, isolated)\n * registry. `FunctionImpl.make` registers each function under a single-segment\n * key, so the registry built for one group contains exactly that group's\n * functions at the top level.\n */\nexport const functionNames = (items: RegistryItems): ReadonlyArray<string> =>\n  pipe(\n    Record.toEntries(items),\n    Array.filter(([, value]) =>\n      FunctionRegistryItem.isFunctionRegistryItem(value),\n    ),\n    Array.map(([name]) => name),\n  );\n\n/**\n * The keys of the middleware implementations registered into a group's registry\n * (stored under `middleware:<key>` entries by `MiddlewareImpl`).\n */\nexport const middlewareKeys = (items: RegistryItems): ReadonlyArray<string> =>\n  pipe(\n    Record.values(items),\n    Array.filter(MiddlewareRegistryItem.isMiddlewareRegistryItem),\n    Array.map((item) => item.middlewareSpec.key),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAAiB,UAC5B,KACE,OAAO,UAAU,KAAK,GACtB,MAAM,QAAQ,GAAG,WACfA,uBAA4C,KAAK,CACnD,GACA,MAAM,KAAK,CAAC,UAAU,IAAI,CAC5B;;;;;AAMF,MAAa,kBAAkB,UAC7B,KACE,OAAO,OAAO,KAAK,GACnB,MAAM,OAAOC,wBAA+C,GAC5D,MAAM,KAAK,SAAS,KAAK,eAAe,GAAG,CAC7C"}
+{"version":3,"file":"RegistryItems.js","names":["FunctionRegistryItem.isFunctionRegistryItem","MiddlewareRegistryItem.isMiddlewareRegistryItem"],"sources":["../src/RegistryItems.ts"],"sourcesContent":["import * as Array from \"effect/Array\";\nimport { pipe } from \"effect/Function\";\nimport * as Record from \"effect/Record\";\nimport * as FunctionRegistryItem from \"./FunctionRegistryItem.js\";\nimport * as MiddlewareRegistryItem from \"./MiddlewareRegistryItem.js\";\n\n/**\n * Runtime tree that mirrors a `Spec`'s group structure. Values remain unknown\n * at this boundary so producers and consumers can narrow branches and registry\n * items as needed.\n */\nexport interface RegistryItems {\n  readonly [key: string]: unknown;\n}\n\n/**\n * The names of the function-shaped entries in a group's (flat, isolated)\n * registry. `FunctionImpl.make` registers each function under a single-segment\n * key, so the registry built for one group contains exactly that group's\n * functions at the top level.\n */\nexport const functionNames = (items: RegistryItems): ReadonlyArray<string> =>\n  pipe(\n    Record.toEntries(items),\n    Array.filter(([, value]) =>\n      FunctionRegistryItem.isFunctionRegistryItem(value),\n    ),\n    Array.map(([name]) => name),\n  );\n\n/**\n * The keys of the middleware implementations registered into a group's registry\n * (stored under `middleware:<key>` entries by `MiddlewareImpl`).\n */\nexport const middlewareKeys = (items: RegistryItems): ReadonlyArray<string> =>\n  pipe(\n    Record.values(items),\n    Array.filter(MiddlewareRegistryItem.isMiddlewareRegistryItem),\n    Array.map((item) => item.middlewareSpec.key),\n  );\n\nexport interface MissingMiddleware {\n  readonly functionName: string;\n  readonly middlewareKey: string;\n}\n\nexport const missingRequired = (\n  items: RegistryItems,\n  required: ReadonlyArray<{ readonly key: string }>,\n  groupPath = \"\",\n): ReadonlyArray<MissingMiddleware> =>\n  Object.entries(items)\n    .sort(([left], [right]) => left.localeCompare(right))\n    .flatMap(([functionName, value]) =>\n      FunctionRegistryItem.isFunctionRegistryItem(value)\n        ? required.flatMap(({ key }) =>\n            value._tag === \"Confect\" &&\n            value.middlewareAttachments.some(({ spec }) => spec.key === key)\n              ? []\n              : [\n                  {\n                    functionName:\n                      groupPath === \"\"\n                        ? functionName\n                        : `${groupPath}.${functionName}`,\n                    middlewareKey: key,\n                  },\n                ],\n          )\n        : [],\n    );\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,MAAa,iBAAiB,UAC5B,KACE,OAAO,UAAU,KAAK,GACtB,MAAM,QAAQ,GAAG,WACfA,uBAA4C,KAAK,CACnD,GACA,MAAM,KAAK,CAAC,UAAU,IAAI,CAC5B;;;;;AAMF,MAAa,kBAAkB,UAC7B,KACE,OAAO,OAAO,KAAK,GACnB,MAAM,OAAOC,wBAA+C,GAC5D,MAAM,KAAK,SAAS,KAAK,eAAe,GAAG,CAC7C;AAOF,MAAa,mBACX,OACA,UACA,YAAY,OAEZ,OAAO,QAAQ,KAAK,CAAC,CAClB,MAAM,CAAC,OAAO,CAAC,WAAW,KAAK,cAAc,KAAK,CAAC,CAAC,CACpD,SAAS,CAAC,cAAc,WACvBD,uBAA4C,KAAK,IAC7C,SAAS,SAAS,EAAE,UAClB,MAAM,SAAS,aACf,MAAM,sBAAsB,MAAM,EAAE,WAAW,KAAK,QAAQ,GAAG,IAC3D,CAAC,IACD,CACE;CACE,cACE,cAAc,KACV,eACA,GAAG,UAAU,GAAG;CACtB,eAAe;AACjB,CACF,CACN,IACA,CAAC,CACP"}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@gaganref/confect-server",
-  "version": "10.3.1-fork.17",
+  "version": "10.3.1-fork.19",
   "dependencies": {
     "@effect/ai-openai-compat": "4.0.4",
     "@effect/ai-openrouter": "4.0.4"
   },
   "peerDependencies": {
-    "@confect/core": "npm:@gaganref/confect-core@10.3.1-fork.17",
+    "@confect/core": "npm:@gaganref/confect-core@10.3.1-fork.19",
     "@effect/platform-node": "^4.0.0",
     "convex": "^1.45.0",
     "effect": "^4.0.4"

package/src/GroupImpl.ts

@@ -5,6 +5,7 @@ import * as RegistryItems from "./RegistryItems.js";
 import * as Array from "effect/Array";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as Data from "effect/Data";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Predicate from "effect/Predicate";
@@ -111,10 +112,20 @@ export const make = <
     FunctionImpl.FromGroupSpec<Group> | MiddlewareImpl.FromGroupSpec<Group>
   >;
 
-const findUnfinalizedGroupImpl = <S>(
-  context: Context.Context<S>,
-): Option.Option<AnyUnfinalized> =>
-  Array.findFirst(context.mapUnsafe.values(), isUnfinalizedGroupImpl);
+const findGroupImpl = <S>(context: Context.Context<S>): Option.Option<Any> =>
+  Array.findFirst(context.mapUnsafe.values(), isGroupImpl);
+
+export class MissingRequiredMiddlewareError extends Data.TaggedError(
+  "MissingRequiredMiddlewareError",
+)<{
+  readonly missing: ReadonlyArray<RegistryItems.MissingMiddleware>;
+}> {
+  override get message(): string {
+    return `GroupImpl.finalize: ${this.missing.map(({ functionName, middlewareKey }) => `${functionName} requires middleware "${middlewareKey}"`).join("\n")}`;
+  }
+}
+
+type Finalizable = Layer.Layer<AnyUnfinalized> | Layer.Layer<AnyFinalized>;
 
 /**
  * Mark a `GroupImpl` layer as fully implemented. The parameter type defaults
@@ -127,20 +138,52 @@ const findUnfinalizedGroupImpl = <S>(
  * 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.
+ * inspect the `Registry` themselves. Pass `{ required }` to check every
+ * registered function's middleware at layer build, including internal
+ * functions. This form also accepts a finalized layer so generated registration
+ * can enforce the backend declaration without changing authored impls. Pass
+ * `groupPath` to qualify uncovered function names in the diagnostic.
  */
-export const finalize = (
+export function finalize(options: {
+  readonly groupPath?: string;
+  readonly required: ReadonlyArray<
+    Pick<MiddlewareSpec.AnyMiddlewareSpec, "key">
+  >;
+}): (group: Finalizable) => Layer.Layer<GroupImpl<"Finalized">>;
+export function finalize(
   group: Layer.Layer<GroupImpl<"Unfinalized">>,
+): Layer.Layer<GroupImpl<"Finalized">>;
+export function finalize(
+  input:
+    | Finalizable
+    | {
+        readonly groupPath?: string;
+        readonly required: ReadonlyArray<
+          Pick<MiddlewareSpec.AnyMiddlewareSpec, "key">
+        >;
+      },
+):
+  | Layer.Layer<GroupImpl<"Finalized">>
+  | ((group: Finalizable) => Layer.Layer<GroupImpl<"Finalized">>) {
+  return "required" in input
+    ? (group) => finalizeWith(group, input.required, input.groupPath)
+    : finalizeWith(input, []);
+}
+
+const finalizeWith = (
+  group: Layer.Layer<never>,
+  required: ReadonlyArray<Pick<MiddlewareSpec.AnyMiddlewareSpec, "key">>,
+  groupPath = "",
 ): Layer.Layer<GroupImpl<"Finalized">> =>
   Layer.flatMap(group, (context): Layer.Layer<GroupImpl<"Finalized">> =>
-    findUnfinalizedGroupImpl(context).pipe(
+    findGroupImpl(context).pipe(
       Option.match({
         onNone: () =>
           Layer.effect(
             GroupImpl<"Finalized">({ finalizationStatus: "Finalized" }),
             Effect.die(
               new Error(
-                "GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.",
+                "GroupImpl.finalize: no GroupImpl service was found in the layer's context.",
               ),
             ),
           ),
@@ -150,6 +193,16 @@ export const finalize = (
             Effect.gen(function* () {
               const registry = yield* Registry.Registry;
               const items = yield* Ref.get(registry);
+              const missing = RegistryItems.missingRequired(
+                items,
+                required,
+                groupPath,
+              );
+              if (missing.length > 0) {
+                return yield* Effect.die(
+                  new MissingRequiredMiddlewareError({ missing }),
+                );
+              }
               return {
                 [TypeId]: TypeId,
                 finalizationStatus: "Finalized" as const,

package/src/RegistryItems.ts

@@ -38,3 +38,34 @@ export const middlewareKeys = (items: RegistryItems): ReadonlyArray<string> =>
     Array.filter(MiddlewareRegistryItem.isMiddlewareRegistryItem),
     Array.map((item) => item.middlewareSpec.key),
   );
+
+export interface MissingMiddleware {
+  readonly functionName: string;
+  readonly middlewareKey: string;
+}
+
+export const missingRequired = (
+  items: RegistryItems,
+  required: ReadonlyArray<{ readonly key: string }>,
+  groupPath = "",
+): ReadonlyArray<MissingMiddleware> =>
+  Object.entries(items)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .flatMap(([functionName, value]) =>
+      FunctionRegistryItem.isFunctionRegistryItem(value)
+        ? required.flatMap(({ key }) =>
+            value._tag === "Confect" &&
+            value.middlewareAttachments.some(({ spec }) => spec.key === key)
+              ? []
+              : [
+                  {
+                    functionName:
+                      groupPath === ""
+                        ? functionName
+                        : `${groupPath}.${functionName}`,
+                    middlewareKey: key,
+                  },
+                ],
+          )
+        : [],
+    );