@confect/server 9.0.0-next.1 → 9.0.0-next.10

package/src/GroupImpl.ts

@@ -1,20 +1,16 @@
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as Registry from "@confect/core/Registry";
-import {
-  Array,
-  Context,
-  Effect,
-  Layer,
-  Option,
-  pipe,
-  Predicate,
-  Record,
-  Ref,
-  String,
-} from "effect";
-import type * as Api from "./Api";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+import * as Ref from "effect/Ref";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as FunctionImpl from "./FunctionImpl";
-import { resolveGroupPathUnsafe } from "./GroupPath";
 
 export const TypeId = "@confect/server/GroupImpl";
 export type TypeId = typeof TypeId;
@@ -22,11 +18,9 @@ export type TypeId = typeof TypeId;
 export type FinalizationStatus = "Unfinalized" | "Finalized";
 
 export 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
@@ -37,13 +31,13 @@ export interface GroupImpl<
   readonly registeredFunctionNames: ReadonlyArray<string>;
 }
 
-export interface Any extends GroupImpl<string, FinalizationStatus> {}
+export interface Any extends GroupImpl<FinalizationStatus> {}
 
 export const isGroupImpl = (u: unknown): u is Any =>
   Predicate.hasProperty(u, TypeId);
 
-export interface AnyFinalized extends GroupImpl<string, "Finalized"> {}
-export interface AnyUnfinalized extends GroupImpl<string, "Unfinalized"> {}
+export interface AnyFinalized extends GroupImpl<"Finalized"> {}
+export interface AnyUnfinalized extends GroupImpl<"Unfinalized"> {}
 
 export const isFinalizedGroupImpl = (u: unknown): u is AnyFinalized =>
   isGroupImpl(u) && u.finalizationStatus === "Finalized";
@@ -55,83 +49,71 @@ export 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
+ * `RegisteredFunctions.buildForGroup` and the CLI's `validateImpl`) retrieve
  * the typed `Finalized` service directly rather than scanning the context.
+ *
+ * The tag is keyed only by finalization status — no group path — because each
+ * group's impl layer is built in its own isolated scope (`buildForGroup` /
+ * `validateImpl` each provide a fresh `Registry`), so at most one `GroupImpl`
+ * service of each status exists per build.
  */
-export const GroupImpl = <
-  GroupPath_ extends string,
-  FinalizationStatus_ extends FinalizationStatus,
->({
-  groupPath,
+export const GroupImpl = <FinalizationStatus_ extends FinalizationStatus>({
   finalizationStatus,
 }: {
-  groupPath: GroupPath_;
   finalizationStatus: FinalizationStatus_;
 }) =>
-  Context.GenericTag<GroupImpl<GroupPath_, FinalizationStatus_>>(
-    `@confect/server/GroupImpl/${finalizationStatus}/${groupPath}`,
+  Context.GenericTag<GroupImpl<FinalizationStatus_>>(
+    `@confect/server/GroupImpl/${finalizationStatus}`,
   );
 
+/**
+ * Begin a group's impl layer. `databaseSchema` and `group` are retained only as
+ * type-level carriers (`group` drives the required `FunctionImpl` services via
+ * `FromGroupSpec<Group>`; `databaseSchema` keeps the impl's dependency on
+ * `_generated/schema` symmetric with `FunctionImpl.make`). Neither is read at
+ * runtime.
+ */
 export const make = <
-  Api_ extends Api.AnyWithProps,
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   Group extends GroupSpec.AnyWithProps,
 >(
-  api: Api_,
-  group: Group,
+  _databaseSchema: DatabaseSchema_,
+  _group: Group,
 ): Layer.Layer<
-  GroupImpl<string, "Unfinalized">,
+  GroupImpl<"Unfinalized">,
   never,
   FunctionImpl.FromGroupSpec<Group>
-> => {
-  const groupPath = resolveGroupPathUnsafe(api.spec, group);
-
-  return Layer.succeed(
-    GroupImpl<string, "Unfinalized">({
-      groupPath,
-      finalizationStatus: "Unfinalized",
-    }),
+> =>
+  Layer.succeed(
+    GroupImpl<"Unfinalized">({ finalizationStatus: "Unfinalized" }),
     {
       [TypeId]: TypeId,
-      groupPath,
       finalizationStatus: "Unfinalized" as const,
       registeredFunctionNames: [],
     },
   ) as Layer.Layer<
-    GroupImpl<string, "Unfinalized">,
+    GroupImpl<"Unfinalized">,
     never,
     FunctionImpl.FromGroupSpec<Group>
   >;
-};
 
 const isFunctionShaped = (value: unknown): boolean =>
   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.
+ * Return the names of the function-shaped entries in a group's (flat,
+ * isolated) registry. `FunctionImpl.make` registers each function under a
+ * single-segment key, so the registry built for one group contains exactly
+ * that group's functions at the top level.
  */
-const collectFunctionNamesAtPath = (
+const collectFunctionNames = (
   items: Registry.RegistryItems,
-  groupPath: string,
 ): ReadonlyArray<string> =>
   pipe(
-    String.split(groupPath, "."),
-    Array.reduce(Option.some<unknown>(items), (acc, segment) =>
-      acc.pipe(
-        Option.filter(Predicate.isRecord),
-        Option.flatMap((node) =>
-          segment in node ? Option.some(node[segment]) : Option.none(),
-        ),
-      ),
+    Record.toEntries(items),
+    Array.filterMap(([name, value]) =>
+      isFunctionShaped(value) ? Option.some(name) : 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((): ReadonlyArray<string> => []),
   );
 
 const findUnfinalizedGroupImpl = <S>(
@@ -152,12 +134,12 @@ const findUnfinalizedGroupImpl = <S>(
  * impl completeness against a `GroupSpec`'s expected functions without
  * having to inspect the `Registry` themselves.
  */
-export const finalize = <GroupPath_ extends string>(
-  group: Layer.Layer<GroupImpl<GroupPath_, "Unfinalized">>,
-): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+export const finalize = (
+  group: Layer.Layer<GroupImpl<"Unfinalized">>,
+): Layer.Layer<GroupImpl<"Finalized">> =>
   Layer.flatMap(
     group,
-    (context): Layer.Layer<GroupImpl<GroupPath_, "Finalized">> =>
+    (context): Layer.Layer<GroupImpl<"Finalized">> =>
       findUnfinalizedGroupImpl(context).pipe(
         Option.match({
           onNone: () =>
@@ -166,28 +148,19 @@ export const finalize = <GroupPath_ extends string>(
                 "GroupImpl.finalize: no Unfinalized GroupImpl service was found in the layer's context.",
               ),
             ),
-          onSome: (unfinalized) => {
-            const groupPath = unfinalized.groupPath as GroupPath_;
-            return Layer.effect(
-              GroupImpl<GroupPath_, "Finalized">({
-                groupPath,
-                finalizationStatus: "Finalized",
-              }),
+          onSome: () =>
+            Layer.effect(
+              GroupImpl<"Finalized">({ finalizationStatus: "Finalized" }),
               Effect.gen(function* () {
                 const registry = yield* Registry.Registry;
                 const items = yield* Ref.get(registry);
                 return {
                   [TypeId]: TypeId,
-                  groupPath,
                   finalizationStatus: "Finalized" as const,
-                  registeredFunctionNames: collectFunctionNamesAtPath(
-                    items,
-                    groupPath,
-                  ),
+                  registeredFunctionNames: collectFunctionNames(items),
                 };
               }),
-            );
-          },
+            ),
         }),
       ),
   );

package/src/HttpApi.ts

@@ -1,11 +1,7 @@
-import {
-  type HttpApi,
-  HttpApiBuilder,
-  HttpApiScalar,
-  type HttpApp,
-  type HttpRouter,
-  HttpServer,
-} from "@effect/platform";
+import type { HttpApi, HttpApp, HttpRouter } from "@effect/platform";
+import * as HttpApiBuilder from "@effect/platform/HttpApiBuilder";
+import * as HttpApiScalar from "@effect/platform/HttpApiScalar";
+import * as HttpServer from "@effect/platform/HttpServer";
 import {
   type HttpRouter as ConvexHttpRouter,
   type GenericActionCtx,
@@ -15,7 +11,10 @@ import {
   ROUTABLE_HTTP_METHODS,
   type RouteSpecWithPathPrefix,
 } from "convex/server";
-import { Array, Layer, pipe, Record } from "effect";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Layer from "effect/Layer";
+import * as Record from "effect/Record";
 import * as ActionCtx from "./ActionCtx";
 import * as ActionRunner from "./ActionRunner";
 import * as Auth from "./Auth";

package/src/MutationCtx.ts

@@ -1,5 +1,5 @@
 import type { GenericDataModel, GenericMutationCtx } from "convex/server";
-import { Context } from "effect";
+import * as Context from "effect/Context";
 
 export const MutationCtx = <DataModel extends GenericDataModel>() =>
   Context.GenericTag<GenericMutationCtx<DataModel>>(

package/src/MutationRunner.ts

@@ -1,7 +1,8 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericMutationCtx } from "convex/server";
 import type { ParseResult, Effect } from "effect";
-import { Context, Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
 
 const make =
   (runMutation: GenericMutationCtx<any>["runMutation"]) =>

package/src/OrderedQuery.ts

@@ -4,7 +4,11 @@ import type {
   OrderedQuery as ConvexOrderedQuery,
   PaginationResult,
 } from "convex/server";
-import { Chunk, Effect, identity, type Option, pipe, Stream } from "effect";
+import { identity, pipe } from "effect/Function";
+import type { Option } from "effect";
+import * as Chunk from "effect/Chunk";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
 import * as Document from "./Document";
 import type * as TableInfo from "./TableInfo";
 

package/src/QueryCtx.ts

@@ -1,5 +1,5 @@
 import type { GenericDataModel, GenericQueryCtx } from "convex/server";
-import { Context } from "effect";
+import * as Context from "effect/Context";
 
 export const QueryCtx = <DataModel extends GenericDataModel>() =>
   Context.GenericTag<GenericQueryCtx<DataModel>>("@confect/server/QueryCtx");

package/src/QueryInitializer.ts

@@ -16,7 +16,11 @@ import type {
   SearchIndexes,
 } from "convex/server";
 import type { GenericId } from "convex/values";
-import { Array, Effect, Either, pipe, Schema } from "effect";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
+import * as Schema from "effect/Schema";
 import type {
   BaseDatabaseReader,
   IndexFieldTypesForEq,
@@ -238,7 +242,13 @@ export const make = <
     return OrderedQuery.make<
       DataModel.TableInfoWithName_<DataModel_, TableName>,
       TableName
-    >(orderedQuery, tableName, table.Fields);
+    >(
+      orderedQuery,
+      tableName,
+      table.Fields as TableInfo.TableSchema<
+        DataModel.TableInfoWithName_<DataModel_, TableName>
+      >,
+    );
   };
 
   const search: QueryInitializerFunction<"search"> = (
@@ -253,7 +263,9 @@ export const make = <
         .query(tableName)
         .withSearchIndex(indexName, searchFilter),
       tableName,
-      table.Fields,
+      table.Fields as TableInfo.TableSchema<
+        DataModel.TableInfoWithName_<DataModel_, TableName>
+      >,
     );
 
   return {

package/src/QueryRunner.ts

@@ -1,7 +1,8 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericQueryCtx } from "convex/server";
 import type { ParseResult, Effect } from "effect";
-import { Context, Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
 
 const make =
   (runQuery: GenericQueryCtx<any>["runQuery"]) =>

package/src/RegisteredConvexFunction.ts

@@ -11,8 +11,12 @@ import {
   queryGeneric,
 } from "convex/server";
 import type { Value } from "convex/values";
-import { Clock, Effect, Layer, Match, pipe, Schema } from "effect";
-import type * as Api from "./Api";
+import { pipe } from "effect/Function";
+import * as Clock from "effect/Clock";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
 import * as Auth from "./Auth";
 import * as ConvexConfigProvider from "./ConvexConfigProvider";
 import * as DatabaseReader from "./DatabaseReader";
@@ -31,8 +35,8 @@ import * as SchemaToValidator from "./SchemaToValidator";
 import { StorageReader } from "./StorageReader";
 import { StorageWriter } from "./StorageWriter";
 
-export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
-  api: Api_,
+export const make = (
+  databaseSchema: DatabaseSchema.AnyWithProps,
   { functionSpec, handler }: RegistryItem.AnyWithProps,
 ): RegisteredFunction.Any =>
   Match.value(functionSpec.functionProvenance).pipe(
@@ -51,7 +55,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
 
           return genericFunction(
             queryFunction({
-              databaseSchema: api.databaseSchema,
+              databaseSchema,
               args: functionProvenance.args,
               returns: functionProvenance.returns,
               error: functionProvenance.error,
@@ -68,7 +72,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
 
           return genericFunction(
             mutationFunction({
-              databaseSchema: api.databaseSchema,
+              databaseSchema,
               args: functionProvenance.args,
               returns: functionProvenance.returns,
               error: functionProvenance.error,
@@ -84,7 +88,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Convex">>(
           );
 
           return genericFunction(
-            convexActionFunction(api.databaseSchema, {
+            convexActionFunction(databaseSchema, {
               args: functionProvenance.args,
               returns: functionProvenance.returns,
               error: functionProvenance.error,

package/src/RegisteredFunction.ts

@@ -10,7 +10,11 @@ import {
 } from "convex/server";
 import type { Value } from "convex/values";
 import { ConvexError } from "convex/values";
-import { Effect, Either, Layer, pipe, Schema } from "effect";
+import { pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Either from "effect/Either";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 import * as ActionCtx from "./ActionCtx";
 import * as ActionRunner from "./ActionRunner";
 import * as Auth from "./Auth";

package/src/RegisteredFunctions.ts

@@ -2,18 +2,10 @@ import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as Registry from "@confect/core/Registry";
 import type * as Spec from "@confect/core/Spec";
-import {
-  Array,
-  Effect,
-  type Layer,
-  Option,
-  pipe,
-  Predicate,
-  Ref,
-  String,
-  type Types,
-} from "effect";
-import type * as Api from "./Api";
+import type { Layer, Types } from "effect";
+import * as Effect from "effect/Effect";
+import * as Ref from "effect/Ref";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as GroupImpl from "./GroupImpl";
 import { mapLeaves } from "./internal/utils";
 import type * as RegisteredFunction from "./RegisteredFunction";
@@ -27,106 +19,90 @@ type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
     Groups,
     GroupName
   > extends infer Group extends GroupSpec.AnyWithProps
-    ? GroupSpec.Groups<Group> extends infer SubGroups extends
-        GroupSpec.AnyWithProps
-      ? Types.Simplify<
-          RegisteredFunctionsHelper<SubGroups> & {
-            [FunctionName in FunctionSpec.Name<
-              GroupSpec.Functions<Group>
-            >]: FunctionSpec.WithName<
-              GroupSpec.Functions<Group>,
-              FunctionName
-            > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
-              ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
-              : never;
-          }
-        >
-      : {
-          [FunctionName in FunctionSpec.Name<
-            GroupSpec.Functions<Group>
-          >]: FunctionSpec.WithName<
-            GroupSpec.Functions<Group>,
-            FunctionName
-          > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
-            ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
-            : never;
-        }
+    ? RegisteredFunctionsForGroupSpec<Group>
     : never;
 };
 
+/** The `RegisteredFunction` record for a group's own declared functions. */
+type RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = {
+  [FunctionName in FunctionSpec.Name<
+    GroupSpec.Functions<Group>
+  >]: FunctionSpec.WithName<
+    GroupSpec.Functions<Group>,
+    FunctionName
+  > extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps
+    ? RegisteredFunction.RegisteredFunction<FunctionSpec_>
+    : never;
+};
+
+/**
+ * The registered-functions record for a single group, derived from the group's
+ * own `GroupSpec`: its declared functions, plus any nested subgroups it carries
+ * directly. This is the node that `buildForGroup` returns — computed from the
+ * leaf `GroupSpec` itself rather than by navigating the project-wide assembled
+ * `Spec` to a dot-path, so the per-group registry's type depends only on its
+ * own leaf. For the filesystem layout a leaf `GroupSpec` carries no subgroups
+ * (subdirectory children are assembled separately into `_generated/spec.ts`),
+ * so this resolves to just the leaf's functions.
+ */
+export type RegisteredFunctionsForGroupSpec<
+  Group extends GroupSpec.AnyWithProps,
+> =
+  GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps
+    ? Types.Simplify<
+        RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>
+      >
+    : RegisteredFunctionsOf<Group>;
+
 export interface AnyWithProps {
   readonly [key: string]: RegisteredFunction.Any | AnyWithProps;
 }
 
-type RegisteredFunctionsAtPath<
-  Tree,
-  Path extends string,
-> = Path extends `${infer Head}.${infer Tail}`
-  ? Head extends keyof Tree
-    ? Tree[Head] extends AnyWithProps
-      ? RegisteredFunctionsAtPath<Tree[Head], Tail>
-      : never
-    : never
-  : Path extends keyof Tree
-    ? Tree[Path]
-    : never;
-
-export type ForGroupPath<
-  Spec_ extends Spec.AnyWithProps,
-  Path extends string,
-> = RegisteredFunctionsAtPath<RegisteredFunctions<Spec_>, Path>;
-
 /**
  * Build the registered Convex functions for a single group from its finalized
  * `GroupImpl` layer.
  *
- * The `groupLayer` parameter requires `GroupImpl<string, "Finalized">`, so
- * impls that were never piped through `GroupImpl.finalize` (and impls with
- * unmet `FunctionImpl` requirements, which cannot be finalized) are rejected
- * at the codegen boundary, not just deep inside Convex at runtime.
+ * The `groupLayer` parameter requires `GroupImpl<"Finalized">`, so impls that
+ * were never piped through `GroupImpl.finalize` (and impls with unmet
+ * `FunctionImpl` requirements, which cannot be finalized) are rejected at the
+ * codegen boundary, not just deep inside Convex at runtime.
+ *
+ * The group layer is built with a fresh, isolated `Registry` (rather than the
+ * globally-cached default `Context.Reference`), so each `FunctionImpl.make`
+ * registers under its flat, single-segment function-name key without colliding
+ * with any other group built in the same process — the built registry holds
+ * exactly this group's functions at the top level.
+ *
+ * Only the runtime `databaseSchema` value is needed at runtime (it is forwarded
+ * to `makeRegisteredFunction` to build each function's ctx services); the
+ * group's `GroupSpec` is supplied purely as the `Group` type parameter to shape
+ * the returned record. The generated caller passes it explicitly and imports
+ * the leaf spec type-only (`typeof import("…/<group>.spec")["default"]`), so a
+ * function's bundle never imports a spec module at runtime.
  */
-export const buildForGroup = <
-  Api_ extends Api.AnyWithProps,
-  const GroupPath_ extends string,
->(
-  api: Api_,
-  groupPath: GroupPath_,
-  groupLayer: Layer.Layer<GroupImpl.GroupImpl<string, "Finalized">>,
+export const buildForGroup = <Group extends GroupSpec.AnyWithProps>(
+  databaseSchema: DatabaseSchema.AnyWithProps,
+  groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>,
   makeRegisteredFunction: (
-    api: Api_,
+    databaseSchema: DatabaseSchema.AnyWithProps,
     registryItem: RegistryItem.AnyWithProps,
   ) => RegisteredFunction.Any,
-): ForGroupPath<Api_["spec"], GroupPath_> => {
+): RegisteredFunctionsForGroupSpec<Group> => {
   const registryItems = Effect.gen(function* () {
     const registry = yield* Registry.Registry;
     return yield* Ref.get(registry);
-  }).pipe(Effect.provide(groupLayer), Effect.runSync);
+  }).pipe(
+    Effect.provide(groupLayer),
+    Effect.provideService(
+      Registry.Registry,
+      Ref.unsafeMake<Registry.RegistryItems>({}),
+    ),
+    Effect.runSync,
+  );
 
-  const registeredFunctions = mapLeaves<
-    RegistryItem.AnyWithProps,
-    RegisteredFunction.Any
-  >(
+  return mapLeaves<RegistryItem.AnyWithProps, RegisteredFunction.Any>(
     registryItems as { [key: string]: RegistryItem.AnyWithProps },
     RegistryItem.isRegistryItem,
-    (registryItem) => makeRegisteredFunction(api, registryItem),
-  );
-
-  return pipe(
-    String.split(groupPath, "."),
-    Array.reduce(
-      Option.some<unknown>(registeredFunctions),
-      (currentNode, segment) =>
-        currentNode.pipe(
-          Option.filter(Predicate.isRecord),
-          Option.flatMap((nodeRecord) =>
-            segment in nodeRecord
-              ? Option.some(nodeRecord[segment])
-              : Option.none(),
-          ),
-        ),
-    ),
-    Option.getOrThrowWith(
-      () => new Error(`No functions registered for group path "${groupPath}"`),
-    ),
-  ) as ForGroupPath<Api_["spec"], GroupPath_>;
+    (registryItem) => makeRegisteredFunction(databaseSchema, registryItem),
+  ) as RegisteredFunctionsForGroupSpec<Group>;
 };

package/src/RegisteredNodeFunction.ts

@@ -1,20 +1,21 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
-import { NodeContext } from "@effect/platform-node";
+import * as NodeContext from "@effect/platform-node/NodeContext";
 import {
   actionGeneric,
   type DefaultFunctionArgs,
   internalActionGeneric,
 } from "convex/server";
 import type { Effect } from "effect";
-import { Layer, Match, type Schema } from "effect";
-import type * as Api from "./Api";
+import type { Schema } from "effect";
+import * as Layer from "effect/Layer";
+import * as Match from "effect/Match";
 import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as Handler from "./Handler";
 import * as RegisteredFunction from "./RegisteredFunction";
 import type * as RegistryItem from "./RegistryItem";
 
-export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Node">>(
-  api: Api_,
+export const make = (
+  databaseSchema: DatabaseSchema.AnyWithProps,
   { functionSpec, handler }: RegistryItem.AnyWithProps,
 ): RegisteredFunction.Any =>
   Match.value(functionSpec.functionProvenance).pipe(
@@ -30,7 +31,7 @@ export const make = <Api_ extends Api.AnyWithPropsWithRuntime<"Node">>(
       );
 
       return genericFunction(
-        nodeActionFunction(api.databaseSchema, {
+        nodeActionFunction(databaseSchema, {
           args: functionProvenance.args,
           returns: functionProvenance.returns,
           error: functionProvenance.error,

package/src/RegistryItem.ts

@@ -1,5 +1,5 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
-import { Predicate } from "effect";
+import * as Predicate from "effect/Predicate";
 import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as Handler from "./Handler";
 

package/src/Scheduler.ts

@@ -1,6 +1,10 @@
 import { Ref } from "@confect/core";
 import type { Scheduler as ConvexScheduler } from "convex/server";
-import { Context, DateTime, Duration, Effect, Layer } from "effect";
+import * as Context from "effect/Context";
+import * as DateTime from "effect/DateTime";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 
 const make = (scheduler: ConvexScheduler) => ({
   runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(