@confect/server 9.0.0-next.9 → 9.0.1

package/CHANGELOG.md

@@ -1,5 +1,159 @@
 # @confect/server
 
+## 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.
+
+- Updated dependencies [445ea9b]
+  - @confect/core@9.0.1
+
+## 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).
+
+- Updated dependencies [9eec71c]
+- Updated dependencies [a905072]
+  - @confect/core@9.0.0
+
+## 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).
+
+- Updated dependencies [9eec71c]
+  - @confect/core@9.0.0-next.10
+
 ## 9.0.0-next.9
 
 ### Major Changes
@@ -13,11 +167,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).
@@ -127,6 +283,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`.
 
@@ -139,6 +296,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`.
 
@@ -155,6 +313,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`:
@@ -244,6 +403,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.
@@ -251,6 +411,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.
@@ -289,6 +450,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.
@@ -297,6 +459,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:
@@ -304,7 +467,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.)
@@ -362,7 +525,7 @@
 
   export class NoteNotFound extends Schema.TaggedError<NoteNotFound>()(
     "NoteNotFound",
-    { noteId: GenericId.GenericId("notes") },
+    { noteId: GenericId.GenericId("notes") }
   ) {}
 
   export const notes = GroupSpec.make("notes").addFunction(
@@ -371,7 +534,7 @@
       args: Schema.Struct({ noteId: GenericId.GenericId("notes") }),
       returns: Notes.Doc,
       error: NoteNotFound,
-    }),
+    })
   );
   ```
 
@@ -391,7 +554,7 @@
         .table("notes")
         .get(noteId)
         .pipe(Effect.mapError(() => new NoteNotFound({ noteId })));
-    }),
+    })
   );
   ```
 
@@ -463,6 +626,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/ActionCtx.d.ts

@@ -1,12 +1,5 @@
+import type { GenericActionCtx, GenericDataModel } from "convex/server";
 import * as Context from "effect/Context";
-import { GenericActionCtx, GenericDataModel } from "convex/server";
-
-//#region src/ActionCtx.d.ts
-declare namespace ActionCtx_d_exports {
-  export { ActionCtx };
-}
-declare const ActionCtx: <DataModel extends GenericDataModel>() => Context.Tag<GenericActionCtx<DataModel>, GenericActionCtx<DataModel>>;
-type ActionCtx<DataModel extends GenericDataModel> = ReturnType<typeof ActionCtx<DataModel>>["Identifier"];
-//#endregion
-export { ActionCtx, ActionCtx_d_exports };
+export declare const ActionCtx: <DataModel extends GenericDataModel>() => Context.Tag<GenericActionCtx<DataModel>, GenericActionCtx<DataModel>>;
+export type ActionCtx<DataModel extends GenericDataModel> = ReturnType<typeof ActionCtx<DataModel>>["Identifier"];
 //# sourceMappingURL=ActionCtx.d.ts.map

package/dist/ActionCtx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionCtx.d.ts","names":[],"sources":["../src/ActionCtx.ts"],"mappings":";;;;;;;cAGa,SAAA,qBAA+B,gBAAA,OAAgB,OAAA,CAAA,GAAA,CAAA,gBAAA,CAAA,SAAA,GAAA,gBAAA,CAAA,SAAA;AAAA,KAGhD,SAAA,mBAA4B,gBAAA,IAAoB,UAAA,QACnD,SAAA,CAAU,SAAA"}
+{"version":3,"file":"ActionCtx.d.ts","sourceRoot":"","sources":["../src/ActionCtx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAE1C,eAAO,MAAM,SAAS,GAAI,SAAS,SAAS,gBAAgB,4EACkB,CAAC;AAE/E,MAAM,MAAM,SAAS,CAAC,SAAS,SAAS,gBAAgB,IAAI,UAAU,CACpE,OAAO,SAAS,CAAC,SAAS,CAAC,CAC5B,CAAC,YAAY,CAAC,CAAC"}

package/dist/ActionRunner.d.ts

@@ -1,16 +1,9 @@
-import * as Context from "effect/Context";
 import * as Ref from "@confect/core/Ref";
-import { GenericActionCtx } from "convex/server";
-import * as Layer$1 from "effect/Layer";
-import { Effect, ParseResult } from "effect";
-
-//#region src/ActionRunner.d.ts
-declare namespace ActionRunner_d_exports {
-  export { ActionRunner, layer };
-}
-declare const ActionRunner: Context.Tag<(<Action extends Ref.AnyAction>(action: Action, ...args: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | ParseResult.ParseError>), <Action extends Ref.AnyAction>(action: Action, ...args: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | ParseResult.ParseError>>;
-type ActionRunner = typeof ActionRunner.Identifier;
-declare const layer: (runAction: GenericActionCtx<any>["runAction"]) => Layer$1.Layer<(<Action extends Ref.AnyAction>(action: Action, ...args: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | ParseResult.ParseError>), never, never>;
-//#endregion
-export { ActionRunner, ActionRunner_d_exports, layer };
+import { type GenericActionCtx } from "convex/server";
+import type { ParseResult, Effect } from "effect";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+export declare const ActionRunner: Context.Tag<(<Action extends Ref.AnyAction>(action: Action, ...args: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | ParseResult.ParseError>), <Action extends Ref.AnyAction>(action: Action, ...args: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | ParseResult.ParseError>>;
+export type ActionRunner = typeof ActionRunner.Identifier;
+export declare const layer: (runAction: GenericActionCtx<any>["runAction"]) => Layer.Layer<(<Action extends Ref.AnyAction>(action: Action, ...args: Ref.OptionalArgs<Action>) => Effect.Effect<Ref.Returns<Action>, Ref.Error<Action> | ParseResult.ParseError>), never, never>;
 //# sourceMappingURL=ActionRunner.d.ts.map

package/dist/ActionRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionRunner.d.ts","names":[],"sources":["../src/ActionRunner.ts"],"mappings":";;;;;;;;;;cAsBa,YAAA,EAAY,OAAA,CAAA,GAAA,kBAdP,GAAA,CAAI,SAAA,EAAS,MAAA,EACnB,MAAA,KAAM,IAAA,EACL,GAAA,CAAI,YAAA,CAAa,MAAA,MACzB,MAAA,CAAO,MAAA,CACR,GAAA,CAAI,OAAA,CAAQ,MAAA,GACZ,GAAA,CAAI,KAAA,CAAM,MAAA,IAAU,WAAA,CAAY,UAAA,oBALlB,GAAA,CAAI,SAAA,EAAS,MAAA,EACnB,MAAA,KAAM,IAAA,EACL,GAAA,CAAI,YAAA,CAAa,MAAA,MACzB,MAAA,CAAO,MAAA,CACR,GAAA,CAAI,OAAA,CAAQ,MAAA,GACZ,GAAA,CAAI,KAAA,CAAM,MAAA,IAAU,WAAA,CAAY,UAAA;AAAA,KAYxB,YAAA,UAAsB,YAAA,CAAa,UAAA;AAAA,cAElC,KAAA,GAAS,SAAA,EAAW,gBAAA,uBAAkC,OAAA,CAAA,KAAA,kBAnBjD,GAAA,CAAI,SAAA,EAAS,MAAA,EACnB,MAAA,KAAM,IAAA,EACL,GAAA,CAAI,YAAA,CAAa,MAAA,MACzB,MAAA,CAAO,MAAA,CACR,GAAA,CAAI,OAAA,CAAQ,MAAA,GACZ,GAAA,CAAI,KAAA,CAAM,MAAA,IAAU,WAAA,CAAY,UAAA"}
+{"version":3,"file":"ActionRunner.d.ts","sourceRoot":"","sources":["../src/ActionRunner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAClD,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAkBtC,eAAO,MAAM,YAAY,gBAdtB,MAAM,SAAS,GAAG,CAAC,SAAS,UACnB,MAAM,WACL,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,KAChC,MAAM,CAAC,MAAM,CACd,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,EACnB,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,UAAU,CAC3C,IANA,MAAM,SAAS,GAAG,CAAC,SAAS,UACnB,MAAM,WACL,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,KAChC,MAAM,CAAC,MAAM,CACd,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,EACnB,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,UAAU,CAC3C,CAUF,CAAC;AACF,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,UAAU,CAAC;AAE1D,eAAO,MAAM,KAAK,GAAI,WAAW,gBAAgB,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,mBAnBhE,MAAM,SAAS,GAAG,CAAC,SAAS,UACnB,MAAM,WACL,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,KAChC,MAAM,CAAC,MAAM,CACd,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,EACnB,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,UAAU,CAC3C,gBAc2C,CAAC"}

package/dist/Auth.d.ts

@@ -1,32 +1,24 @@
-import * as effect_Context0 from "effect/Context";
-import * as convex_server0 from "convex/server";
-import { Auth as Auth$1 } from "convex/server";
-import * as Layer from "effect/Layer";
+import type { Auth as ConvexAuth } from "convex/server";
 import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
-import * as effect_Cause0 from "effect/Cause";
-
-//#region src/Auth.d.ts
-declare namespace Auth_d_exports {
-  export { Auth, NoUserIdentityFoundError, layer };
-}
-declare const Auth_base: effect_Context0.TagClass<Auth, "@confect/server/Auth", {
-  getUserIdentity: Effect.Effect<convex_server0.UserIdentity, NoUserIdentityFoundError, never>;
+declare const Auth_base: import("effect/Context").TagClass<Auth, "@confect/server/Auth", {
+    getUserIdentity: Effect.Effect<import("convex/server").UserIdentity, NoUserIdentityFoundError, never>;
 }> & Effect.Tag.Proxy<Auth, {
-  getUserIdentity: Effect.Effect<convex_server0.UserIdentity, NoUserIdentityFoundError, never>;
+    getUserIdentity: Effect.Effect<import("convex/server").UserIdentity, NoUserIdentityFoundError, never>;
 }> & {
-  use: <X>(body: (_: {
-    getUserIdentity: Effect.Effect<convex_server0.UserIdentity, NoUserIdentityFoundError, never>;
-  }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Auth | R> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, effect_Cause0.UnknownException, Auth> : Effect.Effect<X, never, Auth>;
+    use: <X>(body: (_: {
+        getUserIdentity: Effect.Effect<import("convex/server").UserIdentity, NoUserIdentityFoundError, never>;
+    }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, Auth | R> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, import("effect/Cause").UnknownException, Auth> : Effect.Effect<X, never, Auth>;
 };
-declare class Auth extends Auth_base {}
-declare const layer: (auth: Auth$1) => Layer.Layer<Auth, never, never>;
+export declare class Auth extends Auth_base {
+}
+export declare const layer: (auth: ConvexAuth) => Layer.Layer<Auth, never, never>;
 declare const NoUserIdentityFoundError_base: Schema.TaggedErrorClass<NoUserIdentityFoundError, "NoUserIdentityFoundError", {
-  readonly _tag: Schema.tag<"NoUserIdentityFoundError">;
+    readonly _tag: Schema.tag<"NoUserIdentityFoundError">;
 }>;
-declare class NoUserIdentityFoundError extends NoUserIdentityFoundError_base {
-  get message(): string;
+export declare class NoUserIdentityFoundError extends NoUserIdentityFoundError_base {
+    get message(): string;
 }
-//#endregion
-export { Auth, Auth_d_exports, NoUserIdentityFoundError, layer };
+export {};
 //# sourceMappingURL=Auth.d.ts.map

package/dist/Auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Auth.d.ts","names":[],"sources":["../src/Auth.ts"],"mappings":";;;;;;;;;;;;cAKwC,SAAA;;;;;;;;;cAgB3B,IAAA,SAAa,SAAA;AAAA,cAKb,KAAA,GAAS,IAAA,EAAM,MAAA,KAAU,KAAA,CAAA,KAAA,CAAA,IAAA;AAAA,cAAqC,6BAAA;;;cAE9D,wBAAA,SAAiC,6BAAA;EAAA,IAI/B,OAAA,CAAA;AAAA"}
+{"version":3,"file":"Auth.d.ts","sourceRoot":"","sources":["../src/Auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;;;;;AAgBxC,qBAAa,IAAK,SAAQ,SAGvB;CAAG;AAEN,eAAO,MAAM,KAAK,GAAI,MAAM,UAAU,oCAAoC,CAAC;;;;AAE3E,qBAAa,wBAAyB,SAAQ,6BAG7C;IACC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/BlobNotFoundError.d.ts

@@ -1,17 +1,11 @@
 import * as Schema from "effect/Schema";
-
-//#region src/BlobNotFoundError.d.ts
-declare namespace BlobNotFoundError_d_exports {
-  export { BlobNotFoundError };
-}
 declare const BlobNotFoundError_base: Schema.TaggedErrorClass<BlobNotFoundError, "BlobNotFoundError", {
-  readonly _tag: Schema.tag<"BlobNotFoundError">;
+    readonly _tag: Schema.tag<"BlobNotFoundError">;
 } & {
-  id: typeof Schema.String;
+    id: typeof Schema.String;
 }>;
-declare class BlobNotFoundError extends BlobNotFoundError_base {
-  get message(): string;
+export declare class BlobNotFoundError extends BlobNotFoundError_base {
+    get message(): string;
 }
-//#endregion
-export { BlobNotFoundError, BlobNotFoundError_d_exports };
+export {};
 //# sourceMappingURL=BlobNotFoundError.d.ts.map

package/dist/BlobNotFoundError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlobNotFoundError.d.ts","names":[],"sources":["../src/BlobNotFoundError.ts"],"mappings":";;;;;;cAAwC,sBAAA;;;;;cAE3B,iBAAA,SAA0B,sBAAA;EAAA,IAMxB,OAAA,CAAA;AAAA"}
+{"version":3,"file":"BlobNotFoundError.d.ts","sourceRoot":"","sources":["../src/BlobNotFoundError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;;;;;;AAExC,qBAAa,iBAAkB,SAAQ,sBAKtC;IACC,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/ConvexConfigProvider.d.ts

@@ -1,10 +1,3 @@
 import * as ConfigProvider from "effect/ConfigProvider";
-
-//#region src/ConvexConfigProvider.d.ts
-declare namespace ConvexConfigProvider_d_exports {
-  export { make };
-}
-declare const make: (options?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>) => ConfigProvider.ConfigProvider;
-//#endregion
-export { ConvexConfigProvider_d_exports, make };
+export declare const make: (options?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>) => ConfigProvider.ConfigProvider;
 //# sourceMappingURL=ConvexConfigProvider.d.ts.map

package/dist/ConvexConfigProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConvexConfigProvider.d.ts","names":[],"sources":["../src/ConvexConfigProvider.ts"],"mappings":";;;;;;cASa,IAAA,GACX,OAAA,GAAU,OAAA,CAAQ,cAAA,CAAe,cAAA,CAAe,aAAA,MAC/C,cAAA,CAAe,cAAA"}
+{"version":3,"file":"ConvexConfigProvider.d.ts","sourceRoot":"","sources":["../src/ConvexConfigProvider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,cAAc,MAAM,uBAAuB,CAAC;AAMxD,eAAO,MAAM,IAAI,GACf,UAAU,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,aAAa,CAAC,KAC7D,cAAc,CAAC,cA4CjB,CAAC"}

package/dist/CronJob.d.ts

@@ -1,21 +1,14 @@
-import { Ref } from "@confect/core";
-import { Cron, Duration } from "effect";
-
-//#region src/CronJob.d.ts
-declare namespace CronJob_d_exports {
-  export { CronJob, TypeId, isCronJob, make };
+import type { Ref } from "@confect/core";
+import type { Cron, Duration } from "effect";
+export declare const TypeId = "@confect/server/CronJob";
+export type TypeId = typeof TypeId;
+export interface CronJob {
+    readonly [TypeId]: TypeId;
+    readonly identifier: string;
+    readonly schedule: Cron.Cron | Duration.Duration;
+    readonly ref: Ref.AnyMutation | Ref.AnyAction;
+    readonly args: Record<string, unknown>;
 }
-declare const TypeId = "@confect/server/CronJob";
-type TypeId = typeof TypeId;
-interface CronJob {
-  readonly [TypeId]: TypeId;
-  readonly identifier: string;
-  readonly schedule: Cron.Cron | Duration.Duration;
-  readonly ref: Ref.AnyMutation | Ref.AnyAction;
-  readonly args: Record<string, unknown>;
-}
-declare const isCronJob: (u: unknown) => u is CronJob;
-declare const make: <R extends Ref.AnyMutation | Ref.AnyAction>(identifier: string, schedule: Cron.Cron | Duration.Duration, ref: R, ...args: Ref.OptionalArgs<R>) => CronJob;
-//#endregion
-export { CronJob, CronJob_d_exports, TypeId, isCronJob, make };
+export declare const isCronJob: (u: unknown) => u is CronJob;
+export declare const make: <R extends Ref.AnyMutation | Ref.AnyAction>(identifier: string, schedule: Cron.Cron | Duration.Duration, ref: R, ...args: Ref.OptionalArgs<R>) => CronJob;
 //# sourceMappingURL=CronJob.d.ts.map

package/dist/CronJob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CronJob.d.ts","names":[],"sources":["../src/CronJob.ts"],"mappings":";;;;;;;cAIa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,OAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SAEV,UAAA;EAAA,SACA,QAAA,EAAU,IAAA,CAAK,IAAA,GAAO,QAAA,CAAS,QAAA;EAAA,SAC/B,GAAA,EAAK,GAAA,CAAI,WAAA,GAAc,GAAA,CAAI,SAAA;EAAA,SAC3B,IAAA,EAAM,MAAA;AAAA;AAAA,cAGJ,SAAA,GAAa,CAAA,cAAa,CAAA,IAAK,OAAA;AAAA,cAoB/B,IAAA,aAAkB,GAAA,CAAI,WAAA,GAAc,GAAA,CAAI,SAAA,EACnD,UAAA,UACA,QAAA,EAAU,IAAA,CAAK,IAAA,GAAO,QAAA,CAAS,QAAA,EAC/B,GAAA,EAAK,CAAA,KACF,IAAA,EAAM,GAAA,CAAI,YAAA,CAAa,CAAA,MACzB,OAAA"}
+{"version":3,"file":"CronJob.d.ts","sourceRoot":"","sources":["../src/CronJob.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAG7C,eAAO,MAAM,MAAM,4BAA4B,CAAC;AAChD,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAE1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC;IACjD,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxC;AAED,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,OACV,CAAC;AAmBnC,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,GAAG,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,EAC5D,YAAY,MAAM,EAClB,UAAU,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,QAAQ,EACvC,KAAK,CAAC,EACN,GAAG,MAAM,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,KAC3B,OAA8D,CAAC"}

package/dist/CronJobs.d.ts

@@ -1,20 +1,13 @@
-import { CronJob } from "./CronJob.js";
-import { Crons } from "convex/server";
-
-//#region src/CronJobs.d.ts
-declare namespace CronJobs_d_exports {
-  export { CronJobs, TypeId, isCronJobs, make };
+import { type Crons } from "convex/server";
+import type * as CronJob from "./CronJob";
+export declare const TypeId = "@confect/server/CronJobs";
+export type TypeId = typeof TypeId;
+export interface CronJobs {
+    readonly [TypeId]: TypeId;
+    readonly cronJobs: Record<string, CronJob.CronJob>;
+    readonly convexCronJobs: Crons;
+    add(cron: CronJob.CronJob): CronJobs;
 }
-declare const TypeId = "@confect/server/CronJobs";
-type TypeId = typeof TypeId;
-interface CronJobs {
-  readonly [TypeId]: TypeId;
-  readonly cronJobs: Record<string, CronJob>;
-  readonly convexCronJobs: Crons;
-  add(cron: CronJob): CronJobs;
-}
-declare const isCronJobs: (u: unknown) => u is CronJobs;
-declare const make: () => CronJobs;
-//#endregion
-export { CronJobs, CronJobs_d_exports, TypeId, isCronJobs, make };
+export declare const isCronJobs: (u: unknown) => u is CronJobs;
+export declare const make: () => CronJobs;
 //# sourceMappingURL=CronJobs.d.ts.map

package/dist/CronJobs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CronJobs.d.ts","names":[],"sources":["../src/CronJobs.ts"],"mappings":";;;;;;;cAaa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,QAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,QAAA,EAAU,MAAA,SAAe,OAAA;EAAA,SACzB,cAAA,EAAgB,KAAA;EAEzB,GAAA,CAAI,IAAA,EAAM,OAAA,GAAkB,QAAA;AAAA;AAAA,cAGjB,UAAA,GAAc,CAAA,cAAa,CAAA,IAAK,QAAA;AAAA,cAkDhC,IAAA,QAAW,QAAA"}
+{"version":3,"file":"CronJobs.d.ts","sourceRoot":"","sources":["../src/CronJobs.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+B,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AASxE,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,CAAC;AAE1C,eAAO,MAAM,MAAM,6BAA6B,CAAC;AACjD,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACnD,QAAQ,CAAC,cAAc,EAAE,KAAK,CAAC;IAE/B,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,GAAG,QAAQ,CAAC;CACtC;AAED,eAAO,MAAM,UAAU,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,QACX,CAAC;AAiDnC,eAAO,MAAM,IAAI,QAAO,QAA4C,CAAC"}

package/dist/DataModel.d.ts

@@ -1,33 +1,28 @@
-import { AnyWithProps as AnyWithProps$1, Name, TablesRecord, WithName } from "./Table.js";
-import { AnyWithProps as AnyWithProps$2, Tables as Tables$1 } from "./DatabaseSchema.js";
-import { ConvexTableInfo, Document, TableInfo } from "./TableInfo.js";
-
-//#region src/DataModel.d.ts
-declare namespace DataModel_d_exports {
-  export { Any, AnyWithProps, DataModel, DocumentByName, DocumentWithName, FromSchema, FromTables, TableInfoWithName, TableInfoWithName_, TableNames, TableWithName, Tables, ToConvex, TypeId };
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Table from "./Table";
+import type * as TableInfo from "./TableInfo";
+export declare const TypeId: "@confect/server/DataModel";
+export type TypeId = typeof TypeId;
+export interface DataModel<Tables_ extends Table.AnyWithProps> {
+    readonly [TypeId]: TypeId;
+    readonly tables: Table.TablesRecord<Tables_>;
 }
-declare const TypeId: "@confect/server/DataModel";
-type TypeId = typeof TypeId;
-interface DataModel<Tables_ extends AnyWithProps$1> {
-  readonly [TypeId]: TypeId;
-  readonly tables: TablesRecord<Tables_>;
+export interface Any {
+    readonly [TypeId]: TypeId;
 }
-interface Any {
-  readonly [TypeId]: TypeId;
+export interface AnyWithProps extends Any {
+    readonly tables: Record<string, Table.AnyWithProps>;
 }
-interface AnyWithProps extends Any {
-  readonly tables: Record<string, AnyWithProps$1>;
-}
-type FromSchema<Schema extends AnyWithProps$2> = DataModel<Tables$1<Schema>>;
-type FromTables<Tables_ extends AnyWithProps$1> = DataModel<Tables_>;
-type ToConvex<DataModel_ extends AnyWithProps> = { [TableName_ in TableNames<DataModel_>]: TableInfoWithName<DataModel_, TableName_> };
-type Tables<DataModel_ extends AnyWithProps> = DataModel_ extends DataModel<infer Tables_> ? Tables_ : never;
-type TableNames<DataModel_ extends AnyWithProps> = Name<Tables<DataModel_>> & string;
-type TableWithName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = WithName<Tables<DataModel_>, TableName>;
-type TableInfoWithName_<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = TableInfo<WithName<Tables<DataModel_>, TableName>>;
-type TableInfoWithName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = ConvexTableInfo<TableInfo<WithName<Tables<DataModel_>, TableName>>>;
-type DocumentWithName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = Document<TableInfo<WithName<Tables<DataModel_>, TableName>>>;
-type DocumentByName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = DocumentWithName<DataModel_, TableName>;
-//#endregion
-export { Any, AnyWithProps, DataModel, DataModel_d_exports, DocumentByName, DocumentWithName, FromSchema, FromTables, TableInfoWithName, TableInfoWithName_, TableNames, TableWithName, Tables, ToConvex, TypeId };
+export type FromSchema<Schema extends DatabaseSchema.AnyWithProps> = DataModel<DatabaseSchema.Tables<Schema>>;
+export type FromTables<Tables_ extends Table.AnyWithProps> = DataModel<Tables_>;
+export type ToConvex<DataModel_ extends AnyWithProps> = {
+    [TableName_ in TableNames<DataModel_>]: TableInfoWithName<DataModel_, TableName_>;
+};
+export type Tables<DataModel_ extends AnyWithProps> = DataModel_ extends DataModel<infer Tables_> ? Tables_ : never;
+export type TableNames<DataModel_ extends AnyWithProps> = Table.Name<Tables<DataModel_>> & string;
+export type TableWithName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = Table.WithName<Tables<DataModel_>, TableName>;
+export type TableInfoWithName_<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = TableInfo.TableInfo<Table.WithName<Tables<DataModel_>, TableName>>;
+export type TableInfoWithName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = TableInfo.ConvexTableInfo<TableInfo.TableInfo<Table.WithName<Tables<DataModel_>, TableName>>>;
+export type DocumentWithName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = TableInfo.Document<TableInfo.TableInfo<Table.WithName<Tables<DataModel_>, TableName>>>;
+export type DocumentByName<DataModel_ extends AnyWithProps, TableName extends TableNames<DataModel_>> = DocumentWithName<DataModel_, TableName>;
 //# sourceMappingURL=DataModel.d.ts.map