@confect/react 10.0.0-next.2 → 10.0.0-next.20

package/CHANGELOG.md

@@ -1,5 +1,297 @@
 # @confect/react
 
+## 10.0.0-next.20
+
+## 10.0.0-next.19
+
+## 10.0.0-next.18
+
+## 10.0.0-next.17
+
+### Patch Changes
+
+- 8e4962e: Raise the required `effect` peer version to `^4.0.0-rc.111` (from `^4.0.0-rc.110`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  No Confect API changed, and no call-site edits are needed. `rc.111` is a patch release of Effect with nothing removed or renamed, so upgrading is a matter of installing it alongside `@confect/*`.
+
+## 10.0.0-next.16
+
+### Major Changes
+
+- Migrate to Effect v4. All `@confect/*` packages now require `effect@^4.0.0-beta.97`; `@effect/platform` and `@effect/cli` are no longer dependencies (their functionality moved into `effect` core and `effect/unstable/*`).
+
+  Breaking changes for users:
+
+  - **Schemas** follow Effect v4's Schema API: `Schema.Union([a, b])` (array form), `Schema.Literals([...])` for literal unions, `Schema.optionalKey` in place of `optionalWith({ exact: true })`, and checks like `Schema.String.check(Schema.isMaxLength(...))` in place of piped filters.
+  - **Option-returning functions** must use a codec with a serializable encoded form, such as `Schema.OptionFromNullOr(...)` — v4's `Schema.Option` encodes to an `Option` instance, which is not a Convex value.
+  - **Table schemas** may now be transformations (`Schema.decodeTo` chains, `Schema.encodeKeys`), branded structs, suspended schemas, or unions of these — Convex's system fields are carried through the whole encoding chain. Schemas that do not resolve to an object shape at every step (such as `Schema.Class`) are rejected with a descriptive error when the table is defined.
+  - **Clients**: decode failures surface as `SchemaError` rather than `ParseError` in `@confect/js` and `@confect/react`, and `@confect/react`'s `useMutation`/`useAction` handles with an `error` schema now resolve to `Result` (v4's replacement for `Either`).
+  - **HTTP** is now mounted through the renamed `HttpRouter` module (formerly `HttpApi`). `HttpRouter.make(routes)` takes a single route-registering `Layer` composed from Effect's own `effect/unstable/http` and `effect/unstable/httpapi` modules — `HttpApiBuilder.layer(api)` (with group handler layers supplied via `Layer.provide`; a missing group is a compile-time error), `HttpApiScalar.layer` for docs, `HttpRouter.add` for plain routes, and `HttpRouter.middleware(fn, { global: true })` for middleware, merged with `Layer.mergeAll`. The per-path-prefix record and its `api`/`apiLive`/`middleware`/`scalar` options are gone; Confect registers one catch-all Convex HTTP action at `/`, and plain Convex routes added to the returned router still take precedence. Handlers, middleware, and route-layer construction all run with Confect's Convex-aware `ConfigProvider` in context.
+  - **Node actions** use `effect/unstable/process` (`ChildProcessSpawner`) and `@effect/platform-node`'s `NodeServices` in place of `@effect/platform` `Command`/`NodeContext`.
+  - **Configuration**: Confect's Convex-aware `ConfigProvider` treats empty-string environment variables as missing values (matching Effect v4's built-in providers), so `Config.withDefault` and `Config.option` recover from them.
+  - **CLI**: a malformed `convex.json` now fails codegen with a descriptive error instead of being silently ignored.
+  - Confect queries no longer stub the global `Date.now`. Queries run with a `Clock` whose unsafe accessors return constants, so Effect-internal reads (log timestamps, spans) never evict a query from Convex's cache; explicit time reads — `Clock.currentTimeMillis`/`currentTimeNanos` or a raw `Date.now()` call — opt the query out and evict as they honestly should.
+
+### Patch Changes
+
+- Raise the required `effect` peer version to `^4.0.0-beta.100` (from `^4.0.0-beta.99`).
+
+  This is a peer-range-only change with no consumer-visible API consequences. The `beta.100` release only touches `Cron` internals (month/weekday alias normalization, day/weekday rollover, and equality/hashing), CLI error message formatting (`InvalidValue` prefixes), and `Schema.toTaggedUnion` discriminants that Confect doesn't use.
+
+- Raise the required `effect` peer version to `^4.0.0-beta.101` (from `^4.0.0-beta.100`).
+
+  This is a peer-range-only change with no consumer-visible API consequences. The `beta.101` release only touches fiber/concurrency internals (interrupt handling in concurrent traversal, stack frame annotations, `awaitAllChildren` linearization, `interruptibleMask` interrupt delivery), a `MutableList.filter` fix for empty buckets, a `Schema.Struct` required-readonly-field type display simplification, and an `HttpRouter.toWebHandler` middleware type-inference tightening that Confect doesn't need to accommodate.
+
+- Raise the required `effect` peer version to `^4.0.0-beta.102` (from `^4.0.0-beta.101`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+- Raise the required `effect` peer version to `^4.0.0-beta.105` (from `^4.0.0-beta.102`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  `beta.103` separates wall-clock time from monotonic elapsed time: `Clock.Clock` now also requires `monotonicTimeNanos` and `monotonicTimeNanosUnsafe`, so a custom `Clock` provided to a Confect function has to supply both. Effects that measure elapsed time — `Effect.timed`, duration metrics, `Sink.withDuration` — read the monotonic accessors instead of the wall clock, and continue to report a zero duration inside queries and mutations, where Confect pins the unsafe accessors to constants to keep Convex's query cache from evicting on every logged span.
+
+  `beta.103` also moves synchronous Effect runs off `setImmediate`/`setTimeout` and onto the microtask queue, which Convex's query and mutation isolate permits. Confect no longer suppresses cooperative fiber yielding for the synchronous work it performs while your modules load — registration and schema-to-validator compilation — and relies on that scheduling instead. Neither the "Can't use `setTimeout` in queries and mutations" crash nor any other consumer-visible behavior changes, but this is the area to look at if module loading starts misbehaving.
+
+  `beta.104` renames Effect's schema error constructors to match their `Data` counterparts, which affects any error schema you declare for a Confect function:
+
+  **Before:**
+
+  ```ts
+  export class NoteNotFound extends Schema.TaggedErrorClass<NoteNotFound>()(
+    "NoteNotFound",
+    { noteId: Id("notes") },
+  ) {}
+  ```
+
+  **After:**
+
+  ```ts
+  export class NoteNotFound extends Schema.TaggedError<NoteNotFound>()(
+    "NoteNotFound",
+    { noteId: Id("notes") },
+  ) {}
+  ```
+
+  `Schema.ErrorClass` is likewise now `Schema.Error`; the schema for JavaScript `Error` instances that previously went by `Schema.Error` is now `Schema.ErrorInstance`, and `Schema.ErrorReviver` is now `Schema.ErrorInstanceReviver`. Confect's own error types — `DocumentDecodeError`, `BlobNotFoundError`, and the rest — are unchanged in name, shape, and message.
+
+  `beta.105` restructures how schema validation failures are reported, but not on the path Confect puts you on: decode and encode failures still surface as `Schema.SchemaError` with a formatted `message`, so error text from `@confect/js`, `@confect/react`, and document decoding is unchanged.
+
+- Raise the required `effect` peer version to `^4.0.0-beta.106` (from `^4.0.0-beta.105`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  `beta.106` is a patch-only Effect release. Nothing in Confect's own API changes, and your table, argument, and returns schemas still compile to the same Convex validators.
+
+  One Effect change needs a call-site edit if you derive property-test generators from those schemas: `Schema.toArbitrary` now returns a factory that takes the `fast-check` module instead of returning an arbitrary directly, and `Schema.toArbitraryLazy` and the `{ report: true }` option are gone.
+
+  **Before:**
+
+  ```ts
+  const NoteArbitrary = Schema.toArbitrary(Note);
+  ```
+
+  **After:**
+
+  ```ts
+  import * as FastCheck from "fast-check";
+
+  const NoteArbitrary = Schema.toArbitrary(Note)(FastCheck);
+  ```
+
+  HTTP actions written against `HttpRouter` also inherit Effect's stricter multipart handling: a request that exceeds the configured part count, part size, or field size limits now stops being parsed at the limit rather than being read to completion first.
+
+- Raise the required `effect` peer version to `^4.0.0-beta.107` (from `^4.0.0-beta.106`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  `beta.107` is a patch-only Effect release, so no Confect API changes and no call-site edits are needed — upgrade `effect` alongside `@confect/*` and everything you have written keeps compiling. Your table, argument, and returns schemas still produce the same Convex validators.
+
+  Two Effect fixes are worth knowing about if they touch your code. HTTP actions written with `HttpRouter` now collect uploaded file contents far faster on large multipart bodies, and a file part whose stream is cut short — because a parser limit was exceeded or the request body ended early — now fails instead of hanging. Separately, `Duration` values that are equal now hash equally, so a `Duration` used as a `HashMap` key or a `HashSet` member is found regardless of which constructor built it.
+
+- Raise the required `effect` peer version to `^4.0.0-beta.98` (from `^4.0.0-beta.97`).
+
+  `effect`'s `SchemaError` is now exposed as its own public module (`effect/SchemaError`), which changes the import path TypeScript picks when Confect emits `.d.ts` declarations that reference `Schema.SchemaError` (for example in generated `services.d.ts`). Existing `Schema.SchemaError` / `Schema.isSchemaError` usage is unaffected — this is purely a declaration-emit detail that consumers relying on generated types may notice.
+
+- Raise the required `effect` peer version to `^4.0.0-beta.99` (from `^4.0.0-beta.98`).
+
+  This is a peer-range-only change with no consumer-visible API consequences. The `beta.99` release only touches `Graph`, CLI (`Command`/`CliConfig`/wizard mode), `Tool` cloning, Redis script eval, and multipart parser internals that Confect doesn't use.
+
+- Raise the required `effect` peer version to `^4.0.0-rc.108` (from `^4.0.0-beta.107`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise. Effect v4 has left beta for release candidates, so `effect@rc` is now the tag to install alongside `@confect/*`.
+
+  No Confect API changed, and no call-site edits are needed for Confect itself. One Effect change can reach your code: the standalone `effect/SchemaError` module is gone, and `SchemaError` is now exported from `Schema`. Confect still fails decoding with the same error, so this only matters if you name the type when handling it.
+
+  Before:
+
+  ```ts
+  import type { SchemaError } from "effect/SchemaError";
+  ```
+
+  After:
+
+  ```ts
+  import type { SchemaError } from "effect/Schema";
+  ```
+
+  Also worth knowing if you serve an `HttpApi`: a query parameter declared as an array now decodes correctly when a request supplies exactly one value for it.
+
+  One internal change rides along. Queries and mutations that run long enough to trigger a cooperative fiber yield now take that yield from Effect's own scheduler, which `rc.108` made usable inside Convex's isolate for the first time. The underlying microtask primitive is identical, so behavior should not change — but it is the thing to look at if a long-running query or mutation regresses on this release.
+
+- Raise the required `effect` peer version to `^4.0.0-rc.109` (from `^4.0.0-rc.108`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  No Confect API changed, and no call-site edits are needed. `rc.109` is a patch release of Effect with nothing removed or renamed, so upgrading is a matter of installing it alongside `@confect/*`.
+
+- 8e4962e: Raise the required `effect` peer version to `^4.0.0-rc.110` (from `^4.0.0-rc.109`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  No Confect API changed, and no call-site edits are needed. `rc.110` is a patch release of Effect with nothing removed or renamed, so upgrading is a matter of installing it alongside `@confect/*`.
+
+- 3f0255c: Build and test against `convex` 1.44.0. The published `convex` peer ranges are unchanged, so no consumer action is required.
+- Sync with `main`: this prerelease line now includes all changes released in `@confect/*` 9.2.2–9.2.4 — see those versions' changelog entries.
+- Sync with `main`: this prerelease line now includes all changes released in `@confect/*` 9.2.5 — see that version's changelog entries.
+- Sync with `main`: this prerelease line now includes all changes released in `@confect/*` 9.3.0 — see that version's changelog entries.
+- Sync with `main`: this prerelease line now includes all changes released in `@confect/*` 9.4.0 — see that version's changelog entries.
+
+  The `@effect/platform` and `@effect/cli` peer and dependency floors that 9.4.0 raises do not apply here: this line runs on Effect v4, where those packages are not dependencies at all.
+
+- The published type declarations are now emitted by TypeScript 7 rather than TypeScript 6. No API changed, but the declaration text differs in places, so an inferred type printed in your editor or in a type error may read slightly differently than before.
+
+## 10.0.0-next.15
+
+### Patch Changes
+
+- 8e4962e: Raise the required `effect` peer version to `^4.0.0-rc.109` (from `^4.0.0-rc.108`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  No Confect API changed, and no call-site edits are needed. `rc.109` is a patch release of Effect with nothing removed or renamed, so upgrading is a matter of installing it alongside `@confect/*`.
+
+## 10.0.0-next.14
+
+### Patch Changes
+
+- 9d51bd3: Raise the required `effect` peer version to `^4.0.0-rc.108` (from `^4.0.0-beta.107`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise. Effect v4 has left beta for release candidates, so `effect@rc` is now the tag to install alongside `@confect/*`.
+
+  No Confect API changed, and no call-site edits are needed for Confect itself. One Effect change can reach your code: the standalone `effect/SchemaError` module is gone, and `SchemaError` is now exported from `Schema`. Confect still fails decoding with the same error, so this only matters if you name the type when handling it.
+
+  Before:
+
+  ```ts
+  import type { SchemaError } from "effect/SchemaError";
+  ```
+
+  After:
+
+  ```ts
+  import type { SchemaError } from "effect/Schema";
+  ```
+
+  Also worth knowing if you serve an `HttpApi`: a query parameter declared as an array now decodes correctly when a request supplies exactly one value for it.
+
+  One internal change rides along. Queries and mutations that run long enough to trigger a cooperative fiber yield now take that yield from Effect's own scheduler, which `rc.108` made usable inside Convex's isolate for the first time. The underlying microtask primitive is identical, so behavior should not change — but it is the thing to look at if a long-running query or mutation regresses on this release.
+
+- a4054ab: The published type declarations are now emitted by TypeScript 7 rather than TypeScript 6. No API changed, but the declaration text differs in places, so an inferred type printed in your editor or in a type error may read slightly differently than before.
+
+## 10.0.0-next.13
+
+### Patch Changes
+
+- 5a73763: Raise the required `effect` peer version to `^4.0.0-beta.107` (from `^4.0.0-beta.106`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  `beta.107` is a patch-only Effect release, so no Confect API changes and no call-site edits are needed — upgrade `effect` alongside `@confect/*` and everything you have written keeps compiling. Your table, argument, and returns schemas still produce the same Convex validators.
+
+  Two Effect fixes are worth knowing about if they touch your code. HTTP actions written with `HttpRouter` now collect uploaded file contents far faster on large multipart bodies, and a file part whose stream is cut short — because a parser limit was exceeded or the request body ended early — now fails instead of hanging. Separately, `Duration` values that are equal now hash equally, so a `Duration` used as a `HashMap` key or a `HashSet` member is found regardless of which constructor built it.
+
+## 10.0.0-next.12
+
+### Patch Changes
+
+- 661ee9b: Raise the required `effect` peer version to `^4.0.0-beta.106` (from `^4.0.0-beta.105`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  `beta.106` is a patch-only Effect release. Nothing in Confect's own API changes, and your table, argument, and returns schemas still compile to the same Convex validators.
+
+  One Effect change needs a call-site edit if you derive property-test generators from those schemas: `Schema.toArbitrary` now returns a factory that takes the `fast-check` module instead of returning an arbitrary directly, and `Schema.toArbitraryLazy` and the `{ report: true }` option are gone.
+
+  **Before:**
+
+  ```ts
+  const NoteArbitrary = Schema.toArbitrary(Note);
+  ```
+
+  **After:**
+
+  ```ts
+  import * as FastCheck from "fast-check";
+
+  const NoteArbitrary = Schema.toArbitrary(Note)(FastCheck);
+  ```
+
+  HTTP actions written against `HttpRouter` also inherit Effect's stricter multipart handling: a request that exceeds the configured part count, part size, or field size limits now stops being parsed at the limit rather than being read to completion first.
+
+## 10.0.0-next.11
+
+### Patch Changes
+
+- f782cdd: Raise the required `effect` peer version to `^4.0.0-beta.105` (from `^4.0.0-beta.102`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+
+  `beta.103` separates wall-clock time from monotonic elapsed time: `Clock.Clock` now also requires `monotonicTimeNanos` and `monotonicTimeNanosUnsafe`, so a custom `Clock` provided to a Confect function has to supply both. Effects that measure elapsed time — `Effect.timed`, duration metrics, `Sink.withDuration` — read the monotonic accessors instead of the wall clock, and continue to report a zero duration inside queries and mutations, where Confect pins the unsafe accessors to constants to keep Convex's query cache from evicting on every logged span.
+
+  `beta.103` also moves synchronous Effect runs off `setImmediate`/`setTimeout` and onto the microtask queue, which Convex's query and mutation isolate permits. Confect no longer suppresses cooperative fiber yielding for the synchronous work it performs while your modules load — registration and schema-to-validator compilation — and relies on that scheduling instead. Neither the "Can't use `setTimeout` in queries and mutations" crash nor any other consumer-visible behavior changes, but this is the area to look at if module loading starts misbehaving.
+
+  `beta.104` renames Effect's schema error constructors to match their `Data` counterparts, which affects any error schema you declare for a Confect function:
+
+  **Before:**
+
+  ```ts
+  export class NoteNotFound extends Schema.TaggedErrorClass<NoteNotFound>()(
+    "NoteNotFound",
+    { noteId: Id("notes") },
+  ) {}
+  ```
+
+  **After:**
+
+  ```ts
+  export class NoteNotFound extends Schema.TaggedError<NoteNotFound>()(
+    "NoteNotFound",
+    { noteId: Id("notes") },
+  ) {}
+  ```
+
+  `Schema.ErrorClass` is likewise now `Schema.Error`; the schema for JavaScript `Error` instances that previously went by `Schema.Error` is now `Schema.ErrorInstance`, and `Schema.ErrorReviver` is now `Schema.ErrorInstanceReviver`. Confect's own error types — `DocumentDecodeError`, `BlobNotFoundError`, and the rest — are unchanged in name, shape, and message.
+
+  `beta.105` restructures how schema validation failures are reported, but not on the path Confect puts you on: decode and encode failures still surface as `Schema.SchemaError` with a formatted `message`, so error text from `@confect/js`, `@confect/react`, and document decoding is unchanged.
+
+- Sync with `main`: this prerelease line now includes all changes released in `@confect/*` 9.4.0 — see that version's changelog entries.
+
+  The `@effect/platform` and `@effect/cli` peer and dependency floors that 9.4.0 raises do not apply here: this line runs on Effect v4, where those packages are not dependencies at all.
+
+## 10.0.0-next.10
+
+### Patch Changes
+
+- Sync with `main`: this prerelease line now includes all changes released in `@confect/*` 9.3.0 — see that version's changelog entries.
+
+## 10.0.0-next.9
+
+### Patch Changes
+
+- 0dcc0fb: Raise the required `effect` peer version to `^4.0.0-beta.102` (from `^4.0.0-beta.101`), and `@confect/server`'s optional `@effect/platform-node` peer version likewise.
+- 25e8d19: Sync with `main`: this prerelease line now includes all changes released in `@confect/*` 9.2.5 — see that version's changelog entries.
+
+## 10.0.0-next.8
+
+### Patch Changes
+
+- 913d0e5: Raise the required `effect` peer version to `^4.0.0-beta.101` (from `^4.0.0-beta.100`).
+
+  This is a peer-range-only change with no consumer-visible API consequences. The `beta.101` release only touches fiber/concurrency internals (interrupt handling in concurrent traversal, stack frame annotations, `awaitAllChildren` linearization, `interruptibleMask` interrupt delivery), a `MutableList.filter` fix for empty buckets, a `Schema.Struct` required-readonly-field type display simplification, and an `HttpRouter.toWebHandler` middleware type-inference tightening that Confect doesn't need to accommodate.
+
+## 10.0.0-next.7
+
+## 10.0.0-next.6
+
+## 10.0.0-next.5
+
+## 10.0.0-next.4
+
+## 10.0.0-next.3
+
+### Patch Changes
+
+- 5b63546: Raise the required `effect` peer version to `^4.0.0-beta.100` (from `^4.0.0-beta.99`).
+
+  This is a peer-range-only change with no consumer-visible API consequences. The `beta.100` release only touches `Cron` internals (month/weekday alias normalization, day/weekday rollover, and equality/hashing), CLI error message formatting (`InvalidValue` prefixes), and `Schema.toTaggedUnion` discriminants that Confect doesn't use.
+
 ## 10.0.0-next.2
 
 ### Patch Changes
@@ -43,6 +335,65 @@
 - Updated dependencies [70e313e]
   - @confect/core@10.0.0-next.0
 
+## 9.4.1
+
+### Patch Changes
+
+- a4054ab: The published type declarations are now emitted by TypeScript 7 rather than TypeScript 6. No API changed, but the declaration text differs in places, so an inferred type printed in your editor or in a type error may read slightly differently than before.
+
+## 9.4.0
+
+## 9.3.0
+
+### Minor Changes
+
+- 16b5ad6: Add first-class paginated queries: declare one with `FunctionSpec.publicPaginatedQuery` (or `internalPaginatedQuery`) and read it with the new `usePaginatedQuery` hook from `@confect/react`.
+
+  Pass an `item` schema — the type of one element in a page — in place of `returns`, plus an optional `args` struct for your own arguments. The handler receives `paginationOpts` alongside them and forwards it to `paginate`.
+
+  ```ts
+  // confect/notes.spec.ts
+  FunctionSpec.publicPaginatedQuery({
+    name: "listByAuthor",
+    args: () => Schema.Struct({ author: Schema.String }),
+    item: () => notes.Doc,
+  });
+
+  // confect/notes.impl.ts
+  ({ author, paginationOpts }) =>
+    Effect.gen(function* () {
+      const reader = yield* DatabaseReader;
+
+      return yield* reader
+        .table("notes")
+        .index("by_creation_time", "desc")
+        .paginate(paginationOpts, (q) => q.eq(q.field("author"), author));
+    }).pipe(Effect.orDie);
+  ```
+
+  Declaring `paginationOpts` in `args` yourself is a type and runtime error.
+
+  ```tsx
+  import { PaginatedQueryResult, usePaginatedQuery } from "@confect/react";
+
+  const notes = usePaginatedQuery(
+    refs.public.notes.listByAuthor,
+    { author },
+    { initialNumItems: 10 },
+  );
+
+  // `notes.results` holds the pages decoded through `item`.
+  if (PaginatedQueryResult.isCanLoadMore(notes)) {
+    notes.loadMore(10);
+  }
+  ```
+
+  The hook returns a `PaginatedQueryResult<Item, E>`. `LoadingFirstPage`, `LoadingMore`, `CanLoadMore`, and `Exhausted` all carry `results` and `isLoading`; `loadMore` lives only on `CanLoadMore`, the one state it can make progress from. A declared `error` schema surfaces as a `Failure` variant carrying the decoded error instead of throwing during render, and `Failure` carries `results` too, so the pages loaded before it can still be rendered. Without an `error` schema, `Failure` is absent from the type entirely.
+
+  `paginate` in `@confect/server` now accepts Convex's full `PaginationOptions`, so a handler's `paginationOpts` passes straight through. `@confect/react` now requires `convex` >= 1.36.0.
+
+## 9.2.5
+
 ## 9.2.4
 
 ## 9.2.3

package/README.md

@@ -5,7 +5,9 @@ Confect is a framework that deeply integrates Effect with Convex. It's more than
 - Define your Convex database schema using Effect schemas.
 - Write Convex function args and returns validators using Effect's schema library.
 - Use Confect functions to automatically decode and encode your data according to your Effect schema definitions for end-to-end rich types, from client to function to database (and back).
-- Use Effect's HTTP API modules to define your HTTP API(s). Includes interactive OpenAPI documentation powered by [Scalar](https://github.com/scalar/scalar).
+- Add reusable, type-safe middleware to function groups or individual functions to provide Effect services and run logic around handlers.
+- Declare typed errors on functions and middleware using Effect schemas, then handle the decoded errors at every call site.
+- Use Effect's native HTTP API modules to define your HTTP API.
 - Access Convex platform capabilities via Effect services.
 
 Want to learn more? Read the [docs](https://confect.dev)!

package/dist/OptimisticLocalStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptimisticLocalStore.d.ts","sourceRoot":"","sources":["../src/OptimisticLocalStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,KAAK,EAAE,oBAAoB,IAAI,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AACzF,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,SAAS,GAAG,CAAC,cAAc,EACvC,QAAQ,EAAE,KAAK,EACf,GAAG,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,GAC/B,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAErC,aAAa,CAAC,KAAK,SAAS,GAAG,CAAC,cAAc,EAC5C,QAAQ,EAAE,KAAK,GACd,KAAK,CAAC;QACP,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;KAC1C,CAAC,CAAC;IAEH,QAAQ,CAAC,KAAK,SAAS,GAAG,CAAC,cAAc,EACvC,QAAQ,EAAE,KAAK,EACf,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EACrB,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GACvC,IAAI,CAAC;CACT;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,GACf,kBAAkB,0BAA0B,KAC3C,oBA+BD,CAAC"}
+{"version":3,"file":"OptimisticLocalStore.d.ts","sourceRoot":"","sources":["../src/OptimisticLocalStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACpC,OAAO,KAAK,EAAE,oBAAoB,IAAI,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AACzF,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,SAAS,GAAG,CAAC,cAAc,EACvC,QAAQ,EAAE,KAAK,EACf,GAAG,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,GAC/B,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IAErC,aAAa,CAAC,KAAK,SAAS,GAAG,CAAC,cAAc,EAC5C,QAAQ,EAAE,KAAK,GACd,KAAK,CAAC;QACP,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtB,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;KAC1C,CAAC,CAAC;IAEH,QAAQ,CAAC,KAAK,SAAS,GAAG,CAAC,cAAc,EACvC,QAAQ,EAAE,KAAK,EACf,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,EACrB,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GACvC,IAAI,CAAC;CACT;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,qBACG,0BAA0B,KAC3C,oBA+BD,CAAC"}

package/dist/PaginatedQueryResult.d.ts

@@ -0,0 +1,121 @@
+import * as Pipeable from "effect/Pipeable";
+declare const TypeId = "~@confect/react/PaginatedQueryResult";
+type TypeId = typeof TypeId;
+/**
+ * A `PaginatedQueryResult` represents the result of a Confect paginated query.
+ * The non-`Failure` variants mirror the statuses of `usePaginatedQuery` from
+ * `convex/react` and all carry `results` and `isLoading`, so the common UI
+ * shape — render the list, show a spinner while loading — needs only an
+ * {@link isFailure} early-out and plain field access.
+ *
+ * Every variant carries `results`, including `Failure`: when a later page
+ * fails, the pages already loaded are still worth rendering alongside the
+ * error, so they are not discarded. `Failure` additionally carries the
+ * query's decoded typed error.
+ *
+ * `loadMore` appears only on `CanLoadMore`, the one state it can make
+ * progress from. The underlying Convex hook exposes it on every status, but
+ * calling it while a page is in flight, once the list is exhausted, or after
+ * a failure is an intentional no-op there; narrowing to `CanLoadMore` — via
+ * {@link isCanLoadMore} or {@link match} — makes that statically apparent
+ * instead of silently dropping the call.
+ *
+ * When the query declares no `error` schema (`E` is `never`), the `Failure`
+ * variant is excluded from the type entirely, so `isLoading` is accessible
+ * without any narrowing.
+ *
+ * @typeParam Item - The type of a decoded page item.
+ * @typeParam E - The type of the decoded typed error in the `Failure` variant.
+ */
+export type PaginatedQueryResult<Item, E = never> = [E] extends [never] ? LoadingFirstPage<Item, E> | LoadingMore<Item, E> | CanLoadMore<Item, E> | Exhausted<Item, E> : LoadingFirstPage<Item, E> | LoadingMore<Item, E> | CanLoadMore<Item, E> | Exhausted<Item, E> | Failure<Item, E>;
+/**
+ * Every variant regardless of `E` — the parameter type for guards and
+ * {@link match}, since `PaginatedQueryResult` itself excludes `Failure` when
+ * `E` is `never`.
+ */
+export type Variants<Item, E = never> = LoadingFirstPage<Item, E> | LoadingMore<Item, E> | CanLoadMore<Item, E> | Exhausted<Item, E> | Failure<Item, E>;
+export declare namespace PaginatedQueryResult {
+    interface Proto<out Item, out E> extends Pipeable.Pipeable {
+        readonly [TypeId]: TypeId;
+        readonly "~Item": Item;
+        readonly "~E": E;
+    }
+    type Item<R> = R extends {
+        readonly "~Item": infer Item_;
+    } ? Item_ : never;
+    type Failure<R> = R extends {
+        readonly "~E": infer E;
+    } ? E : never;
+}
+export interface LoadingFirstPage<Item, E = never> extends PaginatedQueryResult.Proto<Item, E> {
+    readonly _tag: "LoadingFirstPage";
+    readonly skipped: boolean;
+    readonly results: ReadonlyArray<Item>;
+    readonly isLoading: true;
+}
+export interface LoadingMore<Item, E = never> extends PaginatedQueryResult.Proto<Item, E> {
+    readonly _tag: "LoadingMore";
+    readonly results: ReadonlyArray<Item>;
+    readonly isLoading: true;
+}
+export interface CanLoadMore<Item, E = never> extends PaginatedQueryResult.Proto<Item, E> {
+    readonly _tag: "CanLoadMore";
+    readonly results: ReadonlyArray<Item>;
+    readonly isLoading: false;
+    readonly loadMore: (numItems: number) => void;
+}
+export interface Exhausted<Item, E = never> extends PaginatedQueryResult.Proto<Item, E> {
+    readonly _tag: "Exhausted";
+    readonly results: ReadonlyArray<Item>;
+    readonly isLoading: false;
+}
+export interface Failure<Item, E = never> extends PaginatedQueryResult.Proto<Item, E> {
+    readonly _tag: "Failure";
+    readonly error: E;
+    /** The pages loaded before the failure. */
+    readonly results: ReadonlyArray<Item>;
+}
+export declare const isPaginatedQueryResult: (u: unknown) => u is Variants<unknown, unknown>;
+export declare const loadingFirstPage: <Item = never, E = never>(options: {
+    skipped: boolean;
+}) => LoadingFirstPage<Item, E>;
+export declare const loadingMore: <Item, E = never>(options: {
+    results: ReadonlyArray<Item>;
+}) => LoadingMore<Item, E>;
+export declare const canLoadMore: <Item, E = never>(options: {
+    results: ReadonlyArray<Item>;
+    loadMore: (numItems: number) => void;
+}) => CanLoadMore<Item, E>;
+export declare const exhausted: <Item, E = never>(options: {
+    results: ReadonlyArray<Item>;
+}) => Exhausted<Item, E>;
+export declare const failure: <E, Item = never>(options: {
+    error: E;
+    results: ReadonlyArray<Item>;
+}) => Failure<Item, E>;
+export declare const isLoadingFirstPage: <Item, E>(result: Variants<Item, E>) => result is LoadingFirstPage<Item, E>;
+export declare const isLoadingMore: <Item, E>(result: Variants<Item, E>) => result is LoadingMore<Item, E>;
+export declare const isCanLoadMore: <Item, E>(result: Variants<Item, E>) => result is CanLoadMore<Item, E>;
+export declare const isExhausted: <Item, E>(result: Variants<Item, E>) => result is Exhausted<Item, E>;
+export declare const isFailure: <Item, E>(result: Variants<Item, E>) => result is Failure<Item, E>;
+export declare const isLoading: <Item, E>(result: Variants<Item, E>) => result is LoadingFirstPage<Item, E> | LoadingMore<Item, E>;
+type MatchOptions<Item, E, V, W, X, Y, Z> = {
+    readonly onLoadingFirstPage: (skipped: boolean) => V;
+    readonly onLoadingMore: (results: ReadonlyArray<Item>) => W;
+    readonly onCanLoadMore: (results: ReadonlyArray<Item>, loadMore: (numItems: number) => void) => X;
+    readonly onExhausted: (results: ReadonlyArray<Item>) => Y;
+} & ([E] extends [never] ? {} : {
+    readonly onFailure: (error: E, results: ReadonlyArray<Item>) => Z;
+});
+type MatchReturns<E, V, W, X, Y, Z> = [E] extends [never] ? V | W | X | Y : V | W | X | Y | Z;
+/**
+ * Matches a {@link PaginatedQueryResult} to the appropriate handler based on
+ * its tag. If the provided result cannot fail (i.e. `E` is `never`),
+ * `onFailure` is not required.
+ */
+export declare const match: {
+    <Item, E, V, W, X, Y, Z = never>(options: MatchOptions<Item, E, V, W, X, Y, Z>): (self: Variants<Item, E>) => MatchReturns<E, V, W, X, Y, Z>;
+    <Item, E, V, W, X, Y, Z = never>(self: Variants<Item, E>, options: MatchOptions<Item, E, V, W, X, Y, Z>): MatchReturns<E, V, W, X, Y, Z>;
+};
+export {};
+//# sourceMappingURL=PaginatedQueryResult.d.ts.map

package/dist/PaginatedQueryResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PaginatedQueryResult.d.ts","sourceRoot":"","sources":["../src/PaginatedQueryResult.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAG5C,QAAA,MAAM,MAAM,yCAAyC,CAAC;AACtD,KAAK,MAAM,GAAG,OAAO,MAAM,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,oBAAoB,CAAC,IAAI,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GAE/D,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,GACzB,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GACpB,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GACpB,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,GAElB,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,GACzB,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GACpB,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GACpB,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,GAClB,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAEzB;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,KAAK,IAChC,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,GACzB,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GACpB,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,GACpB,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,GAClB,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAErB,MAAM,CAAC,OAAO,WAAW,oBAAoB,CAAC;IAE5C,UAAiB,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAE,SAAQ,QAAQ,CAAC,QAAQ;QAC/D,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;QACvB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;KAClB;IAED,KAAY,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,KAAK,CAAA;KAAE,GAC7D,KAAK,GACL,KAAK,CAAC;IAGV,KAAY,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,CAAC,GAAG,KAAK,CAAC;CAC3E;AAED,MAAM,WAAW,gBAAgB,CAC/B,IAAI,EACJ,CAAC,GAAG,KAAK,CACT,SAAQ,oBAAoB,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW,CAC1B,IAAI,EACJ,CAAC,GAAG,KAAK,CACT,SAAQ,oBAAoB,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW,CAC1B,IAAI,EACJ,CAAC,GAAG,KAAK,CACT,SAAQ,oBAAoB,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,SAAS,CAAC,IAAI,EAAE,CAAC,GAAG,KAAK,CAAE,SAAQ,oBAAoB,CAAC,KAAK,CAC5E,IAAI,EACJ,CAAC,CACF;IACC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;CAC3B;AAED,MAAM,WAAW,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,KAAK,CAAE,SAAQ,oBAAoB,CAAC,KAAK,CAC1E,IAAI,EACJ,CAAC,CACF;IACC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,eAAO,MAAM,sBAAsB,MAC9B,OAAO,KACT,CAAC,IAAI,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAqC,CAAC;AAyDvE,eAAO,MAAM,gBAAgB,GAAI,IAAI,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,WAAW;IACjE,OAAO,EAAE,OAAO,CAAC;CAClB,KAAG,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAMxB,CAAC;AAEL,eAAO,MAAM,WAAW,GAAI,IAAI,EAAE,CAAC,GAAG,KAAK,WAAW;IACpD,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;CAC9B,KAAG,WAAW,CAAC,IAAI,EAAE,CAAC,CAKnB,CAAC;AAEL,eAAO,MAAM,WAAW,GAAI,IAAI,EAAE,CAAC,GAAG,KAAK,WAAW;IACpD,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;IAC7B,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC,KAAG,WAAW,CAAC,IAAI,EAAE,CAAC,CAMnB,CAAC;AAEL,eAAO,MAAM,SAAS,GAAI,IAAI,EAAE,CAAC,GAAG,KAAK,WAAW;IAClD,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;CAC9B,KAAG,SAAS,CAAC,IAAI,EAAE,CAAC,CAKjB,CAAC;AAEL,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,IAAI,GAAG,KAAK,WAAW;IAChD,KAAK,EAAE,CAAC,CAAC;IACT,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,CAAC;CAC9B,KAAG,OAAO,CAAC,IAAI,EAAE,CAAC,CAKf,CAAC;AAEL,eAAO,MAAM,kBAAkB,GAAI,IAAI,EAAE,CAAC,UAChC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KACxB,MAAM,IAAI,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAuC,CAAC;AAE7E,eAAO,MAAM,aAAa,GAAI,IAAI,EAAE,CAAC,UAC3B,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KACxB,MAAM,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,CAAkC,CAAC;AAEnE,eAAO,MAAM,aAAa,GAAI,IAAI,EAAE,CAAC,UAC3B,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KACxB,MAAM,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC,CAAkC,CAAC;AAEnE,eAAO,MAAM,WAAW,GAAI,IAAI,EAAE,CAAC,UACzB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KACxB,MAAM,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC,CAAgC,CAAC;AAE/D,eAAO,MAAM,SAAS,GAAI,IAAI,EAAE,CAAC,UACvB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KACxB,MAAM,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC,CAA8B,CAAC;AAE3D,eAAO,MAAM,SAAS,GAAI,IAAI,EAAE,CAAC,UACvB,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KACxB,MAAM,IAAI,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,CACS,CAAC;AAEtE,KAAK,YAAY,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI;IAC1C,QAAQ,CAAC,kBAAkB,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,CAAC,CAAC;IACrD,QAAQ,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5D,QAAQ,CAAC,aAAa,EAAE,CACtB,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,EAC5B,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,KACjC,CAAC,CAAC;IACP,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;CAC3D,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACpB,EAAE,GACF;IACE,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;CACnE,CAAC,CAAC;AAEP,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACrD,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GACb,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEtB;;;;GAIG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,EAC7B,OAAO,EAAE,YAAY,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC5C,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,EAC7B,IAAI,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,EACvB,OAAO,EAAE,YAAY,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC5C,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CA8BnC,CAAC"}

package/dist/PaginatedQueryResult.js

@@ -0,0 +1,91 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Match from "effect/Match";
+import * as Equal from "effect/Equal";
+import * as Function from "effect/Function";
+import * as Hash from "effect/Hash";
+import * as Pipeable from "effect/Pipeable";
+import * as Predicate from "effect/Predicate";
+//#region src/PaginatedQueryResult.ts
+var PaginatedQueryResult_exports = /* @__PURE__ */ __exportAll({
+	canLoadMore: () => canLoadMore,
+	exhausted: () => exhausted,
+	failure: () => failure,
+	isCanLoadMore: () => isCanLoadMore,
+	isExhausted: () => isExhausted,
+	isFailure: () => isFailure,
+	isLoading: () => isLoading,
+	isLoadingFirstPage: () => isLoadingFirstPage,
+	isLoadingMore: () => isLoadingMore,
+	isPaginatedQueryResult: () => isPaginatedQueryResult,
+	loadingFirstPage: () => loadingFirstPage,
+	loadingMore: () => loadingMore,
+	match: () => match
+});
+const TypeId = "~@confect/react/PaginatedQueryResult";
+const isPaginatedQueryResult = (u) => Predicate.hasProperty(u, TypeId);
+const PaginatedQueryResultProto = {
+	[TypeId]: TypeId,
+	pipe(...args) {
+		return Pipeable.pipeArguments(this, args);
+	},
+	/**
+	* `CanLoadMore`'s `loadMore` is excluded from equality and hashing, like
+	* function fields generally: two results that render identically are equal
+	* even though their callbacks differ by identity.
+	*/
+	[Equal.symbol](that) {
+		if (this._tag !== that._tag) return false;
+		return Match.value(this).pipe(Match.tag("LoadingFirstPage", (self) => self.skipped === that.skipped), Match.tag("LoadingMore", "CanLoadMore", "Exhausted", (self) => Equal.equals(self.results, that.results)), Match.tag("Failure", (self) => Equal.equals(self.error, that.error) && Equal.equals(self.results, that.results)), Match.exhaustive);
+	},
+	[Hash.symbol]() {
+		const tagHash = Hash.string(this._tag);
+		return Match.value(this).pipe(Match.tag("LoadingFirstPage", (self) => Hash.combine(tagHash)(Hash.hash(self.skipped))), Match.tag("LoadingMore", "CanLoadMore", "Exhausted", (self) => Hash.combine(tagHash)(Hash.hash(self.results))), Match.tag("Failure", (self) => Hash.combine(tagHash)(Hash.combine(Hash.hash(self.error))(Hash.hash(self.results)))), Match.exhaustive);
+	}
+};
+const noResults = [];
+const loadingFirstPage = (options) => Object.assign(Object.create(PaginatedQueryResultProto), {
+	_tag: "LoadingFirstPage",
+	skipped: options.skipped,
+	results: noResults,
+	isLoading: true
+});
+const loadingMore = (options) => Object.assign(Object.create(PaginatedQueryResultProto), {
+	_tag: "LoadingMore",
+	results: options.results,
+	isLoading: true
+});
+const canLoadMore = (options) => Object.assign(Object.create(PaginatedQueryResultProto), {
+	_tag: "CanLoadMore",
+	results: options.results,
+	isLoading: false,
+	loadMore: options.loadMore
+});
+const exhausted = (options) => Object.assign(Object.create(PaginatedQueryResultProto), {
+	_tag: "Exhausted",
+	results: options.results,
+	isLoading: false
+});
+const failure = (options) => Object.assign(Object.create(PaginatedQueryResultProto), {
+	_tag: "Failure",
+	error: options.error,
+	results: options.results
+});
+const isLoadingFirstPage = (result) => result._tag === "LoadingFirstPage";
+const isLoadingMore = (result) => result._tag === "LoadingMore";
+const isCanLoadMore = (result) => result._tag === "CanLoadMore";
+const isExhausted = (result) => result._tag === "Exhausted";
+const isFailure = (result) => result._tag === "Failure";
+const isLoading = (result) => result._tag === "LoadingFirstPage" || result._tag === "LoadingMore";
+/**
+* Matches a {@link PaginatedQueryResult} to the appropriate handler based on
+* its tag. If the provided result cannot fail (i.e. `E` is `never`),
+* `onFailure` is not required.
+*/
+const match = Function.dual(2, (self, options) => Match.value(self).pipe(Match.tag("LoadingFirstPage", (loadingFirstPage_) => options.onLoadingFirstPage(loadingFirstPage_.skipped)), Match.tag("LoadingMore", (loadingMore_) => options.onLoadingMore(loadingMore_.results)), Match.tag("CanLoadMore", (canLoadMore_) => options.onCanLoadMore(canLoadMore_.results, canLoadMore_.loadMore)), Match.tag("Exhausted", (exhausted_) => options.onExhausted(exhausted_.results)), Match.tag("Failure", (failure_) => {
+	if (Predicate.hasProperty(options, "onFailure")) return options.onFailure(failure_.error, failure_.results);
+	throw new Error("`onFailure` is required when error schema is provided");
+}), Match.exhaustive));
+//#endregion
+export { PaginatedQueryResult_exports, canLoadMore, exhausted, failure, isCanLoadMore, isExhausted, isFailure, isLoading, isLoadingFirstPage, isLoadingMore, isPaginatedQueryResult, loadingFirstPage, loadingMore, match };
+
+//# sourceMappingURL=PaginatedQueryResult.js.map