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

package/package.json

@@ -1,47 +1,11 @@
 {
   "name": "@confect/server",
-  "version": "9.0.0-next.0",
   "description": "Backend bindings to the Convex platform",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rjdellecese/confect.git"
-  },
+  "version": "9.0.0-next.10",
+  "author": "RJ Dellecese",
   "bugs": {
     "url": "https://github.com/rjdellecese/confect/issues"
   },
-  "homepage": "https://confect.dev",
-  "sideEffects": false,
-  "type": "module",
-  "files": [
-    "CHANGELOG.md",
-    "LICENSE",
-    "README.md",
-    "dist",
-    "package.json",
-    "src"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
-    },
-    "./package.json": "./package.json",
-    "./internal/*": null,
-    "./node": {
-      "types": "./dist/node.d.ts",
-      "default": "./dist/node.js"
-    }
-  },
-  "keywords": [
-    "effect",
-    "convex"
-  ],
-  "author": "RJ Dellecese",
-  "license": "ISC",
   "devDependencies": {
     "@ark/attest": "0.56.0",
     "@effect/cluster": "0.58.2",
@@ -51,50 +15,77 @@
     "@effect/sql": "0.51.1",
     "@effect/vitest": "0.29.0",
     "@effect/workflow": "0.18.1",
-    "@eslint/js": "10.0.1",
     "@swc/jest": "0.2.39",
     "@types/node": "25.3.3",
     "@vitest/coverage-v8": "3.2.4",
     "convex-test": "0.0.50",
     "dotenv": "17.3.1",
     "effect": "3.21.2",
-    "eslint": "10.0.2",
-    "prettier": "3.8.1",
     "tsdown": "0.20.3",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.56.1",
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.1.1",
     "vitest": "3.2.4"
   },
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json",
+    "./internal/*": null,
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    }
+  },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "dist",
+    "package.json",
+    "src"
+  ],
+  "homepage": "https://confect.dev",
+  "keywords": [
+    "convex",
+    "effect"
+  ],
+  "license": "ISC",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "peerDependencies": {
     "@effect/platform": "^0.96.1",
     "@effect/platform-node": "^0.106.0",
     "convex": "1.39.1",
     "effect": "^3.21.2",
-    "@confect/core": "^9.0.0-next.0"
+    "@confect/core": "^9.0.0-next.10"
   },
-  "engines": {
-    "node": ">=22",
-    "pnpm": ">=10"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rjdellecese/confect.git"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "sideEffects": false,
+  "type": "module",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsdown --config-loader unrun",
-    "dev": "tsdown --watch",
+    "bench": "tsx test/SchemaToValidator.bench.ts && tsx test/Document.bench.ts",
+    "clean": "rm -rf dist coverage node_modules",
+    "codegen:local-backend": "cd test/local-backend/fixtures && pnpm confect codegen && CONVEX_AGENT_MODE=anonymous pnpm convex dev --once --typecheck=disable --tail-logs=disable",
+    "codegen:mock-backend": "cd test/mock-backend/fixtures && pnpm confect codegen && CONVEX_AGENT_MODE=anonymous pnpm convex dev --once --typecheck=disable --tail-logs=disable",
+    "dev": "tsdown --watch --config-loader unrun",
     "test": "vitest run",
-    "test:mock-backend": "vitest run --config vitest.mock-backend.config.ts",
     "test:local-backend": "vitest run --config vitest.local-backend.config.ts",
-    "codegen:mock-backend": "cd test/mock-backend/fixtures && pnpm confect codegen && CONVEX_AGENT_MODE=anonymous pnpm convex dev --once --typecheck=disable --tail-logs=disable",
-    "codegen:local-backend": "cd test/local-backend/fixtures && pnpm confect codegen && CONVEX_AGENT_MODE=anonymous pnpm convex dev --once --typecheck=disable --tail-logs=disable",
-    "typecheck": "tsc --noEmit --project tsconfig.json",
-    "fix": "prettier --write . && eslint --fix . --max-warnings=0",
-    "format": "prettier --check .",
-    "lint": "eslint . --max-warnings=0",
-    "bench": "tsx test/SchemaToValidator.bench.ts && tsx test/Document.bench.ts",
-    "clean": "rm -rf dist coverage node_modules"
+    "test:mock-backend": "vitest run --config vitest.mock-backend.config.ts",
+    "typecheck": "tsc -b tsconfig.src.json"
   }
 }

package/src/ActionCtx.ts

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

package/src/ActionRunner.ts

@@ -1,7 +1,8 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericActionCtx } 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 =
   (runAction: GenericActionCtx<any>["runAction"]) =>

package/src/Auth.ts

@@ -1,5 +1,9 @@
 import type { Auth as ConvexAuth } from "convex/server";
-import { Effect, flow, Layer, Option, Schema } from "effect";
+import { flow } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 
 const make = (auth: ConvexAuth) => ({
   getUserIdentity: Effect.promise(() => auth.getUserIdentity()).pipe(

package/src/BlobNotFoundError.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 export class BlobNotFoundError extends Schema.TaggedError<BlobNotFoundError>()(
   "BlobNotFoundError",

package/src/ConvexConfigProvider.ts

@@ -1,11 +1,9 @@
-import {
-  Array,
-  ConfigError,
-  ConfigProvider,
-  ConfigProviderPathPatch,
-  Effect,
-  pipe,
-} from "effect";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as ConfigError from "effect/ConfigError";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as ConfigProviderPathPatch from "effect/ConfigProviderPathPatch";
+import * as Effect from "effect/Effect";
 
 declare const process: { env: Record<string, string | undefined> };
 

package/src/CronJob.ts

@@ -1,6 +1,6 @@
 import type { Ref } from "@confect/core";
 import type { Cron, Duration } from "effect";
-import { Predicate } from "effect";
+import * as Predicate from "effect/Predicate";
 
 export const TypeId = "@confect/server/CronJob";
 export type TypeId = typeof TypeId;

package/src/CronJobs.ts

@@ -1,16 +1,14 @@
 import { Ref } from "@confect/core";
 import type { CronJob as ConvexCronJob } from "convex/server";
 import { cronJobs as makeConvexCrons, type Crons } from "convex/server";
-import {
-  Array,
-  Cron,
-  Duration,
-  Match,
-  Order,
-  pipe,
-  Predicate,
-  Record,
-} from "effect";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as Cron from "effect/Cron";
+import * as Duration from "effect/Duration";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
 import type * as CronJob from "./CronJob";
 
 export const TypeId = "@confect/server/CronJobs";

package/src/DatabaseReader.ts

@@ -1,7 +1,8 @@
 import type { GenericDatabaseReader } from "convex/server";
-import { Array, Context, Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
 import type { BaseDatabaseReader } from "@confect/core/Types";
-import * as DatabaseSchema from "./DatabaseSchema";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as DataModel from "./DataModel";
 import * as QueryInitializer from "./QueryInitializer";
 import * as Table from "./Table";
@@ -13,35 +14,31 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
   >,
 ) => {
   type Tables = DatabaseSchema.Tables<DatabaseSchema_>;
-  type IncludedTables = DatabaseSchema.IncludeSystemTables<Tables>;
-  const extendedTables = DatabaseSchema.extendWithSystemTables(
-    databaseSchema.tables as Table.TablesRecord<Tables>,
-  );
+  type IncludedTables = Tables | Table.SystemTables;
 
   return {
     table: <const TableName extends Table.Name<IncludedTables>>(
       tableName: TableName,
     ) => {
-      const table = Object.values(extendedTables).find(
-        (def) => def.name === tableName,
-      ) as Table.WithName<IncludedTables, TableName>;
+      const isSystem = Object.hasOwn(Table.systemTables, tableName);
 
-      const baseDatabaseReader: BaseDatabaseReader<any> = Array.some(
-        Object.values(Table.systemTables),
-        (systemTableDef) => systemTableDef.name === tableName,
-      )
-        ? ({
+      const baseDatabaseReader: BaseDatabaseReader<any> = isSystem
+        ? {
             get: convexDatabaseReader.system.get,
             query: convexDatabaseReader.system.query,
-          } as BaseDatabaseReader<
-            DataModel.ToConvex<DataModel.FromTables<Table.SystemTables>>
-          >)
-        : ({
+          }
+        : {
             get: convexDatabaseReader.get,
             query: convexDatabaseReader.query,
-          } as BaseDatabaseReader<
-            DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>
-          >);
+          };
+
+      const table = (
+        isSystem
+          ? (Table.systemTables as Record<string, Table.AnyWithProps>)[
+              tableName
+            ]
+          : databaseSchema.tables[tableName]
+      ) as Table.WithName<IncludedTables, TableName>;
 
       return QueryInitializer.make<IncludedTables, TableName>(
         tableName,

package/src/DatabaseSchema.ts

@@ -1,10 +1,5 @@
-import type { Expand, GenericSchema } from "convex/server";
-import {
-  defineSchema as defineConvexSchema,
-  type SchemaDefinition,
-} from "convex/server";
-import { Array, pipe, Predicate, Record } from "effect";
-import * as Table from "./Table";
+import * as Predicate from "effect/Predicate";
+import type * as Table from "./Table";
 
 export const TypeId = "@confect/server/DatabaseSchema";
 export type TypeId = typeof TypeId;
@@ -17,29 +12,25 @@ export const isDatabaseSchema = (u: unknown): u is Any =>
   Predicate.hasProperty(u, TypeId);
 
 /**
- * A schema definition tracks the schema and its Convex schema definition.
+ * A schema definition holding a record of bound `Table`s keyed by table
+ * name. Codegen emits a single static `DatabaseSchema.make({ ... })` call;
+ * laziness lives entirely on each `Table` (its `Fields`, `Doc`, and
+ * `tableDefinition` are lazy memoised getters), so this layer is a plain
+ * record indirection with no module-loading or async machinery.
  */
 export interface DatabaseSchema<Tables_ extends Table.AnyWithProps = never> {
   readonly [TypeId]: TypeId;
-  readonly tables: Table.TablesRecord<Tables_>;
-  readonly convexSchemaDefinition: SchemaDefinition<
-    ConvexDatabaseSchemaFromTables<Tables_>,
-    true
-  >;
-
-  /**
-   * Add a table definition to the schema.
-   */
-  addTable<TableDef extends Table.AnyWithProps>(
-    table: TableDef,
-  ): DatabaseSchema<Tables_ | TableDef>;
+  readonly tables: {
+    readonly [TableName in Table.Name<Tables_>]: Table.WithName<
+      Tables_,
+      TableName
+    >;
+  };
 }
 
 export interface AnyWithProps {
   readonly [TypeId]: TypeId;
   readonly tables: Record<string, Table.AnyWithProps>;
-  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
-  addTable<TableDef extends Table.AnyWithProps>(table: TableDef): AnyWithProps;
 }
 
 export type Tables<DatabaseSchema_ extends AnyWithProps> =
@@ -53,82 +44,31 @@ export type TableNames<DatabaseSchema_ extends AnyWithProps> = Table.Name<
 export type TableWithName<
   DatabaseSchema_ extends AnyWithProps,
   TableName extends TableNames<DatabaseSchema_>,
-> = Extract<Tables<DatabaseSchema_>, { readonly name: TableName }>;
-
-const Proto = {
-  [TypeId]: TypeId,
-
-  addTable<TableDef extends Table.AnyWithProps>(
-    this: DatabaseSchema<Table.AnyWithProps>,
-    table: TableDef,
-  ) {
-    const tablesArray = Object.values(this.tables) as Table.AnyWithProps[];
-    const newTablesArray = [...tablesArray, table];
-
-    return makeProto({
-      tables: Record.set(this.tables, table.name, table),
-      convexSchemaDefinition: pipe(
-        newTablesArray,
-        Array.map(
-          ({ name, tableDefinition }) => [name, tableDefinition] as const,
-        ),
-        Record.fromEntries,
-        defineConvexSchema,
-      ),
-    });
-  },
-};
-
-const makeProto = <Tables_ extends Table.AnyWithProps>({
-  tables,
-  convexSchemaDefinition,
-}: {
-  tables: Record.ReadonlyRecord<string, Tables_>;
-  convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
-}): DatabaseSchema<Tables_> =>
-  Object.assign(Object.create(Proto), {
-    tables,
-    convexSchemaDefinition,
-  });
+> = Extract<Tables<DatabaseSchema_>, { readonly tableName: TableName }>;
 
 /**
- * Create an empty schema definition. Add tables incrementally via `addTable`.
+ * Construct a `DatabaseSchema` from a record of bound `Table`s. The empty
+ * case is `DatabaseSchema.make({})`. The `Tables_` union is inferred from
+ * the value record's values, so codegen-emitted calls of the form
+ * `DatabaseSchema.make({ notes, tags, users })` do not need an explicit
+ * type argument.
+ *
+ * Invariant: each record **key must equal its value's `tableName`**. The
+ * record is stored verbatim and later read by key (`databaseSchema.tables[
+ * tableName]` in `DatabaseReader`/`DatabaseWriter`), so a key that diverges
+ * from the bound table's name would make those lookups silently miss. The
+ * type signature does not enforce this — codegen upholds it by deriving both
+ * the key and the table name from the same filename (and the shorthand
+ * `{ notes, tags, users }` form it emits makes them identical by
+ * construction). Hand-written calls must preserve it.
  */
-export const make = (): DatabaseSchema<never> =>
-  makeProto({
-    tables: Record.empty(),
-    convexSchemaDefinition: defineConvexSchema({}),
-  });
-
-export type ConvexDatabaseSchemaFromTables<Tables_ extends Table.AnyWithProps> =
-  Expand<{
-    [TableName in Table.Name<Tables_> & string]: Table.WithName<
-      Tables_,
-      TableName
-    >["tableDefinition"];
-  }>;
-
-// System tables
-
-export const systemSchema = make()
-  .addTable(Table.scheduledFunctionsTable)
-  .addTable(Table.storageTable);
-
-export const extendWithSystemTables = <Tables_ extends Table.AnyWithProps>(
-  tables: Table.TablesRecord<Tables_>,
-): ExtendWithSystemTables<Tables_> =>
-  ({
-    ...tables,
-    ...Table.systemTables,
-  }) as ExtendWithSystemTables<Tables_>;
-
-export type ExtendWithSystemTables<Tables_ extends Table.AnyWithProps> =
-  Table.TablesRecord<Tables_ | Table.SystemTables>;
-
-export type IncludeSystemTables<Tables_ extends Table.AnyWithProps> =
-  | Tables_
-  | Table.SystemTables extends infer T
-  ? T extends Table.AnyWithProps
-    ? T
-    : never
-  : never;
+export const make = <
+  const TablesRecord extends Record<string, Table.AnyWithProps>,
+>(
+  tables: TablesRecord,
+): DatabaseSchema<TablesRecord[keyof TablesRecord]> => ({
+  [TypeId]: TypeId,
+  tables: tables as unknown as DatabaseSchema<
+    TablesRecord[keyof TablesRecord]
+  >["tables"],
+});

package/src/DatabaseWriter.ts

@@ -6,7 +6,11 @@ import type {
   WithoutSystemFields,
 } from "convex/server";
 import type { GenericId } from "convex/values";
-import { Context, Effect, Layer, pipe, Record } from "effect";
+import { pipe } from "effect/Function";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Record from "effect/Record";
 import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as DataModel from "./DataModel";
 import type { DocumentByName as DocumentByName_ } from "./DataModel";
@@ -22,14 +26,13 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
   >,
 ) => {
   type DataModel_ = DataModel.FromSchema<DatabaseSchema_>;
-  const tables = databaseSchema.tables as Record<string, Table.AnyWithProps>;
 
   const table = <const TableName extends DataModel.TableNames<DataModel_>>(
     tableName: TableName,
   ) => {
-    const tableDef = tables[tableName]!;
-    const tableSchema = tableDef.Fields as TableInfo.TableSchema<
-      DataModel.TableInfoWithName_<DataModel_, TableName>
+    const tableDef = databaseSchema.tables[tableName] as Table.WithName<
+      DatabaseSchema.Tables<DatabaseSchema_>,
+      TableName
     >;
 
     const insert = (
@@ -63,6 +66,10 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
       >,
     ) =>
       Effect.gen(function* () {
+        const tableSchema = tableDef.Fields as TableInfo.TableSchema<
+          DataModel.TableInfoWithName_<DataModel_, TableName>
+        >;
+
         const originalDecodedDoc = yield* QueryInitializer.getById(
           tableName,
           convexDatabaseWriter as any,
@@ -100,7 +107,7 @@ export const make = <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(
         const updatedEncodedDoc = yield* Document.encode(
           value,
           tableName,
-          tableSchema,
+          tableDef.Fields,
         );
 
         yield* Effect.promise(() =>

package/src/Document.ts

@@ -1,5 +1,9 @@
 import * as SystemFields from "@confect/core/SystemFields";
-import { Effect, Function, ParseResult, pipe, Schema } from "effect";
+import { pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as ParseResult from "effect/ParseResult";
+import * as Schema from "effect/Schema";
 import type { ReadonlyRecord } from "effect/Record";
 import type * as DataModel from "./DataModel";
 import type { ReadonlyValue } from "./SchemaToValidator";

package/src/FunctionImpl.ts

@@ -1,64 +1,69 @@
 import type * as FunctionSpec from "@confect/core/FunctionSpec";
 import type * as GroupSpec from "@confect/core/GroupSpec";
 import * as Registry from "@confect/core/Registry";
-import { Context, Effect, Layer, Ref, String } from "effect";
-import type * as Api from "./Api";
-import { resolveGroupPathUnsafe } from "./GroupPath";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
+import type * as DatabaseSchema from "./DatabaseSchema";
 import type * as Handler from "./Handler";
 import { setNestedProperty } from "./internal/utils";
 import * as RegistryItem from "./RegistryItem";
 
-export interface FunctionImpl<
-  GroupPath_ extends string,
-  FunctionName extends string,
-> {
-  readonly groupPath: GroupPath_;
+export interface FunctionImpl<FunctionName extends string> {
   readonly functionName: FunctionName;
 }
 
-export const FunctionImpl = <
-  GroupPath_ extends string,
-  FunctionName extends string,
->({
-  groupPath,
+export const FunctionImpl = <FunctionName extends string>({
   functionName,
 }: {
-  groupPath: GroupPath_;
   functionName: FunctionName;
 }) =>
-  Context.GenericTag<FunctionImpl<GroupPath_, FunctionName>>(
-    `@confect/server/FunctionImpl/${groupPath}/${functionName}`,
+  Context.GenericTag<FunctionImpl<FunctionName>>(
+    `@confect/server/FunctionImpl/${functionName}`,
   );
 
+/**
+ * Register a single function's implementation into the group's `Registry`.
+ *
+ * The function is registered under a flat, single-segment key (its own
+ * `functionName`), not a project-wide dot-path. Each group's impl layer is
+ * built in isolation — `RegisteredFunctions.buildForGroup` (and the CLI's
+ * `validateImpl`) provide a fresh `Registry` per group — so function names
+ * only need to be unique within their own group.
+ *
+ * `databaseSchema` is retained purely as a type-level carrier: the handler's
+ * ctx-service requirements (`DatabaseReader`, `QueryCtx<DataModel>`, …) are
+ * derived from it via `Handler.WithName`. It is not read at runtime — the
+ * generated per-group registry forwards the schema value to the function
+ * builders — so impls depend on `_generated/schema` (table schemas) rather than
+ * `_generated/api` (which transitively imports every function spec).
+ */
 export const make = <
-  Api_ extends Api.AnyWithProps,
+  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,
   Group extends GroupSpec.AnyWithProps,
   const FunctionName extends FunctionSpec.Name<GroupSpec.Functions<Group>>,
 >(
-  api: Api_,
+  _databaseSchema: DatabaseSchema_,
   group: Group,
   functionName: FunctionName,
   handler: Handler.WithName<
-    Api.Schema<Api_>,
+    DatabaseSchema_,
     GroupSpec.Functions<Group>,
     FunctionName
   >,
-): Layer.Layer<FunctionImpl<string, FunctionName>> => {
-  const groupPath = resolveGroupPathUnsafe(api.spec, group);
+): Layer.Layer<FunctionImpl<FunctionName>> => {
   const functionSpec = group.functions[functionName]!;
 
   return Layer.effect(
-    FunctionImpl<string, FunctionName>({
-      groupPath,
-      functionName,
-    }),
+    FunctionImpl<FunctionName>({ functionName }),
     Effect.gen(function* () {
       const registry = yield* Registry.Registry;
 
       yield* Ref.update(registry, (registryItems) =>
         setNestedProperty(
           registryItems,
-          [...String.split(groupPath, "."), functionName],
+          [functionName],
           RegistryItem.make({
             functionSpec,
             handler,
@@ -66,21 +71,16 @@ export const make = <
         ),
       );
 
-      return {
-        groupPath,
-        functionName,
-      };
+      return { functionName };
     }),
   );
 };
 
 /**
- * Get the function implementation service type for a specific group path and function name.
+ * Get the function implementation service type for a specific function name.
  */
-export type ForGroupPathAndFunction<
-  GroupPath_ extends string,
-  FunctionName extends string,
-> = FunctionImpl<GroupPath_, FunctionName>;
+export type ForFunction<FunctionName extends string> =
+  FunctionImpl<FunctionName>;
 
 /**
  * Get all function implementation services required for a group spec.
@@ -90,14 +90,6 @@ export type FromGroupSpec<Group extends GroupSpec.AnyWithProps> =
     GroupSpec.Functions<Group>
   > extends infer FunctionNames extends string
     ? FunctionNames extends string
-      ? FunctionImpl<string, FunctionNames>
+      ? FunctionImpl<FunctionNames>
       : never
     : never;
-
-/**
- * @deprecated Use {@link FromGroupSpec} instead.
- */
-export type FromGroupAtPath<
-  _GroupPath extends string,
-  Group extends GroupSpec.AnyWithProps,
-> = FromGroupSpec<Group>;