@confect/core 9.0.0-next.9 → 9.0.1

package/CHANGELOG.md

@@ -1,5 +1,149 @@
 # @confect/core
 
+## 9.0.1
+
+### Patch Changes
+
+- 445ea9b: Loosen and align dependency ranges across all packages:
+
+  - The `convex` peer dependency is now `^1.32.0` in every package (previously pinned exactly to `1.39.1`, or `^1.30.0` in `@confect/react`). The range is validated against convex 1.32.0 through 1.40.0.
+  - `@confect/server`'s `@effect/platform-node` peer dependency is now optional — it is only needed when using the `@confect/server/node` entrypoint.
+  - `@confect/cli` now uses caret ranges for its `@effect/platform` and `@effect/platform-node` dependencies so they can deduplicate with the versions resolved for `@confect/server`, and no longer declares an unused direct dependency on `@effect/platform-node-shared`.
+  - `@confect/test` now accepts any `convex-test` release in `>=0.0.50 <0.1.0` instead of exactly 0.0.50.
+
+## 9.0.0
+
+### Major Changes
+
+- a905072: Rearchitect Confect so that cold-starting a Convex function only evaluates its own group's module graph, cutting cold-start execution time on large projects. The change touches how you author tables, specs, and impls, and removes the project-wide aggregation that used to make every function evaluate every other function's code—and every table's schema—the first time it ran.
+
+  Convex bundles a deployment into a single artifact, but a function's cold start only _evaluates_ the module graph reachable from its own entry point. Previously, all impls were assembled into a single root `confect/impl.ts` that every generated `convex/` module imported, so cold-starting any one query, mutation, or action transitively evaluated the impl of every other function in the project, plus every function spec and every table schema, at module-load time. Cold-start execution time scaled with the size of the whole project. In v9, `confect codegen` emits one registry per group and each generated `convex/` module imports only its own group—so a function's cold-start work scales with its own group, not the project.
+
+  ### Filesystem-driven groups
+
+  Your API is now authored as colocated `*.spec.ts`/`*.impl.ts` pairs, one pair per group, and **the file's path within `confect/` is the group's name** (its stem for top-level groups, the dot-joined directory path for nested groups). `GroupSpec.make()` and `GroupSpec.makeNode()` no longer take a name argument.
+
+  - Each `*.spec.ts` `export default`s its `GroupSpec` (named co-exports like error classes are still allowed).
+  - Each `*.impl.ts` default-imports its sibling spec, passes it to `FunctionImpl.make` / `GroupImpl.make`, and ends the layer pipeline with `GroupImpl.finalize`—a compile-time completeness check that only typechecks once every function the spec declares has a `FunctionImpl` provided.
+  - The root `confect/spec.ts`, `confect/impl.ts`, `confect/nodeSpec.ts`, and `confect/nodeImpl.ts` files are gone, along with `Impl.make` and `Impl.finalize`. `confect codegen` deletes any of these (and the stale aggregate `_generated/registeredFunctions.ts` / `_generated/nodeRegisteredFunctions.ts`) on upgrade.
+
+  ### Tables are the source of truth, named by their filename
+
+  Your schema now lives entirely in `confect/tables/`, one `Table` per file, and **the filename is the table name**—`confect/tables/notes.ts` defines the `notes` table. `Table.make` no longer takes a name argument. The user-authored `confect/schema.ts` is removed; codegen scans `confect/tables/*.ts` and generates everything else.
+
+  Each table file is a default-export-only module, and its field schema is wrapped in a `() =>` callback so it is built lazily—a function only pays a table's schema-construction cost at cold start for tables it actually reads.
+
+  ```ts confect/tables/notes.ts
+  import { Table } from "@confect/server";
+  import { Schema } from "effect";
+  import { Id } from "../_generated/id";
+
+  export default Table.make(() =>
+    Schema.Struct({
+      userId: Schema.optional(Id("users")),
+      text: Schema.String,
+    })
+  );
+  ```
+
+  Codegen emits, alongside it:
+
+  - `_generated/schema.ts`—the runtime `DatabaseSchema`. Never imports `convex/server`, so a runtime cold start no longer evaluates `defineSchema(...)`.
+  - `_generated/convexSchema.ts`—the Convex deploy `SchemaDefinition`, re-exported from `convex/schema.ts`.
+  - `_generated/id.ts`—a type-safe `Id` constructor whose argument is constrained to your table names. Use `Id("notes")` everywhere you previously wrote `GenericId.GenericId("notes")`; cross-table `_id` typos are now caught at compile time.
+  - `_generated/tables/<name>.ts`—a thin wrapper that binds the filename to the table. Read a table's `Doc`, `Fields`, and `tableName` from this wrapper (`import notes from "../_generated/tables/notes"`), not from `confect/tables/`.
+
+  A bound table's `name` property is renamed to `tableName` (avoiding a collision with `Function.prototype.name`).
+
+  ### Specs and impls: lazy schemas, and impls take the `DatabaseSchema`
+
+  `FunctionSpec.*` constructors now take `args`, `returns`, and the optional `error` as `() => Schema` thunks, so importing a spec builds no schemas until a function is invoked. `FunctionImpl.make` and `GroupImpl.make` take the runtime `DatabaseSchema` (the default export of `_generated/schema`) as their first argument instead of the whole `Api`—which keeps the project-wide spec graph out of a function's cold-start module graph. The `Api` module (`Api.make`, the `Api` type) and the generated `_generated/api.ts` / `_generated/nodeApi.ts` files are removed.
+
+  **Before:**
+
+  ```ts confect/notes.spec.ts
+  export const notes = GroupSpec.make("notes").addFunction(
+    FunctionSpec.publicQuery({
+      name: "list",
+      args: Schema.Struct({}),
+      returns: Schema.Array(Notes.Doc),
+    })
+  );
+  ```
+
+  ```ts confect/notes.impl.ts
+  const list = FunctionImpl.make(api, "notes", "list", handler);
+  export const notes = GroupImpl.make(api, "notes").pipe(Layer.provide(list));
+  ```
+
+  **After:**
+
+  ```ts confect/notes.spec.ts
+  import notes from "./_generated/tables/notes";
+
+  export default GroupSpec.make().addFunction(
+    FunctionSpec.publicQuery({
+      name: "list",
+      args: () => Schema.Struct({}),
+      returns: () => Schema.Array(notes.Doc),
+    })
+  );
+  ```
+
+  ```ts confect/notes.impl.ts
+  import databaseSchema from "./_generated/schema";
+  import notes from "./notes.spec";
+
+  const list = FunctionImpl.make(databaseSchema, notes, "list", handler);
+  export default GroupImpl.make(databaseSchema, notes).pipe(
+    Layer.provide(list),
+    GroupImpl.finalize
+  );
+  ```
+
+  ### Node functions are first-class
+
+  A group's runtime is now declared solely by its spec—`GroupSpec.makeNode()` for a Node action group, `GroupSpec.make()` otherwise—mirroring vanilla Convex's per-file `"use node"` directive. The separate `node` namespace is gone: Node specs/impls are ordinary colocated pairs that can live anywhere in `confect/`, and codegen emits the `"use node"` directive based on the spec.
+
+  - A Node group at `confect/email.spec.ts` is now reached at `refs.public.email.send` instead of `refs.public.node.email.send`.
+  - `@confect/core` removes `Spec.makeNode`, `Spec.merge`, and `Spec.isConvexSpec` / `Spec.isNodeSpec`; `Spec.make()` is a single mixed-runtime container and `Refs.make(spec)` takes one argument. `GroupSpec.makeNode()`, `FunctionSpec.publicNodeAction()` / `internalNodeAction()` are unchanged.
+
+  ### Less work at cold start
+
+  Confect's own packages now import Effect from its submodule paths (`import * as Schema from "effect/Schema"`) instead of the `"effect"` barrel. A barrel import of a namespace re-export pulls the entire namespace into the module graph a function evaluates at cold start, even when only a small part is used; importing the submodule path evaluates only what's needed. On a minimal function this cut cold-start module-evaluation time by ~35%. This is an internal change with no effect on your code—but to get the full win, import Effect from its submodule paths in your own `confect/` files too, since a single barrel import anywhere in a function's module graph re-pins the whole namespace.
+
+  ### Stable React hook results
+
+  `@confect/react` hooks now hold stable identities across renders, matching Convex's own hooks. `useQuery` memoizes the decoded `QueryResult` by the (referentially stable) Convex result, so unchanged data keeps the same `QueryResult` instead of a fresh one each render—fixing effect/memo loops (including `Maximum update depth exceeded`) for code that derives off the result. `useMutation` and `useAction` return a stable `useCallback`, and `Ref.getFunctionReference` caches the Convex function reference per function name.
+
+  ### Codegen robustness
+
+  The codegen bundler now uses [`bundle-require`](https://github.com/egoist/bundle-require), so impls may import third-party packages and use `tsconfig.json` `paths` aliases (`~/*`, `@/*`, …) for their own source. A parent `confect/{path}.spec.ts` may now declare functions alongside a sibling `confect/{path}/` subdirectory of further specs, and codegen reports a clear error on a name collision between the two.
+
+  ### Migration
+
+  1. **Tables.** Delete `confect/schema.ts`. Rename each table file to a valid JS identifier (e.g. `confect/tables/notes.ts`); the basename becomes the table name. Drop the name argument from `Table.make`, wrap the field struct in `() =>`, and replace `GenericId.GenericId("x")` with `Id("x")` from `_generated/id`. If you read `table.name` off a bound table, rename it to `table.tableName`.
+  2. **Specs.** Split each group into a colocated `*.spec.ts` that `export default`s `GroupSpec.make()` (no name). Wrap every `args`/`returns`/`error` in `() =>`. Import a table's `Doc`/`Fields` from its wrapper, `import notes from "./_generated/tables/notes"`.
+  3. **Impls.** In each `*.impl.ts`, default-import the sibling spec, import `databaseSchema` from `_generated/schema`, pass it to `FunctionImpl.make` / `GroupImpl.make` in place of `api`, end the pipeline with `GroupImpl.finalize`, and `export default` it. Delete the root `confect/spec.ts`, `impl.ts`, `nodeSpec.ts`, and `nodeImpl.ts` (codegen will also remove them).
+  4. **Node groups.** Move any `confect/node/<path>` files anywhere you like under `confect/`; the `node/` directory no longer has special meaning. Drop the `node` segment from call sites (`refs.public.node.<group>` → `refs.public.<group>`) and replace `Refs.make(spec, nodeSpec)` with `Refs.make(spec)`.
+  5. **Tests.** If you use `@confect/test`, import `confectSchema` from `_generated/schema`, import the generated `convexSchema` from `_generated/convexSchema`, and pass `convexSchema` as the new second argument to `TestConfect.layer`.
+  6. **Optional.** Adopt submodule Effect imports (`import * as Schema from "effect/Schema"`) in your own `confect/` files for the full cold-start savings.
+  7. Run `confect codegen`. It re-emits the entire `convex/` tree and `confect/_generated/`, deleting any stale files from earlier versions.
+
+### Patch Changes
+
+- 9eec71c: Generate the published `.d.ts` declarations with the TypeScript compiler instead of tsdown's declaration bundler. tsdown now emits JavaScript only (`dts: false`); each package has a composite `tsconfig.src.json`, and `tsc -b` emits the declarations into `dist/` as part of the build. (`@confect/cli` is the exception: it ships only a binary, so it emits no declarations at all.)
+
+  The emitted types are equivalent to before—same exported surface, same inferred shapes—so no consumer-facing type changes. One incidental improvement comes with the switch: declaration maps (`.d.ts.map`) now ship alongside the types (with `src/` included in the published files, so "go to definition" lands on the original source).
+
+## 9.0.0-next.10
+
+### Patch Changes
+
+- 9eec71c: Generate the published `.d.ts` declarations with the TypeScript compiler instead of tsdown's declaration bundler. tsdown now emits JavaScript only (`dts: false`); each package has a composite `tsconfig.src.json`, and `tsc -b` emits the declarations into `dist/` as part of the build. (`@confect/cli` is the exception: it ships only a binary, so it emits no declarations at all.)
+
+  The emitted types are equivalent to before—same exported surface, same inferred shapes—so no consumer-facing type changes. One incidental improvement comes with the switch: declaration maps (`.d.ts.map`) now ship alongside the types (with `src/` included in the published files, so "go to definition" lands on the original source).
+
 ## 9.0.0-next.9
 
 ### Major Changes
@@ -13,11 +157,13 @@
   The `node` namespace existed only because the pre-v9 architecture aggregated every function's impl into one module that all generated `convex/` modules imported; Node functions had to be quarantined into a separate spec/impl/registry tree so Convex-runtime functions wouldn't transitively import Node-only code. v9's per-group isolation removed that constraint, so the namespace was no longer load-bearing — only ergonomic overhead that diverged from vanilla Convex (which identifies Node modules per-file, with no directory requirement).
 
   ### Breaking changes
+
   - **API namespace removed.** A Node group at `confect/email.spec.ts` is now referenced as `refs.public.email.send` instead of `refs.public.node.email.send`. Node groups are ordinary groups in the refs tree, nesting preserved like any other group.
   - **Generated layout changed.** Node modules are emitted at `convex/<path>.ts` (carrying `"use node"`) instead of `convex/node/<path>.ts`, and their registries at `confect/_generated/registeredFunctions/<path>.ts`. The single assembled `confect/_generated/spec.ts` now contains every group regardless of runtime; `confect/_generated/nodeSpec.ts` is no longer generated (codegen deletes any stale copy on upgrade).
   - **`@confect/core` API.** Removed `Spec.makeNode`, `Spec.merge`, and `Spec.isConvexSpec`/`Spec.isNodeSpec`. `Spec` is now a single mixed-runtime container (`Spec.make()` accepts groups of any runtime). `Refs.make(spec)` takes a single argument (the unified spec) instead of `(convexSpec, nodeSpec)`. `GroupSpec.makeNode()`/`makeNodeAt()` and `FunctionSpec.publicNodeAction()`/`internalNodeAction()` are unchanged; `GroupSpec` subgroups may now be of any runtime (a group is just a namespace for its children).
 
   ### Migration
+
   1. Move any `confect/node/<path>.spec.ts`/`.impl.ts` files to wherever you want them under `confect/` (e.g. `confect/<path>.spec.ts`); the `node/` directory has no special meaning anymore. Their specs already use `GroupSpec.makeNode()`, so no spec-body change is needed — only fix the impl's relative import of `_generated/schema` if its depth changed.
   2. Update call sites to drop the `node` segment: `refs.public.node.<group>.<fn>` → `refs.public.<group>.<fn>`.
   3. Replace `Refs.make(spec, nodeSpec)` with `Refs.make(spec)` (codegen does this for `_generated/refs.ts` automatically).
@@ -124,6 +270,7 @@
   Previously, `confect/schema.ts` was user-authored and `DatabaseSchema` carried a `convexSchemaDefinition` field that was eagerly rebuilt on every `.addTable(...)`. That field was an `O(n²)` allocation for `n` tables, and it forced both the deploy CLI (which only needs `defineSchema(...)`) and the runtime (which only needs the table codec lookup) through the same module — so any runtime function bundle dragged in `convex/server`'s `defineSchema`. Issue 1.
 
   Codegen now scans `confect/tables/*.ts` (every file must default-export a `Table`) and emits two siblings:
+
   - `confect/_generated/schema.ts` — the runtime `DatabaseSchema`, consumed by `_generated/api.ts`. Imports `@confect/server` but never `convex/server`.
   - `confect/_generated/convexSchema.ts` — the Convex deploy `SchemaDefinition`, re-exported one-line from `convex/schema.ts`. Imports `convex/server` but never `@confect/server`.
 
@@ -136,6 +283,7 @@
   This eliminates a class of subtle infelicities: the file basename and the table name can never drift out of sync, cross-table `_id` references are type-constrained against the actual set of declared tables (catching typos at compile time), and ESM cycle hazards for mutual cross-table `Id` references are gone because authoring files no longer transitively import each other.
 
   Codegen now emits two new sets of files alongside `_generated/schema.ts` and `_generated/convexSchema.ts`:
+
   - `confect/_generated/id.ts` — a single `Id` constructor whose argument is type-constrained to the union of your table names. Use `Id("notes")` everywhere you previously wrote `GenericId.GenericId("notes")`.
   - `confect/_generated/tables/<name>.ts` — one thin wrapper per table that binds the unnamed value from `confect/tables/<name>.ts` to its filename. This is what other modules (specs, impls, HTTP handlers) default-import to reach a table's `Doc`, `Fields`, and `tableName`.
 
@@ -152,6 +300,7 @@
   The bound `Table` now exposes `Fields` / `Doc` / `tableDefinition` as lazy getters that compute their value on first access, then replace themselves with a plain non-writable data property so second-and-subsequent accesses are observably indistinguishable from a plain property (and skip all function-call overhead). The result: a function bundle only pays the schema-construction cost for tables it actually touches via `db.table(name)` (which reaches `Fields` through `Document.decode`). The `UnnamedTable` callable no longer exposes `Fields` or `tableDefinition` — read these off the bound `Table` (the generated `_generated/tables/<name>.ts` wrapper already binds the name).
 
   ### Migration
+
   1. Delete your `confect/schema.ts`. Codegen will refuse to run while a stray copy is present.
   2. Rename each `confect/tables/<Name>.ts` to a valid JS identifier in your chosen casing convention (e.g. `confect/tables/notes.ts`). The basename becomes the table name; you no longer pass it as an argument.
   3. Convert each table file to a **default-export-only** unnamed module: drop the name argument from `Table.make`, wrap the field-schema struct in a `() => ...` callback, and switch any `GenericId.GenericId("users")` references to `Id("users")` imported from `../_generated/id`:
@@ -227,6 +376,7 @@
   Since `9.0.0-next.1`, codegen has wrapped every parent leaf that has sibling subdirectory specs in `<parent>.addGroupAt("child", <child>)`. Because `GroupSpec.addGroupAt` is immutable, that produced a fresh object in the assembled tree, while the parent's `*.impl.ts` continued to hold a reference to the original imported leaf. The runtime resolver compared by `===`, so every such impl failed `validateImpl` with "Could not resolve group path for the provided GroupSpec." Child impls happened to work only because `GroupSpec.withName` was secretly mutating its argument in place to keep the child's identity stable — an asymmetry that was load-bearing for one half of the API and broken for the other.
 
   ### What changed
+
   - `@confect/core/Spec` carries a new `readonly paths: ReadonlyMap<GroupSpec.AnyWithProps, string>` field and exposes a chainable `Spec#addPath(group, path)` builder. `add` / `addAt` / `merge` propagate `paths` unchanged; `merge` re-prefixes a node spec's entries with `"node."` to match the merged tree.
   - `@confect/core/GroupSpec.withName` is now pure: it returns a fresh copy when the name differs and no longer rewrites the input in place. No new identity-tracking machinery is introduced.
   - `@confect/server/FunctionImpl.make` and `GroupImpl.make` resolve their group path via `api.spec.paths.get(group)` — an O(1) map lookup instead of a tree walk — and throw a clearer error pointing at `Spec.addPath` when the spec hasn't been registered.
@@ -234,6 +384,7 @@
   - `@confect/cli` codegen emits one `.addPath(<binding>, "<dot.path>")` call per leaf in `_generated/spec.ts` (and `_generated/nodeSpec.ts`) so the imported leaves carry their full paths into the assembled spec value.
 
   ### User-facing impact
+
   - Spec authoring (`*.spec.ts`) and impl authoring (`*.impl.ts`) APIs are unchanged. `FunctionImpl.make(api, spec, name, handler)` and `GroupImpl.make(api, spec)` keep their exact signatures.
   - Generated `_generated/spec.ts` (and `_generated/nodeSpec.ts`) pick up one `.addPath(...)` chain entry per leaf on the next `confect codegen` run. The shape is fully immutable — no module-load mutation, no hidden side effects.
   - Hand-rolled tests that construct a `Spec` and pass it to `Api.make` must now also call `.addPath(spec, "dot.path")` for any group they intend to look up.
@@ -261,6 +412,7 @@
   Splitting impl across colocated `*.impl.ts` files is the vehicle for fixing that. With this change, `confect codegen` emits one `_generated/registeredFunctions/{path}.ts` per group, and each generated `convex/` module imports only its own group's per-group registry — which in turn imports only its own sibling `.impl.ts`. A Convex function's cold-start bundle now scales with its own group's impl rather than with the size of the whole project.
 
   ### Breaking changes
+
   - `GroupSpec.make()` and `GroupSpec.makeNode()` no longer take a name argument; the group name is derived from the spec file's path within `confect/`.
   - `FunctionImpl.make(api, groupSpec, fn, handler)` and `GroupImpl.make(api, groupSpec)` now take the imported sibling spec object as their second argument instead of a dot-path string.
   - Every `GroupImpl` pipeline must end with `GroupImpl.finalize`, which only typechecks once every function declared by the spec has a corresponding `FunctionImpl` provided to the group layer. `GroupImpl.finalize` snapshots the names of every registered function onto the produced `Finalized` `GroupImpl` service value, and `confect codegen` reads those names to verify per-function coverage against the spec at runtime.
@@ -269,6 +421,7 @@
   - Every module under `convex/` is re-emitted to import from `_generated/registeredFunctions/{path}` instead of the previous aggregate file. Users who commit `convex/` to source control should expect a full rewrite of that directory on first codegen.
 
   ### Migration
+
   1. For each existing group, create a colocated `confect/{path}.spec.ts` and `confect/{path}.impl.ts` pair (under a subdirectory for nested groups).
      - In each spec, call `GroupSpec.make()` (or `GroupSpec.makeNode()`) without a name and `export default` the result.
      - In each impl, default-import the sibling spec (e.g. `import notes from "./notes.spec"`), pass it to `FunctionImpl.make`/`GroupImpl.make` in place of the previous dot-path string, append `GroupImpl.finalize` to the pipeline, and `export default` the resulting `GroupImpl` layer:
@@ -276,7 +429,7 @@
        export default GroupImpl.make(api, notes).pipe(
          Layer.provide(list),
          Layer.provide(insert),
-         GroupImpl.finalize,
+         GroupImpl.finalize
        );
        ```
   2. Delete root `confect/spec.ts`, `confect/impl.ts`, `confect/nodeSpec.ts`, `confect/nodeImpl.ts`, and any parent aggregator spec/impl files. (`confect codegen` will also delete any of these it finds, plus the stale `_generated/registeredFunctions.ts` and `_generated/nodeRegisteredFunctions.ts`, so this step can be skipped.)
@@ -314,7 +467,7 @@
 
   export class NoteNotFound extends Schema.TaggedError<NoteNotFound>()(
     "NoteNotFound",
-    { noteId: GenericId.GenericId("notes") },
+    { noteId: GenericId.GenericId("notes") }
   ) {}
 
   export const notes = GroupSpec.make("notes").addFunction(
@@ -323,7 +476,7 @@
       args: Schema.Struct({ noteId: GenericId.GenericId("notes") }),
       returns: Notes.Doc,
       error: NoteNotFound,
-    }),
+    })
   );
   ```
 
@@ -343,7 +496,7 @@
         .table("notes")
         .get(noteId)
         .pipe(Effect.mapError(() => new NoteNotFound({ noteId })));
-    }),
+    })
   );
   ```
 
@@ -415,6 +568,7 @@
   Unspecified failures continue to reject the promise.
 
   ### Migration
+
   - For each `useQuery` call site, replace `result === undefined` checks and direct property access with `QueryResult.match` (or the lower-level `QueryResult.isLoading`/`isSuccess`/`isFailure` predicates).
   - For each `useMutation`/`useAction` call site whose ref now declares an `error` schema, unwrap the resolved `Either` (e.g. with `Either.match`); call sites against refs without an `error` schema need no change.
 

package/dist/FunctionProvenance.d.ts

@@ -1,105 +1,101 @@
+import type { DefaultFunctionArgs } from "convex/server";
+import type { Schema } from "effect";
 import * as Data from "effect/Data";
-import { DefaultFunctionArgs } from "convex/server";
-import * as effect_Unify0 from "effect/Unify";
-import { Schema } from "effect";
-
-//#region src/FunctionProvenance.d.ts
-declare namespace FunctionProvenance_d_exports {
-  export { AnyConfect, AnyConvex, Confect, Convex, FunctionProvenance };
-}
-type FunctionProvenance = Data.TaggedEnum<{
-  Confect: {
-    args: Schema.Schema.AnyNoContext;
-    returns: Schema.Schema.AnyNoContext;
-    error?: Schema.Schema.AnyNoContext;
-  };
-  Convex: {};
+export type FunctionProvenance = Data.TaggedEnum<{
+    Confect: {
+        args: Schema.Schema.AnyNoContext;
+        returns: Schema.Schema.AnyNoContext;
+        error?: Schema.Schema.AnyNoContext;
+    };
+    Convex: {};
 }>;
-interface Confect<Args extends Schema.Schema.AnyNoContext, Returns extends Schema.Schema.AnyNoContext, Error extends Schema.Schema.AnyNoContext = never> {
-  readonly _tag: "Confect";
-  readonly args: Args;
-  readonly returns: Returns;
-  readonly error?: Error;
+export interface Confect<Args extends Schema.Schema.AnyNoContext, Returns extends Schema.Schema.AnyNoContext, Error extends Schema.Schema.AnyNoContext = never> {
+    readonly _tag: "Confect";
+    readonly args: Args;
+    readonly returns: Returns;
+    readonly error?: Error;
 }
-interface AnyConfect extends Confect<Schema.Schema.AnyNoContext, Schema.Schema.AnyNoContext, Schema.Schema.AnyNoContext> {}
-interface Convex<Args extends DefaultFunctionArgs, Returns> {
-  readonly _tag: "Convex";
-  readonly _args: Args;
-  readonly _returns: Returns;
+export interface AnyConfect extends Confect<Schema.Schema.AnyNoContext, Schema.Schema.AnyNoContext, Schema.Schema.AnyNoContext> {
 }
-interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}
-declare const FunctionProvenance: {
-  readonly Confect: Data.Case.Constructor<{
-    readonly _tag: "Confect";
-    readonly args: Schema.Schema.AnyNoContext;
-    readonly returns: Schema.Schema.AnyNoContext;
-    readonly error?: Schema.Schema.AnyNoContext;
-  }, "_tag">;
-  readonly Convex: Data.Case.Constructor<{
-    readonly _tag: "Convex";
-    readonly _args: DefaultFunctionArgs;
-    readonly _returns: any;
-  }, "_tag">;
-  readonly $is: <Tag extends "Confect" | "Convex">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Confect";
-    readonly args: Schema.Schema.AnyNoContext;
-    readonly returns: Schema.Schema.AnyNoContext;
-    readonly error?: Schema.Schema.AnyNoContext;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
+export interface Convex<Args extends DefaultFunctionArgs, Returns> {
     readonly _tag: "Convex";
-    readonly _args: DefaultFunctionArgs;
-    readonly _returns: any;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <const Cases extends {
-      readonly Confect: (args: {
+    readonly _args: Args;
+    readonly _returns: Returns;
+}
+export interface AnyConvex extends Convex<DefaultFunctionArgs, any> {
+}
+export declare const FunctionProvenance: {
+    readonly Confect: Data.Case.Constructor<{
         readonly _tag: "Confect";
         readonly args: Schema.Schema.AnyNoContext;
         readonly returns: Schema.Schema.AnyNoContext;
         readonly error?: Schema.Schema.AnyNoContext;
-      }) => any;
-      readonly Convex: (args: {
+    }, "_tag">;
+    readonly Convex: Data.Case.Constructor<{
         readonly _tag: "Convex";
         readonly _args: DefaultFunctionArgs;
         readonly _returns: any;
-      }) => any;
-    }>(cases: Cases & { [K in Exclude<keyof Cases, "Confect" | "Convex">]: never }): (value: {
-      readonly _tag: "Confect";
-      readonly args: Schema.Schema.AnyNoContext;
-      readonly returns: Schema.Schema.AnyNoContext;
-      readonly error?: Schema.Schema.AnyNoContext;
-    } | {
-      readonly _tag: "Convex";
-      readonly _args: DefaultFunctionArgs;
-      readonly _returns: any;
-    }) => effect_Unify0.Unify<ReturnType<Cases["Confect" | "Convex"]>>;
-    <const Cases extends {
-      readonly Confect: (args: {
+    }, "_tag">;
+    readonly $is: <Tag extends "Confect" | "Convex">(tag: Tag) => (u: unknown) => u is Extract<{
         readonly _tag: "Confect";
         readonly args: Schema.Schema.AnyNoContext;
         readonly returns: Schema.Schema.AnyNoContext;
         readonly error?: Schema.Schema.AnyNoContext;
-      }) => any;
-      readonly Convex: (args: {
+    }, {
+        readonly _tag: Tag;
+    }> | Extract<{
         readonly _tag: "Convex";
         readonly _args: DefaultFunctionArgs;
         readonly _returns: any;
-      }) => any;
-    }>(value: {
-      readonly _tag: "Confect";
-      readonly args: Schema.Schema.AnyNoContext;
-      readonly returns: Schema.Schema.AnyNoContext;
-      readonly error?: Schema.Schema.AnyNoContext;
-    } | {
-      readonly _tag: "Convex";
-      readonly _args: DefaultFunctionArgs;
-      readonly _returns: any;
-    }, cases: Cases & { [K in Exclude<keyof Cases, "Confect" | "Convex">]: never }): effect_Unify0.Unify<ReturnType<Cases["Confect" | "Convex"]>>;
-  };
+    }, {
+        readonly _tag: Tag;
+    }>;
+    readonly $match: {
+        <const Cases extends {
+            readonly Confect: (args: {
+                readonly _tag: "Confect";
+                readonly args: Schema.Schema.AnyNoContext;
+                readonly returns: Schema.Schema.AnyNoContext;
+                readonly error?: Schema.Schema.AnyNoContext;
+            }) => any;
+            readonly Convex: (args: {
+                readonly _tag: "Convex";
+                readonly _args: DefaultFunctionArgs;
+                readonly _returns: any;
+            }) => any;
+        }>(cases: Cases & { [K in Exclude<keyof Cases, "Confect" | "Convex">]: never; }): (value: {
+            readonly _tag: "Confect";
+            readonly args: Schema.Schema.AnyNoContext;
+            readonly returns: Schema.Schema.AnyNoContext;
+            readonly error?: Schema.Schema.AnyNoContext;
+        } | {
+            readonly _tag: "Convex";
+            readonly _args: DefaultFunctionArgs;
+            readonly _returns: any;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Confect" | "Convex"]>>;
+        <const Cases extends {
+            readonly Confect: (args: {
+                readonly _tag: "Confect";
+                readonly args: Schema.Schema.AnyNoContext;
+                readonly returns: Schema.Schema.AnyNoContext;
+                readonly error?: Schema.Schema.AnyNoContext;
+            }) => any;
+            readonly Convex: (args: {
+                readonly _tag: "Convex";
+                readonly _args: DefaultFunctionArgs;
+                readonly _returns: any;
+            }) => any;
+        }>(value: {
+            readonly _tag: "Confect";
+            readonly args: Schema.Schema.AnyNoContext;
+            readonly returns: Schema.Schema.AnyNoContext;
+            readonly error?: Schema.Schema.AnyNoContext;
+        } | {
+            readonly _tag: "Convex";
+            readonly _args: DefaultFunctionArgs;
+            readonly _returns: any;
+        }, cases: Cases & { [K in Exclude<keyof Cases, "Confect" | "Convex">]: never; }): import("effect/Unify").Unify<ReturnType<Cases["Confect" | "Convex"]>>;
+    };
 };
 /**
  * Build a `Confect` provenance from lazy schema thunks. `args`, `returns`,
@@ -117,12 +113,10 @@ declare const FunctionProvenance: {
  * is observable via `"error" in provenance` without forcing anything; nothing
  * relies on `Data`'s structural `Equal`/`Hash` for provenance values.
  */
-declare const Confect: <Args extends Schema.Schema.AnyNoContext, Returns extends Schema.Schema.AnyNoContext, Error extends Schema.Schema.AnyNoContext = never>(args: () => Args, returns: () => Returns, error?: () => Error) => Confect<Args, Returns, Error>;
-declare const Convex: <_Args extends DefaultFunctionArgs, _Returns>() => {
-  readonly _tag: "Convex";
-  readonly _args: DefaultFunctionArgs;
-  readonly _returns: any;
+export declare const Confect: <Args extends Schema.Schema.AnyNoContext, Returns extends Schema.Schema.AnyNoContext, Error extends Schema.Schema.AnyNoContext = never>(args: () => Args, returns: () => Returns, error?: () => Error) => Confect<Args, Returns, Error>;
+export declare const Convex: <_Args extends DefaultFunctionArgs, _Returns>() => {
+    readonly _tag: "Convex";
+    readonly _args: DefaultFunctionArgs;
+    readonly _returns: any;
 };
-//#endregion
-export { AnyConfect, AnyConvex, Confect, Convex, FunctionProvenance, FunctionProvenance_d_exports };
 //# sourceMappingURL=FunctionProvenance.d.ts.map

package/dist/FunctionProvenance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionProvenance.d.ts","names":[],"sources":["../src/FunctionProvenance.ts"],"mappings":";;;;;;;;;KAKY,kBAAA,GAAqB,IAAA,CAAK,UAAA;EACpC,OAAA;IACE,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,YAAA;IACpB,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,YAAA;IACvB,KAAA,GAAQ,MAAA,CAAO,MAAA,CAAO,YAAA;EAAA;EAExB,MAAA;AAAA;AAAA,UAQe,OAAA,cACF,MAAA,CAAO,MAAA,CAAO,YAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA,gBAChB,MAAA,CAAO,MAAA,CAAO,YAAA;EAAA,SAEnB,IAAA;EAAA,SACA,IAAA,EAAM,IAAA;EAAA,SACN,OAAA,EAAS,OAAA;EAAA,SACT,KAAA,GAAQ,KAAA;AAAA;AAAA,UAGF,UAAA,SAAmB,OAAA,CAClC,MAAA,CAAO,MAAA,CAAO,YAAA,EACd,MAAA,CAAO,MAAA,CAAO,YAAA,EACd,MAAA,CAAO,MAAA,CAAO,YAAA;AAAA,UAGC,MAAA,cAAoB,mBAAA;EAAA,SAC1B,IAAA;EAAA,SACA,KAAA,EAAO,IAAA;EAAA,SACP,QAAA,EAAU,OAAA;AAAA;AAAA,UAGJ,SAAA,SAAkB,MAAA,CAAO,mBAAA;AAAA,cAE7B,kBAAA;EAAA;;mBArCH,MAAA,CAAO,MAAA,CAAO,YAAA;IAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA;IAAA,iBACf,MAAA,CAAO,MAAA,CAAO,YAAA;EAAA;EAAA;;oBAIf,mBAAA;IAAA;;;;mBAND,MAAA,CAAO,MAAA,CAAO,YAAA;IAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA;IAAA,iBACf,MAAA,CAAO,MAAA,CAAO,YAAA;EAAA;IAAA;;;oBAIf,mBAAA;IAAA;;;;;;;;uBAND,MAAA,CAAO,MAAA,CAAO,YAAA;QAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA;QAAA,iBACf,MAAA,CAAO,MAAA,CAAO,YAAA;MAAA;MAAA;;wBAIf,mBAAA;QAAA;;;;qBAND,MAAA,CAAO,MAAA,CAAO,YAAA;MAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA;MAAA,iBACf,MAAA,CAAO,MAAA,CAAO,YAAA;IAAA;MAAA;sBAIf,mBAAA;MAAA;;;;;uBAND,MAAA,CAAO,MAAA,CAAO,YAAA;QAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA;QAAA,iBACf,MAAA,CAAO,MAAA,CAAO,YAAA;MAAA;MAAA;;wBAIf,mBAAA;QAAA;;;;qBAND,MAAA,CAAO,MAAA,CAAO,YAAA;MAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA;MAAA,iBACf,MAAA,CAAO,MAAA,CAAO,YAAA;IAAA;MAAA;sBAIf,mBAAA;MAAA;;;;;;;;;;;;;;;;;AA6BX;;;cAoBa,OAAA,gBACE,MAAA,CAAO,MAAA,CAAO,YAAA,kBACX,MAAA,CAAO,MAAA,CAAO,YAAA,gBAChB,MAAA,CAAO,MAAA,CAAO,YAAA,UAE5B,IAAA,QAAY,IAAA,EACZ,OAAA,QAAe,OAAA,EACf,KAAA,SAAc,KAAA,KACb,OAAA,CAAQ,IAAA,EAAM,OAAA,EAAS,KAAA;AAAA,cAYb,MAAA,iBAAwB,mBAAA;EAAA;kBArE1B,mBAAA;EAAA"}
+{"version":3,"file":"FunctionProvenance.d.ts","sourceRoot":"","sources":["../src/FunctionProvenance.ts"],"names":[],"mappings":"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"}