@confect/server 7.0.0 → 9.0.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # @confect/server
 
+## 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
+
+- 87b7207: Renamed `DatabaseSchema.isSchema` to `DatabaseSchema.isDatabaseSchema` for consistency with the `is<TypeName>` predicate convention used elsewhere (e.g. `Spec.isSpec`). `TypeId` and `Any` are now defined in `@confect/core/DatabaseSchema` and re-exported from `@confect/server`; the underlying brand string is unchanged, so existing schema values continue to be recognized. Migration: replace `DatabaseSchema.isSchema(x)` with `DatabaseSchema.isDatabaseSchema(x)`.
+
+  Internally, this removes a cyclic workspace dependency between `@confect/cli` and `@confect/server` that triggered a pnpm install warning. `@confect/cli` no longer peer-depends on `@confect/server`.
+
+### Minor Changes
+
+- 4bb2722: Bump Effect ecosystem to latest. `@effect/platform` is now `^0.96.1` and `@effect/platform-node` is now `^0.106.0` in `@confect/server`'s peer dependencies; `effect` peer is now `^3.21.2` across packages. Consumers must upgrade `@effect/platform`, `@effect/platform-node`, and `effect` in lockstep when bumping `@confect/server`.
+
+### Patch Changes
+
+- f308edd: Fix Convex query cache invalidation when handlers use `Effect.log`, `Effect.withSpan`, or other Effect features that read the clock through its `unsafe*` methods.
+
+  The `Clock` provided to confect-wrapped handlers previously implemented `unsafeCurrentTimeMillis`/`unsafeCurrentTimeNanos` by calling the real `Date.now`, so Effect internals (logging, span events, the default scheduler) would read real time during handler execution and invalidate Convex's per-query cache. Those unsafe methods now return constants (`0`/`0n`), making the only opt-in to cache invalidation the user-facing `Clock.currentTimeMillis`/`Clock.currentTimeNanos` effects, as originally intended.
+
+- a02ef8a: Memoize `Document.decode` and `Document.encode` parsers in module-scoped `WeakMap` caches. Decoders are keyed by table schema and table name so shared schemas across tables get the correct `extendWithSystemFields` parser; encoders are keyed by schema only.
+- 40c1cff: Switch sibling `@confect/*` peer-dependency specifiers from `workspace:*` to `workspace:^`. Published peer ranges are now caret-based (e.g. `^7.0.0`) instead of exact-pinned, so non-major upgrades of one `@confect/*` package no longer fall out of range for its peer dependents.
+
+  Paired with the Changesets `onlyUpdatePeerDependentsWhenOutOfRange` flag, this prevents the entire `@confect/*` family from being promoted to a major bump on every release when only minor/patch changes are present.
+
+  `@confect/cli` additionally moves `@effect/platform` from `peerDependencies` to `dependencies`, since the CLI consumes it as an internal implementation detail (for `FileSystem`/`Path`) rather than exposing it in its public API. Consumers no longer need to install `@effect/platform` themselves to use the CLI.
+
+- Updated dependencies [4bb2722]
+- Updated dependencies [40c1cff]
+  - @confect/core@8.0.0
+
 ## 7.0.0
 
 ### Minor Changes

package/dist/DatabaseSchema.d.ts

@@ -5,11 +5,14 @@ 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, isSchema, make, systemSchema };
+  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;
-declare const isSchema: (u: unknown) => u is Any;
+interface Any {
+  readonly [TypeId]: TypeId;
+}
+declare const isDatabaseSchema: (u: unknown) => u is Any;
 /**
  * A schema definition tracks the schema and its Convex schema definition.
  */
@@ -22,9 +25,6 @@ interface DatabaseSchema<Tables_ extends AnyWithProps$1 = never> {
    */
   addTable<TableDef extends AnyWithProps$1>(table: TableDef): DatabaseSchema<Tables_ | TableDef>;
 }
-interface Any {
-  readonly [TypeId]: TypeId;
-}
 interface AnyWithProps {
   readonly [TypeId]: TypeId;
   readonly tables: Record<string, AnyWithProps$1>;
@@ -135,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 { Any, AnyWithProps, ConvexDatabaseSchemaFromTables, DatabaseSchema, DatabaseSchema_d_exports, ExtendWithSystemTables, IncludeSystemTables, TableNames, TableWithName, Tables, TypeId, extendWithSystemTables, isSchema, 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":";;;;;;;;;cAQa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,QAAA,GAAY,CAAA,cAAa,CAAA,IAAK,GAAA;;;;UAM1B,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,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,UAGJ,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"}
+{"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

@@ -7,12 +7,12 @@ import { defineSchema } from "convex/server";
 var DatabaseSchema_exports = /* @__PURE__ */ __exportAll({
 	TypeId: () => TypeId,
 	extendWithSystemTables: () => extendWithSystemTables,
-	isSchema: () => isSchema,
+	isDatabaseSchema: () => isDatabaseSchema,
 	make: () => make,
 	systemSchema: () => systemSchema
 });
 const TypeId = "@confect/server/DatabaseSchema";
-const isSchema = (u) => Predicate.hasProperty(u, TypeId);
+const isDatabaseSchema = (u) => Predicate.hasProperty(u, TypeId);
 const Proto = {
 	[TypeId]: TypeId,
 	addTable(table) {
@@ -41,5 +41,5 @@ const extendWithSystemTables = (tables) => ({
 });
 
 //#endregion
-export { DatabaseSchema_exports, TypeId, extendWithSystemTables, isSchema, make, systemSchema };
+export { DatabaseSchema_exports, TypeId, extendWithSystemTables, isDatabaseSchema, make, systemSchema };
 //# sourceMappingURL=DatabaseSchema.js.map

package/dist/DatabaseSchema.js.map

@@ -1 +1 @@
-{"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 const isSchema = (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 Any {\n  readonly [TypeId]: TypeId;\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;AAGtB,MAAa,YAAY,MACvB,UAAU,YAAY,GAAG,OAAO;AA6ClC,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"}
+{"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/Document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Document.d.ts","names":[],"sources":["../src/Document.ts"],"mappings":";;;;;;;;;;KAOY,mBAAA,QAA2B,IAAA,CAAK,GAAA;AAAA,KAEhC,GAAA;AAAA,KACA,UAAA,GAAa,cAAA,SAAuB,aAAA;AAAA,cAEnC,MAAA,uBAEU,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,SAAA,EAEvC,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,QAG3C,IAAA,EAAM,kBAAA,CAA6B,UAAA,EAAY,SAAA,wBAC5C,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,eACzC,mBAAA,0BAGmB,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,IAAA,EAE5C,kBAAA,CAA6B,UAAA,EAAY,SAAA,qBAA4B,SAAA,EAChE,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,OAExC,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,eACzC,mBAAA;AAAA,cA+CS,MAAA,uBAEU,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,SAAA,EAEvC,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,QAG3C,IAAA,EAAM,kBAAA,CAA6B,UAAA,EAAY,SAAA,kBAC5C,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,sBACzC,mBAAA,0BAGmB,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,IAAA,EAE5C,kBAAA,CAA6B,UAAA,EAAY,SAAA,eAAsB,SAAA,EAC1D,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,OAExC,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,sBACzC,mBAAA;AAAA,cA8CF,wBAAA;;;;;;;cAEW,mBAAA,SAA4B,wBAAA;EAAA,IAQ1B,OAAA,CAAA;AAAA;AAAA,cAOd,wBAAA;;;;;;;cAEY,mBAAA,SAA4B,wBAAA;EAAA,IAQ1B,OAAA,CAAA;AAAA;AAAA,cASF,oBAAA;EAAwB,EAAA;EAAA,SAAA;EAAA;AAAA;EAKnC,EAAA;EACA,SAAA;EACA,OAAA;AAAA"}
+{"version":3,"file":"Document.d.ts","names":[],"sources":["../src/Document.ts"],"mappings":";;;;;;;;;;KAOY,mBAAA,QAA2B,IAAA,CAAK,GAAA;AAAA,KAEhC,GAAA;AAAA,KACA,UAAA,GAAa,cAAA,SAAuB,aAAA;AAAA,cAiCnC,MAAA,uBAEU,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,SAAA,EAEvC,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,QAG3C,IAAA,EAAM,kBAAA,CAA6B,UAAA,EAAY,SAAA,wBAC5C,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,eACzC,mBAAA,0BAGmB,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,IAAA,EAE5C,kBAAA,CAA6B,UAAA,EAAY,SAAA,qBAA4B,SAAA,EAChE,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,OAExC,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,eACzC,mBAAA;AAAA,cAsDS,MAAA,uBAEU,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,SAAA,EAEvC,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,QAG3C,IAAA,EAAM,kBAAA,CAA6B,UAAA,EAAY,SAAA,kBAC5C,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,sBACzC,mBAAA,0BAGmB,YAAA,oBACD,UAAA,CAAqB,UAAA,GAAW,IAAA,EAE5C,kBAAA,CAA6B,UAAA,EAAY,SAAA,eAAsB,SAAA,EAC1D,SAAA,EAAS,WAAA,EACP,WAAA,CACX,kBAAA,CAA6B,UAAA,EAAY,SAAA,OAExC,MAAA,CAAO,MAAA,CACV,kBAAA,CAA6B,UAAA,EAAY,SAAA,sBACzC,mBAAA;AAAA,cAwCF,wBAAA;;;;;;;cAEW,mBAAA,SAA4B,wBAAA;EAAA,IAQ1B,OAAA,CAAA;AAAA;AAAA,cAOd,wBAAA;;;;;;;cAEY,mBAAA,SAA4B,wBAAA;EAAA,IAQ1B,OAAA,CAAA;AAAA;AAAA,cASF,oBAAA;EAAwB,EAAA;EAAA,SAAA;EAAA;AAAA;EAKnC,EAAA;EACA,SAAA;EACA,OAAA;AAAA"}

package/dist/Document.js

@@ -10,29 +10,41 @@ var Document_exports = /* @__PURE__ */ __exportAll({
 	documentErrorMessage: () => documentErrorMessage,
 	encode: () => encode
 });
-const decode = Function.dual(3, (self, tableName, tableSchema) => Effect.gen(function* () {
-	const TableSchemaWithSystemFields = SystemFields.extendWithSystemFields(tableName, tableSchema);
-	const encodedDoc = self;
-	return yield* pipe(encodedDoc, Schema.decode(TableSchemaWithSystemFields), Effect.catchTag("ParseError", (parseError) => Effect.gen(function* () {
-		const formattedParseError = yield* ParseResult.TreeFormatter.formatError(parseError);
-		return yield* new DocumentDecodeError({
-			tableName,
-			id: encodedDoc._id,
-			parseError: formattedParseError
-		});
-	})));
-}));
-const encode = Function.dual(3, (self, tableName, tableSchema) => Effect.gen(function* () {
-	const decodedDoc = self;
-	return yield* pipe(decodedDoc, Schema.encode(tableSchema), Effect.catchTag("ParseError", (parseError) => Effect.gen(function* () {
-		const formattedParseError = yield* ParseResult.TreeFormatter.formatError(parseError);
-		return yield* new DocumentEncodeError({
-			tableName,
-			id: decodedDoc._id,
-			parseError: formattedParseError
-		});
-	})));
-}));
+const decoderCache = /* @__PURE__ */ new WeakMap();
+const getDecoder = (tableName, tableSchema) => {
+	const byTable = decoderCache.get(tableSchema) ?? (() => {
+		const map = /* @__PURE__ */ new Map();
+		decoderCache.set(tableSchema, map);
+		return map;
+	})();
+	return byTable.get(tableName) ?? (() => {
+		const decoder = Schema.decode(SystemFields.extendWithSystemFields(tableName, tableSchema));
+		byTable.set(tableName, decoder);
+		return decoder;
+	})();
+};
+const decode = Function.dual(3, (self, tableName, tableSchema) => pipe(self, getDecoder(tableName, tableSchema), Effect.catchIf(ParseResult.isParseError, (parseError) => Effect.gen(function* () {
+	const formattedParseError = yield* ParseResult.TreeFormatter.formatError(parseError);
+	return yield* new DocumentDecodeError({
+		tableName,
+		id: self._id,
+		parseError: formattedParseError
+	});
+})), Effect.map((decodedDoc) => decodedDoc)));
+const encoderCache = /* @__PURE__ */ new WeakMap();
+const getEncoder = (tableSchema) => encoderCache.get(tableSchema) ?? (() => {
+	const encoder = Schema.encode(tableSchema);
+	encoderCache.set(tableSchema, encoder);
+	return encoder;
+})();
+const encode = Function.dual(3, (self, tableName, tableSchema) => pipe(self, getEncoder(tableSchema), Effect.catchIf(ParseResult.isParseError, (parseError) => Effect.gen(function* () {
+	const formattedParseError = yield* ParseResult.TreeFormatter.formatError(parseError);
+	return yield* new DocumentEncodeError({
+		tableName,
+		id: self._id,
+		parseError: formattedParseError
+	});
+})), Effect.map((encodedDoc) => encodedDoc)));
 var DocumentDecodeError = class extends Schema.TaggedError()("DocumentDecodeError", {
 	tableName: Schema.String,
 	id: Schema.String,

package/dist/Document.js.map

@@ -1 +1 @@
-{"version":3,"file":"Document.js","names":[],"sources":["../src/Document.ts"],"sourcesContent":["import { Effect, Function, ParseResult, pipe, Schema } from \"effect\";\nimport type { ReadonlyRecord } from \"effect/Record\";\nimport * as SystemFields from \"@confect/core/SystemFields\";\nimport type * as DataModel from \"./DataModel\";\nimport type { ReadonlyValue } from \"./SchemaToValidator\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport type WithoutSystemFields<Doc> = Omit<Doc, \"_creationTime\" | \"_id\">;\n\nexport type Any = any;\nexport type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;\n\nexport const decode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  > =>\n    Effect.gen(function* () {\n      const TableSchemaWithSystemFields = SystemFields.extendWithSystemFields(\n        tableName,\n        tableSchema,\n      );\n\n      const encodedDoc =\n        self as (typeof TableSchemaWithSystemFields)[\"Encoded\"];\n\n      const decodedDoc = yield* pipe(\n        encodedDoc,\n        Schema.decode(TableSchemaWithSystemFields),\n        Effect.catchTag(\"ParseError\", (parseError) =>\n          Effect.gen(function* () {\n            const formattedParseError =\n              yield* ParseResult.TreeFormatter.formatError(parseError);\n\n            return yield* new DocumentDecodeError({\n              tableName,\n              id: encodedDoc._id,\n              parseError: formattedParseError,\n            });\n          }),\n        ),\n      );\n\n      return decodedDoc;\n    }),\n);\n\nexport const encode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  > =>\n    Effect.gen(function* () {\n      type TableSchemaWithSystemFields = SystemFields.ExtendWithSystemFields<\n        TableName,\n        TableInfo.TableSchema<\n          DataModel.TableInfoWithName_<DataModel_, TableName>\n        >\n      >;\n\n      const decodedDoc = self as TableSchemaWithSystemFields[\"Type\"];\n\n      const encodedDoc = yield* pipe(\n        decodedDoc,\n        Schema.encode(tableSchema),\n        Effect.catchTag(\"ParseError\", (parseError) =>\n          Effect.gen(function* () {\n            const formattedParseError =\n              yield* ParseResult.TreeFormatter.formatError(parseError);\n\n            return yield* new DocumentEncodeError({\n              tableName,\n              id: decodedDoc._id,\n              parseError: formattedParseError,\n            });\n          }),\n        ),\n      );\n\n      return encodedDoc;\n    }),\n);\n\nexport class DocumentDecodeError extends Schema.TaggedError<DocumentDecodeError>()(\n  \"DocumentDecodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be decoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport class DocumentEncodeError extends Schema.TaggedError<DocumentEncodeError>()(\n  \"DocumentEncodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be encoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport const documentErrorMessage = ({\n  id,\n  tableName,\n  message,\n}: {\n  id: string;\n  tableName: string;\n  message: string;\n}) => `Document with ID '${id}' in table '${tableName}' ${message}`;\n"],"mappings":";;;;;;;;;;;;AAYA,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,OAAO,IAAI,aAAa;CACtB,MAAM,8BAA8B,aAAa,uBAC/C,WACA,YACD;CAED,MAAM,aACJ;AAmBF,QAjBmB,OAAO,KACxB,YACA,OAAO,OAAO,4BAA4B,EAC1C,OAAO,SAAS,eAAe,eAC7B,OAAO,IAAI,aAAa;EACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,SAAO,OAAO,IAAI,oBAAoB;GACpC;GACA,IAAI,WAAW;GACf,YAAY;GACb,CAAC;GACF,CACH,CACF;EAGD,CACL;AAED,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,OAAO,IAAI,aAAa;CAQtB,MAAM,aAAa;AAmBnB,QAjBmB,OAAO,KACxB,YACA,OAAO,OAAO,YAAY,EAC1B,OAAO,SAAS,eAAe,eAC7B,OAAO,IAAI,aAAa;EACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,SAAO,OAAO,IAAI,oBAAoB;GACpC;GACA,IAAI,WAAW;GACf,YAAY;GACb,CAAC;GACF,CACH,CACF;EAGD,CACL;AAED,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,MAAa,wBAAwB,EACnC,IACA,WACA,cAKI,qBAAqB,GAAG,cAAc,UAAU,IAAI"}
+{"version":3,"file":"Document.js","names":[],"sources":["../src/Document.ts"],"sourcesContent":["import * as SystemFields from \"@confect/core/SystemFields\";\nimport { Effect, Function, ParseResult, pipe, Schema } from \"effect\";\nimport type { ReadonlyRecord } from \"effect/Record\";\nimport type * as DataModel from \"./DataModel\";\nimport type { ReadonlyValue } from \"./SchemaToValidator\";\nimport type * as TableInfo from \"./TableInfo\";\n\nexport type WithoutSystemFields<Doc> = Omit<Doc, \"_creationTime\" | \"_id\">;\n\nexport type Any = any;\nexport type AnyEncoded = ReadonlyRecord<string, ReadonlyValue>;\n\ntype Decode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;\n\nconst decoderCache = new WeakMap<\n  Schema.Schema.AnyNoContext,\n  Map<string, Decode>\n>();\n\nconst getDecoder = (\n  tableName: string,\n  tableSchema: Schema.Schema.AnyNoContext,\n): Decode => {\n  const byTable =\n    decoderCache.get(tableSchema) ??\n    (() => {\n      const map = new Map<string, Decode>();\n      decoderCache.set(tableSchema, map);\n      return map;\n    })();\n\n  return (\n    byTable.get(tableName) ??\n    (() => {\n      const decoder = Schema.decode(\n        SystemFields.extendWithSystemFields(tableName, tableSchema),\n      ) as Decode;\n      byTable.set(tableName, decoder);\n      return decoder;\n    })()\n  );\n};\n\nexport const decode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"convexDocument\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    DocumentDecodeError\n  > =>\n    pipe(\n      self,\n      getDecoder(tableName, tableSchema),\n      Effect.catchIf(ParseResult.isParseError, (parseError) =>\n        Effect.gen(function* () {\n          const formattedParseError =\n            yield* ParseResult.TreeFormatter.formatError(parseError);\n\n          return yield* new DocumentDecodeError({\n            tableName,\n            id: self._id,\n            parseError: formattedParseError,\n          });\n        }),\n      ),\n      Effect.map(\n        (decodedDoc) =>\n          decodedDoc as DataModel.TableInfoWithName_<\n            DataModel_,\n            TableName\n          >[\"document\"],\n      ),\n    ),\n);\n\ntype Encode = (doc: unknown) => Effect.Effect<unknown, ParseResult.ParseError>;\n\nconst encoderCache = new WeakMap<Schema.Schema.AnyNoContext, Encode>();\n\nconst getEncoder = (tableSchema: Schema.Schema.AnyNoContext): Encode =>\n  encoderCache.get(tableSchema) ??\n  (() => {\n    const encoder = Schema.encode(tableSchema) as Encode;\n    encoderCache.set(tableSchema, encoder);\n    return encoder;\n  })();\n\nexport const encode = Function.dual<\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => (\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ) => Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  >\n>(\n  3,\n  <\n    DataModel_ extends DataModel.AnyWithProps,\n    TableName extends DataModel.TableNames<DataModel_>,\n  >(\n    self: DataModel.TableInfoWithName_<DataModel_, TableName>[\"document\"],\n    tableName: TableName,\n    tableSchema: TableInfo.TableSchema<\n      DataModel.TableInfoWithName_<DataModel_, TableName>\n    >,\n  ): Effect.Effect<\n    DataModel.TableInfoWithName_<DataModel_, TableName>[\"encodedDocument\"],\n    DocumentEncodeError\n  > =>\n    pipe(\n      self,\n      getEncoder(tableSchema),\n      Effect.catchIf(ParseResult.isParseError, (parseError) =>\n        Effect.gen(function* () {\n          const formattedParseError =\n            yield* ParseResult.TreeFormatter.formatError(parseError);\n\n          return yield* new DocumentEncodeError({\n            tableName,\n            id: self._id,\n            parseError: formattedParseError,\n          });\n        }),\n      ),\n      Effect.map(\n        (encodedDoc) =>\n          encodedDoc as DataModel.TableInfoWithName_<\n            DataModel_,\n            TableName\n          >[\"encodedDocument\"],\n      ),\n    ),\n);\n\nexport class DocumentDecodeError extends Schema.TaggedError<DocumentDecodeError>()(\n  \"DocumentDecodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be decoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport class DocumentEncodeError extends Schema.TaggedError<DocumentEncodeError>()(\n  \"DocumentEncodeError\",\n  {\n    tableName: Schema.String,\n    id: Schema.String,\n    parseError: Schema.String,\n  },\n) {\n  override get message(): string {\n    return documentErrorMessage({\n      id: this.id,\n      tableName: this.tableName,\n      message: `could not be encoded:\\n\\n${this.parseError}`,\n    });\n  }\n}\n\nexport const documentErrorMessage = ({\n  id,\n  tableName,\n  message,\n}: {\n  id: string;\n  tableName: string;\n  message: string;\n}) => `Document with ID '${id}' in table '${tableName}' ${message}`;\n"],"mappings":";;;;;;;;;;;;AAcA,MAAM,+BAAe,IAAI,SAGtB;AAEH,MAAM,cACJ,WACA,gBACW;CACX,MAAM,UACJ,aAAa,IAAI,YAAY,WACtB;EACL,MAAM,sBAAM,IAAI,KAAqB;AACrC,eAAa,IAAI,aAAa,IAAI;AAClC,SAAO;KACL;AAEN,QACE,QAAQ,IAAI,UAAU,WACf;EACL,MAAM,UAAU,OAAO,OACrB,aAAa,uBAAuB,WAAW,YAAY,CAC5D;AACD,UAAQ,IAAI,WAAW,QAAQ;AAC/B,SAAO;KACL;;AAIR,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,KACE,MACA,WAAW,WAAW,YAAY,EAClC,OAAO,QAAQ,YAAY,eAAe,eACxC,OAAO,IAAI,aAAa;CACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,QAAO,OAAO,IAAI,oBAAoB;EACpC;EACA,IAAI,KAAK;EACT,YAAY;EACb,CAAC;EACF,CACH,EACD,OAAO,KACJ,eACC,WAIH,CACF,CACJ;AAID,MAAM,+BAAe,IAAI,SAA6C;AAEtE,MAAM,cAAc,gBAClB,aAAa,IAAI,YAAY,WACtB;CACL,MAAM,UAAU,OAAO,OAAO,YAAY;AAC1C,cAAa,IAAI,aAAa,QAAQ;AACtC,QAAO;IACL;AAEN,MAAa,SAAS,SAAS,KA6B7B,IAKE,MACA,WACA,gBAOA,KACE,MACA,WAAW,YAAY,EACvB,OAAO,QAAQ,YAAY,eAAe,eACxC,OAAO,IAAI,aAAa;CACtB,MAAM,sBACJ,OAAO,YAAY,cAAc,YAAY,WAAW;AAE1D,QAAO,OAAO,IAAI,oBAAoB;EACpC;EACA,IAAI,KAAK;EACT,YAAY;EACb,CAAC;EACF,CACH,EACD,OAAO,KACJ,eACC,WAIH,CACF,CACJ;AAED,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,IAAa,sBAAb,cAAyC,OAAO,aAAkC,CAChF,uBACA;CACE,WAAW,OAAO;CAClB,IAAI,OAAO;CACX,YAAY,OAAO;CACpB,CACF,CAAC;CACA,IAAa,UAAkB;AAC7B,SAAO,qBAAqB;GAC1B,IAAI,KAAK;GACT,WAAW,KAAK;GAChB,SAAS,4BAA4B,KAAK;GAC3C,CAAC;;;AAIN,MAAa,wBAAwB,EACnC,IACA,WACA,cAKI,qBAAqB,GAAG,cAAc,UAAU,IAAI"}

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