@confect/server 8.0.0 → 9.0.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @confect/server
 
+## 9.0.0-next.1
+
+### Patch Changes
+
+- @confect/core@9.0.0-next.1
+
+## 9.0.0-next.0
+
+### Major Changes
+
+- 6db3a3a: Derive Confect function paths from the filesystem layout of `confect/`. Each group lives in a colocated `*.spec.ts`/`*.impl.ts` pair, and the group's name is its path within `confect/` (file stem for top-level groups, dot-joined directory path for nested groups). See [Project Structure](https://confect.dev/concepts/project-structure), [File Naming Conventions](https://confect.dev/concepts/file-naming-conventions), and [The Spec/Impl Model](https://confect.dev/concepts/spec-impl-model) for the current model.
+
+  Each `*.spec.ts` default-exports its `GroupSpec`. Each `*.impl.ts` default-imports its sibling spec, builds its `GroupImpl`, and default-exports the result of `GroupImpl.finalize`. Named co-exports on `*.spec.ts` (such as error classes) remain allowed.
+
+  ### Why
+
+  The previous model assembled every group's impl into a single root `confect/impl.ts` (plus `confect/nodeImpl.ts`), which `confect codegen` emitted as the aggregate `_generated/registeredFunctions.ts`. Every generated `convex/` module — one per Convex function — imported from that aggregate, so loading any single query, mutation, or action transitively loaded the impl module of every other Convex function in the project, along with all of their dependencies. For large projects this inflated each function's bundle and added meaningful cold-start cost on Convex.
+
+  Splitting impl across colocated `*.impl.ts` files is the vehicle for fixing that. With this change, `confect codegen` emits one `_generated/registeredFunctions/{path}.ts` per group, and each generated `convex/` module imports only its own group's per-group registry — which in turn imports only its own sibling `.impl.ts`. A Convex function's cold-start bundle now scales with its own group's impl rather than with the size of the whole project.
+
+  ### Breaking changes
+  - `GroupSpec.make()` and `GroupSpec.makeNode()` no longer take a name argument; the group name is derived from the spec file's path within `confect/`.
+  - `FunctionImpl.make(api, groupSpec, fn, handler)` and `GroupImpl.make(api, groupSpec)` now take the imported sibling spec object as their second argument instead of a dot-path string.
+  - Every `GroupImpl` pipeline must end with `GroupImpl.finalize`, which only typechecks once every function declared by the spec has a corresponding `FunctionImpl` provided to the group layer. `GroupImpl.finalize` snapshots the names of every registered function onto the produced `Finalized` `GroupImpl` service value, and `confect codegen` reads those names to verify per-function coverage against the spec at runtime.
+  - The previously-exported `Impl.make` and `Impl.finalize` (used by the old root `impl.ts`/`nodeImpl.ts` files) are removed. Per-group completeness is now enforced by `GroupImpl.finalize`.
+  - Root `confect/spec.ts`, `confect/impl.ts`, `confect/nodeSpec.ts`, `confect/nodeImpl.ts`, and any parent aggregator `*.spec.ts`/`*.impl.ts` files are no longer used. `confect codegen` deletes any of these on upgrade, along with the stale `_generated/registeredFunctions.ts` and `_generated/nodeRegisteredFunctions.ts`.
+  - Every module under `convex/` is re-emitted to import from `_generated/registeredFunctions/{path}` instead of the previous aggregate file. Users who commit `convex/` to source control should expect a full rewrite of that directory on first codegen.
+
+  ### Migration
+  1. For each existing group, create a colocated `confect/{path}.spec.ts` and `confect/{path}.impl.ts` pair (under a subdirectory for nested groups).
+     - In each spec, call `GroupSpec.make()` (or `GroupSpec.makeNode()`) without a name and `export default` the result.
+     - In each impl, default-import the sibling spec (e.g. `import notes from "./notes.spec"`), pass it to `FunctionImpl.make`/`GroupImpl.make` in place of the previous dot-path string, append `GroupImpl.finalize` to the pipeline, and `export default` the resulting `GroupImpl` layer:
+       ```ts
+       export default GroupImpl.make(api, notes).pipe(
+         Layer.provide(list),
+         Layer.provide(insert),
+         GroupImpl.finalize,
+       );
+       ```
+  2. Delete root `confect/spec.ts`, `confect/impl.ts`, `confect/nodeSpec.ts`, `confect/nodeImpl.ts`, and any parent aggregator spec/impl files. (`confect codegen` will also delete any of these it finds, plus the stale `_generated/registeredFunctions.ts` and `_generated/nodeRegisteredFunctions.ts`, so this step can be skipped.)
+  3. Run `confect codegen`. Every module under `convex/` will be re-emitted.
+
+### Patch Changes
+
+- Updated dependencies [6db3a3a]
+  - @confect/core@9.0.0-next.0
+
 ## 8.0.0
 
 ### Major Changes

package/dist/Auth.d.ts

@@ -15,7 +15,7 @@ declare const Auth_base: effect_Context0.TagClass<Auth, "@confect/server/Auth",
 }> & {
   use: <X>(body: (_: {
     getUserIdentity: Effect.Effect<convex_server0.UserIdentity, NoUserIdentityFoundError, never>;
-  }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Auth | R> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, Auth> : Effect.Effect<X, never, Auth>;
+  }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | Auth> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, Auth> : Effect.Effect<X, never, Auth>;
 };
 declare class Auth extends Auth_base {}
 declare const layer: (auth: Auth$1) => Layer.Layer<Auth, never, never>;

package/dist/DatabaseReader.d.ts

@@ -19,7 +19,7 @@ declare namespace DatabaseReader_d_exports {
 declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<ToConvex<FromSchema<DatabaseSchema_>>>) => {
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {
@@ -32,7 +32,7 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
 declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {
@@ -44,7 +44,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
 }, {
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {
@@ -58,7 +58,7 @@ type DatabaseReader<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof Da
 declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {

package/dist/DatabaseSchema.d.ts

@@ -1,18 +1,23 @@
 import { AnyWithProps as AnyWithProps$1, Name, SystemTables, Table, TablesRecord, WithName } from "./Table.js";
 import { Expand, GenericSchema, SchemaDefinition } from "convex/server";
 import * as convex_values0 from "convex/values";
-import { Any, TypeId, TypeId as TypeId$1, isDatabaseSchema } from "@confect/core/DatabaseSchema";
 import * as effect_Schema0 from "effect/Schema";
 
 //#region src/DatabaseSchema.d.ts
 declare namespace DatabaseSchema_d_exports {
   export { Any, AnyWithProps, ConvexDatabaseSchemaFromTables, DatabaseSchema, ExtendWithSystemTables, IncludeSystemTables, TableNames, TableWithName, Tables, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
 }
+declare const TypeId = "@confect/server/DatabaseSchema";
+type TypeId = typeof TypeId;
+interface Any {
+  readonly [TypeId]: TypeId;
+}
+declare const isDatabaseSchema: (u: unknown) => u is Any;
 /**
  * A schema definition tracks the schema and its Convex schema definition.
  */
 interface DatabaseSchema<Tables_ extends AnyWithProps$1 = never> {
-  readonly [TypeId$1]: TypeId$1;
+  readonly [TypeId]: TypeId;
   readonly tables: TablesRecord<Tables_>;
   readonly convexSchemaDefinition: SchemaDefinition<ConvexDatabaseSchemaFromTables<Tables_>, true>;
   /**
@@ -21,7 +26,7 @@ interface DatabaseSchema<Tables_ extends AnyWithProps$1 = never> {
   addTable<TableDef extends AnyWithProps$1>(table: TableDef): DatabaseSchema<Tables_ | TableDef>;
 }
 interface AnyWithProps {
-  readonly [TypeId$1]: TypeId$1;
+  readonly [TypeId]: TypeId;
   readonly tables: Record<string, AnyWithProps$1>;
   readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
   addTable<TableDef extends AnyWithProps$1>(table: TableDef): AnyWithProps;
@@ -130,5 +135,5 @@ declare const extendWithSystemTables: <Tables_ extends AnyWithProps$1>(tables: T
 type ExtendWithSystemTables<Tables_ extends AnyWithProps$1> = TablesRecord<Tables_ | SystemTables>;
 type IncludeSystemTables<Tables_ extends AnyWithProps$1> = Tables_ | SystemTables extends infer T ? T extends AnyWithProps$1 ? T : never : never;
 //#endregion
-export { type Any, AnyWithProps, ConvexDatabaseSchemaFromTables, DatabaseSchema, DatabaseSchema_d_exports, ExtendWithSystemTables, IncludeSystemTables, TableNames, TableWithName, Tables, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
+export { Any, AnyWithProps, ConvexDatabaseSchemaFromTables, DatabaseSchema, DatabaseSchema_d_exports, ExtendWithSystemTables, IncludeSystemTables, TableNames, TableWithName, Tables, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
 //# sourceMappingURL=DatabaseSchema.d.ts.map

package/dist/DatabaseSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseSchema.d.ts","names":[],"sources":["../src/DatabaseSchema.ts"],"mappings":";;;;;;;;;;;;;UAkBiB,cAAA,iBAA+B,cAAA;EAAA,UACpC,QAAA,GAAS,QAAA;EAAA,SACV,MAAA,EAAQ,YAAA,CAAmB,OAAA;EAAA,SAC3B,sBAAA,EAAwB,gBAAA,CAC/B,8BAAA,CAA+B,OAAA;;;;EAOjC,QAAA,kBAA0B,cAAA,EACxB,KAAA,EAAO,QAAA,GACN,cAAA,CAAe,OAAA,GAAU,QAAA;AAAA;AAAA,UAGb,YAAA;EAAA,UACL,QAAA,GAAS,QAAA;EAAA,SACV,MAAA,EAAQ,MAAA,SAAe,cAAA;EAAA,SACvB,sBAAA,EAAwB,gBAAA,CAAiB,aAAA;EAClD,QAAA,kBAA0B,cAAA,EAAoB,KAAA,EAAO,QAAA,GAAW,YAAA;AAAA;AAAA,KAGtD,MAAA,yBAA+B,YAAA,IACzC,eAAA,SAAwB,cAAA,kBAAgC,OAAA;AAAA,KAE9C,UAAA,yBAAmC,YAAA,IAAgB,IAAA,CAC7D,MAAA,CAAO,eAAA;AAAA,KAIG,aAAA,yBACc,YAAA,oBACN,UAAA,CAAW,eAAA,KAC3B,OAAA,CAAQ,MAAA,CAAO,eAAA;EAAA,SAA6B,IAAA,EAAM,SAAA;AAAA;;;;cAyCzC,IAAA,QAAW,cAAA;AAAA,KAMZ,8BAAA,iBAA+C,cAAA,IACzD,MAAA,iBACgB,IAAA,CAAW,OAAA,aAAoB,QAAA,CAC3C,OAAA,EACA,SAAA;AAAA,cAMO,YAAA,EAAY,cAAA,CAAA,KAAA,wCAAA,MAAA;eAEM,cAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAFN,cAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAA,cAAA,CAAA,MAAA;;;;;;;;;;;;;;cAIZ,sBAAA,mBAA0C,cAAA,EACrD,MAAA,EAAQ,YAAA,CAAmB,OAAA,MAC1B,sBAAA,CAAuB,OAAA;AAAA,KAMd,sBAAA,iBAAuC,cAAA,IACjD,YAAA,CAAmB,OAAA,GAAU,YAAA;AAAA,KAEnB,mBAAA,iBAAoC,cAAA,IAC5C,OAAA,GACA,YAAA,mBACA,CAAA,SAAU,cAAA,GACR,CAAA"}
+{"version":3,"file":"DatabaseSchema.d.ts","names":[],"sources":["../src/DatabaseSchema.ts"],"mappings":";;;;;;;;;cAQa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,cAGR,gBAAA,GAAoB,CAAA,cAAa,CAAA,IAAK,GAAA;;;;UAMlC,cAAA,iBAA+B,cAAA;EAAA,UACpC,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,EAAQ,YAAA,CAAmB,OAAA;EAAA,SAC3B,sBAAA,EAAwB,gBAAA,CAC/B,8BAAA,CAA+B,OAAA;;;;EAOjC,QAAA,kBAA0B,cAAA,EACxB,KAAA,EAAO,QAAA,GACN,cAAA,CAAe,OAAA,GAAU,QAAA;AAAA;AAAA,UAGb,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,MAAA,EAAQ,MAAA,SAAe,cAAA;EAAA,SACvB,sBAAA,EAAwB,gBAAA,CAAiB,aAAA;EAClD,QAAA,kBAA0B,cAAA,EAAoB,KAAA,EAAO,QAAA,GAAW,YAAA;AAAA;AAAA,KAGtD,MAAA,yBAA+B,YAAA,IACzC,eAAA,SAAwB,cAAA,kBAAgC,OAAA;AAAA,KAE9C,UAAA,yBAAmC,YAAA,IAAgB,IAAA,CAC7D,MAAA,CAAO,eAAA;AAAA,KAIG,aAAA,yBACc,YAAA,oBACN,UAAA,CAAW,eAAA,KAC3B,OAAA,CAAQ,MAAA,CAAO,eAAA;EAAA,SAA6B,IAAA,EAAM,SAAA;AAAA;;AA5CtD;;cAqFa,IAAA,QAAW,cAAA;AAAA,KAMZ,8BAAA,iBAA+C,cAAA,IACzD,MAAA,iBACgB,IAAA,CAAW,OAAA,aAAoB,QAAA,CAC3C,OAAA,EACA,SAAA;AAAA,cAMO,YAAA,EAAY,cAAA,CAAA,KAAA,wCAAA,MAAA;eAEM,cAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAFN,cAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAA,cAAA,CAAA,MAAA;;;;;;;;;;;;;;cAIZ,sBAAA,mBAA0C,cAAA,EACrD,MAAA,EAAQ,YAAA,CAAmB,OAAA,MAC1B,sBAAA,CAAuB,OAAA;AAAA,KAMd,sBAAA,iBAAuC,cAAA,IACjD,YAAA,CAAmB,OAAA,GAAU,YAAA;AAAA,KAEnB,mBAAA,iBAAoC,cAAA,IAC5C,OAAA,GACA,YAAA,mBACA,CAAA,SAAU,cAAA,GACR,CAAA"}

package/dist/DatabaseSchema.js

@@ -1,8 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { scheduledFunctionsTable, storageTable, systemTables } from "./Table.js";
-import { Array, Record, pipe } from "effect";
+import { Array, Predicate, Record, pipe } from "effect";
 import { defineSchema } from "convex/server";
-import { TypeId, TypeId as TypeId$1, isDatabaseSchema } from "@confect/core/DatabaseSchema";
 
 //#region src/DatabaseSchema.ts
 var DatabaseSchema_exports = /* @__PURE__ */ __exportAll({
@@ -12,8 +11,10 @@ var DatabaseSchema_exports = /* @__PURE__ */ __exportAll({
 	make: () => make,
 	systemSchema: () => systemSchema
 });
+const TypeId = "@confect/server/DatabaseSchema";
+const isDatabaseSchema = (u) => Predicate.hasProperty(u, TypeId);
 const Proto = {
-	[TypeId$1]: TypeId$1,
+	[TypeId]: TypeId,
 	addTable(table) {
 		const newTablesArray = [...Object.values(this.tables), table];
 		return makeProto({

package/dist/DatabaseSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseSchema.js","names":["TypeId","defineConvexSchema","Table.scheduledFunctionsTable","Table.storageTable","Table.systemTables"],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import type { Expand, GenericSchema } from \"convex/server\";\nimport {\n  defineSchema as defineConvexSchema,\n  type SchemaDefinition,\n} from \"convex/server\";\nimport { Array, pipe, Record } from \"effect\";\nimport * as Table from \"./Table\";\nimport { TypeId } from \"@confect/core/DatabaseSchema\";\n\nexport {\n  type Any,\n  isDatabaseSchema,\n  TypeId,\n} from \"@confect/core/DatabaseSchema\";\n\n/**\n * A schema definition tracks the schema and its Convex schema definition.\n */\nexport interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {\n  readonly [TypeId]: TypeId;\n  readonly tables: Table.TablesRecord<Tables_>;\n  readonly convexSchemaDefinition: SchemaDefinition<\n    ConvexDatabaseSchemaFromTables<Tables_>,\n    true\n  >;\n\n  /**\n   * Add a table definition to the schema.\n   */\n  addTable<TableDef extends Table.AnyWithProps>(\n    table: TableDef,\n  ): DatabaseSchema<Tables_ | TableDef>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly tables: Record<string, Table.AnyWithProps>;\n  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;\n  addTable<TableDef extends Table.AnyWithProps>(table: TableDef): AnyWithProps;\n}\n\nexport type Tables<DatabaseSchema_ extends AnyWithProps> =\n  DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;\n\nexport type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<\n  Tables<DatabaseSchema_>\n> &\n  string;\n\nexport type TableWithName<\n  DatabaseSchema_ extends AnyWithProps,\n  TableName extends TableNames<DatabaseSchema_>,\n> = Extract<Tables<DatabaseSchema_>, { readonly name: TableName }>;\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  addTable<TableDef extends Table.AnyWithProps>(\n    this: DatabaseSchema<Table.AnyWithProps>,\n    table: TableDef,\n  ) {\n    const tablesArray = Object.values(this.tables) as Table.AnyWithProps[];\n    const newTablesArray = [...tablesArray, table];\n\n    return makeProto({\n      tables: Record.set(this.tables, table.name, table),\n      convexSchemaDefinition: pipe(\n        newTablesArray,\n        Array.map(\n          ({ name, tableDefinition }) => [name, tableDefinition] as const,\n        ),\n        Record.fromEntries,\n        defineConvexSchema,\n      ),\n    });\n  },\n};\n\nconst makeProto = <Tables_ extends Table.AnyWithProps>({\n  tables,\n  convexSchemaDefinition,\n}: {\n  tables: Record.ReadonlyRecord<string, Tables_>;\n  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;\n}): DatabaseSchema<Tables_> =>\n  Object.assign(Object.create(Proto), {\n    tables,\n    convexSchemaDefinition,\n  });\n\n/**\n * Create an empty schema definition. Add tables incrementally via `addTable`.\n */\nexport const make = (): DatabaseSchema<never> =>\n  makeProto({\n    tables: Record.empty(),\n    convexSchemaDefinition: defineConvexSchema({}),\n  });\n\nexport type ConvexDatabaseSchemaFromTables<Tables_ extends Table.AnyWithProps> =\n  Expand<{\n    [TableName in Table.Name<Tables_> & string]: Table.WithName<\n      Tables_,\n      TableName\n    >[\"tableDefinition\"];\n  }>;\n\n// System tables\n\nexport const systemSchema = make()\n  .addTable(Table.scheduledFunctionsTable)\n  .addTable(Table.storageTable);\n\nexport const extendWithSystemTables = <Tables_ extends Table.AnyWithProps>(\n  tables: Table.TablesRecord<Tables_>,\n): ExtendWithSystemTables<Tables_> =>\n  ({\n    ...tables,\n    ...Table.systemTables,\n  }) as ExtendWithSystemTables<Tables_>;\n\nexport type ExtendWithSystemTables<Tables_ extends Table.AnyWithProps> =\n  Table.TablesRecord<Tables_ | Table.SystemTables>;\n\nexport type IncludeSystemTables<Tables_ extends Table.AnyWithProps> =\n  | Tables_\n  | Table.SystemTables extends infer T\n  ? T extends Table.AnyWithProps\n    ? T\n    : never\n  : never;\n"],"mappings":";;;;;;;;;;;;;;AAsDA,MAAM,QAAQ;EACXA,WAASA;CAEV,SAEE,OACA;EAEA,MAAM,iBAAiB,CAAC,GADJ,OAAO,OAAO,KAAK,OAAO,EACN,MAAM;AAE9C,SAAO,UAAU;GACf,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM;GAClD,wBAAwB,KACtB,gBACA,MAAM,KACH,EAAE,MAAM,sBAAsB,CAAC,MAAM,gBAAgB,CACvD,EACD,OAAO,aACPC,aACD;GACF,CAAC;;CAEL;AAED,MAAM,aAAiD,EACrD,QACA,6BAKA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACD,CAAC;;;;AAKJ,MAAa,aACX,UAAU;CACR,QAAQ,OAAO,OAAO;CACtB,wBAAwBA,aAAmB,EAAE,CAAC;CAC/C,CAAC;AAYJ,MAAa,eAAe,MAAM,CAC/B,SAASC,wBAA8B,CACvC,SAASC,aAAmB;AAE/B,MAAa,0BACX,YAEC;CACC,GAAG;CACH,GAAGC;CACJ"}
+{"version":3,"file":"DatabaseSchema.js","names":["defineConvexSchema","Table.scheduledFunctionsTable","Table.storageTable","Table.systemTables"],"sources":["../src/DatabaseSchema.ts"],"sourcesContent":["import type { Expand, GenericSchema } from \"convex/server\";\nimport {\n  defineSchema as defineConvexSchema,\n  type SchemaDefinition,\n} from \"convex/server\";\nimport { Array, pipe, Predicate, Record } from \"effect\";\nimport * as Table from \"./Table\";\n\nexport const TypeId = \"@confect/server/DatabaseSchema\";\nexport type TypeId = typeof TypeId;\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport const isDatabaseSchema = (u: unknown): u is Any =>\n  Predicate.hasProperty(u, TypeId);\n\n/**\n * A schema definition tracks the schema and its Convex schema definition.\n */\nexport interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {\n  readonly [TypeId]: TypeId;\n  readonly tables: Table.TablesRecord<Tables_>;\n  readonly convexSchemaDefinition: SchemaDefinition<\n    ConvexDatabaseSchemaFromTables<Tables_>,\n    true\n  >;\n\n  /**\n   * Add a table definition to the schema.\n   */\n  addTable<TableDef extends Table.AnyWithProps>(\n    table: TableDef,\n  ): DatabaseSchema<Tables_ | TableDef>;\n}\n\nexport interface AnyWithProps {\n  readonly [TypeId]: TypeId;\n  readonly tables: Record<string, Table.AnyWithProps>;\n  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;\n  addTable<TableDef extends Table.AnyWithProps>(table: TableDef): AnyWithProps;\n}\n\nexport type Tables<DatabaseSchema_ extends AnyWithProps> =\n  DatabaseSchema_ extends DatabaseSchema<infer Tables_> ? Tables_ : never;\n\nexport type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<\n  Tables<DatabaseSchema_>\n> &\n  string;\n\nexport type TableWithName<\n  DatabaseSchema_ extends AnyWithProps,\n  TableName extends TableNames<DatabaseSchema_>,\n> = Extract<Tables<DatabaseSchema_>, { readonly name: TableName }>;\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  addTable<TableDef extends Table.AnyWithProps>(\n    this: DatabaseSchema<Table.AnyWithProps>,\n    table: TableDef,\n  ) {\n    const tablesArray = Object.values(this.tables) as Table.AnyWithProps[];\n    const newTablesArray = [...tablesArray, table];\n\n    return makeProto({\n      tables: Record.set(this.tables, table.name, table),\n      convexSchemaDefinition: pipe(\n        newTablesArray,\n        Array.map(\n          ({ name, tableDefinition }) => [name, tableDefinition] as const,\n        ),\n        Record.fromEntries,\n        defineConvexSchema,\n      ),\n    });\n  },\n};\n\nconst makeProto = <Tables_ extends Table.AnyWithProps>({\n  tables,\n  convexSchemaDefinition,\n}: {\n  tables: Record.ReadonlyRecord<string, Tables_>;\n  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;\n}): DatabaseSchema<Tables_> =>\n  Object.assign(Object.create(Proto), {\n    tables,\n    convexSchemaDefinition,\n  });\n\n/**\n * Create an empty schema definition. Add tables incrementally via `addTable`.\n */\nexport const make = (): DatabaseSchema<never> =>\n  makeProto({\n    tables: Record.empty(),\n    convexSchemaDefinition: defineConvexSchema({}),\n  });\n\nexport type ConvexDatabaseSchemaFromTables<Tables_ extends Table.AnyWithProps> =\n  Expand<{\n    [TableName in Table.Name<Tables_> & string]: Table.WithName<\n      Tables_,\n      TableName\n    >[\"tableDefinition\"];\n  }>;\n\n// System tables\n\nexport const systemSchema = make()\n  .addTable(Table.scheduledFunctionsTable)\n  .addTable(Table.storageTable);\n\nexport const extendWithSystemTables = <Tables_ extends Table.AnyWithProps>(\n  tables: Table.TablesRecord<Tables_>,\n): ExtendWithSystemTables<Tables_> =>\n  ({\n    ...tables,\n    ...Table.systemTables,\n  }) as ExtendWithSystemTables<Tables_>;\n\nexport type ExtendWithSystemTables<Tables_ extends Table.AnyWithProps> =\n  Table.TablesRecord<Tables_ | Table.SystemTables>;\n\nexport type IncludeSystemTables<Tables_ extends Table.AnyWithProps> =\n  | Tables_\n  | Table.SystemTables extends infer T\n  ? T extends Table.AnyWithProps\n    ? T\n    : never\n  : never;\n"],"mappings":";;;;;;;;;;;;;AAQA,MAAa,SAAS;AAOtB,MAAa,oBAAoB,MAC/B,UAAU,YAAY,GAAG,OAAO;AAyClC,MAAM,QAAQ;EACX,SAAS;CAEV,SAEE,OACA;EAEA,MAAM,iBAAiB,CAAC,GADJ,OAAO,OAAO,KAAK,OAAO,EACN,MAAM;AAE9C,SAAO,UAAU;GACf,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM;GAClD,wBAAwB,KACtB,gBACA,MAAM,KACH,EAAE,MAAM,sBAAsB,CAAC,MAAM,gBAAgB,CACvD,EACD,OAAO,aACPA,aACD;GACF,CAAC;;CAEL;AAED,MAAM,aAAiD,EACrD,QACA,6BAKA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACD,CAAC;;;;AAKJ,MAAa,aACX,UAAU;CACR,QAAQ,OAAO,OAAO;CACtB,wBAAwBA,aAAmB,EAAE,CAAC;CAC/C,CAAC;AAYJ,MAAa,eAAe,MAAM,CAC/B,SAASC,wBAA8B,CACvC,SAASC,aAAmB;AAE/B,MAAa,0BACX,YAEC;CACC,GAAG;CACH,GAAGC;CACJ"}

package/dist/DatabaseWriter.d.ts

@@ -13,7 +13,7 @@ declare namespace DatabaseWriter_d_exports {
 declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => {
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
@@ -21,14 +21,14 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
 declare const DatabaseWriter: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
 }, {
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
@@ -37,7 +37,7 @@ type DatabaseWriter<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof Da
 declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentDecodeError | GetByIdFailure | DocumentEncodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };

package/dist/DatabaseWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;cAiBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAMH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,mBAAA,GAAA,cAAA,GAAA,mBAAA;kBAiCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCA7GrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAmHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA3H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}
+{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;cAiBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAMH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,cAAA,GAAA,mBAAA,GAAA,mBAAA;kBAiCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCA7GrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAmHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA3H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}

package/dist/FunctionImpl.d.ts

@@ -1,13 +1,12 @@
-import { AnyWithProps, Groups, Schema as Schema$1 } from "./Api.js";
+import { AnyWithProps, Schema as Schema$1 } from "./Api.js";
 import { WithName } from "./Handler.js";
 import { Context, Layer } from "effect";
 import * as FunctionSpec from "@confect/core/FunctionSpec";
-import * as GroupPath from "@confect/core/GroupPath";
 import * as GroupSpec from "@confect/core/GroupSpec";
 
 //#region src/FunctionImpl.d.ts
 declare namespace FunctionImpl_d_exports {
-  export { ForGroupPathAndFunction, FromGroupAtPath, FunctionImpl, make };
+  export { ForGroupPathAndFunction, FromGroupAtPath, FromGroupSpec, FunctionImpl, make };
 }
 interface FunctionImpl<GroupPath_ extends string, FunctionName extends string> {
   readonly groupPath: GroupPath_;
@@ -20,15 +19,19 @@ declare const FunctionImpl: <GroupPath_ extends string, FunctionName extends str
   groupPath: GroupPath_;
   functionName: FunctionName;
 }) => Context.Tag<FunctionImpl<GroupPath_, FunctionName>, FunctionImpl<GroupPath_, FunctionName>>;
-declare const make: <Api_ extends AnyWithProps, const GroupPath_ extends GroupPath.All<Groups<Api_>>, const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<GroupPath.GroupAt<Groups<Api_>, GroupPath_>>>>(api: Api_, groupPath: GroupPath_, functionName: FunctionName, handler: WithName<Schema$1<Api_>, GroupSpec.Functions<GroupPath.GroupAt<Groups<Api_>, GroupPath_>>, FunctionName>) => Layer.Layer<FunctionImpl<GroupPath_, FunctionName>>;
+declare const make: <Api_ extends AnyWithProps, Group extends GroupSpec.AnyWithProps, const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>>(api: Api_, group: Group, functionName: FunctionName, handler: WithName<Schema$1<Api_>, GroupSpec.Functions<Group>, FunctionName>) => Layer.Layer<FunctionImpl<string, FunctionName>>;
 /**
  * Get the function implementation service type for a specific group path and function name.
  */
 type ForGroupPathAndFunction<GroupPath_ extends string, FunctionName extends string> = FunctionImpl<GroupPath_, FunctionName>;
 /**
- * Get all function implementation services required for a group at a given path.
+ * Get all function implementation services required for a group spec.
  */
-type FromGroupAtPath<GroupPath_ extends string, Group extends GroupSpec.AnyWithProps> = GroupPath.GroupAt<Group, GroupPath_> extends infer GroupAtPath extends GroupSpec.AnyWithProps ? FunctionSpec.Name<GroupSpec.Functions<GroupAtPath>> extends infer FunctionNames extends string ? FunctionNames extends string ? FunctionImpl<GroupPath_, FunctionNames> : never : never : never;
+type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FunctionSpec.Name<GroupSpec.Functions<Group>> extends infer FunctionNames extends string ? FunctionNames extends string ? FunctionImpl<string, FunctionNames> : never : never;
+/**
+ * @deprecated Use {@link FromGroupSpec} instead.
+ */
+type FromGroupAtPath<_GroupPath extends string, Group extends GroupSpec.AnyWithProps> = FromGroupSpec<Group>;
 //#endregion
-export { ForGroupPathAndFunction, FromGroupAtPath, FunctionImpl, FunctionImpl_d_exports, make };
+export { ForGroupPathAndFunction, FromGroupAtPath, FromGroupSpec, FunctionImpl, FunctionImpl_d_exports, make };
 //# sourceMappingURL=FunctionImpl.d.ts.map

package/dist/FunctionImpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionImpl.d.ts","names":[],"sources":["../src/FunctionImpl.ts"],"mappings":";;;;;;;;;;;UAUiB,YAAA;EAAA,SAIN,SAAA,EAAW,UAAA;EAAA,SACX,YAAA,EAAc,YAAA;AAAA;AAAA,cAGZ,YAAA;EAGX,SAAA;EAAA;AAAA;EAIA,SAAA,EAAW,UAAA;EACX,YAAA,EAAc,YAAA;AAAA,MACf,OAAA,CAAA,GAAA,CAAA,YAAA,CAAA,UAAA,EAAA,YAAA,GAAA,YAAA,CAAA,UAAA,EAAA,YAAA;AAAA,cAKY,IAAA,gBACE,YAAA,2BACY,SAAA,CAAU,GAAA,CAAI,MAAA,CAAW,IAAA,+BACvB,YAAA,CAAa,IAAA,CACtC,SAAA,CAAU,SAAA,CAAU,SAAA,CAAU,OAAA,CAAQ,MAAA,CAAW,IAAA,GAAO,UAAA,KAG1D,GAAA,EAAK,IAAA,EACL,SAAA,EAAW,UAAA,EACX,YAAA,EAAc,YAAA,EACd,OAAA,EAAS,QAAA,CACP,QAAA,CAAW,IAAA,GACX,SAAA,CAAU,SAAA,CAAU,SAAA,CAAU,OAAA,CAAQ,MAAA,CAAW,IAAA,GAAO,UAAA,IACxD,YAAA,MAED,KAAA,CAAM,KAAA,CAAM,YAAA,CAAa,UAAA,EAAY,YAAA;AArCxC;;;AAAA,KAgFY,uBAAA,2DAGR,YAAA,CAAa,UAAA,EAAY,YAAA;;;;KAKjB,eAAA,0CAEI,SAAA,CAAU,YAAA,IAExB,SAAA,CAAU,OAAA,CAAQ,KAAA,EAAO,UAAA,oCACvB,SAAA,CAAU,YAAA,GACR,YAAA,CAAa,IAAA,CACX,SAAA,CAAU,SAAA,CAAU,WAAA,gDAEpB,aAAA,kBACE,YAAA,CAAa,UAAA,EAAY,aAAA"}
+{"version":3,"file":"FunctionImpl.d.ts","names":[],"sources":["../src/FunctionImpl.ts"],"mappings":";;;;;;;;;;UAUiB,YAAA;EAAA,SAIN,SAAA,EAAW,UAAA;EAAA,SACX,YAAA,EAAc,YAAA;AAAA;AAAA,cAGZ,YAAA;EAGX,SAAA;EAAA;AAAA;EAIA,SAAA,EAAW,UAAA;EACX,YAAA,EAAc,YAAA;AAAA,MACf,OAAA,CAAA,GAAA,CAAA,YAAA,CAAA,UAAA,EAAA,YAAA,GAAA,YAAA,CAAA,UAAA,EAAA,YAAA;AAAA,cAKY,IAAA,gBACE,YAAA,gBACC,SAAA,CAAU,YAAA,6BACG,YAAA,CAAa,IAAA,CAAK,SAAA,CAAU,SAAA,CAAU,KAAA,IAEjE,GAAA,EAAK,IAAA,EACL,KAAA,EAAO,KAAA,EACP,YAAA,EAAc,YAAA,EACd,OAAA,EAAS,QAAA,CACP,QAAA,CAAW,IAAA,GACX,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,MAED,KAAA,CAAM,KAAA,CAAM,YAAA,SAAqB,YAAA;;AAnCpC;;KAqEY,uBAAA,2DAGR,YAAA,CAAa,UAAA,EAAY,YAAA;;;;KAKjB,aAAA,eAA4B,SAAA,CAAU,YAAA,IAChD,YAAA,CAAa,IAAA,CACX,SAAA,CAAU,SAAA,CAAU,KAAA,gDAElB,aAAA,kBACE,YAAA,SAAqB,aAAA;;;;KAOjB,eAAA,0CAEI,SAAA,CAAU,YAAA,IACtB,aAAA,CAAc,KAAA"}

package/dist/FunctionImpl.js

@@ -1,8 +1,9 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { resolveGroupPathUnsafe } from "./GroupPath.js";
 import { setNestedProperty } from "./internal/utils.js";
-import { Registry } from "./Registry.js";
 import { make as make$1 } from "./RegistryItem.js";
-import { Array, Context, Effect, Layer, Ref, String } from "effect";
+import { Context, Effect, Layer, Ref, String } from "effect";
+import * as Registry from "@confect/core/Registry";
 
 //#region src/FunctionImpl.ts
 var FunctionImpl_exports = /* @__PURE__ */ __exportAll({
@@ -10,16 +11,15 @@ var FunctionImpl_exports = /* @__PURE__ */ __exportAll({
 	make: () => make
 });
 const FunctionImpl = ({ groupPath, functionName }) => Context.GenericTag(`@confect/server/FunctionImpl/${groupPath}/${functionName}`);
-const make = (api, groupPath, functionName, handler) => {
-	const groupPathParts = String.split(groupPath, ".");
-	const [firstGroupPathPart, ...restGroupPathParts] = groupPathParts;
-	const functionSpec = Array.reduce(restGroupPathParts, api.spec.groups[firstGroupPathPart], (currentGroup, groupPathPart) => currentGroup.groups[groupPathPart]).functions[functionName];
+const make = (api, group, functionName, handler) => {
+	const groupPath = resolveGroupPathUnsafe(api.spec, group);
+	const functionSpec = group.functions[functionName];
 	return Layer.effect(FunctionImpl({
 		groupPath,
 		functionName
 	}), Effect.gen(function* () {
-		const registry = yield* Registry;
-		yield* Ref.update(registry, (registryItems) => setNestedProperty(registryItems, [...groupPathParts, functionName], make$1({
+		const registry = yield* Registry.Registry;
+		yield* Ref.update(registry, (registryItems) => setNestedProperty(registryItems, [...String.split(groupPath, "."), functionName], make$1({
 			functionSpec,
 			handler
 		})));

package/dist/FunctionImpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionImpl.js","names":["Registry.Registry","RegistryItem.make"],"sources":["../src/FunctionImpl.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupPath from \"@confect/core/GroupPath\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport { Array, Context, Effect, Layer, Ref, String } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as Handler from \"./Handler\";\nimport { setNestedProperty } from \"./internal/utils\";\nimport * as Registry from \"./Registry\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport interface FunctionImpl<\n  GroupPath_ extends string,\n  FunctionName extends string,\n> {\n  readonly groupPath: GroupPath_;\n  readonly functionName: FunctionName;\n}\n\nexport const FunctionImpl = <\n  GroupPath_ extends string,\n  FunctionName extends string,\n>({\n  groupPath,\n  functionName,\n}: {\n  groupPath: GroupPath_;\n  functionName: FunctionName;\n}) =>\n  Context.GenericTag<FunctionImpl<GroupPath_, FunctionName>>(\n    `@confect/server/FunctionImpl/${groupPath}/${functionName}`,\n  );\n\nexport const make = <\n  Api_ extends Api.AnyWithProps,\n  const GroupPath_ extends GroupPath.All<Api.Groups<Api_>>,\n  const FunctionName extends FunctionSpec.Name<\n    GroupSpec.Functions<GroupPath.GroupAt<Api.Groups<Api_>, GroupPath_>>\n  >,\n>(\n  api: Api_,\n  groupPath: GroupPath_,\n  functionName: FunctionName,\n  handler: Handler.WithName<\n    Api.Schema<Api_>,\n    GroupSpec.Functions<GroupPath.GroupAt<Api.Groups<Api_>, GroupPath_>>,\n    FunctionName\n  >,\n): Layer.Layer<FunctionImpl<GroupPath_, FunctionName>> => {\n  const groupPathParts = String.split(groupPath, \".\");\n  const [firstGroupPathPart, ...restGroupPathParts] = groupPathParts;\n\n  const group_: GroupSpec.AnyWithProps = Array.reduce(\n    restGroupPathParts,\n    (api as any).spec.groups[firstGroupPathPart as any]!,\n    (currentGroup: any, groupPathPart: any) =>\n      currentGroup.groups[groupPathPart],\n  );\n\n  const functionSpec = group_.functions[functionName]!;\n\n  return Layer.effect(\n    FunctionImpl<GroupPath_, FunctionName>({\n      groupPath,\n      functionName,\n    }),\n    Effect.gen(function* () {\n      const registry = yield* Registry.Registry;\n\n      yield* Ref.update(registry, (registryItems) =>\n        setNestedProperty(\n          registryItems,\n          [...groupPathParts, functionName],\n          RegistryItem.make({\n            functionSpec,\n            handler,\n          }),\n        ),\n      );\n\n      return {\n        groupPath,\n        functionName,\n      };\n    }),\n  );\n};\n\n/**\n * Get the function implementation service type for a specific group path and function name.\n */\nexport type ForGroupPathAndFunction<\n  GroupPath_ extends string,\n  FunctionName extends string,\n> = FunctionImpl<GroupPath_, FunctionName>;\n\n/**\n * Get all function implementation services required for a group at a given path.\n */\nexport type FromGroupAtPath<\n  GroupPath_ extends string,\n  Group extends GroupSpec.AnyWithProps,\n> =\n  GroupPath.GroupAt<Group, GroupPath_> extends infer GroupAtPath extends\n    GroupSpec.AnyWithProps\n    ? FunctionSpec.Name<\n        GroupSpec.Functions<GroupAtPath>\n      > extends infer FunctionNames extends string\n      ? FunctionNames extends string\n        ? FunctionImpl<GroupPath_, FunctionNames>\n        : never\n      : never\n    : never;\n"],"mappings":";;;;;;;;;;;AAkBA,MAAa,gBAGX,EACA,WACA,mBAKA,QAAQ,WACN,gCAAgC,UAAU,GAAG,eAC9C;AAEH,MAAa,QAOX,KACA,WACA,cACA,YAKwD;CACxD,MAAM,iBAAiB,OAAO,MAAM,WAAW,IAAI;CACnD,MAAM,CAAC,oBAAoB,GAAG,sBAAsB;CASpD,MAAM,eAPiC,MAAM,OAC3C,oBACC,IAAY,KAAK,OAAO,sBACxB,cAAmB,kBAClB,aAAa,OAAO,eACvB,CAE2B,UAAU;AAEtC,QAAO,MAAM,OACX,aAAuC;EACrC;EACA;EACD,CAAC,EACF,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,OAAOA;AAExB,SAAO,IAAI,OAAO,WAAW,kBAC3B,kBACE,eACA,CAAC,GAAG,gBAAgB,aAAa,EACjCC,OAAkB;GAChB;GACA;GACD,CAAC,CACH,CACF;AAED,SAAO;GACL;GACA;GACD;GACD,CACH"}
+{"version":3,"file":"FunctionImpl.js","names":["RegistryItem.make"],"sources":["../src/FunctionImpl.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport * as Registry from \"@confect/core/Registry\";\nimport { Context, Effect, Layer, Ref, String } from \"effect\";\nimport type * as Api from \"./Api\";\nimport { resolveGroupPathUnsafe } from \"./GroupPath\";\nimport type * as Handler from \"./Handler\";\nimport { setNestedProperty } from \"./internal/utils\";\nimport * as RegistryItem from \"./RegistryItem\";\n\nexport interface FunctionImpl<\n  GroupPath_ extends string,\n  FunctionName extends string,\n> {\n  readonly groupPath: GroupPath_;\n  readonly functionName: FunctionName;\n}\n\nexport const FunctionImpl = <\n  GroupPath_ extends string,\n  FunctionName extends string,\n>({\n  groupPath,\n  functionName,\n}: {\n  groupPath: GroupPath_;\n  functionName: FunctionName;\n}) =>\n  Context.GenericTag<FunctionImpl<GroupPath_, FunctionName>>(\n    `@confect/server/FunctionImpl/${groupPath}/${functionName}`,\n  );\n\nexport const make = <\n  Api_ extends Api.AnyWithProps,\n  Group extends GroupSpec.AnyWithProps,\n  const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>,\n>(\n  api: Api_,\n  group: Group,\n  functionName: FunctionName,\n  handler: Handler.WithName<\n    Api.Schema<Api_>,\n    GroupSpec.Functions<Group>,\n    FunctionName\n  >,\n): Layer.Layer<FunctionImpl<string, FunctionName>> => {\n  const groupPath = resolveGroupPathUnsafe(api.spec, group);\n  const functionSpec = group.functions[functionName]!;\n\n  return Layer.effect(\n    FunctionImpl<string, FunctionName>({\n      groupPath,\n      functionName,\n    }),\n    Effect.gen(function* () {\n      const registry = yield* Registry.Registry;\n\n      yield* Ref.update(registry, (registryItems) =>\n        setNestedProperty(\n          registryItems,\n          [...String.split(groupPath, \".\"), functionName],\n          RegistryItem.make({\n            functionSpec,\n            handler,\n          }),\n        ),\n      );\n\n      return {\n        groupPath,\n        functionName,\n      };\n    }),\n  );\n};\n\n/**\n * Get the function implementation service type for a specific group path and function name.\n */\nexport type ForGroupPathAndFunction<\n  GroupPath_ extends string,\n  FunctionName extends string,\n> = FunctionImpl<GroupPath_, FunctionName>;\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<string, FunctionNames>\n      : never\n    : never;\n\n/**\n * @deprecated Use {@link FromGroupSpec} instead.\n */\nexport type FromGroupAtPath<\n  _GroupPath extends string,\n  Group extends GroupSpec.AnyWithProps,\n> = FromGroupSpec<Group>;\n"],"mappings":";;;;;;;;;;;;AAkBA,MAAa,gBAGX,EACA,WACA,mBAKA,QAAQ,WACN,gCAAgC,UAAU,GAAG,eAC9C;AAEH,MAAa,QAKX,KACA,OACA,cACA,YAKoD;CACpD,MAAM,YAAY,uBAAuB,IAAI,MAAM,MAAM;CACzD,MAAM,eAAe,MAAM,UAAU;AAErC,QAAO,MAAM,OACX,aAAmC;EACjC;EACA;EACD,CAAC,EACF,OAAO,IAAI,aAAa;EACtB,MAAM,WAAW,OAAO,SAAS;AAEjC,SAAO,IAAI,OAAO,WAAW,kBAC3B,kBACE,eACA,CAAC,GAAG,OAAO,MAAM,WAAW,IAAI,EAAE,aAAa,EAC/CA,OAAkB;GAChB;GACA;GACD,CAAC,CACH,CACF;AAED,SAAO;GACL;GACA;GACD;GACD,CACH"}

package/dist/GroupImpl.d.ts

@@ -1,24 +1,63 @@
-import { AnyWithProps, Groups } from "./Api.js";
-import { FromGroupAtPath } from "./FunctionImpl.js";
+import { AnyWithProps } from "./Api.js";
+import { FromGroupSpec as FromGroupSpec$1 } from "./FunctionImpl.js";
 import { Context, Layer } from "effect";
-import * as GroupPath from "@confect/core/GroupPath";
 import * as GroupSpec from "@confect/core/GroupSpec";
 
 //#region src/GroupImpl.d.ts
 declare namespace GroupImpl_d_exports {
-  export { FromGroupWithPath, FromGroups, GroupImpl, make };
+  export { Any, AnyFinalized, AnyUnfinalized, FinalizationStatus, FromGroupSpec, GroupImpl, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
 }
-interface GroupImpl<GroupPath_ extends string> {
+declare const TypeId = "@confect/server/GroupImpl";
+type TypeId = typeof TypeId;
+type FinalizationStatus = "Unfinalized" | "Finalized";
+interface GroupImpl<GroupPath_ extends string, FinalizationStatus_ extends FinalizationStatus = "Unfinalized"> {
+  readonly [TypeId]: TypeId;
   readonly groupPath: GroupPath_;
+  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>;
 }
-declare const GroupImpl: <GroupPath_ extends string>({
-  groupPath
+interface Any extends GroupImpl<string, FinalizationStatus> {}
+declare const isGroupImpl: (u: unknown) => u is Any;
+interface AnyFinalized extends GroupImpl<string, "Finalized"> {}
+interface AnyUnfinalized extends GroupImpl<string, "Unfinalized"> {}
+declare const isFinalizedGroupImpl: (u: unknown) => u is AnyFinalized;
+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 `implValidation`) retrieve
+ * the typed `Finalized` service directly rather than scanning the context.
+ */
+declare const GroupImpl: <GroupPath_ extends string, FinalizationStatus_ extends FinalizationStatus>({
+  groupPath,
+  finalizationStatus
 }: {
   groupPath: GroupPath_;
-}) => Context.Tag<GroupImpl<GroupPath_>, GroupImpl<GroupPath_>>;
-declare const make: <Api_ extends AnyWithProps, const GroupPath_ extends GroupPath.All<Groups<Api_>>>(_api: Api_, groupPath: GroupPath_) => Layer.Layer<GroupImpl<GroupPath_>, never, FromGroupWithPath<GroupPath_, Groups<Api_>> | FromGroupAtPath<GroupPath_, Groups<Api_>>>;
-type FromGroups<Groups extends GroupSpec.Any> = Groups extends never ? never : Groups extends GroupSpec.AnyWithProps ? GroupImpl<GroupSpec.Name<Groups>> : never;
-type FromGroupWithPath<GroupPath_ extends string, Group extends GroupSpec.AnyWithProps> = GroupPath.SubGroupsAt<Group, GroupPath_> extends infer SubGroupPaths ? SubGroupPaths extends string ? GroupImpl<SubGroupPaths> : never : never;
+  finalizationStatus: FinalizationStatus_;
+}) => Context.Tag<GroupImpl<GroupPath_, FinalizationStatus_>, GroupImpl<GroupPath_, FinalizationStatus_>>;
+declare const make: <Api_ extends AnyWithProps, Group extends GroupSpec.AnyWithProps>(api: Api_, group: Group) => Layer.Layer<GroupImpl<string, "Unfinalized">, never, FromGroupSpec$1<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.
+ */
+declare const finalize: <GroupPath_ extends string>(group: Layer.Layer<GroupImpl<GroupPath_, "Unfinalized">>) => Layer.Layer<GroupImpl<GroupPath_, "Finalized">>;
+type FromGroupSpec<Group extends GroupSpec.AnyWithProps> = FromGroupSpec$1<Group>;
 //#endregion
-export { FromGroupWithPath, FromGroups, GroupImpl, GroupImpl_d_exports, make };
+export { Any, AnyFinalized, AnyUnfinalized, FinalizationStatus, FromGroupSpec, GroupImpl, GroupImpl_d_exports, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
 //# sourceMappingURL=GroupImpl.d.ts.map

package/dist/GroupImpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GroupImpl.d.ts","names":[],"sources":["../src/GroupImpl.ts"],"mappings":";;;;;;;;;;UAMiB,SAAA;EAAA,SACN,SAAA,EAAW,UAAA;AAAA;AAAA,cAGT,SAAA;EAAwC;AAAA;EAGnD,SAAA,EAAW,UAAA;AAAA,MACZ,OAAA,CAAA,GAAA,CAAA,SAAA,CAAA,UAAA,GAAA,SAAA,CAAA,UAAA;AAAA,cAKY,IAAA,gBACE,YAAA,2BACY,SAAA,CAAU,GAAA,CAAI,MAAA,CAAW,IAAA,IAElD,IAAA,EAAM,IAAA,EACN,SAAA,EAAW,UAAA,KACV,KAAA,CAAM,KAAA,CACP,SAAA,CAAU,UAAA,UAER,iBAAA,CAAkB,UAAA,EAAY,MAAA,CAAW,IAAA,KACzC,eAAA,CAA6B,UAAA,EAAY,MAAA,CAAW,IAAA;AAAA,KAgB5C,UAAA,gBAA0B,SAAA,CAAU,GAAA,IAAO,MAAA,yBAEnD,MAAA,SAAe,SAAA,CAAU,YAAA,GACvB,SAAA,CAAU,SAAA,CAAU,IAAA,CAAK,MAAA;AAAA,KAGnB,iBAAA,0CAEI,SAAA,CAAU,YAAA,IAExB,SAAA,CAAU,WAAA,CAAY,KAAA,EAAO,UAAA,gCACzB,aAAA,kBACE,SAAA,CAAU,aAAA"}
+{"version":3,"file":"GroupImpl.d.ts","names":[],"sources":["../src/GroupImpl.ts"],"mappings":";;;;;;;;;cAkBa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,KAEhB,kBAAA;AAAA,UAEK,SAAA,wDAEa,kBAAA;EAAA,UAElB,MAAA,GAAS,MAAA;EAAA,SACV,SAAA,EAAW,UAAA;EAAA,SACX,kBAAA,EAAoB,mBAAA;;;;;;;WAOpB,uBAAA,EAAyB,aAAA;AAAA;AAAA,UAGnB,GAAA,SAAY,SAAA,SAAkB,kBAAA;AAAA,cAElC,WAAA,GAAe,CAAA,cAAa,CAAA,IAAK,GAAA;AAAA,UAG7B,YAAA,SAAqB,SAAA;AAAA,UACrB,cAAA,SAAuB,SAAA;AAAA,cAE3B,oBAAA,GAAwB,CAAA,cAAa,CAAA,IAAK,YAAA;AAAA,cAG1C,sBAAA,GAA0B,CAAA,cAAa,CAAA,IAAK,cAAA;;;;AA7BzD;;;;cAuCa,SAAA,0DAEiB,kBAAA;EAC5B,SAAA;EAAA;AAAA;EAIA,SAAA,EAAW,UAAA;EACX,kBAAA,EAAoB,mBAAA;AAAA,MACrB,OAAA,CAAA,GAAA,CAAA,SAAA,CAAA,UAAA,EAAA,mBAAA,GAAA,SAAA,CAAA,UAAA,EAAA,mBAAA;AAAA,cAKY,IAAA,gBACE,YAAA,gBACC,SAAA,CAAU,YAAA,EAExB,GAAA,EAAK,IAAA,EACL,KAAA,EAAO,KAAA,KACN,KAAA,CAAM,KAAA,CACP,SAAA,gCAEA,eAAA,CAA2B,KAAA;;;;;;;;;;;;;;cAuEhB,QAAA,8BACX,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,SAAA,CAAU,UAAA,sBAC5B,KAAA,CAAM,KAAA,CAAM,SAAA,CAAU,UAAA;AAAA,KAsCb,aAAA,eAA4B,SAAA,CAAU,YAAA,IAChD,eAAA,CAA2B,KAAA"}

package/dist/GroupImpl.js

@@ -1,14 +1,82 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Layer } from "effect";
+import { resolveGroupPathUnsafe } from "./GroupPath.js";
+import { Array, Context, Effect, Layer, Option, Predicate, Record, Ref, String, pipe } from "effect";
+import * as Registry from "@confect/core/Registry";
 
 //#region src/GroupImpl.ts
 var GroupImpl_exports = /* @__PURE__ */ __exportAll({
 	GroupImpl: () => GroupImpl,
+	TypeId: () => TypeId,
+	finalize: () => finalize,
+	isFinalizedGroupImpl: () => isFinalizedGroupImpl,
+	isGroupImpl: () => isGroupImpl,
+	isUnfinalizedGroupImpl: () => isUnfinalizedGroupImpl,
 	make: () => make
 });
-const GroupImpl = ({ groupPath }) => Context.GenericTag(`@confect/server/GroupImpl/${groupPath}`);
-const make = (_api, groupPath) => Layer.succeed(GroupImpl({ groupPath }), { groupPath });
+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 `implValidation`) retrieve
+* the typed `Finalized` service directly rather than scanning the context.
+*/
+const GroupImpl = ({ groupPath, finalizationStatus }) => Context.GenericTag(`@confect/server/GroupImpl/${finalizationStatus}/${groupPath}`);
+const make = (api, group) => {
+	const groupPath = resolveGroupPathUnsafe(api.spec, group);
+	return Layer.succeed(GroupImpl({
+		groupPath,
+		finalizationStatus: "Unfinalized"
+	}), {
+		[TypeId]: TypeId,
+		groupPath,
+		finalizationStatus: "Unfinalized",
+		registeredFunctionNames: []
+	});
+};
+const isFunctionShaped = (value) => Predicate.isRecord(value) && "functionSpec" in value;
+/**
+* Walk a `RegistryItems` tree to the entries at `groupPath` and return the
+* names of the function-shaped leaves directly underneath.
+*/
+const collectFunctionNamesAtPath = (items, groupPath) => pipe(String.split(groupPath, "."), Array.reduce(Option.some(items), (acc, segment) => acc.pipe(Option.filter(Predicate.isRecord), Option.flatMap((node) => segment in node ? Option.some(node[segment]) : Option.none()))), Option.filter(Predicate.isRecord), Option.map(Record.toEntries), Option.map(Array.filterMap(([name, value]) => isFunctionShaped(value) ? Option.some(name) : Option.none())), Option.getOrElse(() => []));
+const findUnfinalizedGroupImpl = (context) => Array.findFirst(context.unsafeMap.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.die(/* @__PURE__ */ new Error("GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.")),
+	onSome: (unfinalized) => {
+		const groupPath = unfinalized.groupPath;
+		return Layer.effect(GroupImpl({
+			groupPath,
+			finalizationStatus: "Finalized"
+		}), Effect.gen(function* () {
+			const registry = yield* Registry.Registry;
+			const items = yield* Ref.get(registry);
+			return {
+				[TypeId]: TypeId,
+				groupPath,
+				finalizationStatus: "Finalized",
+				registeredFunctionNames: collectFunctionNamesAtPath(items, groupPath)
+			};
+		}));
+	}
+})));
 
 //#endregion
-export { GroupImpl, GroupImpl_exports, make };
+export { GroupImpl, GroupImpl_exports, TypeId, finalize, isFinalizedGroupImpl, isGroupImpl, isUnfinalizedGroupImpl, make };
 //# sourceMappingURL=GroupImpl.js.map

package/dist/GroupImpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"GroupImpl.js","names":[],"sources":["../src/GroupImpl.ts"],"sourcesContent":["import type * as GroupPath from \"@confect/core/GroupPath\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport { Context, Layer } from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as FunctionImpl from \"./FunctionImpl\";\n\nexport interface GroupImpl<GroupPath_ extends string> {\n  readonly groupPath: GroupPath_;\n}\n\nexport const GroupImpl = <GroupPath_ extends string>({\n  groupPath,\n}: {\n  groupPath: GroupPath_;\n}) =>\n  Context.GenericTag<GroupImpl<GroupPath_>>(\n    `@confect/server/GroupImpl/${groupPath}`,\n  );\n\nexport const make = <\n  Api_ extends Api.AnyWithProps,\n  const GroupPath_ extends GroupPath.All<Api.Groups<Api_>>,\n>(\n  _api: Api_,\n  groupPath: GroupPath_,\n): Layer.Layer<\n  GroupImpl<GroupPath_>,\n  never,\n  | FromGroupWithPath<GroupPath_, Api.Groups<Api_>>\n  | FunctionImpl.FromGroupAtPath<GroupPath_, Api.Groups<Api_>>\n> =>\n  Layer.succeed(\n    GroupImpl<GroupPath_>({\n      groupPath,\n    }),\n    {\n      groupPath,\n    },\n  ) as Layer.Layer<\n    GroupImpl<GroupPath_>,\n    never,\n    | FromGroupWithPath<GroupPath_, Api.Groups<Api_>>\n    | FunctionImpl.FromGroupAtPath<GroupPath_, Api.Groups<Api_>>\n  >;\n\nexport type FromGroups<Groups extends GroupSpec.Any> = Groups extends never\n  ? never\n  : Groups extends GroupSpec.AnyWithProps\n    ? GroupImpl<GroupSpec.Name<Groups>>\n    : never;\n\nexport type FromGroupWithPath<\n  GroupPath_ extends string,\n  Group extends GroupSpec.AnyWithProps,\n> =\n  GroupPath.SubGroupsAt<Group, GroupPath_> extends infer SubGroupPaths\n    ? SubGroupPaths extends string\n      ? GroupImpl<SubGroupPaths>\n      : never\n    : never;\n"],"mappings":";;;;;;;;AAUA,MAAa,aAAwC,EACnD,gBAIA,QAAQ,WACN,6BAA6B,YAC9B;AAEH,MAAa,QAIX,MACA,cAOA,MAAM,QACJ,UAAsB,EACpB,WACD,CAAC,EACF,EACE,WACD,CACF"}
+{"version":3,"file":"GroupImpl.js","names":[],"sources":["../src/GroupImpl.ts"],"sourcesContent":["import type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport * as Registry from \"@confect/core/Registry\";\nimport {\n  Array,\n  Context,\n  Effect,\n  Layer,\n  Option,\n  pipe,\n  Predicate,\n  Record,\n  Ref,\n  String,\n} from \"effect\";\nimport type * as Api from \"./Api\";\nimport type * as FunctionImpl from \"./FunctionImpl\";\nimport { resolveGroupPathUnsafe } from \"./GroupPath\";\n\nexport const TypeId = \"@confect/server/GroupImpl\";\nexport type TypeId = typeof TypeId;\n\nexport type FinalizationStatus = \"Unfinalized\" | \"Finalized\";\n\nexport interface GroupImpl<\n  GroupPath_ extends string,\n  FinalizationStatus_ extends FinalizationStatus = \"Unfinalized\",\n> {\n  readonly [TypeId]: TypeId;\n  readonly groupPath: GroupPath_;\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\nexport interface Any extends GroupImpl<string, FinalizationStatus> {}\n\nexport const isGroupImpl = (u: unknown): u is Any =>\n  Predicate.hasProperty(u, TypeId);\n\nexport interface AnyFinalized extends GroupImpl<string, \"Finalized\"> {}\nexport interface AnyUnfinalized extends GroupImpl<string, \"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 `implValidation`) retrieve\n * the typed `Finalized` service directly rather than scanning the context.\n */\nexport const GroupImpl = <\n  GroupPath_ extends string,\n  FinalizationStatus_ extends FinalizationStatus,\n>({\n  groupPath,\n  finalizationStatus,\n}: {\n  groupPath: GroupPath_;\n  finalizationStatus: FinalizationStatus_;\n}) =>\n  Context.GenericTag<GroupImpl<GroupPath_, FinalizationStatus_>>(\n    `@confect/server/GroupImpl/${finalizationStatus}/${groupPath}`,\n  );\n\nexport const make = <\n  Api_ extends Api.AnyWithProps,\n  Group extends GroupSpec.AnyWithProps,\n>(\n  api: Api_,\n  group: Group,\n): Layer.Layer<\n  GroupImpl<string, \"Unfinalized\">,\n  never,\n  FunctionImpl.FromGroupSpec<Group>\n> => {\n  const groupPath = resolveGroupPathUnsafe(api.spec, group);\n\n  return Layer.succeed(\n    GroupImpl<string, \"Unfinalized\">({\n      groupPath,\n      finalizationStatus: \"Unfinalized\",\n    }),\n    {\n      [TypeId]: TypeId,\n      groupPath,\n      finalizationStatus: \"Unfinalized\" as const,\n      registeredFunctionNames: [],\n    },\n  ) as Layer.Layer<\n    GroupImpl<string, \"Unfinalized\">,\n    never,\n    FunctionImpl.FromGroupSpec<Group>\n  >;\n};\n\nconst isFunctionShaped = (value: unknown): boolean =>\n  Predicate.isRecord(value) && \"functionSpec\" in value;\n\n/**\n * Walk a `RegistryItems` tree to the entries at `groupPath` and return the\n * names of the function-shaped leaves directly underneath.\n */\nconst collectFunctionNamesAtPath = (\n  items: Registry.RegistryItems,\n  groupPath: string,\n): ReadonlyArray<string> =>\n  pipe(\n    String.split(groupPath, \".\"),\n    Array.reduce(Option.some<unknown>(items), (acc, segment) =>\n      acc.pipe(\n        Option.filter(Predicate.isRecord),\n        Option.flatMap((node) =>\n          segment in node ? Option.some(node[segment]) : Option.none(),\n        ),\n      ),\n    ),\n    Option.filter(Predicate.isRecord),\n    Option.map(Record.toEntries),\n    Option.map(\n      Array.filterMap(([name, value]) =>\n        isFunctionShaped(value) ? Option.some(name) : Option.none(),\n      ),\n    ),\n    Option.getOrElse((): ReadonlyArray<string> => []),\n  );\n\nconst findUnfinalizedGroupImpl = <S>(\n  context: Context.Context<S>,\n): Option.Option<AnyUnfinalized> =>\n  Array.findFirst(context.unsafeMap.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\n * boundary requires the resulting `\"Finalized\"` brand, so omitting this call\n * is also 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\n * service value's `registeredFunctionNames` field, so consumers can verify\n * impl completeness against a `GroupSpec`'s expected functions without\n * having to inspect the `Registry` themselves.\n */\nexport const finalize = <GroupPath_ extends string>(\n  group: Layer.Layer<GroupImpl<GroupPath_, \"Unfinalized\">>,\n): Layer.Layer<GroupImpl<GroupPath_, \"Finalized\">> =>\n  Layer.flatMap(\n    group,\n    (context): Layer.Layer<GroupImpl<GroupPath_, \"Finalized\">> =>\n      findUnfinalizedGroupImpl(context).pipe(\n        Option.match({\n          onNone: () =>\n            Layer.die(\n              new Error(\n                \"GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.\",\n              ),\n            ),\n          onSome: (unfinalized) => {\n            const groupPath = unfinalized.groupPath as GroupPath_;\n            return Layer.effect(\n              GroupImpl<GroupPath_, \"Finalized\">({\n                groupPath,\n                finalizationStatus: \"Finalized\",\n              }),\n              Effect.gen(function* () {\n                const registry = yield* Registry.Registry;\n                const items = yield* Ref.get(registry);\n                return {\n                  [TypeId]: TypeId,\n                  groupPath,\n                  finalizationStatus: \"Finalized\" as const,\n                  registeredFunctionNames: collectFunctionNamesAtPath(\n                    items,\n                    groupPath,\n                  ),\n                };\n              }),\n            );\n          },\n        }),\n      ),\n  );\n\nexport type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =\n  FunctionImpl.FromGroupSpec<Group>;\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,MAAa,SAAS;AAuBtB,MAAa,eAAe,MAC1B,UAAU,YAAY,GAAG,OAAO;AAKlC,MAAa,wBAAwB,MACnC,YAAY,EAAE,IAAI,EAAE,uBAAuB;AAE7C,MAAa,0BAA0B,MACrC,YAAY,EAAE,IAAI,EAAE,uBAAuB;;;;;;;;AAS7C,MAAa,aAGX,EACA,WACA,yBAKA,QAAQ,WACN,6BAA6B,mBAAmB,GAAG,YACpD;AAEH,MAAa,QAIX,KACA,UAKG;CACH,MAAM,YAAY,uBAAuB,IAAI,MAAM,MAAM;AAEzD,QAAO,MAAM,QACX,UAAiC;EAC/B;EACA,oBAAoB;EACrB,CAAC,EACF;GACG,SAAS;EACV;EACA,oBAAoB;EACpB,yBAAyB,EAAE;EAC5B,CACF;;AAOH,MAAM,oBAAoB,UACxB,UAAU,SAAS,MAAM,IAAI,kBAAkB;;;;;AAMjD,MAAM,8BACJ,OACA,cAEA,KACE,OAAO,MAAM,WAAW,IAAI,EAC5B,MAAM,OAAO,OAAO,KAAc,MAAM,GAAG,KAAK,YAC9C,IAAI,KACF,OAAO,OAAO,UAAU,SAAS,EACjC,OAAO,SAAS,SACd,WAAW,OAAO,OAAO,KAAK,KAAK,SAAS,GAAG,OAAO,MAAM,CAC7D,CACF,CACF,EACD,OAAO,OAAO,UAAU,SAAS,EACjC,OAAO,IAAI,OAAO,UAAU,EAC5B,OAAO,IACL,MAAM,WAAW,CAAC,MAAM,WACtB,iBAAiB,MAAM,GAAG,OAAO,KAAK,KAAK,GAAG,OAAO,MAAM,CAC5D,CACF,EACD,OAAO,gBAAuC,EAAE,CAAC,CAClD;AAEH,MAAM,4BACJ,YAEA,MAAM,UAAU,QAAQ,UAAU,QAAQ,EAAE,uBAAuB;;;;;;;;;;;;;;AAerE,MAAa,YACX,UAEA,MAAM,QACJ,QACC,YACC,yBAAyB,QAAQ,CAAC,KAChC,OAAO,MAAM;CACX,cACE,MAAM,oBACJ,IAAI,MACF,yFACD,CACF;CACH,SAAS,gBAAgB;EACvB,MAAM,YAAY,YAAY;AAC9B,SAAO,MAAM,OACX,UAAmC;GACjC;GACA,oBAAoB;GACrB,CAAC,EACF,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,OAAO,SAAS;GACjC,MAAM,QAAQ,OAAO,IAAI,IAAI,SAAS;AACtC,UAAO;KACJ,SAAS;IACV;IACA,oBAAoB;IACpB,yBAAyB,2BACvB,OACA,UACD;IACF;IACD,CACH;;CAEJ,CAAC,CACH,CACJ"}

package/dist/GroupPath.d.ts

@@ -0,0 +1,8 @@
+import * as Spec from "@confect/core/Spec";
+import * as GroupSpec from "@confect/core/GroupSpec";
+
+//#region src/GroupPath.d.ts
+declare const resolveGroupPathUnsafe: (spec: Spec.AnyWithProps, target: GroupSpec.AnyWithProps) => string;
+//#endregion
+export { resolveGroupPathUnsafe };
+//# sourceMappingURL=GroupPath.d.ts.map

package/dist/GroupPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupPath.d.ts","names":[],"sources":["../src/GroupPath.ts"],"mappings":";;;;cA+Ba,sBAAA,GACX,IAAA,EAAM,IAAA,CAAK,YAAA,EACX,MAAA,EAAQ,SAAA,CAAU,YAAA"}