@confect/core 10.0.0-next.18 → 10.0.0-next.19

package/src/FunctionProvenance.ts

@@ -5,17 +5,41 @@ import * as Lazy from "./Lazy";
 import * as PaginationOptions from "./PaginationOptions";
 import * as PaginationResult from "./PaginationResult";
 
+/**
+ * A field map accepted as Confect function args. Restricting each field to a
+ * context-free codec means the struct assembled from the fields can always be
+ * encoded and decoded synchronously at a Convex boundary.
+ */
+// eslint-disable-next-line import/namespace -- oxlint's namespace resolution misses type-only exports, and `Schema` is an interface/namespace
+export type ArgsFields = {
+  readonly [key: PropertyKey]: Schema.ConstraintCodec<any, any>;
+};
+
+/**
+ * A struct-shaped Confect args schema that keeps its exact field map while
+ * erasing the rest of `Schema.Struct`'s large implementation type. Decoded and
+ * encoded args are derived directly from `ArgsFields_`; keeping the runtime
+ * codec structural prevents every ref lookup from expanding the full Effect
+ * schema type.
+ */
+export interface ArgsSchema<
+  ArgsFields_ extends ArgsFields,
+> extends Schema.Codec<any, any> {
+  readonly fields: ArgsFields_;
+}
+
+/** Erased structural view used after the exact field map is no longer needed. */
+export type AnyArgsSchema = ArgsSchema<ArgsFields>;
+
 export type FunctionProvenance = Data.TaggedEnum<{
   Confect: {
-    args: Schema.Codec<any, any>;
+    args: AnyArgsSchema;
     returns: Schema.Codec<any, any>;
     error?: Schema.Codec<any, any>;
     kind: ConfectKind;
   };
   Convex: {
-    /** @internal */
     "~args": DefaultFunctionArgs;
-    /** @internal */
     "~returns": any;
   };
 }>;
@@ -23,9 +47,10 @@ export type FunctionProvenance = Data.TaggedEnum<{
 /**
  * The declaration shape of a Confect function — orthogonal to both the
  * provenance origin (Confect vs Convex) and the function type
- * (query/mutation/action). A `Standard` function declares its `args` and
- * `returns` schemas directly; a `Paginated` function declares `userArgs` and
- * `item` schemas from which the Convex-facing `args`/`returns` are composed.
+ * (query/mutation/action). A `Standard` function declares its args fields and
+ * returns schema directly; a `Paginated` function declares user-args fields
+ * and an item schema from which the Convex-facing `args`/`returns` are
+ * composed.
  */
 export type ConfectKind = Standard | Paginated;
 
@@ -34,12 +59,12 @@ export interface Standard {
 }
 
 export interface Paginated<
-  UserArgs extends AnyUserArgs = AnyUserArgs,
+  UserArgsFields_ extends ArgsFields = ArgsFields,
   Item extends Schema.Codec<any, any> = Schema.Codec<any, any>,
 > {
   readonly _tag: "Paginated";
   /** User-declared args — no `paginationOpts`. */
-  readonly userArgs: UserArgs;
+  readonly userArgs: ArgsSchema<UserArgsFields_>;
   /** Page element schema. */
   readonly item: Item;
   /** Mutable array of items — the page decode target. */
@@ -47,23 +72,26 @@ export interface Paginated<
 }
 
 export interface Confect<
-  Args extends Schema.Codec<any, any>,
+  ArgsFields_ extends ArgsFields,
   Returns extends Schema.Codec<any, any>,
   Error extends Schema.Codec<any, any> = never,
   Kind extends ConfectKind = ConfectKind,
 > {
   readonly _tag: "Confect";
-  readonly args: Args;
+  readonly "~ArgsFields": ArgsFields_;
+  readonly args: ArgsSchema<ArgsFields_>;
   readonly returns: Returns;
   readonly error?: Error;
   readonly kind: Kind;
 }
 
-export interface AnyConfect extends Confect<
-  Schema.Codec<any, any>,
-  Schema.Codec<any, any>,
-  Schema.Codec<any, any>
-> {}
+export interface AnyConfect {
+  readonly _tag: "Confect";
+  readonly args: AnyArgsSchema;
+  readonly returns: Schema.Codec<any, any>;
+  readonly error?: Schema.Codec<any, any>;
+  readonly kind: ConfectKind;
+}
 
 export interface Convex<Args extends DefaultFunctionArgs, Returns> {
   readonly _tag: "Convex";
@@ -78,13 +106,13 @@ export const FunctionProvenance = Data.taggedEnum<FunctionProvenance>();
 const Standard: Standard = { _tag: "Standard" };
 
 /**
- * Build a `Confect` provenance from lazy schema thunks. `args`, `returns`,
- * and `error` are exposed as sync lazy memoised getters (via {@link Lazy.defineProperty})
- * that only evaluate their thunk on first access, mirroring how `Table`
- * defers `Fields`/`Doc`. This keeps importing the assembled
- * `_generated/spec.ts` cheap — no `Schema.Struct(...)` / `Schema.Array(...)`
- * work runs at module load; it is deferred to the first invocation that
- * actually compiles validators or runs a codec.
+ * Build a `Confect` provenance from lazy args-fields and schema thunks.
+ * `args`, `returns`, and `error` are exposed as sync lazy memoised getters
+ * (via {@link Lazy.defineProperty}) that only evaluate their thunk on first
+ * access, mirroring how `Table` defers `Fields`/`Doc`. This keeps importing the
+ * assembled `_generated/spec.ts` cheap — no `Schema.Struct(...)` /
+ * `Schema.Array(...)` work runs at module load; it is deferred to the first
+ * invocation that actually compiles validators or runs a codec.
  *
  * The object is built by hand rather than through `FunctionProvenance.Confect`
  * because the `Data` constructor copies its input with `Object.assign`, which
@@ -94,53 +122,40 @@ const Standard: Standard = { _tag: "Standard" };
  * relies on `Data`'s structural `Equal`/`Hash` for provenance values.
  */
 export const Confect = <
-  Args extends Schema.Codec<any, any>,
+  const ArgsFields_ extends ArgsFields,
   Returns extends Schema.Codec<any, any>,
   Error extends Schema.Codec<any, any> = never,
 >(
-  args: () => Args,
+  args: () => ArgsFields_,
   returns: () => Returns,
   error?: () => Error,
-): Confect<Args, Returns, Error, Standard> => {
+): Confect<ArgsFields_, Returns, Error, Standard> => {
   const provenance = { _tag: "Confect" as const, kind: Standard };
 
-  Lazy.defineProperty(provenance, "args", args);
+  Lazy.defineProperty(provenance, "args", () => Schema.Struct(args()));
   Lazy.defineProperty(provenance, "returns", returns);
   if (error !== undefined) {
     Lazy.defineProperty(provenance, "error", error);
   }
 
-  return provenance as Confect<Args, Returns, Error, Standard>;
+  return provenance as Confect<ArgsFields_, Returns, Error, Standard>;
 };
 
-/**
- * Any struct-shaped, context-free schema usable as a paginated query's user
- * args. A structural bound rather than `Schema.Struct<Schema.Struct.Fields>`
- * because `Schema.Struct` is not covariant in its fields parameter — concrete
- * structs do not extend `Schema.Struct<Schema.Struct.Fields>`.
- */
-// eslint-disable-next-line import/namespace -- oxlint's namespace resolution misses type-only exports, and `Schema` is an interface/namespace
-export interface AnyUserArgs extends Schema.Codec<any, any> {
-  readonly fields: Schema.Struct.Fields;
-}
-
 /**
  * The composed args schema of a paginated query: the user-declared fields
  * plus the `paginationOpts` field managed by Convex's pagination protocol.
  *
- * The `extends infer ... extends` conditional lets TypeScript accept the
- * composed struct where `Schema.Codec<any, any>` is required even while
- * `UserArgs` is an unresolved type parameter; for concrete user args it
- * evaluates away entirely.
+ * The fields-first representation keeps the user-declared map available for
+ * type-level composition without reconstructing it from an erased schema.
  */
-export type PaginatedArgs<UserArgs extends AnyUserArgs> =
-  Schema.Struct<
-    UserArgs["fields"] & {
-      paginationOpts: typeof PaginationOptions.PaginationOptions;
-    }
-  > extends infer ComposedArgs extends Schema.Codec<any, any>
-    ? ComposedArgs
-    : never;
+export type PaginatedArgsFields<UserArgsFields extends ArgsFields> =
+  UserArgsFields & {
+    readonly paginationOpts: typeof PaginationOptions.PaginationOptions;
+  };
+
+export type PaginatedArgs<UserArgsFields extends ArgsFields> = Schema.Struct<
+  PaginatedArgsFields<UserArgsFields>
+>;
 
 /**
  * The composed returns schema of a paginated query: a `PaginationResult` of
@@ -153,21 +168,19 @@ export type PaginatedReturns<Item extends Schema.Codec<any, any>> =
     : never;
 
 export interface ConfectPaginated<
-  UserArgs extends AnyUserArgs,
+  UserArgsFields extends ArgsFields,
   Item extends Schema.Codec<any, any>,
   Error extends Schema.Codec<any, any> = never,
 > extends Confect<
-  PaginatedArgs<UserArgs>,
+  PaginatedArgsFields<UserArgsFields>,
   PaginatedReturns<Item>,
   Error,
-  Paginated<UserArgs, Item>
+  Paginated<UserArgsFields, Item>
 > {}
 
-export interface AnyConfectPaginated extends ConfectPaginated<
-  AnyUserArgs,
-  Schema.Codec<any, any>,
-  Schema.Codec<any, any>
-> {}
+export interface AnyConfectPaginated extends AnyConfect {
+  readonly kind: Paginated;
+}
 
 /**
  * Build the provenance of a paginated query from lazy schema thunks, with the
@@ -180,25 +193,25 @@ export interface AnyConfectPaginated extends ConfectPaginated<
  * composed schemas can never drift from the stored user schemas.
  */
 export const ConfectPaginated = <
-  UserArgs extends AnyUserArgs,
+  const UserArgsFields_ extends ArgsFields,
   Item extends Schema.Codec<any, any>,
   Error extends Schema.Codec<any, any> = never,
 >(
-  userArgs: () => UserArgs,
+  userArgs: () => UserArgsFields_,
   item: () => Item,
   error?: () => Error,
-): ConfectPaginated<UserArgs, Item, Error> => {
+): ConfectPaginated<UserArgsFields_, Item, Error> => {
   const kind = { _tag: "Paginated" as const };
-  const paginatedKind = kind as Paginated<UserArgs, Item>;
+  const paginatedKind = kind as Paginated<UserArgsFields_, Item>;
 
-  Lazy.defineProperty(kind, "userArgs", userArgs);
+  Lazy.defineProperty(kind, "userArgs", () => Schema.Struct(userArgs()));
   Lazy.defineProperty(kind, "item", item);
   Lazy.defineProperty(kind, "page", () =>
     Schema.mutable(Schema.Array(paginatedKind.item)),
   );
 
   const provenance = { _tag: "Confect" as const, kind: paginatedKind };
-  const self = provenance as ConfectPaginated<UserArgs, Item, Error>;
+  const self = provenance as ConfectPaginated<UserArgsFields_, Item, Error>;
 
   Lazy.defineProperty(provenance, "args", () => {
     const fields = paginatedKind.userArgs.fields;

package/src/FunctionSpec.ts

@@ -1,11 +1,12 @@
 import type {
+  DefaultFunctionArgs,
   FunctionType,
   FunctionVisibility,
   RegisteredAction,
   RegisteredMutation,
   RegisteredQuery,
 } from "convex/server";
-import * as Schema from "effect/Schema";
+import type * as Schema from "effect/Schema";
 import * as Predicate from "effect/Predicate";
 import * as FunctionProvenance from "./FunctionProvenance";
 import { validateConfectFunctionIdentifier } from "./Identifier";
@@ -127,86 +128,122 @@ export type GetRuntimeAndFunctionType<FunctionSpec_ extends AnyWithProps> =
 export type GetFunctionVisibility<FunctionSpec_ extends AnyWithProps> =
   FunctionSpec_["functionVisibility"];
 
+export type GetFunctionProvenance<FunctionSpec_ extends AnyWithProps> =
+  FunctionSpec_["functionProvenance"];
+
 export type Name<FunctionSpec_ extends AnyWithProps> = FunctionSpec_["name"];
 
 export type MiddlewareSpecs<FunctionSpec_ extends AnyWithProps> =
   FunctionSpec_["middlewareSpecs"][number];
 
+/** The field map declared by a Confect-provenance spec. */
+export type ArgsFields<FunctionSpec_ extends AnyWithProps> =
+  FunctionSpec_ extends {
+    readonly functionProvenance: {
+      readonly _tag: "Confect";
+      readonly "~ArgsFields": infer ArgsFields_ extends
+        FunctionProvenance.ArgsFields;
+    };
+  }
+    ? ArgsFields_
+    : FunctionSpec_ extends {
+          readonly functionProvenance: { readonly _tag: "Confect" };
+        }
+      ? FunctionProvenance.ArgsFields
+      : never;
+
+/** The args schema assembled from a Confect-provenance spec's field map. */
+export type ArgsSchema<FunctionSpec_ extends AnyWithProps> =
+  FunctionSpec_ extends {
+    readonly functionProvenance: {
+      readonly _tag: "Confect";
+      readonly "~ArgsFields": infer ArgsFields_ extends
+        FunctionProvenance.ArgsFields;
+    };
+  }
+    ? Schema.Struct<ArgsFields_>
+    : FunctionSpec_ extends {
+          readonly functionProvenance: {
+            readonly _tag: "Confect";
+            readonly args: infer ArgsSchema_ extends
+              FunctionProvenance.AnyArgsSchema;
+          };
+        }
+      ? ArgsSchema_
+      : never;
+
+export type ReturnsSchema<FunctionSpec_ extends AnyWithProps> =
+  FunctionSpec_ extends {
+    readonly functionProvenance: {
+      readonly _tag: "Confect";
+      readonly returns: infer ReturnsSchema_ extends Schema.Codec<any, any>;
+    };
+  }
+    ? ReturnsSchema_
+    : never;
+
+export type ErrorSchema<FunctionSpec_ extends AnyWithProps> =
+  FunctionSpec_ extends {
+    readonly functionProvenance: {
+      readonly _tag: "Confect";
+      readonly error?: infer ErrorSchema_ extends Schema.Codec<any, any>;
+    };
+  }
+    ? ErrorSchema_
+    : never;
+
 export type Args<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
-  functionProvenance: {
-    _tag: "Confect";
-    args: infer ArgsSchema_ extends Schema.Codec<any, any>;
-  };
+  readonly functionProvenance: { readonly _tag: "Confect" };
 }
-  ? ArgsSchema_["Type"]
-  : FunctionSpec_ extends {
-        functionProvenance: { _tag: "Convex"; "~args": infer Args_ };
-      }
+  ? ArgsSchema<FunctionSpec_>["Type"]
+  : GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<
+        infer Args_,
+        any
+      >
     ? Args_
     : never;
 
 export type Returns<FunctionSpec_ extends AnyWithProps> =
   FunctionSpec_ extends {
-    functionProvenance: {
-      _tag: "Confect";
-      returns: infer ReturnsSchema_ extends Schema.Codec<any, any>;
-    };
+    readonly functionProvenance: { readonly _tag: "Confect" };
   }
-    ? ReturnsSchema_["Type"]
-    : FunctionSpec_ extends {
-          functionProvenance: { _tag: "Convex"; "~returns": infer Returns_ };
-        }
+    ? ReturnsSchema<FunctionSpec_>["Type"]
+    : GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<
+          any,
+          infer Returns_
+        >
       ? Awaited<Returns_>
       : never;
 
 export type EncodedArgs<FunctionSpec_ extends AnyWithProps> =
   FunctionSpec_ extends {
-    functionProvenance: {
-      _tag: "Confect";
-      args: infer ArgsSchema_ extends Schema.Codec<any, any>;
-    };
+    readonly functionProvenance: { readonly _tag: "Confect" };
   }
-    ? ArgsSchema_["Encoded"]
-    : FunctionSpec_ extends {
-          functionProvenance: { _tag: "Convex"; "~args": infer Args_ };
-        }
+    ? ArgsSchema<FunctionSpec_>["Encoded"]
+    : GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<
+          infer Args_,
+          any
+        >
       ? Args_
       : never;
 
 export type EncodedReturns<FunctionSpec_ extends AnyWithProps> =
   FunctionSpec_ extends {
-    functionProvenance: {
-      _tag: "Confect";
-      returns: infer ReturnsSchema_ extends Schema.Codec<any, any>;
-    };
+    readonly functionProvenance: { readonly _tag: "Confect" };
   }
-    ? ReturnsSchema_["Encoded"]
-    : FunctionSpec_ extends {
-          functionProvenance: { _tag: "Convex"; "~returns": infer Returns_ };
-        }
+    ? ReturnsSchema<FunctionSpec_>["Encoded"]
+    : GetFunctionProvenance<FunctionSpec_> extends FunctionProvenance.Convex<
+          any,
+          infer Returns_
+        >
       ? Returns_
       : never;
 
-export type Error<FunctionSpec_ extends AnyWithProps> = FunctionSpec_ extends {
-  functionProvenance: FunctionProvenance.Confect<
-    any,
-    any,
-    infer ErrorSchema_ extends Schema.Codec<any, any>
-  >;
-}
-  ? ErrorSchema_["Type"]
-  : never;
+export type Error<FunctionSpec_ extends AnyWithProps> =
+  ErrorSchema<FunctionSpec_>["Type"];
 
 export type EncodedError<FunctionSpec_ extends AnyWithProps> =
-  FunctionSpec_ extends {
-    functionProvenance: FunctionProvenance.Confect<
-      any,
-      any,
-      infer ErrorSchema_ extends Schema.Codec<any, any>
-    >;
-  }
-    ? ErrorSchema_["Encoded"]
-    : never;
+  ErrorSchema<FunctionSpec_>["Encoded"];
 
 export type WithName<
   FunctionSpec_ extends AnyWithProps,
@@ -280,46 +317,68 @@ const Proto = {
   },
 };
 
-const make =
-  <
-    RuntimeAndFunctionType_ extends
-      RuntimeAndFunctionType.RuntimeAndFunctionType,
-    FunctionVisibility_ extends FunctionVisibility,
-  >(
-    runtimeAndFunctionType: RuntimeAndFunctionType_,
-    functionVisibility: FunctionVisibility_,
-  ) =>
-  <
+interface Options {
+  readonly name: string;
+  readonly args?: () => FunctionProvenance.ArgsFields;
+  readonly returns: () => Schema.Codec<any, any>;
+  readonly error?: () => Schema.Codec<any, any>;
+}
+
+const make = <
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+>(
+  runtimeAndFunctionType: RuntimeAndFunctionType_,
+  functionVisibility: FunctionVisibility_,
+) => {
+  function makeSpec<
     const Name_ extends string,
-    Args_ extends Schema.Codec<any, any>,
+    const ArgsFields_ extends FunctionProvenance.ArgsFields,
     Returns_ extends Schema.Codec<any, any>,
     Error_ extends Schema.Codec<any, any> = never,
-  >({
-    name,
-    args,
-    returns,
-    error,
-  }: {
+  >(options: {
     name: Name_;
-    args: () => Args_;
+    args: () => ArgsFields_;
     returns: () => Returns_;
     error?: () => Error_;
   }): Builder<
     RuntimeAndFunctionType_,
     FunctionVisibility_,
     Name_,
-    FunctionProvenance.Confect<Args_, Returns_, Error_>
-  > => {
+    FunctionProvenance.Confect<ArgsFields_, Returns_, Error_>
+  >;
+  function makeSpec<
+    const Name_ extends string,
+    Returns_ extends Schema.Codec<any, any>,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(options: {
+    name: Name_;
+    args?: never;
+    returns: () => Returns_;
+    error?: () => Error_;
+  }): Builder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance.Confect<{}, Returns_, Error_>
+  >;
+  function makeSpec({ name, args, returns, error }: Options) {
     validateConfectFunctionIdentifier(name);
 
     return Object.assign(Object.create(Proto), {
       runtimeAndFunctionType,
       functionVisibility,
       name,
-      functionProvenance: FunctionProvenance.Confect(args, returns, error),
+      functionProvenance:
+        args === undefined
+          ? FunctionProvenance.Confect(() => ({}), returns, error)
+          : FunctionProvenance.Confect(args, returns, error),
       middlewareSpecs: [],
     });
-  };
+  }
+
+  return makeSpec;
+};
 
 /**
  * `Schema.Struct` fields that must not declare `paginationOpts`. Used to
@@ -327,58 +386,74 @@ const make =
  * constructors add themselves; the check reports at the `args` thunk with an
  * unsatisfiable type when violated.
  */
-type ForbidPaginationOpts<UserArgs extends FunctionProvenance.AnyUserArgs> =
-  "paginationOpts" extends keyof UserArgs["fields"]
-    ? { readonly fields: { readonly paginationOpts: never } }
-    : unknown;
+type ForbidPaginationOpts<
+  UserArgsFields extends FunctionProvenance.ArgsFields,
+> = "paginationOpts" extends keyof UserArgsFields
+  ? { readonly paginationOpts: never }
+  : unknown;
+
+interface PaginatedOptions {
+  readonly name: string;
+  readonly args?: () => FunctionProvenance.ArgsFields;
+  readonly item: () => Schema.Codec<any, any>;
+  readonly error?: () => Schema.Codec<any, any>;
+}
 
-const makePaginated =
-  <
-    RuntimeAndFunctionType_ extends
-      RuntimeAndFunctionType.RuntimeAndFunctionType,
-    FunctionVisibility_ extends FunctionVisibility,
-  >(
-    runtimeAndFunctionType: RuntimeAndFunctionType_,
-    functionVisibility: FunctionVisibility_,
-  ) =>
-  <
+const makePaginated = <
+  RuntimeAndFunctionType_ extends RuntimeAndFunctionType.RuntimeAndFunctionType,
+  FunctionVisibility_ extends FunctionVisibility,
+>(
+  runtimeAndFunctionType: RuntimeAndFunctionType_,
+  functionVisibility: FunctionVisibility_,
+) => {
+  function makeSpec<
     const Name_ extends string,
+    const UserArgsFields_ extends FunctionProvenance.ArgsFields,
     Item_ extends Schema.Codec<any, any>,
-    UserArgs_ extends FunctionProvenance.AnyUserArgs = Schema.Struct<{}>,
     Error_ extends Schema.Codec<any, any> = never,
-  >({
-    name,
-    args,
-    item,
-    error,
-  }: {
+  >(options: {
     name: Name_;
-    /** User-declared args, without `paginationOpts` — it is added automatically. */
-    args?: (() => UserArgs_) & ForbidPaginationOpts<UserArgs_>;
-    /** The page element schema. */
+    args: () => UserArgsFields_ & ForbidPaginationOpts<UserArgsFields_>;
     item: () => Item_;
     error?: () => Error_;
   }): Builder<
     RuntimeAndFunctionType_,
     FunctionVisibility_,
     Name_,
-    FunctionProvenance.ConfectPaginated<UserArgs_, Item_, Error_>
-  > => {
+    FunctionProvenance.ConfectPaginated<UserArgsFields_, Item_, Error_>
+  >;
+  function makeSpec<
+    const Name_ extends string,
+    Item_ extends Schema.Codec<any, any>,
+    Error_ extends Schema.Codec<any, any> = never,
+  >(options: {
+    name: Name_;
+    args?: never;
+    item: () => Item_;
+    error?: () => Error_;
+  }): Builder<
+    RuntimeAndFunctionType_,
+    FunctionVisibility_,
+    Name_,
+    FunctionProvenance.ConfectPaginated<{}, Item_, Error_>
+  >;
+  function makeSpec({ name, args, item, error }: PaginatedOptions) {
     validateConfectFunctionIdentifier(name);
 
     return Object.assign(Object.create(Proto), {
       runtimeAndFunctionType,
       functionVisibility,
       name,
-      functionProvenance: FunctionProvenance.ConfectPaginated(
-        // When `args` is omitted, `UserArgs_` is its `Schema.Struct<{}>` default.
-        args ?? ((() => Schema.Struct({})) as unknown as () => UserArgs_),
-        item,
-        error,
-      ),
+      functionProvenance:
+        args === undefined
+          ? FunctionProvenance.ConfectPaginated(() => ({}), item, error)
+          : FunctionProvenance.ConfectPaginated(args, item, error),
       middlewareSpecs: [],
     });
-  };
+  }
+
+  return makeSpec;
+};
 
 export const publicQuery = make(RuntimeAndFunctionType.ConvexQuery, "public");
 export const internalQuery = make(
@@ -429,11 +504,19 @@ type MatchingRegisteredFunction<
         : never;
 
 type ExtractArgs<F> =
-  F extends RegisteredQuery<any, infer A, any>
+  F extends RegisteredQuery<any, infer A extends DefaultFunctionArgs, any>
     ? A
-    : F extends RegisteredMutation<any, infer A, any>
+    : F extends RegisteredMutation<
+          any,
+          infer A extends DefaultFunctionArgs,
+          any
+        >
       ? A
-      : F extends RegisteredAction<any, infer A, any>
+      : F extends RegisteredAction<
+            any,
+            infer A extends DefaultFunctionArgs,
+            any
+          >
         ? A
         : never;