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

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # @confect/core
 
+## 10.0.0-next.19
+
+### Minor Changes
+
+- c1087eb: Add `@confect/foldkit` — client-side bindings for [Foldkit](https://foldkit.dev) apps. The package maps Confect's client surface onto Foldkit's integration seams: `Client.layer` provides the scoped WebSocket client and pagination-session allocator through an application's `resources`, `Subscription.reactiveQuery` builds a subscription entry that opens, re-opens, and closes a reactive query as `Option`-wrapped args derived from the Model change, and `Command.query` / `Command.mutation` / `Command.action` build Command definitions whose args are the ref's args and whose Messages are declared with the same `messages` field Foldkit's own `Command.define` takes. Every failure is folded into a Message via the required `onError` handler, so Command and Subscription error channels stay `never` as Foldkit requires.
+
+  ```ts
+  import * as Confect from "@confect/foldkit";
+  import * as Schema from "effect/Schema";
+  import * as Subscription from "foldkit/subscription";
+
+  const SaveNote = Confect.Command.mutation(
+    "SaveNote",
+    refs.public.notes.insert,
+    {
+      messages: [SucceededSaveNote, FailedSaveNote],
+      onSuccess: (noteId) => SucceededSaveNote({ noteId }),
+      onError: (error) => FailedSaveNote({ message: String(error) }),
+    },
+  );
+
+  const subscriptions = Subscription.make<
+    Model,
+    Message,
+    Confect.Client.Client
+  >()(() => ({
+    note: Confect.Subscription.reactiveQuery<Model>()(refs.public.notes.get, {
+      args: (model) => Option.map(model.noteId, (noteId) => ({ noteId })),
+      onSuccess: (note) => SucceededGetNote({ note }),
+      onError: (error) => FailedGetNote({ message: String(error) }),
+    }),
+  }));
+  ```
+
+  The Command factories accept Foldkit's `interrupt` option — `true` keys invocations by the Command name, `{ keyFields, toKey }` by a part derived from the ref's args — and the returned definition gains the `Interrupt` constructor for stopping in-flight invocations. Factory-built definitions instantiate Foldkit's own definition interfaces, so they are accepted wherever Foldkit accepts a Command definition — including Story/Scene `Command.resolve` and `expectExact` matchers. `Command.queryEffect`, `Command.mutationEffect`, and `Command.actionEffect` return execute bodies for hand-written `Command.define` calls (custom args schemas, multi-call Commands), and `Subscription.reactiveQueryStream` is the `dependenciesToStream` escape hatch for hand-written subscription entries.
+
+  `PaginatedQuery` navigates a paginated query one page at a time over Convex's cursor pagination. `PaginatedQuery.make(ref)` returns the Model and settlement schemas. Its states use Foldkit `AsyncData`'s vocabulary and semantics: `Idle`, `Loading`, `Refreshing`, `Success`, `Failure`, and `Stale`. Failed settlements preserve the complete error contract: declared function and middleware errors are wrapped as `FunctionError`, Convex's invalid-cursor pseudo-error is normalized to the new `@confect/core/PaginationError.InvalidCursor`, and `WebSocketClientError` and `SchemaError` are carried directly. `settle` accepts a request-bound `Result`, turns a failed refresh into `Stale`, automatically resets an invalid cursor, and ignores successes or failures from superseded requests. All machine operations (`init`, `reinitialize`, `reset`, `close`, `next`, `prev`, and `first`) remain pure.
+
+  `Subscription.paginatedQuery` keeps exactly one live, reactive page subscription in sync with the machine and emits one `onSettled` Message shape for either outcome. It allocates Convex's pagination `id` internally and returns it with the first settlement, so session allocation is not a separate Command or application Message. Installing that id is keep-alive-equivalent and does not restart the subscription. Query errors are emitted as values without closing the underlying Convex subscription, allowing a later successful result to recover naturally. Each request supports `maximumRowsRead` and `maximumBytesRead` and uses `initialNumItems` for the initial page and split heuristic. Page splits remain transparent, the last complete page stays visible during navigation and after refresh failure, and an empty terminal page automatically retreats to the preceding page.
+
+  ```ts
+  const Notes = Confect.PaginatedQuery.make(refs.public.notes.paginate);
+
+  // Model: notes: Notes.schema
+  // Initial Model value: notes: Notes.idle
+  // Message: settlement: Notes.settlement
+  // update after matching Idle: Notes.init(idle, { channel }, { initialNumItems: 20 })
+
+  const subscriptions = Subscription.make<
+    Model,
+    Message,
+    Confect.Client.Client
+  >()(() => ({
+    notesPage: Confect.Subscription.paginatedQuery<Model>()(Notes, {
+      state: (model) => model.notes,
+      onSettled: (settlement) => SettledGetNotesPage({ settlement }),
+    }),
+  }));
+  ```
+
+- b34e029: Declare Confect function arguments as optional lazy `Schema.Struct` field maps instead of constructed struct schemas. Confect now derives and builds the struct schema itself, defaults omitted args to `{}`, matches Convex's object-only argument model, and preserves exact field types through function specs and refs.
+
+## 10.0.0-next.18
+
+### Minor Changes
+
+- 91aebe4: Move `Table.make` to `@confect/core` so a spec that returns `notes.Doc` from `_generated/tables/notes` no longer ships `@confect/server` to the client.
+
+  ```ts confect/tables/notes.ts
+  import { Table } from "@confect/core";
+  import * as Schema from "effect/Schema";
+
+  export default Table.make(() =>
+    Schema.Struct({
+      text: Schema.String,
+    }),
+  );
+  ```
+
+  `confect codegen` now fails if any module a spec reaches value-imports `@confect/server`, including `confect/tables/` and `_generated/`. Type-only imports remain allowed.
+
 ## 10.0.0-next.17
 
 ### Minor Changes

package/dist/FunctionProvenance.d.ts

@@ -3,55 +3,85 @@ import * as Data from "effect/Data";
 import * as Schema from "effect/Schema";
 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.
+ */
+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: {};
+    Convex: {
+        "~args": DefaultFunctionArgs;
+        "~returns": any;
+    };
 }>;
 /**
  * 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;
 export interface Standard {
     readonly _tag: "Standard";
 }
-export interface Paginated<UserArgs extends AnyUserArgs = AnyUserArgs, Item extends Schema.Codec<any, any> = Schema.Codec<any, any>> {
+export interface Paginated<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. */
     readonly page: Schema.Codec<any, any>;
 }
-export interface Confect<Args extends Schema.Codec<any, any>, Returns extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never, Kind extends ConfectKind = ConfectKind> {
+export interface Confect<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";
-    readonly _args: Args;
-    readonly _returns: Returns;
+    readonly "~args": Args;
+    readonly "~returns": Returns;
 }
 export interface AnyConvex extends Convex<DefaultFunctionArgs, any> {
 }
 export declare const FunctionProvenance: {
     readonly $is: <Tag extends "Confect" | "Convex">(tag: Tag) => (u: unknown) => u is Extract<{
         readonly _tag: "Confect";
-        readonly args: Schema.Codec<any, any>;
+        readonly args: AnyArgsSchema;
         readonly returns: Schema.Codec<any, any>;
         readonly error?: Schema.Codec<any, any>;
         readonly kind: ConfectKind;
@@ -59,80 +89,80 @@ export declare const FunctionProvenance: {
         readonly _tag: Tag;
     }> | Extract<{
         readonly _tag: "Convex";
-        readonly _args: DefaultFunctionArgs;
-        readonly _returns: any;
+        readonly "~args": DefaultFunctionArgs;
+        readonly "~returns": any;
     }, {
         readonly _tag: Tag;
     }>;
     readonly $match: {
         <Cases extends { readonly [Tag in "Confect" | "Convex"]: (args: Extract<{
             readonly _tag: "Confect";
-            readonly args: Schema.Codec<any, any>;
+            readonly args: AnyArgsSchema;
             readonly returns: Schema.Codec<any, any>;
             readonly error?: Schema.Codec<any, any>;
             readonly kind: ConfectKind;
         } | {
             readonly _tag: "Convex";
-            readonly _args: DefaultFunctionArgs;
-            readonly _returns: any;
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
         }, {
             readonly _tag: Tag;
         }>) => any; }>(cases: Cases): (value: {
             readonly _tag: "Confect";
-            readonly args: Schema.Codec<any, any>;
+            readonly args: AnyArgsSchema;
             readonly returns: Schema.Codec<any, any>;
             readonly error?: Schema.Codec<any, any>;
             readonly kind: ConfectKind;
         } | {
             readonly _tag: "Convex";
-            readonly _args: DefaultFunctionArgs;
-            readonly _returns: any;
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
         }) => import("effect/Unify").Unify<ReturnType<Cases["Confect" | "Convex"]>>;
         <Cases extends { readonly [Tag in "Confect" | "Convex"]: (args: Extract<{
             readonly _tag: "Confect";
-            readonly args: Schema.Codec<any, any>;
+            readonly args: AnyArgsSchema;
             readonly returns: Schema.Codec<any, any>;
             readonly error?: Schema.Codec<any, any>;
             readonly kind: ConfectKind;
         } | {
             readonly _tag: "Convex";
-            readonly _args: DefaultFunctionArgs;
-            readonly _returns: any;
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
         }, {
             readonly _tag: Tag;
         }>) => any; }>(value: {
             readonly _tag: "Confect";
-            readonly args: Schema.Codec<any, any>;
+            readonly args: AnyArgsSchema;
             readonly returns: Schema.Codec<any, any>;
             readonly error?: Schema.Codec<any, any>;
             readonly kind: ConfectKind;
         } | {
             readonly _tag: "Convex";
-            readonly _args: DefaultFunctionArgs;
-            readonly _returns: any;
+            readonly "~args": DefaultFunctionArgs;
+            readonly "~returns": any;
         }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Confect" | "Convex"]>>;
     };
     readonly Confect: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Confect";
-        readonly args: Schema.Codec<any, any>;
+        readonly args: AnyArgsSchema;
         readonly returns: Schema.Codec<any, any>;
         readonly error?: Schema.Codec<any, any>;
         readonly kind: ConfectKind;
     }, "_tag">;
     readonly Convex: Data.TaggedEnum.ConstructorFrom<{
         readonly _tag: "Convex";
-        readonly _args: DefaultFunctionArgs;
-        readonly _returns: any;
+        readonly "~args": DefaultFunctionArgs;
+        readonly "~returns": any;
     }, "_tag">;
 };
 /**
- * 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`/`tableDefinition`. 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
@@ -141,36 +171,27 @@ export declare const FunctionProvenance: {
  * is observable via `"error" in provenance` without forcing anything; nothing
  * relies on `Data`'s structural `Equal`/`Hash` for provenance values.
  */
-export declare const Confect: <Args extends Schema.Codec<any, any>, Returns extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never>(args: () => Args, returns: () => Returns, error?: () => Error) => Confect<Args, 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>`.
- */
-export interface AnyUserArgs extends Schema.Codec<any, any> {
-    readonly fields: Schema.Struct.Fields;
-}
+export declare const Confect: <const ArgsFields_ extends ArgsFields, Returns extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never>(args: () => ArgsFields_, returns: () => Returns, error?: () => Error) => Confect<ArgsFields_, Returns, Error, Standard>;
 /**
  * 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
  * the item schema. Same deferred-conditional device as {@link PaginatedArgs}.
  */
 export type PaginatedReturns<Item extends Schema.Codec<any, any>> = PaginationResult.PaginationResult<Item> extends infer ComposedReturns extends Schema.Codec<any, any> ? ComposedReturns : never;
-export interface ConfectPaginated<UserArgs extends AnyUserArgs, Item extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never> extends Confect<PaginatedArgs<UserArgs>, PaginatedReturns<Item>, Error, Paginated<UserArgs, Item>> {
+export interface ConfectPaginated<UserArgsFields extends ArgsFields, Item extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never> extends Confect<PaginatedArgsFields<UserArgsFields>, PaginatedReturns<Item>, Error, 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
@@ -182,10 +203,10 @@ export interface AnyConfectPaginated extends ConfectPaginated<AnyUserArgs, Schem
  * wraps the item in `PaginationResult`. Composition living here means the
  * composed schemas can never drift from the stored user schemas.
  */
-export declare const ConfectPaginated: <UserArgs extends AnyUserArgs, Item extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never>(userArgs: () => UserArgs, item: () => Item, error?: () => Error) => ConfectPaginated<UserArgs, Item, Error>;
-export declare const Convex: <_Args extends DefaultFunctionArgs, _Returns>() => {
+export declare const ConfectPaginated: <const UserArgsFields_ extends ArgsFields, Item extends Schema.Codec<any, any>, Error extends Schema.Codec<any, any> = never>(userArgs: () => UserArgsFields_, item: () => Item, error?: () => Error) => ConfectPaginated<UserArgsFields_, Item, Error>;
+export declare const Convex: <Args extends DefaultFunctionArgs, Returns>() => {
     readonly _tag: "Convex";
-    readonly _args: DefaultFunctionArgs;
-    readonly _returns: any;
+    readonly "~args": DefaultFunctionArgs;
+    readonly "~returns": any;
 };
 //# sourceMappingURL=FunctionProvenance.d.ts.map

package/dist/FunctionProvenance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionProvenance.d.ts","sourceRoot":"","sources":["../src/FunctionProvenance.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"FunctionProvenance.d.ts","sourceRoot":"","sources":["../src/FunctionProvenance.ts"],"names":[],"mappings":"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"}

package/dist/FunctionProvenance.js

@@ -14,13 +14,13 @@ var FunctionProvenance_exports = /* @__PURE__ */ __exportAll({
 const FunctionProvenance = Data.taggedEnum();
 const 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`/`tableDefinition`. 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
@@ -34,7 +34,7 @@ const Confect = (args, returns, error) => {
 		_tag: "Confect",
 		kind: Standard
 	};
-	defineProperty(provenance, "args", args);
+	defineProperty(provenance, "args", () => Schema.Struct(args()));
 	defineProperty(provenance, "returns", returns);
 	if (error !== void 0) defineProperty(provenance, "error", error);
 	return provenance;
@@ -52,7 +52,7 @@ const Confect = (args, returns, error) => {
 const ConfectPaginated = (userArgs, item, error) => {
 	const kind = { _tag: "Paginated" };
 	const paginatedKind = kind;
-	defineProperty(kind, "userArgs", userArgs);
+	defineProperty(kind, "userArgs", () => Schema.Struct(userArgs()));
 	defineProperty(kind, "item", item);
 	defineProperty(kind, "page", () => Schema.mutable(Schema.Array(paginatedKind.item)));
 	const provenance = {

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\nexport type FunctionProvenance = Data.TaggedEnum<{\n  Confect: {\n    args: Schema.Codec<any, any>;\n    returns: Schema.Codec<any, any>;\n    error?: Schema.Codec<any, any>;\n    kind: ConfectKind;\n  };\n  Convex: {\n    /** @internal */\n    _args: DefaultFunctionArgs;\n    /** @internal */\n    _returns: any;\n  };\n}>;\n\n/**\n * The declaration shape of a Confect function — orthogonal to both the\n * provenance origin (Confect vs Convex) and the function type\n * (query/mutation/action). A `Standard` function declares its `args` and\n * `returns` schemas directly; a `Paginated` function declares `userArgs` and\n * `item` schemas from which 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  UserArgs extends AnyUserArgs = AnyUserArgs,\n  Item extends Schema.Codec<any, any> = Schema.Codec<any, any>,\n> {\n  readonly _tag: \"Paginated\";\n  /** User-declared args — no `paginationOpts`. */\n  readonly userArgs: UserArgs;\n  /** Page element schema. */\n  readonly item: Item;\n  /** Mutable array of items — the page decode target. */\n  readonly page: Schema.Codec<any, any>;\n}\n\nexport interface Confect<\n  Args extends Schema.Codec<any, any>,\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 args: Args;\n  readonly returns: Returns;\n  readonly error?: Error;\n  readonly kind: Kind;\n}\n\nexport interface AnyConfect extends Confect<\n  Schema.Codec<any, any>,\n  Schema.Codec<any, any>,\n  Schema.Codec<any, any>\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 schema thunks. `args`, `returns`,\n * and `error` are exposed as sync lazy memoised getters (via {@link Lazy.defineProperty})\n * that only evaluate their thunk on first access, mirroring how `Table`\n * defers `Fields`/`Doc`/`tableDefinition`. This keeps importing the assembled\n * `_generated/spec.ts` cheap — no `Schema.Struct(...)` / `Schema.Array(...)`\n * work runs at module load; it is deferred to the first invocation that\n * actually compiles validators or runs a 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.\n * `error` is only installed when an `errorThunk` is provided, so its absence\n * is 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  Args extends Schema.Codec<any, any>,\n  Returns extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  args: () => Args,\n  returns: () => Returns,\n  error?: () => Error,\n): Confect<Args, Returns, Error, Standard> => {\n  const provenance = { _tag: \"Confect\" as const, kind: Standard };\n\n  Lazy.defineProperty(provenance, \"args\", args);\n  Lazy.defineProperty(provenance, \"returns\", returns);\n  if (error !== undefined) {\n    Lazy.defineProperty(provenance, \"error\", error);\n  }\n\n  return provenance as Confect<Args, Returns, Error, Standard>;\n};\n\n/**\n * Any struct-shaped, context-free schema usable as a paginated query's user\n * args. A structural bound rather than `Schema.Struct<Schema.Struct.Fields>`\n * because `Schema.Struct` is not covariant in its fields parameter — concrete\n * structs do not extend `Schema.Struct<Schema.Struct.Fields>`.\n */\n// eslint-disable-next-line import/namespace -- oxlint's namespace resolution misses type-only exports, and `Schema` is an interface/namespace\nexport interface AnyUserArgs extends Schema.Codec<any, any> {\n  readonly fields: Schema.Struct.Fields;\n}\n\n/**\n * The composed args schema of a paginated query: the user-declared fields\n * plus the `paginationOpts` field managed by Convex's pagination protocol.\n *\n * The `extends infer ... extends` conditional lets TypeScript accept the\n * composed struct where `Schema.Codec<any, any>` is required even while\n * `UserArgs` is an unresolved type parameter; for concrete user args it\n * evaluates away entirely.\n */\nexport type PaginatedArgs<UserArgs extends AnyUserArgs> =\n  Schema.Struct<\n    UserArgs[\"fields\"] & {\n      paginationOpts: typeof PaginationOptions.PaginationOptions;\n    }\n  > extends infer ComposedArgs extends Schema.Codec<any, any>\n    ? ComposedArgs\n    : never;\n\n/**\n * The composed returns schema of a paginated query: a `PaginationResult` of\n * the 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  UserArgs extends AnyUserArgs,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n> extends Confect<\n  PaginatedArgs<UserArgs>,\n  PaginatedReturns<Item>,\n  Error,\n  Paginated<UserArgs, Item>\n> {}\n\nexport interface AnyConfectPaginated extends ConfectPaginated<\n  AnyUserArgs,\n  Schema.Codec<any, any>,\n  Schema.Codec<any, any>\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\n * the `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  UserArgs extends AnyUserArgs,\n  Item extends Schema.Codec<any, any>,\n  Error extends Schema.Codec<any, any> = never,\n>(\n  userArgs: () => UserArgs,\n  item: () => Item,\n  error?: () => Error,\n): ConfectPaginated<UserArgs, Item, Error> => {\n  const kind = { _tag: \"Paginated\" as const };\n  const paginatedKind = kind as Paginated<UserArgs, Item>;\n\n  Lazy.defineProperty(kind, \"userArgs\", 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<UserArgs, 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":";;;;;;;;;;;;;AA2EA,MAAa,qBAAqB,KAAK,WAA+B;AAEtE,MAAM,WAAqB,EAAE,MAAM,WAAW;;;;;;;;;;;;;;;;;AAkB9C,MAAa,WAKX,MACA,SACA,UAC4C;CAC5C,MAAM,aAAa;EAAE,MAAM;EAAoB,MAAM;CAAS;CAE9D,eAAoB,YAAY,QAAQ,IAAI;CAC5C,eAAoB,YAAY,WAAW,OAAO;CAClD,IAAI,UAAU,KAAA,GACZ,eAAoB,YAAY,SAAS,KAAK;CAGhD,OAAO;AACT;;;;;;;;;;;AAoEA,MAAa,oBAKX,UACA,MACA,UAC4C;CAC5C,MAAM,OAAO,EAAE,MAAM,YAAqB;CAC1C,MAAM,gBAAgB;CAEtB,eAAoB,MAAM,YAAY,QAAQ;CAC9C,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,mIAEF;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\";\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 */\n// eslint-disable-next-line import/namespace -- oxlint's namespace resolution misses type-only exports, and `Schema` is an interface/namespace\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/** Erased structural view used after the exact field map is no longer needed. */\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\n * provenance origin (Confect vs Convex) and the function type\n * (query/mutation/action). A `Standard` function declares its args fields and\n * returns schema directly; a `Paginated` function declares user-args fields\n * and an item schema from which the Convex-facing `args`/`returns` are\n * 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  /** User-declared args — no `paginationOpts`. */\n  readonly userArgs: ArgsSchema<UserArgsFields_>;\n  /** Page element schema. */\n  readonly item: Item;\n  /** Mutable array of items — the page decode target. */\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.\n * `args`, `returns`, and `error` are exposed as sync lazy memoised getters\n * (via {@link Lazy.defineProperty}) that only evaluate their thunk on first\n * access, mirroring how `Table` defers `Fields`/`Doc`. This keeps importing the\n * assembled `_generated/spec.ts` cheap — no `Schema.Struct(...)` /\n * `Schema.Array(...)` work runs at module load; it is deferred to the first\n * invocation that actually compiles validators or runs a 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.\n * `error` is only installed when an `errorThunk` is provided, so its absence\n * is 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\n * plus 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\n * the 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\n * the `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":";;;;;;;;;;;;;AAuGA,MAAa,qBAAqB,KAAK,WAA+B;AAEtE,MAAM,WAAqB,EAAE,MAAM,WAAW;;;;;;;;;;;;;;;;;AAkB9C,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,mIAEF;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"}