@confect/server 9.0.0-next.0 → 9.0.0-next.10

package/src/SchemaToValidator.ts

@@ -17,22 +17,20 @@ import type {
   VUnion,
 } from "convex/values";
 import { v } from "convex/values";
-import {
-  Array,
-  Cause,
-  Data,
-  Effect,
-  Exit,
-  Match,
-  Number,
-  Option,
-  type ParseResult,
-  pipe,
-  Predicate,
-  Schema,
-  SchemaAST,
-  String,
-} from "effect";
+import { pipe } from "effect/Function";
+import type { ParseResult } from "effect";
+import * as Array from "effect/Array";
+import * as Cause from "effect/Cause";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Match from "effect/Match";
+import * as Number from "effect/Number";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import * as String from "effect/String";
 
 import * as GenericId from "@confect/core/GenericId";
 import type {

package/src/StorageActionWriter.ts

@@ -1,6 +1,9 @@
 import type { StorageActionWriter as ConvexStorageActionWriter } from "convex/server";
 import type { GenericId } from "convex/values";
-import { Effect, flow, Layer, Option } from "effect";
+import { flow } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import { BlobNotFoundError } from "./BlobNotFoundError";
 
 const make = (storageActionWriter: ConvexStorageActionWriter) => ({

package/src/StorageReader.ts

@@ -1,6 +1,10 @@
 import type { StorageReader as ConvexStorageReader } from "convex/server";
 import type { GenericId } from "convex/values";
-import { Effect, flow, Layer, Option, pipe, Schema } from "effect";
+import { flow, pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 import { BlobNotFoundError } from "./BlobNotFoundError";
 
 const make = (storageReader: ConvexStorageReader) => ({

package/src/StorageWriter.ts

@@ -1,6 +1,9 @@
 import type { StorageWriter as ConvexStorageWriter } from "convex/server";
 import type { GenericId } from "convex/values";
-import { Effect, Layer, pipe, Schema } from "effect";
+import { pipe } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
 import { BlobNotFoundError } from "./BlobNotFoundError";
 
 const make = (storageWriter: ConvexStorageWriter) => ({

package/src/Table.ts

@@ -1,3 +1,4 @@
+import * as Lazy from "@confect/core/Lazy";
 import * as SystemFields from "@confect/core/SystemFields";
 import {
   defineTable,
@@ -12,7 +13,8 @@ import {
   type VectorIndexConfig,
 } from "convex/server";
 import type { GenericValidator, Validator } from "convex/values";
-import { Predicate, Schema } from "effect";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
 import {
   compileTableSchema,
   type TableSchemaToTableValidator,
@@ -21,8 +23,26 @@ import {
 export const TypeId = "@confect/server/Table";
 export type TypeId = typeof TypeId;
 
+// -----------------------------------------------------------------------------
+// Predicates
+// -----------------------------------------------------------------------------
+//
+// Both bound `Table`s and `UnnamedTable` callables share the same `[TypeId]`
+// brand. They disambiguate by whether a `tableName` property is set: bound
+// tables have one, unnamed callables do not.
+//
+// The discriminator is `tableName` (not `name`) so it does not collide with
+// the built-in `Function.prototype.name` that every JS function carries.
+
 export const isTable = (u: unknown): u is Any =>
-  Predicate.hasProperty(u, TypeId);
+  Predicate.hasProperty(u, TypeId) && Predicate.hasProperty(u, "tableName");
+
+export const isUnnamedTable = (u: unknown): u is UnnamedAny =>
+  Predicate.hasProperty(u, TypeId) && !Predicate.hasProperty(u, "tableName");
+
+// -----------------------------------------------------------------------------
+// Bound Table
+// -----------------------------------------------------------------------------
 
 export interface Table<
   Name_ extends string,
@@ -34,18 +54,65 @@ export interface Table<
   VectorIndexes_ extends GenericTableVectorIndexes = {},
 > {
   readonly [TypeId]: TypeId;
+  readonly tableName: Name_;
   readonly tableDefinition: TableDefinition<
     TableValidator_,
     Indexes_,
     SearchIndexes_,
     VectorIndexes_
   >;
-
-  readonly name: Name_;
-
   readonly Fields: TableSchema_;
   readonly Doc: SystemFields.ExtendWithSystemFields<Name_, TableSchema_>;
+  readonly indexes: Indexes_;
+}
+
+export interface Any {
+  readonly [TypeId]: TypeId;
+  readonly tableName: string;
+}
+
+export type AnyWithProps = Table<
+  any,
+  Schema.Schema.AnyNoContext,
+  GenericValidator,
+  GenericTableIndexes,
+  GenericTableSearchIndexes,
+  GenericTableVectorIndexes
+>;
+
+// -----------------------------------------------------------------------------
+// UnnamedTable (callable)
+// -----------------------------------------------------------------------------
+//
+// `Table.make(lazyFields)` returns an `UnnamedTable`: a callable that
+// produces a fully bound `Table` when invoked with a name. Chaining methods
+// (`.index`, `.searchIndex`, `.vectorIndex`) live here and return new
+// `UnnamedTable`s, accumulating plain index metadata records. Neither the
+// field-schema nor the deploy-time `tableDefinition` is constructed at this
+// stage — the user-supplied `lazyFields` callback is just carried through.
+// The codegen pipeline emits a wrapper file per user-authored table that
+// simply invokes the unnamed callable with the filename basename.
+
+export interface UnnamedTable<
+  TableSchema_ extends Schema.Schema.AnyNoContext,
+  TableValidator_ extends GenericValidator =
+    TableSchemaToTableValidator<TableSchema_>,
+  Indexes_ extends GenericTableIndexes = {},
+  SearchIndexes_ extends GenericTableSearchIndexes = {},
+  VectorIndexes_ extends GenericTableVectorIndexes = {},
+> {
+  <const Name_ extends string>(
+    tableName: Name_,
+  ): Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
 
+  readonly [TypeId]: TypeId;
   readonly indexes: Indexes_;
 
   index<
@@ -55,8 +122,7 @@ export interface Table<
   >(
     name: IndexName,
     fields: [FirstFieldPath, ...RestFieldPaths],
-  ): Table<
-    Name_,
+  ): UnnamedTable<
     TableSchema_,
     TableValidator_,
     Expand<
@@ -77,8 +143,7 @@ export interface Table<
   >(
     name: IndexName,
     indexConfig: Expand<SearchIndexConfig<SearchField, FilterFields>>,
-  ): Table<
-    Name_,
+  ): UnnamedTable<
     TableSchema_,
     TableValidator_,
     Indexes_,
@@ -102,8 +167,7 @@ export interface Table<
   >(
     name: IndexName,
     indexConfig: Expand<VectorIndexConfig<VectorField, FilterFields>>,
-  ): Table<
-    Name_,
+  ): UnnamedTable<
     TableSchema_,
     TableValidator_,
     Indexes_,
@@ -122,12 +186,11 @@ export interface Table<
   >;
 }
 
-export interface Any {
+export interface UnnamedAny {
   readonly [TypeId]: TypeId;
 }
 
-export type AnyWithProps = Table<
-  any,
+export type UnnamedAnyWithProps = UnnamedTable<
   Schema.Schema.AnyNoContext,
   GenericValidator,
   GenericTableIndexes,
@@ -135,6 +198,10 @@ export type AnyWithProps = Table<
   GenericTableVectorIndexes
 >;
 
+// -----------------------------------------------------------------------------
+// Type extractors
+// -----------------------------------------------------------------------------
+
 export type Name<TableDef extends AnyWithProps> =
   TableDef extends Table<
     infer TableName,
@@ -234,162 +301,217 @@ export type Fields<TableDef extends AnyWithProps> =
 export type WithName<
   TableDef extends AnyWithProps,
   Name_ extends string,
-> = TableDef extends { readonly name: Name_ } ? TableDef : never;
+> = TableDef extends { readonly tableName: Name_ } ? TableDef : never;
 
 export type TablesRecord<Tables extends AnyWithProps> = {
   readonly [TableName_ in Name<Tables>]: WithName<Tables, TableName_>;
 };
 
-const Proto = {
-  [TypeId]: TypeId,
-
-  index<
-    IndexName extends string,
-    FirstFieldPath extends string,
-    RestFieldPaths extends string[],
-  >(
-    this: AnyWithProps,
-    name: IndexName,
-    fields: [FirstFieldPath, ...RestFieldPaths],
-  ) {
-    return makeProto({
-      name: this.name,
-      Fields: this.Fields,
-      Doc: this.Doc,
-      tableDefinition: this.tableDefinition.index(name, fields as any),
-      indexes: {
-        ...this.indexes,
-        [name]: fields,
-      },
-    });
-  },
-
-  searchIndex<IndexName extends string, SearchField extends string>(
-    this: AnyWithProps,
-    name: IndexName,
-    indexConfig: SearchIndexConfig<SearchField, any>,
-  ) {
-    return makeProto({
-      name: this.name,
-      Fields: this.Fields,
-      Doc: this.Doc,
-      tableDefinition: this.tableDefinition.searchIndex(name, indexConfig),
-      indexes: this.indexes,
-    });
-  },
-
-  vectorIndex<IndexName extends string, VectorField extends string>(
-    this: AnyWithProps,
-    name: IndexName,
-    indexConfig: {
-      vectorField: VectorField;
-      dimensions: number;
-      filterFields?: string[] | undefined;
-    },
-  ) {
-    return makeProto({
-      name: this.name,
-      Fields: this.Fields,
-      Doc: this.Doc,
-      tableDefinition: this.tableDefinition.vectorIndex(name, {
-        vectorField: indexConfig.vectorField,
-        dimensions: indexConfig.dimensions,
-        ...(indexConfig.filterFields
-          ? { filterFields: indexConfig.filterFields }
-          : {}),
-      }),
-      indexes: this.indexes,
-    });
-  },
-};
+// -----------------------------------------------------------------------------
+// Construction
+// -----------------------------------------------------------------------------
+//
+// `make` only stores the user-supplied `lazyFields` callback alongside any
+// chained index metadata. Neither `Fields` nor `Doc` nor `tableDefinition`
+// is constructed until first access on a bound `Table`. Each chain step is
+// O(1) (plain object spread of the metadata records) and never invokes the
+// callback. Binding via `unnamed(tableName)` installs lazy memoised getters
+// for `Fields`, `Doc`, and `tableDefinition` via `Lazy.defineProperty`, so the
+// first access materialises the value and replaces the getter with a plain
+// data property — second-and-subsequent accesses are observably
+// indistinguishable from a plain property and avoid all function-call
+// overhead.
+
+interface UnnamedState<
+  TableSchema_ extends Schema.Schema.AnyNoContext,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
+> {
+  readonly lazyFields: () => TableSchema_;
+  readonly indexes: Indexes_;
+  readonly searchIndexes: SearchIndexes_;
+  readonly vectorIndexes: VectorIndexes_;
+}
 
-const makeProto = <
+const makeBound = <
   Name_ extends string,
   TableSchema_ extends Schema.Schema.AnyNoContext,
   TableValidator_ extends Validator<any, any, any>,
   Indexes_ extends GenericTableIndexes,
   SearchIndexes_ extends GenericTableSearchIndexes,
   VectorIndexes_ extends GenericTableVectorIndexes,
->({
-  name,
-  Fields,
-  Doc,
-  tableDefinition,
-  indexes,
-}: {
-  name: Name_;
-  Fields: TableSchema_;
-  Doc: SystemFields.ExtendWithSystemFields<Name_, TableSchema_>;
-  tableDefinition: TableDefinition<
-    TableValidator_,
-    Indexes_,
-    SearchIndexes_,
-    VectorIndexes_
-  >;
-  indexes: Indexes_;
-}): Table<
+>(
+  tableName: Name_,
+  state: UnnamedState<TableSchema_, Indexes_, SearchIndexes_, VectorIndexes_>,
+): Table<
   Name_,
   TableSchema_,
   TableValidator_,
   Indexes_,
   SearchIndexes_,
   VectorIndexes_
-> =>
-  Object.assign(Object.create(Proto), {
-    name,
-    Fields,
-    Doc,
-    tableDefinition,
-    indexes,
+> => {
+  const bound = {
+    [TypeId]: TypeId as TypeId,
+    tableName,
+    indexes: state.indexes,
+  } as Table<
+    Name_,
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
+
+  Lazy.defineProperty(bound, "Fields", () => state.lazyFields());
+
+  Lazy.defineProperty(bound, "Doc", () =>
+    SystemFields.extendWithSystemFields(
+      tableName,
+      (bound as { Fields: TableSchema_ }).Fields,
+    ),
+  );
+
+  Lazy.defineProperty(bound, "tableDefinition", () => {
+    const fields = (bound as { Fields: TableSchema_ }).Fields;
+    let definition: TableDefinition<any, any, any, any> = defineTable(
+      compileTableSchema(fields),
+    );
+    for (const [name, indexFields] of Object.entries(
+      state.indexes as Record<string, any>,
+    )) {
+      definition = definition.index(name, indexFields);
+    }
+    for (const [name, config] of Object.entries(
+      state.searchIndexes as Record<string, any>,
+    )) {
+      definition = definition.searchIndex(name, config);
+    }
+    for (const [name, config] of Object.entries(
+      state.vectorIndexes as Record<string, any>,
+    )) {
+      definition = definition.vectorIndex(name, config);
+    }
+    return definition;
   });
 
-/**
- * Create a table.
- */
-export const make = <
-  const Name_ extends string,
+  return bound;
+};
+
+const makeUnnamed = <
   TableSchema_ extends Schema.Schema.AnyNoContext,
-  TableValidator_ extends GenericValidator =
-    TableSchemaToTableValidator<TableSchema_>,
-  Indexes_ extends GenericTableIndexes = {},
-  SearchIndexes_ extends GenericTableSearchIndexes = {},
-  VectorIndexes_ extends GenericTableVectorIndexes = {},
+  TableValidator_ extends Validator<any, any, any>,
+  Indexes_ extends GenericTableIndexes,
+  SearchIndexes_ extends GenericTableSearchIndexes,
+  VectorIndexes_ extends GenericTableVectorIndexes,
 >(
-  name: Name_,
-  fields: TableSchema_,
-): Table<
-  Name_,
+  state: UnnamedState<TableSchema_, Indexes_, SearchIndexes_, VectorIndexes_>,
+): UnnamedTable<
   TableSchema_,
   TableValidator_,
   Indexes_,
   SearchIndexes_,
   VectorIndexes_
 > => {
-  const tableValidator = compileTableSchema(fields) as any;
-  const tableDefinition = defineTable(tableValidator) as any;
+  type UnnamedTable_ = UnnamedTable<
+    TableSchema_,
+    TableValidator_,
+    Indexes_,
+    SearchIndexes_,
+    VectorIndexes_
+  >;
 
-  return makeProto<
+  type UnnamedTableFunction<FunctionName extends keyof UnnamedTable_> =
+    UnnamedTable_[FunctionName];
+
+  const bind = <const Name_ extends string>(
+    tableName: Name_,
+  ): Table<
     Name_,
     TableSchema_,
     TableValidator_,
     Indexes_,
     SearchIndexes_,
     VectorIndexes_
-  >({
+  > =>
+    makeBound<
+      Name_,
+      TableSchema_,
+      TableValidator_,
+      Indexes_,
+      SearchIndexes_,
+      VectorIndexes_
+    >(tableName, state);
+
+  const index: UnnamedTableFunction<"index"> = (name, fields) =>
+    makeUnnamed({
+      lazyFields: state.lazyFields,
+      indexes: {
+        ...state.indexes,
+        [name]: fields,
+      } as any,
+      searchIndexes: state.searchIndexes,
+      vectorIndexes: state.vectorIndexes,
+    });
+
+  const searchIndex: UnnamedTableFunction<"searchIndex"> = (
     name,
-    Fields: fields,
-    Doc: SystemFields.extendWithSystemFields(name, fields),
-    tableDefinition,
-    indexes: {} as Indexes_,
-  });
+    indexConfig,
+  ) =>
+    makeUnnamed({
+      lazyFields: state.lazyFields,
+      indexes: state.indexes,
+      searchIndexes: {
+        ...state.searchIndexes,
+        [name]: indexConfig,
+      } as any,
+      vectorIndexes: state.vectorIndexes,
+    });
+
+  const vectorIndex: UnnamedTableFunction<"vectorIndex"> = (
+    name,
+    indexConfig,
+  ) =>
+    makeUnnamed({
+      lazyFields: state.lazyFields,
+      indexes: state.indexes,
+      searchIndexes: state.searchIndexes,
+      vectorIndexes: {
+        ...state.vectorIndexes,
+        [name]: indexConfig,
+      } as any,
+    });
+
+  return Object.assign(bind, {
+    [TypeId]: TypeId as TypeId,
+    indexes: state.indexes,
+    index,
+    searchIndex,
+    vectorIndex,
+  }) satisfies UnnamedTable_;
+};
+
+export const make = <const TableSchema_ extends Schema.Schema.AnyNoContext>(
+  lazyFields: () => TableSchema_,
+): UnnamedTable<TableSchema_, TableSchemaToTableValidator<TableSchema_>> => {
+  type TableValidator_ = TableSchemaToTableValidator<TableSchema_>;
+  type UnnamedTable_ = UnnamedTable<TableSchema_, TableValidator_>;
+
+  return makeUnnamed<TableSchema_, TableValidator_, {}, {}, {}>({
+    lazyFields,
+    indexes: {},
+    searchIndexes: {},
+    vectorIndexes: {},
+  }) satisfies UnnamedTable_;
 };
 
 // -----------------------------------------------------------------------------
 // System tables
 // -----------------------------------------------------------------------------
 
-export const scheduledFunctionsTable = make(
-  "_scheduled_functions",
+export const scheduledFunctionsTable = make(() =>
   Schema.Struct({
     name: Schema.String,
     args: Schema.Array(Schema.Any),
@@ -406,16 +528,15 @@ export const scheduledFunctionsTable = make(
       Schema.Struct({ kind: Schema.Literal("canceled") }),
     ),
   }),
-);
+)("_scheduled_functions");
 
-export const storageTable = make(
-  "_storage",
+export const storageTable = make(() =>
   Schema.Struct({
     sha256: Schema.String,
     size: Schema.Number,
     contentType: Schema.optionalWith(Schema.String, { exact: true }),
   }),
-);
+)("_storage");
 
 export const systemTables = {
   _scheduled_functions: scheduledFunctionsTable,

package/src/VectorSearch.ts

@@ -6,7 +6,9 @@ import type {
   VectorSearchQuery,
 } from "convex/server";
 import type { GenericId } from "convex/values";
-import { Context, Effect, Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import type * as DataModel from "./DataModel";
 
 type ConvexVectorSearch<DataModel_ extends DataModel.AnyWithProps> =

package/src/index.ts

@@ -1,6 +1,5 @@
 export * as ActionCtx from "./ActionCtx";
 export * as ActionRunner from "./ActionRunner";
-export * as Api from "./Api";
 export * as Auth from "./Auth";
 export * as BlobNotFoundError from "./BlobNotFoundError";
 export * as ConvexConfigProvider from "./ConvexConfigProvider";

package/src/internal/utils.ts

@@ -1,5 +1,7 @@
 import type { Predicate } from "effect";
-import { Array, Effect, Record } from "effect";
+import * as Array from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Record from "effect/Record";
 
 type NestedObject<T> = {
   [key: string]: T | NestedObject<T>;

package/dist/Api.d.ts

@@ -1,30 +0,0 @@
-import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
-import { GenericSchema, SchemaDefinition } from "convex/server";
-import { RuntimeAndFunctionType } from "@confect/core";
-import * as Spec from "@confect/core/Spec";
-
-//#region src/Api.d.ts
-declare namespace Api_d_exports {
-  export { Any, AnyWithProps, AnyWithPropsWithRuntime, Api, GetSpec, Groups, Schema, TypeId, isApi, make };
-}
-declare const TypeId = "@confect/server/Api";
-type TypeId = typeof TypeId;
-declare const isApi: (u: unknown) => u is Any;
-interface Api<DatabaseSchema_ extends AnyWithProps$1, Spec_ extends Spec.AnyWithProps> {
-  readonly [TypeId]: TypeId;
-  readonly spec: Spec_;
-  readonly databaseSchema: DatabaseSchema_;
-  readonly convexSchemaDefinition: SchemaDefinition<GenericSchema, true>;
-}
-interface Any {
-  readonly [TypeId]: TypeId;
-}
-interface AnyWithProps extends Api<AnyWithProps$1, Spec.AnyWithProps> {}
-interface AnyWithPropsWithRuntime<Runtime extends RuntimeAndFunctionType.Runtime> extends Api<AnyWithProps$1, Spec.AnyWithPropsWithRuntime<Runtime>> {}
-type Schema<Api_ extends AnyWithProps> = Api_["databaseSchema"];
-type GetSpec<Api_ extends AnyWithProps> = Api_["spec"];
-type Groups<Api_ extends AnyWithProps> = Spec.Groups<Api_["spec"]>;
-declare const make: <DatabaseSchema_ extends AnyWithProps$1, Spec_ extends Spec.AnyWithProps>(databaseSchema: DatabaseSchema_, spec: Spec_) => Api<DatabaseSchema_, Spec_>;
-//#endregion
-export { Any, AnyWithProps, AnyWithPropsWithRuntime, Api, Api_d_exports, GetSpec, Groups, Schema, TypeId, isApi, make };
-//# sourceMappingURL=Api.d.ts.map

package/dist/Api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Api.d.ts","names":[],"sources":["../src/Api.ts"],"mappings":";;;;;;;;;cAOa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,KAAA,GAAS,CAAA,cAAa,CAAA,IAAK,GAAA;AAAA,UAEvB,GAAA,yBACS,cAAA,gBACV,IAAA,CAAK,YAAA;EAAA,UAET,MAAA,GAAS,MAAA;EAAA,SACV,IAAA,EAAM,KAAA;EAAA,SACN,cAAA,EAAgB,eAAA;EAAA,SAChB,sBAAA,EAAwB,gBAAA,CAAiB,aAAA;AAAA;AAAA,UAGnC,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,UAGJ,YAAA,SAAqB,GAAA,CACpC,cAAA,EACA,IAAA,CAAK,YAAA;AAAA,UAGU,uBAAA,iBACC,sBAAA,CAAuB,OAAA,UAC/B,GAAA,CACR,cAAA,EACA,IAAA,CAAK,uBAAA,CAAwB,OAAA;AAAA,KAGnB,MAAA,cAAoB,YAAA,IAAgB,IAAA;AAAA,KAEpC,OAAA,cAAqB,YAAA,IAAgB,IAAA;AAAA,KAErC,MAAA,cAAoB,YAAA,IAAgB,IAAA,CAAK,MAAA,CAAO,IAAA;AAAA,cA0B/C,IAAA,2BACa,cAAA,gBACV,IAAA,CAAK,YAAA,EAEnB,cAAA,EAAgB,eAAA,EAChB,IAAA,EAAM,KAAA,KACL,GAAA,CAAI,eAAA,EAAiB,KAAA"}

package/dist/Api.js

@@ -1,26 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Predicate, Record, pipe } from "effect";
-import { defineSchema } from "convex/server";
-
-//#region src/Api.ts
-var Api_exports = /* @__PURE__ */ __exportAll({
-	TypeId: () => TypeId,
-	isApi: () => isApi,
-	make: () => make
-});
-const TypeId = "@confect/server/Api";
-const isApi = (u) => Predicate.hasProperty(u, TypeId);
-const Proto = { [TypeId]: TypeId };
-const makeProto = ({ databaseSchema, spec }) => Object.assign(Object.create(Proto), {
-	databaseSchema,
-	spec,
-	convexSchemaDefinition: pipe(databaseSchema.tables, Record.map(({ tableDefinition }) => tableDefinition), defineSchema)
-});
-const make = (databaseSchema, spec) => makeProto({
-	databaseSchema,
-	spec
-});
-
-//#endregion
-export { Api_exports, TypeId, isApi, make };
-//# sourceMappingURL=Api.js.map