@gaganref/confect-core 10.3.1-fork.3 → 10.3.1-fork.30

package/dist/FunctionProvenance.js.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionProvenance.js","names":["PaginationOptions.PaginationOptions","PaginationResult.PaginationResult"],"sources":["../src/FunctionProvenance.ts"],"sourcesContent":["import type { DefaultFunctionArgs } from \"convex/server\";\nimport * as Data from \"effect/Data\";\nimport * as Schema from \"effect/Schema\";\nimport * as Lazy from \"./Lazy\";\nimport * as PaginationOptions from \"./PaginationOptions\";\nimport * as PaginationResult from \"./PaginationResult\";\n\n/**\n * A field map accepted as Confect function args. Restricting each field to a\n * context-free codec means the struct assembled from the fields can always be\n * encoded and decoded synchronously at a Convex boundary.\n */\nexport type ArgsFields = {\n  readonly [key: PropertyKey]: Schema.ConstraintCodec<any, any>;\n};\n\n/**\n * A struct-shaped Confect args schema that keeps its exact field map while\n * erasing the rest of `Schema.Struct`'s large implementation type. Decoded and\n * encoded args are derived directly from `ArgsFields_`; keeping the runtime\n * codec structural prevents every ref lookup from expanding the full Effect\n * schema type.\n */\nexport interface ArgsSchema<\n  ArgsFields_ extends ArgsFields,\n> extends Schema.Codec<any, any> {\n  readonly fields: ArgsFields_;\n}\n\n/**\n * Erased structural view used after the exact field map is no longer needed.\n */\nexport type AnyArgsSchema = ArgsSchema<ArgsFields>;\n\nexport type FunctionProvenance = Data.TaggedEnum<{\n  Confect: {\n    args: AnyArgsSchema;\n    returns: Schema.Codec<any, any>;\n    error?: Schema.Codec<any, any>;\n    kind: ConfectKind;\n  };\n  Convex: {\n    \"~args\": DefaultFunctionArgs;\n    \"~returns\": any;\n  };\n}>;\n\n/**\n * The declaration shape of a Confect function—orthogonal to both the provenance\n * origin (Confect vs Convex) and the function type (query/mutation/action). A\n * `Standard` function declares its args fields and returns schema directly; a\n * `Paginated` function declares user-args fields and an item schema from which\n * the Convex-facing `args`/`returns` are composed.\n */\nexport type ConfectKind = Standard | Paginated;\n\nexport interface Standard {\n  readonly _tag: \"Standard\";\n}\n\nexport interface Paginated<\n  UserArgsFields_ extends ArgsFields = ArgsFields,\n  Item extends Schema.Codec<any, any> = Schema.Codec<any, any>,\n> {\n  readonly _tag: \"Paginated\";\n  /**\n   * User-declared args—no `paginationOpts`.\n   */\n  readonly userArgs: ArgsSchema<UserArgsFields_>;\n  /**\n   * Page element schema.\n   */\n  readonly item: Item;\n  /**\n   * Mutable array of items—the page decode target.\n   */\n  readonly page: Schema.Codec<any, any>;\n}\n\nexport interface Confect<\n  ArgsFields_ extends ArgsFields,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n  Kind extends ConfectKind = ConfectKind,\n> {\n  readonly _tag: \"Confect\";\n  readonly \"~ArgsFields\": ArgsFields_;\n  readonly args: ArgsSchema<ArgsFields_>;\n  readonly returns: Returns;\n  readonly error?: Error;\n  readonly kind: Kind;\n}\n\nexport interface AnyConfect {\n  readonly _tag: \"Confect\";\n  readonly args: AnyArgsSchema;\n  readonly returns: Schema.Codec<any, any>;\n  readonly error?: Schema.Codec<any, any>;\n  readonly kind: ConfectKind;\n}\n\nexport interface Convex<Args extends DefaultFunctionArgs, Returns> {\n  readonly _tag: \"Convex\";\n  readonly \"~args\": Args;\n  readonly \"~returns\": Returns;\n}\n\nexport interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}\n\nexport const FunctionProvenance = Data.taggedEnum<FunctionProvenance>();\n\nconst Standard: Standard = { _tag: \"Standard\" };\n\n/**\n * Build a `Confect` provenance from lazy args-fields and schema thunks. `args`,\n * `returns`, and `error` are exposed as sync lazy memoised getters (via\n * {@link Lazy.defineProperty}) that only evaluate their thunk on first access,\n * mirroring how `Table` defers `Fields`/`Doc`. This keeps importing the\n * assembled `_generated/spec.ts` cheap—no\n * `Schema.Struct(...)`/`Schema.Array(...)` work runs at module load; it is\n * deferred to the first invocation that actually compiles validators or runs a\n * codec.\n *\n * The object is built by hand rather than through `FunctionProvenance.Confect`\n * because the `Data` constructor copies its input with `Object.assign`, which\n * would force the getters at construction time and defeat the laziness. `error`\n * is only installed when an `errorThunk` is provided, so its absence is\n * observable via `\"error\" in provenance` without forcing anything; nothing\n * relies on `Data`'s structural `Equal`/`Hash` for provenance values.\n */\nexport const Confect = <\n  const ArgsFields_ extends ArgsFields,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  args: () => ArgsFields_,\n  returns: () => Returns,\n  error?: () => Error,\n): Confect<ArgsFields_, Returns, Error, Standard> => {\n  const provenance = { _tag: \"Confect\" as const, kind: Standard };\n\n  Lazy.defineProperty(provenance, \"args\", () => Schema.Struct(args()));\n  Lazy.defineProperty(provenance, \"returns\", returns);\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return provenance as Confect<ArgsFields_, Returns, Error, Standard>;\n};\n\n/**\n * The composed args schema of a paginated query: the user-declared fields plus\n * the `paginationOpts` field managed by Convex's pagination protocol.\n *\n * The fields-first representation keeps the user-declared map available for\n * type-level composition without reconstructing it from an erased schema.\n */\nexport type PaginatedArgsFields<UserArgsFields extends ArgsFields> =\n  UserArgsFields & {\n    readonly paginationOpts: typeof PaginationOptions.PaginationOptions;\n  };\n\nexport type PaginatedArgs<UserArgsFields extends ArgsFields> = Schema.Struct<\n  PaginatedArgsFields<UserArgsFields>\n>;\n\n/**\n * The composed returns schema of a paginated query: a `PaginationResult` of the\n * item schema. Same deferred-conditional device as {@link PaginatedArgs}.\n */\nexport type PaginatedReturns<Item extends Schema.Codec<any, any>> =\n  PaginationResult.PaginationResult<Item> extends infer ComposedReturns extends\n    Schema.Codec<any, any>\n    ? ComposedReturns\n    : never;\n\nexport interface ConfectPaginated<\n  UserArgsFields extends ArgsFields,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n> extends Confect<\n  PaginatedArgsFields<UserArgsFields>,\n  PaginatedReturns<Item>,\n  Error,\n  Paginated<UserArgsFields, Item>\n> {}\n\nexport interface AnyConfectPaginated extends AnyConfect {\n  readonly kind: Paginated;\n}\n\n/**\n * Build the provenance of a paginated query from lazy schema thunks, with the\n * same laziness contract as {@link Confect}. The user-facing schemas live on the\n * `Paginated` kind (`kind.userArgs`, `kind.item`, `kind.page`)—the kind\n * container is built eagerly (it is cheap) while the schemas inside it stay\n * lazy. The composed Convex-facing `args`/`returns` are derived lazily from\n * them: `args` spreads the user fields plus `paginationOpts`, and `returns`\n * wraps the item in `PaginationResult`. Composition living here means the\n * composed schemas can never drift from the stored user schemas.\n */\nexport const ConfectPaginated = <\n  const UserArgsFields_ extends ArgsFields,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  userArgs: () => UserArgsFields_,\n  item: () => Item,\n  error?: () => Error,\n): ConfectPaginated<UserArgsFields_, Item, Error> => {\n  const kind = { _tag: \"Paginated\" as const };\n  const paginatedKind = kind as Paginated<UserArgsFields_, Item>;\n\n  Lazy.defineProperty(kind, \"userArgs\", () => Schema.Struct(userArgs()));\n  Lazy.defineProperty(kind, \"item\", item);\n  Lazy.defineProperty(kind, \"page\", () =>\n    Schema.mutable(Schema.Array(paginatedKind.item)),\n  );\n\n  const provenance = { _tag: \"Confect\" as const, kind: paginatedKind };\n  const self = provenance as ConfectPaginated<UserArgsFields_, Item, Error>;\n\n  Lazy.defineProperty(provenance, \"args\", () => {\n    const fields = paginatedKind.userArgs.fields;\n    if (\"paginationOpts\" in fields) {\n      throw new globalThis.Error(\n        \"A paginated query's args schema must not declare `paginationOpts`—\" +\n          \"it is added automatically from the `PaginationOptions` schema\",\n      );\n    }\n    return Schema.Struct({\n      ...fields,\n      paginationOpts: PaginationOptions.PaginationOptions,\n    });\n  });\n  Lazy.defineProperty(provenance, \"returns\", () =>\n    PaginationResult.PaginationResult(paginatedKind.item),\n  );\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return self;\n};\n\nexport const Convex = <Args extends DefaultFunctionArgs, Returns>() =>\n  FunctionProvenance.Convex(\n    {} as {\n      \"~args\": Args;\n      \"~returns\": Returns;\n    },\n  );\n"],"mappings":";;;;;;;;;;;;;AA6GA,MAAa,qBAAqB,KAAK,WAA+B;AAEtE,MAAM,WAAqB,EAAE,MAAM,WAAW;;;;;;;;;;;;;;;;;;AAmB9C,MAAa,WAKX,MACA,SACA,UACmD;CACnD,MAAM,aAAa;EAAE,MAAM;EAAoB,MAAM;CAAS;CAE9D,eAAoB,YAAY,cAAc,OAAO,OAAO,KAAK,CAAC,CAAC;CACnE,eAAoB,YAAY,WAAW,OAAO;CAClD,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;;;;;;;;;;;AAqDA,MAAa,oBAKX,UACA,MACA,UACmD;CACnD,MAAM,OAAO,EAAE,MAAM,YAAqB;CAC1C,MAAM,gBAAgB;CAEtB,eAAoB,MAAM,kBAAkB,OAAO,OAAO,SAAS,CAAC,CAAC;CACrE,eAAoB,MAAM,QAAQ,IAAI;CACtC,eAAoB,MAAM,cACxB,OAAO,QAAQ,OAAO,MAAM,cAAc,IAAI,CAAC,CACjD;CAEA,MAAM,aAAa;EAAE,MAAM;EAAoB,MAAM;CAAc;CACnE,MAAM,OAAO;CAEb,eAAoB,YAAY,cAAc;EAC5C,MAAM,SAAS,cAAc,SAAS;EACtC,IAAI,oBAAoB,QACtB,MAAM,IAAI,WAAW,MACnB,iIAEF;EAEF,OAAO,OAAO,OAAO;GACnB,GAAG;GACH,gBAAgBA;EAClB,CAAC;CACH,CAAC;CACD,eAAoB,YAAY,iBAC9BC,iBAAkC,cAAc,IAAI,CACtD;CACA,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;AAEA,MAAa,eACX,mBAAmB,OACjB,CAAC,CAIH"}
+{"version":3,"file":"FunctionProvenance.js","names":["PaginationOptions.PaginationOptions","PaginationResult.PaginationResult"],"sources":["../src/FunctionProvenance.ts"],"sourcesContent":["import type { DefaultFunctionArgs } from \"convex/server\";\nimport * as Data from \"effect/Data\";\nimport * as Schema from \"effect/Schema\";\nimport * as Lazy from \"./Lazy.js\";\nimport * as PaginationOptions from \"./PaginationOptions.js\";\nimport * as PaginationResult from \"./PaginationResult.js\";\n\n/**\n * A field map accepted as Confect function args. Restricting each field to a\n * context-free codec means the struct assembled from the fields can always be\n * encoded and decoded synchronously at a Convex boundary.\n */\nexport type ArgsFields = {\n  readonly [key: PropertyKey]: Schema.ConstraintCodec<any, any>;\n};\n\n/**\n * A struct-shaped Confect args schema that keeps its exact field map while\n * erasing the rest of `Schema.Struct`'s large implementation type. Decoded and\n * encoded args are derived directly from `ArgsFields_`; keeping the runtime\n * codec structural prevents every ref lookup from expanding the full Effect\n * schema type.\n */\nexport interface ArgsSchema<\n  ArgsFields_ extends ArgsFields,\n> extends Schema.Codec<any, any> {\n  readonly fields: ArgsFields_;\n}\n\n/**\n * Erased structural view used after the exact field map is no longer needed.\n */\nexport type AnyArgsSchema = ArgsSchema<ArgsFields>;\n\nexport type FunctionProvenance = Data.TaggedEnum<{\n  Confect: {\n    args: AnyArgsSchema;\n    returns: Schema.Codec<any, any>;\n    error?: Schema.Codec<any, any>;\n    kind: ConfectKind;\n  };\n  Convex: {\n    \"~args\": DefaultFunctionArgs;\n    \"~returns\": any;\n  };\n}>;\n\n/**\n * The declaration shape of a Confect function—orthogonal to both the provenance\n * origin (Confect vs Convex) and the function type (query/mutation/action). A\n * `Standard` function declares its args fields and returns schema directly; a\n * `Paginated` function declares user-args fields and an item schema from which\n * the Convex-facing `args`/`returns` are composed.\n */\nexport type ConfectKind = Standard | Paginated;\n\nexport interface Standard {\n  readonly _tag: \"Standard\";\n}\n\nexport interface Paginated<\n  UserArgsFields_ extends ArgsFields = ArgsFields,\n  Item extends Schema.Codec<any, any> = Schema.Codec<any, any>,\n> {\n  readonly _tag: \"Paginated\";\n  /**\n   * User-declared args—no `paginationOpts`.\n   */\n  readonly userArgs: ArgsSchema<UserArgsFields_>;\n  /**\n   * Page element schema.\n   */\n  readonly item: Item;\n  /**\n   * Mutable array of items—the page decode target.\n   */\n  readonly page: Schema.Codec<any, any>;\n}\n\nexport interface Confect<\n  ArgsFields_ extends ArgsFields,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n  Kind extends ConfectKind = ConfectKind,\n> {\n  readonly _tag: \"Confect\";\n  readonly \"~ArgsFields\": ArgsFields_;\n  readonly args: ArgsSchema<ArgsFields_>;\n  readonly returns: Returns;\n  readonly error?: Error;\n  readonly kind: Kind;\n}\n\nexport interface AnyConfect {\n  readonly _tag: \"Confect\";\n  readonly args: AnyArgsSchema;\n  readonly returns: Schema.Codec<any, any>;\n  readonly error?: Schema.Codec<any, any>;\n  readonly kind: ConfectKind;\n}\n\nexport interface Convex<Args extends DefaultFunctionArgs, Returns> {\n  readonly _tag: \"Convex\";\n  readonly \"~args\": Args;\n  readonly \"~returns\": Returns;\n}\n\nexport interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}\n\nexport const FunctionProvenance = Data.taggedEnum<FunctionProvenance>();\n\nconst Standard: Standard = { _tag: \"Standard\" };\n\n/**\n * Build a `Confect` provenance from lazy args-fields and schema thunks. `args`,\n * `returns`, and `error` are exposed as sync lazy memoised getters (via\n * {@link Lazy.defineProperty}) that only evaluate their thunk on first access,\n * mirroring how `Table` defers `Fields`/`Doc`. This keeps importing the\n * assembled `_generated/spec.ts` cheap—no\n * `Schema.Struct(...)`/`Schema.Array(...)` work runs at module load; it is\n * deferred to the first invocation that actually compiles validators or runs a\n * codec.\n *\n * The object is built by hand rather than through `FunctionProvenance.Confect`\n * because the `Data` constructor copies its input with `Object.assign`, which\n * would force the getters at construction time and defeat the laziness. `error`\n * is only installed when an `errorThunk` is provided, so its absence is\n * observable via `\"error\" in provenance` without forcing anything; nothing\n * relies on `Data`'s structural `Equal`/`Hash` for provenance values.\n */\nexport const Confect = <\n  const ArgsFields_ extends ArgsFields,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  args: () => ArgsFields_,\n  returns: () => Returns,\n  error?: () => Error,\n): Confect<ArgsFields_, Returns, Error, Standard> => {\n  const provenance = { _tag: \"Confect\" as const, kind: Standard };\n\n  Lazy.defineProperty(provenance, \"args\", () => Schema.Struct(args()));\n  Lazy.defineProperty(provenance, \"returns\", returns);\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return provenance as Confect<ArgsFields_, Returns, Error, Standard>;\n};\n\n/**\n * The composed args schema of a paginated query: the user-declared fields plus\n * the `paginationOpts` field managed by Convex's pagination protocol.\n *\n * The fields-first representation keeps the user-declared map available for\n * type-level composition without reconstructing it from an erased schema.\n */\nexport type PaginatedArgsFields<UserArgsFields extends ArgsFields> =\n  UserArgsFields & {\n    readonly paginationOpts: typeof PaginationOptions.PaginationOptions;\n  };\n\nexport type PaginatedArgs<UserArgsFields extends ArgsFields> = Schema.Struct<\n  PaginatedArgsFields<UserArgsFields>\n>;\n\n/**\n * The composed returns schema of a paginated query: a `PaginationResult` of the\n * item schema. Same deferred-conditional device as {@link PaginatedArgs}.\n */\nexport type PaginatedReturns<Item extends Schema.Codec<any, any>> =\n  PaginationResult.PaginationResult<Item> extends infer ComposedReturns extends\n    Schema.Codec<any, any>\n    ? ComposedReturns\n    : never;\n\nexport interface ConfectPaginated<\n  UserArgsFields extends ArgsFields,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n> extends Confect<\n  PaginatedArgsFields<UserArgsFields>,\n  PaginatedReturns<Item>,\n  Error,\n  Paginated<UserArgsFields, Item>\n> {}\n\nexport interface AnyConfectPaginated extends AnyConfect {\n  readonly kind: Paginated;\n}\n\n/**\n * Build the provenance of a paginated query from lazy schema thunks, with the\n * same laziness contract as {@link Confect}. The user-facing schemas live on the\n * `Paginated` kind (`kind.userArgs`, `kind.item`, `kind.page`)—the kind\n * container is built eagerly (it is cheap) while the schemas inside it stay\n * lazy. The composed Convex-facing `args`/`returns` are derived lazily from\n * them: `args` spreads the user fields plus `paginationOpts`, and `returns`\n * wraps the item in `PaginationResult`. Composition living here means the\n * composed schemas can never drift from the stored user schemas.\n */\nexport const ConfectPaginated = <\n  const UserArgsFields_ extends ArgsFields,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  userArgs: () => UserArgsFields_,\n  item: () => Item,\n  error?: () => Error,\n): ConfectPaginated<UserArgsFields_, Item, Error> => {\n  const kind = { _tag: \"Paginated\" as const };\n  const paginatedKind = kind as Paginated<UserArgsFields_, Item>;\n\n  Lazy.defineProperty(kind, \"userArgs\", () => Schema.Struct(userArgs()));\n  Lazy.defineProperty(kind, \"item\", item);\n  Lazy.defineProperty(kind, \"page\", () =>\n    Schema.mutable(Schema.Array(paginatedKind.item)),\n  );\n\n  const provenance = { _tag: \"Confect\" as const, kind: paginatedKind };\n  const self = provenance as ConfectPaginated<UserArgsFields_, Item, Error>;\n\n  Lazy.defineProperty(provenance, \"args\", () => {\n    const fields = paginatedKind.userArgs.fields;\n    if (\"paginationOpts\" in fields) {\n      throw new globalThis.Error(\n        \"A paginated query's args schema must not declare `paginationOpts`—\" +\n          \"it is added automatically from the `PaginationOptions` schema\",\n      );\n    }\n    return Schema.Struct({\n      ...fields,\n      paginationOpts: PaginationOptions.PaginationOptions,\n    });\n  });\n  Lazy.defineProperty(provenance, \"returns\", () =>\n    PaginationResult.PaginationResult(paginatedKind.item),\n  );\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return self;\n};\n\nexport const Convex = <Args extends DefaultFunctionArgs, Returns>() =>\n  FunctionProvenance.Convex(\n    {} as {\n      \"~args\": Args;\n      \"~returns\": Returns;\n    },\n  );\n"],"mappings":";;;;;;;;;;;;;AA6GA,MAAa,qBAAqB,KAAK,WAA+B;AAEtE,MAAM,WAAqB,EAAE,MAAM,WAAW;;;;;;;;;;;;;;;;;;AAmB9C,MAAa,WAKX,MACA,SACA,UACmD;CACnD,MAAM,aAAa;EAAE,MAAM;EAAoB,MAAM;CAAS;CAE9D,eAAoB,YAAY,cAAc,OAAO,OAAO,KAAK,CAAC,CAAC;CACnE,eAAoB,YAAY,WAAW,OAAO;CAClD,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;;;;;;;;;;;AAqDA,MAAa,oBAKX,UACA,MACA,UACmD;CACnD,MAAM,OAAO,EAAE,MAAM,YAAqB;CAC1C,MAAM,gBAAgB;CAEtB,eAAoB,MAAM,kBAAkB,OAAO,OAAO,SAAS,CAAC,CAAC;CACrE,eAAoB,MAAM,QAAQ,IAAI;CACtC,eAAoB,MAAM,cACxB,OAAO,QAAQ,OAAO,MAAM,cAAc,IAAI,CAAC,CACjD;CAEA,MAAM,aAAa;EAAE,MAAM;EAAoB,MAAM;CAAc;CACnE,MAAM,OAAO;CAEb,eAAoB,YAAY,cAAc;EAC5C,MAAM,SAAS,cAAc,SAAS;EACtC,IAAI,oBAAoB,QACtB,MAAM,IAAI,WAAW,MACnB,iIAEF;EAEF,OAAO,OAAO,OAAO;GACnB,GAAG;GACH,gBAAgBA;EAClB,CAAC;CACH,CAAC;CACD,eAAoB,YAAY,iBAC9BC,iBAAkC,cAAc,IAAI,CACtD;CACA,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;AAEA,MAAa,eACX,mBAAmB,OACjB,CAAC,CAIH"}

package/dist/FunctionSpec.d.ts

@@ -1,9 +1,10 @@
-import type * as MiddlewareAttachment from "./MiddlewareAttachment";
+import type * as MiddlewareAttachment from "./MiddlewareAttachment.js";
 import type { DefaultFunctionArgs, FunctionType, FunctionVisibility, RegisteredAction, RegisteredMutation, RegisteredQuery } from "convex/server";
-import type * as Schema from "effect/Schema";
-import * as FunctionProvenance from "./FunctionProvenance";
-import type * as MiddlewareSpec from "./MiddlewareSpec";
-import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
+import * as Schema from "effect/Schema";
+import * as FunctionProvenance from "./FunctionProvenance.js";
+import * as MiddlewareSpec from "./MiddlewareSpec.js";
+import type * as Profile from "./Profile.js";
+import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType.js";
 export declare const TypeId = "~@confect/core/FunctionSpec";
 export type TypeId = typeof TypeId;
 export declare const isFunctionSpec: (u: unknown) => u is AnyWithProps;
@@ -19,10 +20,24 @@ export interface FunctionSpec<RuntimeAndFunctionType_ extends RuntimeAndFunction
 export interface Builder<RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility_ extends FunctionVisibility, Name_ extends string, FunctionProvenance_ extends FunctionProvenance.FunctionProvenance, MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec = never> extends FunctionSpec<RuntimeAndFunctionType_, FunctionVisibility_, Name_, FunctionProvenance_, MiddlewareSpecs_> {
     middleware<MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec>(middlewareSpec: MiddlewareSpec_ & MiddlewareSpec.ValidateFunctionAttach<MiddlewareSpec_, RuntimeAndFunctionType_, FunctionProvenance_, MiddlewareSpecs_>, ...options: MiddlewareAttachment.Args<NoInfer<MiddlewareSpec_>>): Builder<RuntimeAndFunctionType_, FunctionVisibility_, Name_, FunctionProvenance_, MiddlewareSpecs_ | MiddlewareSpec_>;
 }
+export interface DescribedBuilder<RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility_ extends FunctionVisibility, Name_ extends string, FunctionProvenance_ extends FunctionProvenance.FunctionProvenance, MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec = never> extends Builder<RuntimeAndFunctionType_, FunctionVisibility_, Name_, FunctionProvenance_, MiddlewareSpecs_> {
+    readonly description?: string;
+    middleware<MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec>(middlewareSpec: MiddlewareSpec_ & MiddlewareSpec.ValidateFunctionAttach<MiddlewareSpec_, RuntimeAndFunctionType_, FunctionProvenance_, MiddlewareSpecs_>, ...options: MiddlewareAttachment.Args<NoInfer<MiddlewareSpec_>>): DescribedBuilder<RuntimeAndFunctionType_, FunctionVisibility_, Name_, FunctionProvenance_, MiddlewareSpecs_ | MiddlewareSpec_>;
+}
+/**
+ * A spec built through {@link extend}, keeping its fields through middleware.
+ */
+export interface ExtendedBuilder<RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility_ extends FunctionVisibility, Name_ extends string, FunctionProvenance_ extends FunctionProvenance.FunctionProvenance, MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec, Fields_> extends Builder<RuntimeAndFunctionType_, FunctionVisibility_, Name_, FunctionProvenance_, MiddlewareSpecs_> {
+    readonly description?: string;
+    readonly fields: Profile.Info<Fields_>["fields"];
+    middleware<MiddlewareSpec_ extends MiddlewareSpec.AnyMiddlewareSpec>(middlewareSpec: MiddlewareSpec_ & MiddlewareSpec.ValidateFunctionAttach<MiddlewareSpec_, RuntimeAndFunctionType_, FunctionProvenance_, MiddlewareSpecs_>, ...options: MiddlewareAttachment.Args<NoInfer<MiddlewareSpec_>>): ExtendedBuilder<RuntimeAndFunctionType_, FunctionVisibility_, Name_, FunctionProvenance_, MiddlewareSpecs_ | MiddlewareSpec_, Fields_>;
+}
 export interface Any {
     readonly [TypeId]: TypeId;
 }
 export interface AnyWithProps extends FunctionSpec<RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility, string, FunctionProvenance.FunctionProvenance, MiddlewareSpec.AnyMiddlewareSpec> {
+    readonly description?: string;
+    readonly fields?: object;
 }
 export interface AnyConfect extends FunctionSpec<RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility, string, FunctionProvenance.AnyConfect, MiddlewareSpec.AnyMiddlewareSpec> {
 }
@@ -129,6 +144,7 @@ type ForbidPaginationOpts<UserArgsFields extends FunctionProvenance.ArgsFields>
 export declare const publicQuery: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -138,6 +154,7 @@ export declare const publicQuery: {
     }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -145,10 +162,31 @@ export declare const publicQuery: {
         readonly runtime: "Convex";
         readonly functionType: "query";
     }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
 };
 export declare const internalQuery: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -158,6 +196,7 @@ export declare const internalQuery: {
     }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -165,10 +204,31 @@ export declare const internalQuery: {
         readonly runtime: "Convex";
         readonly functionType: "query";
     }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
 };
 export declare const publicPaginatedQuery: {
     <const Name_ extends string, const UserArgsFields_ extends FunctionProvenance.ArgsFields, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
         item: () => Item_;
         error?: () => Error_;
@@ -178,6 +238,7 @@ export declare const publicPaginatedQuery: {
     }, "public", Name_, FunctionProvenance.ConfectPaginated<UserArgsFields_, Item_, Error_>, never>;
     <const Name_ extends string, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         item: () => Item_;
         error?: () => Error_;
@@ -185,10 +246,31 @@ export declare const publicPaginatedQuery: {
         readonly runtime: "Convex";
         readonly functionType: "query";
     }, "public", Name_, FunctionProvenance.ConfectPaginated<{}, Item_, Error_>, never>;
+    <const Name_ extends string, const UserArgsFields_ extends FunctionProvenance.ArgsFields, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
+        item: () => Item_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "public", Name_, FunctionProvenance.ConfectPaginated<UserArgsFields_, Item_, Error_>, never>;
+    <const Name_ extends string, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args?: never;
+        item: () => Item_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "public", Name_, FunctionProvenance.ConfectPaginated<{}, Item_, Error_>, never>;
 };
 export declare const internalPaginatedQuery: {
     <const Name_ extends string, const UserArgsFields_ extends FunctionProvenance.ArgsFields, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
         item: () => Item_;
         error?: () => Error_;
@@ -198,6 +280,7 @@ export declare const internalPaginatedQuery: {
     }, "internal", Name_, FunctionProvenance.ConfectPaginated<UserArgsFields_, Item_, Error_>, never>;
     <const Name_ extends string, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         item: () => Item_;
         error?: () => Error_;
@@ -205,10 +288,31 @@ export declare const internalPaginatedQuery: {
         readonly runtime: "Convex";
         readonly functionType: "query";
     }, "internal", Name_, FunctionProvenance.ConfectPaginated<{}, Item_, Error_>, never>;
+    <const Name_ extends string, const UserArgsFields_ extends FunctionProvenance.ArgsFields, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
+        item: () => Item_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "internal", Name_, FunctionProvenance.ConfectPaginated<UserArgsFields_, Item_, Error_>, never>;
+    <const Name_ extends string, Item_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args?: never;
+        item: () => Item_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "query";
+    }, "internal", Name_, FunctionProvenance.ConfectPaginated<{}, Item_, Error_>, never>;
 };
 export declare const publicMutation: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -218,6 +322,7 @@ export declare const publicMutation: {
     }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -225,10 +330,31 @@ export declare const publicMutation: {
         readonly runtime: "Convex";
         readonly functionType: "mutation";
     }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "mutation";
+    }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "mutation";
+    }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
 };
 export declare const internalMutation: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -238,6 +364,7 @@ export declare const internalMutation: {
     }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -245,10 +372,31 @@ export declare const internalMutation: {
         readonly runtime: "Convex";
         readonly functionType: "mutation";
     }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "mutation";
+    }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "mutation";
+    }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
 };
 export declare const publicAction: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -258,6 +406,7 @@ export declare const publicAction: {
     }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -265,10 +414,31 @@ export declare const publicAction: {
         readonly runtime: "Convex";
         readonly functionType: "action";
     }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "action";
+    }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "action";
+    }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
 };
 export declare const internalAction: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -278,6 +448,7 @@ export declare const internalAction: {
     }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -285,10 +456,31 @@ export declare const internalAction: {
         readonly runtime: "Convex";
         readonly functionType: "action";
     }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "action";
+    }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Convex";
+        readonly functionType: "action";
+    }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
 };
 export declare const publicNodeAction: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -298,6 +490,7 @@ export declare const publicNodeAction: {
     }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -305,10 +498,31 @@ export declare const publicNodeAction: {
         readonly runtime: "Node";
         readonly functionType: "action";
     }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Node";
+        readonly functionType: "action";
+    }, "public", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: string;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Node";
+        readonly functionType: "action";
+    }, "public", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
 };
 export declare const internalNodeAction: {
     <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args: () => ArgsFields_;
         returns: () => Returns_;
         error?: () => Error_;
@@ -318,6 +532,7 @@ export declare const internalNodeAction: {
     }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
     <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
         name: Name_;
+        description?: never;
         args?: never;
         returns: () => Returns_;
         error?: () => Error_;
@@ -325,7 +540,116 @@ export declare const internalNodeAction: {
         readonly runtime: "Node";
         readonly functionType: "action";
     }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args: () => ArgsFields_;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Node";
+        readonly functionType: "action";
+    }, "internal", Name_, FunctionProvenance.Confect<ArgsFields_, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+    <const Name_ extends string, Returns_ extends Schema.Codec<any, any>, Error_ extends Schema.Codec<any, any> = never>(options: {
+        name: Name_;
+        description?: never;
+        args?: never;
+        returns: () => Returns_;
+        error?: () => Error_;
+    }): DescribedBuilder<{
+        readonly runtime: "Node";
+        readonly functionType: "action";
+    }, "internal", Name_, FunctionProvenance.Confect<{}, Returns_, Error_, FunctionProvenance.ConfectKind>, never>;
+};
+type OptionlessMiddlewareSpec = MiddlewareSpec.AnyMiddlewareSpec & {
+    readonly "~Options": never;
+};
+type BuilderOption = "name" | "description" | "args" | "returns" | "item" | "error";
+/**
+ * Only a required description string may name a builder option. The builder
+ * reads it as that option. The conditional keeps the mapped type out of a
+ * builder call's inference, which would otherwise widen the function's name to
+ * `string` when reporting the error.
+ */
+type OptionFree<Type> = [keyof Type & BuilderOption] extends [never] ? unknown : {
+    readonly [Option in keyof Type & BuilderOption as Option extends "description" ? Type[Option] extends string ? string extends Type[Option] ? never : Option : Option : Option]: never;
 };
+/**
+ * A function's fields, checked once applied, since a profile's field type can
+ * branch on the function's name.
+ */
+type CheckedFields<Type> = Type & OptionFree<Type>;
+type NotRepeated<Middleware_, Inherited extends MiddlewareSpec.AnyMiddlewareSpec> = Middleware_ extends {
+    readonly key: infer Key extends MiddlewareSpec.Key<Inherited>;
+} ? MiddlewareSpec.AttachmentError<`Middleware "${Key}" is already attached by this profile`> : Middleware_;
+/**
+ * Refuses a middleware without options that an earlier layer attached, as it is
+ * attached at most once; one with options may repeat. Each member of an
+ * element's union is checked, so an array typed `(A | B)[]` is refused when
+ * either was attached.
+ */
+type NotInherited<Middleware_ extends ReadonlyArray<unknown>, Inherited extends MiddlewareSpec.AnyMiddlewareSpec> = {
+    readonly [Index in keyof Middleware_]: NotRepeated<Middleware_[Index], Inherited>;
+};
+/**
+ * A profile's middleware: a spec without options, or an attachment.
+ */
+type ProfileMiddleware<FieldsType> = OptionlessMiddlewareSpec | Profile.Attachment<MiddlewareSpec.AnyMiddlewareSpec, FieldsType>;
+type SpecOf<Middleware_> = Middleware_ extends Profile.Attachment<infer MiddlewareSpec_, any> ? MiddlewareSpec_ : Extract<Middleware_, MiddlewareSpec.AnyMiddlewareSpec>;
+/**
+ * `never` when a profile middleware does not declare the function type.
+ */
+type Declared<MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec, FunctionType_ extends FunctionType, Make> = [
+    MiddlewareSpecs_ extends unknown ? FunctionType_ extends MiddlewareSpec.FunctionTypes<MiddlewareSpecs_> ? never : MiddlewareSpecs_ : never
+] extends [never] ? Make : never;
+type Wrapped<Layers extends ReadonlyArray<Profile.Transforms>, Key extends keyof Profile.Transforms, Input> = Layers extends readonly [
+    infer First extends Profile.Transforms,
+    ...infer Rest extends ReadonlyArray<Profile.Transforms>
+] ? Wrapped<Rest, Key, Key extends keyof First ? [Input] extends [never] ? Key extends "error" ? Profile.Transform<First[Key], typeof Schema.Never> : never : Profile.Transform<First[Key], Input> : Input> : Input;
+type UserArgs<A> = [A] extends [never] ? {} : A;
+type ExtendedMake<RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType, Fields_ extends Profile.Fields, MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec, Layers extends ReadonlyArray<Profile.Transforms>> = Declared<MiddlewareSpecs_, RuntimeAndFunctionType_["functionType"], <const Name_ extends string, const ArgsFields_ extends FunctionProvenance.ArgsFields = never, Returns_ extends Schema.Codec<any, any> = never, Error_ extends Schema.Codec<any, any> = never>(options: {
+    readonly name: Name_;
+    readonly description?: string;
+    readonly args?: () => ArgsFields_;
+    readonly returns: () => Returns_;
+    readonly error?: () => Error_;
+} & NoInfer<CheckedFields<Profile.Apply<Fields_, Name_, UserArgs<ArgsFields_>>>>) => ExtendedBuilder<RuntimeAndFunctionType_, "public", Name_, FunctionProvenance.Confect<UserArgs<Wrapped<Layers, "args", ArgsFields_>>, Wrapped<Layers, "returns", Returns_>, Wrapped<Layers, "error", Error_>>, MiddlewareSpecs_, Profile.Apply<Fields_, Name_, UserArgs<ArgsFields_>>>>;
+type ExtendedMakePaginated<Fields_ extends Profile.Fields, MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec, Layers extends ReadonlyArray<Profile.Transforms>> = Declared<MiddlewareSpecs_, "query", <const Name_ extends string, const UserArgsFields_ extends FunctionProvenance.ArgsFields = never, Item_ extends Schema.Codec<any, any> = never, Error_ extends Schema.Codec<any, any> = never>(options: {
+    readonly name: Name_;
+    readonly description?: string;
+    readonly args?: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
+    readonly item: () => Item_;
+    readonly error?: () => Error_;
+} & NoInfer<CheckedFields<Profile.Apply<Fields_, Name_, UserArgs<UserArgsFields_>>>>) => ExtendedBuilder<RuntimeAndFunctionType.ConvexQuery, "public", Name_, FunctionProvenance.ConfectPaginated<UserArgs<Wrapped<Layers, "args", UserArgsFields_>>, Wrapped<Layers, "item", Item_>, Wrapped<Layers, "error", Error_>>, MiddlewareSpecs_, Profile.Apply<Fields_, Name_, UserArgs<UserArgsFields_>>>>;
+interface ExtendedRuntimes {
+    readonly publicQuery: RuntimeAndFunctionType.ConvexQuery;
+    readonly publicMutation: RuntimeAndFunctionType.ConvexMutation;
+    readonly publicAction: RuntimeAndFunctionType.ConvexAction;
+    readonly publicNodeAction: RuntimeAndFunctionType.NodeAction;
+}
+/**
+ * A profile's five public builders and its own `extend`.
+ */
+export type Extended<Fields_ extends Profile.Fields, MiddlewareSpecs_ extends MiddlewareSpec.AnyMiddlewareSpec, Layers extends ReadonlyArray<Profile.Transforms> = []> = {
+    readonly [Builder_ in keyof ExtendedRuntimes]: ExtendedMake<ExtendedRuntimes[Builder_], Fields_, MiddlewareSpecs_, Layers>;
+} & {
+    readonly publicPaginatedQuery: ExtendedMakePaginated<Fields_, MiddlewareSpecs_, Layers>;
+    /**
+     * Require more fields and attach more middleware after this profile's.
+     */
+    extend<Extension extends Profile.Fields = Profile.NoFields, Transforms extends Profile.Transforms = {}>(): <const Middleware_ extends ReadonlyArray<ProfileMiddleware<Profile.Apply<Profile.Both<Fields_, Extension>, string, any>>>>(config: {
+        readonly middleware: Middleware_ & NotInherited<Middleware_, MiddlewareSpecs_>;
+    } & OptionFree<Extension["Type"]> & Profile.SchemaConfig<Transforms, Profile.Apply<Profile.Both<Fields_, Extension>, string, any>>) => Extended<Profile.Both<Fields_, Extension>, MiddlewareSpecs_ | SpecOf<Middleware_[number]>, [
+        ...Layers,
+        Transforms
+    ]>;
+};
+/**
+ * Public builders whose specs require and keep `Fields_`, with `middleware`.
+ */
+export declare const extend: <Fields_ extends Profile.Fields = Profile.NoFields, Transforms extends Profile.Transforms = {}>() => <const Middleware_ extends ReadonlyArray<ProfileMiddleware<Profile.Apply<Fields_, string, any>>>>(config: {
+    readonly middleware: Middleware_;
+} & OptionFree<Fields_["Type"]> & Profile.SchemaConfig<Transforms, Profile.Apply<Fields_, string, any>>) => Extended<Fields_, SpecOf<Middleware_[number]>, [Transforms]>;
 type MatchingRegisteredFunction<RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType, FunctionVisibility_ extends FunctionVisibility> = RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_> extends "query" ? RegisteredQuery<FunctionVisibility_, any, any> : RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_> extends "mutation" ? RegisteredMutation<FunctionVisibility_, any, any> : RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_> extends "action" ? RegisteredAction<FunctionVisibility_, any, any> : never;
 type ExtractArgs<F> = F extends RegisteredQuery<any, infer A extends DefaultFunctionArgs, any> ? A : F extends RegisteredMutation<any, infer A extends DefaultFunctionArgs, any> ? A : F extends RegisteredAction<any, infer A extends DefaultFunctionArgs, any> ? A : never;
 type ExtractReturns<F> = F extends RegisteredQuery<any, any, infer R> ? R : F extends RegisteredMutation<any, any, infer R> ? R : F extends RegisteredAction<any, any, infer R> ? R : never;