@gaganref/confect-server 0.0.0-stage → 10.3.1-fork.10

package/dist/Table.d.ts

@@ -0,0 +1,274 @@
+import type * as IdScope from "@confect/core/IdScope";
+import * as Table_ from "@confect/core/Table";
+import * as Schema from "effect/Schema";
+import { type TableDefinition } from "convex/server";
+export { TypeId, isTable, isUnnamedTable, make, type Table, type Any, type AnyWithProps, type UnnamedTable, type UnnamedAny, type UnnamedAnyWithProps, type Name, type TableSchema, type TableValidator, type Indexes, type SearchIndexes, type VectorIndexes, type Doc, type Fields, type Scope, type WithName, type TablesRecord, } from "@confect/core/Table";
+export declare const tableDefinition: <Table extends Table_.AnyWithProps>(table: Table) => TableDefinition<Table_.TableValidator<Table>, Table_.Indexes<Table>, Table_.SearchIndexes<Table>, Table_.VectorIndexes<Table>>;
+export declare const scheduledFunctionsTable: Table_.Table<"_scheduled_functions", Schema.Struct<{
+    readonly name: Schema.String;
+    readonly args: Schema.$Array<Schema.Any>;
+    readonly scheduledTime: Schema.Finite;
+    readonly completedTime: Schema.optionalKey<Schema.Finite>;
+    readonly state: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"pending">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"inProgress">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"success">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"failed">;
+        readonly error: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"canceled">;
+    }>]>;
+}>, import("convex/values").VObject<{
+    name: string;
+    args: any[];
+    scheduledTime: number;
+    completedTime?: number;
+    state: {
+        kind: "pending";
+    } | {
+        kind: "inProgress";
+    } | {
+        kind: "success";
+    } | {
+        kind: "failed";
+        error: string;
+    } | {
+        kind: "canceled";
+    };
+}, {
+    name: import("convex/values").VString<string, "required">;
+    args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+    scheduledTime: import("convex/values").VFloat64<number, "required">;
+    completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+    state: import("convex/values").VUnion<{
+        kind: "pending";
+    } | {
+        kind: "inProgress";
+    } | {
+        kind: "success";
+    } | {
+        kind: "failed";
+        error: string;
+    } | {
+        kind: "canceled";
+    }, [import("convex/values").VObject<{
+        kind: "pending";
+    }, {
+        kind: import("convex/values").VLiteral<"pending", "required">;
+    }, "required", "kind">, import("convex/values").VObject<{
+        kind: "inProgress";
+    }, {
+        kind: import("convex/values").VLiteral<"inProgress", "required">;
+    }, "required", "kind">, import("convex/values").VObject<{
+        kind: "success";
+    }, {
+        kind: import("convex/values").VLiteral<"success", "required">;
+    }, "required", "kind">, import("convex/values").VObject<{
+        kind: "failed";
+        error: string;
+    }, {
+        kind: import("convex/values").VLiteral<"failed", "required">;
+        error: import("convex/values").VString<string, "required">;
+    }, "required", "error" | "kind">, import("convex/values").VObject<{
+        kind: "canceled";
+    }, {
+        kind: import("convex/values").VLiteral<"canceled", "required">;
+    }, "required", "kind">], "required", "error" | "kind">;
+}, "required", "args" | "completedTime" | "name" | "scheduledTime" | "state" | "state.error" | "state.kind">, {}, {}, {}, IdScope.App>;
+export declare const storageTable: Table_.Table<"_storage", Schema.Struct<{
+    readonly sha256: Schema.String;
+    readonly size: Schema.Finite;
+    readonly contentType: Schema.optionalKey<Schema.String>;
+}>, import("convex/values").VObject<{
+    sha256: string;
+    size: number;
+    contentType?: string;
+}, {
+    sha256: import("convex/values").VString<string, "required">;
+    size: import("convex/values").VFloat64<number, "required">;
+    contentType: import("convex/values").VString<string | undefined, "optional">;
+}, "required", "contentType" | "sha256" | "size">, {}, {}, {}, IdScope.App>;
+export declare const systemTables: {
+    readonly _scheduled_functions: Table_.Table<"_scheduled_functions", Schema.Struct<{
+        readonly name: Schema.String;
+        readonly args: Schema.$Array<Schema.Any>;
+        readonly scheduledTime: Schema.Finite;
+        readonly completedTime: Schema.optionalKey<Schema.Finite>;
+        readonly state: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"pending">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"inProgress">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"success">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"failed">;
+            readonly error: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"canceled">;
+        }>]>;
+    }>, import("convex/values").VObject<{
+        name: string;
+        args: any[];
+        scheduledTime: number;
+        completedTime?: number;
+        state: {
+            kind: "pending";
+        } | {
+            kind: "inProgress";
+        } | {
+            kind: "success";
+        } | {
+            kind: "failed";
+            error: string;
+        } | {
+            kind: "canceled";
+        };
+    }, {
+        name: import("convex/values").VString<string, "required">;
+        args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+        scheduledTime: import("convex/values").VFloat64<number, "required">;
+        completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+        state: import("convex/values").VUnion<{
+            kind: "pending";
+        } | {
+            kind: "inProgress";
+        } | {
+            kind: "success";
+        } | {
+            kind: "failed";
+            error: string;
+        } | {
+            kind: "canceled";
+        }, [import("convex/values").VObject<{
+            kind: "pending";
+        }, {
+            kind: import("convex/values").VLiteral<"pending", "required">;
+        }, "required", "kind">, import("convex/values").VObject<{
+            kind: "inProgress";
+        }, {
+            kind: import("convex/values").VLiteral<"inProgress", "required">;
+        }, "required", "kind">, import("convex/values").VObject<{
+            kind: "success";
+        }, {
+            kind: import("convex/values").VLiteral<"success", "required">;
+        }, "required", "kind">, import("convex/values").VObject<{
+            kind: "failed";
+            error: string;
+        }, {
+            kind: import("convex/values").VLiteral<"failed", "required">;
+            error: import("convex/values").VString<string, "required">;
+        }, "required", "error" | "kind">, import("convex/values").VObject<{
+            kind: "canceled";
+        }, {
+            kind: import("convex/values").VLiteral<"canceled", "required">;
+        }, "required", "kind">], "required", "error" | "kind">;
+    }, "required", "args" | "completedTime" | "name" | "scheduledTime" | "state" | "state.error" | "state.kind">, {}, {}, {}, IdScope.App>;
+    readonly _storage: Table_.Table<"_storage", Schema.Struct<{
+        readonly sha256: Schema.String;
+        readonly size: Schema.Finite;
+        readonly contentType: Schema.optionalKey<Schema.String>;
+    }>, import("convex/values").VObject<{
+        sha256: string;
+        size: number;
+        contentType?: string;
+    }, {
+        sha256: import("convex/values").VString<string, "required">;
+        size: import("convex/values").VFloat64<number, "required">;
+        contentType: import("convex/values").VString<string | undefined, "optional">;
+    }, "required", "contentType" | "sha256" | "size">, {}, {}, {}, IdScope.App>;
+};
+declare const makeSystemTables: <const Scope_ extends IdScope.IdScope>(scope: Scope_) => {
+    _scheduled_functions: Table_.Table<"_scheduled_functions", Schema.Struct<{
+        readonly name: Schema.String;
+        readonly args: Schema.$Array<Schema.Any>;
+        readonly scheduledTime: Schema.Finite;
+        readonly completedTime: Schema.optionalKey<Schema.Finite>;
+        readonly state: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"pending">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"inProgress">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"success">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"failed">;
+            readonly error: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"canceled">;
+        }>]>;
+    }>, import("convex/values").VObject<{
+        name: string;
+        args: any[];
+        scheduledTime: number;
+        completedTime?: number;
+        state: {
+            kind: "pending";
+        } | {
+            kind: "inProgress";
+        } | {
+            kind: "success";
+        } | {
+            kind: "failed";
+            error: string;
+        } | {
+            kind: "canceled";
+        };
+    }, {
+        name: import("convex/values").VString<string, "required">;
+        args: import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">;
+        scheduledTime: import("convex/values").VFloat64<number, "required">;
+        completedTime: import("convex/values").VFloat64<number | undefined, "optional">;
+        state: import("convex/values").VUnion<{
+            kind: "pending";
+        } | {
+            kind: "inProgress";
+        } | {
+            kind: "success";
+        } | {
+            kind: "failed";
+            error: string;
+        } | {
+            kind: "canceled";
+        }, [import("convex/values").VObject<{
+            kind: "pending";
+        }, {
+            kind: import("convex/values").VLiteral<"pending", "required">;
+        }, "required", "kind">, import("convex/values").VObject<{
+            kind: "inProgress";
+        }, {
+            kind: import("convex/values").VLiteral<"inProgress", "required">;
+        }, "required", "kind">, import("convex/values").VObject<{
+            kind: "success";
+        }, {
+            kind: import("convex/values").VLiteral<"success", "required">;
+        }, "required", "kind">, import("convex/values").VObject<{
+            kind: "failed";
+            error: string;
+        }, {
+            kind: import("convex/values").VLiteral<"failed", "required">;
+            error: import("convex/values").VString<string, "required">;
+        }, "required", "error" | "kind">, import("convex/values").VObject<{
+            kind: "canceled";
+        }, {
+            kind: import("convex/values").VLiteral<"canceled", "required">;
+        }, "required", "kind">], "required", "error" | "kind">;
+    }, "required", "args" | "completedTime" | "name" | "scheduledTime" | "state" | "state.error" | "state.kind">, {}, {}, {}, Scope_>;
+    _storage: Table_.Table<"_storage", Schema.Struct<{
+        readonly sha256: Schema.String;
+        readonly size: Schema.Finite;
+        readonly contentType: Schema.optionalKey<Schema.String>;
+    }>, import("convex/values").VObject<{
+        sha256: string;
+        size: number;
+        contentType?: string;
+    }, {
+        sha256: import("convex/values").VString<string, "required">;
+        size: import("convex/values").VFloat64<number, "required">;
+        contentType: import("convex/values").VString<string | undefined, "optional">;
+    }, "required", "contentType" | "sha256" | "size">, {}, {}, {}, Scope_>;
+};
+export declare const systemTablesForScope: <const Scope_ extends IdScope.IdScope>(scope: Scope_) => ReturnType<typeof makeSystemTables<Scope_>>;
+export type SystemTables<Scope_ extends IdScope.IdScope = IdScope.App> = ReturnType<typeof systemTablesForScope<Scope_>>[keyof typeof systemTables];
+//# sourceMappingURL=Table.d.ts.map

package/dist/Table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Table.d.ts","sourceRoot":"","sources":["../src/Table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,uBAAuB,CAAC;AAEtD,OAAO,KAAK,MAAM,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAElE,OAAO,EACL,MAAM,EACN,OAAO,EACP,cAAc,EACd,IAAI,EACJ,KAAK,KAAK,EACV,KAAK,GAAG,EACR,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,mBAAmB,EACxB,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,GAAG,EACR,KAAK,MAAM,EACX,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAC;AAgB7B,eAAO,MAAM,eAAe,GAAI,KAAK,SAAS,MAAM,CAAC,YAAY,SACxD,KAAK,KACX,eAAe,CAChB,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,EAC5B,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EACrB,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,EAC3B,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAsC5B,CAAC;AAMF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sIAiBX,CAAC;AAE1B,eAAO,MAAM,YAAY;;;;;;;;;;;;2EAMZ,CAAC;AAEd,eAAO,MAAM,YAAY;aACvB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aACpB,QAAQ;;;;;;;;;;;;;CACA,CAAC;AAEX,QAAA,MAAM,gBAAgB,GAAI,KAAK,CAAC,MAAM,SAAS,OAAO,CAAC,OAAO,SACrD,MAAM;IAEb,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIpB,QAAQ;;;;;;;;;;;;;CACR,CAAC;AAOH,eAAO,MAAM,oBAAoB,GAAI,KAAK,CAAC,MAAM,SAAS,OAAO,CAAC,OAAO,SAChE,MAAM,KACZ,UAAU,CAAC,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAS5C,CAAC;AAEF,MAAM,MAAM,YAAY,CAAC,MAAM,SAAS,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,IACnE,UAAU,CAAC,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}

package/dist/Table.js

@@ -0,0 +1,70 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { defineTable } from "convex/server";
+import * as Schema from "effect/Schema";
+import { compileTableSchema } from "@confect/core/SchemaToValidator";
+import * as Table_ from "@confect/core/Table";
+import { TypeId, isTable, isUnnamedTable, make } from "@confect/core/Table";
+//#region src/Table.ts
+var Table_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	isTable: () => isTable,
+	isUnnamedTable: () => isUnnamedTable,
+	make: () => make,
+	scheduledFunctionsTable: () => scheduledFunctionsTable,
+	storageTable: () => storageTable,
+	systemTables: () => systemTables,
+	systemTablesForScope: () => systemTablesForScope,
+	tableDefinition: () => tableDefinition
+});
+const tableDefinitionCache = /* @__PURE__ */ new WeakMap();
+const tableDefinition = (table) => {
+	const cached = tableDefinitionCache.get(table);
+	if (cached !== void 0) return cached;
+	let definition = defineTable(compileTableSchema(table.Fields, table.scope));
+	for (const [name, indexFields] of Object.entries(table.indexes)) definition = definition.index(name, indexFields);
+	for (const [name, config] of Object.entries(table.searchIndexes)) definition = definition.searchIndex(name, config);
+	for (const [name, config] of Object.entries(table.vectorIndexes)) definition = definition.vectorIndex(name, config);
+	tableDefinitionCache.set(table, definition);
+	return definition;
+};
+const scheduledFunctionsTable = Table_.make(() => Schema.Struct({
+	name: Schema.String,
+	args: Schema.Array(Schema.Any),
+	scheduledTime: Schema.Finite,
+	completedTime: Schema.optionalKey(Schema.Finite),
+	state: Schema.Union([
+		Schema.Struct({ kind: Schema.Literal("pending") }),
+		Schema.Struct({ kind: Schema.Literal("inProgress") }),
+		Schema.Struct({ kind: Schema.Literal("success") }),
+		Schema.Struct({
+			kind: Schema.Literal("failed"),
+			error: Schema.String
+		}),
+		Schema.Struct({ kind: Schema.Literal("canceled") })
+	])
+}))("_scheduled_functions");
+const storageTable = Table_.make(() => Schema.Struct({
+	sha256: Schema.String,
+	size: Schema.Finite,
+	contentType: Schema.optionalKey(Schema.String)
+}))("_storage");
+const systemTables = {
+	_scheduled_functions: scheduledFunctionsTable,
+	_storage: storageTable
+};
+const makeSystemTables = (scope) => ({
+	_scheduled_functions: Table_.make(() => scheduledFunctionsTable.Fields)("_scheduled_functions", scope),
+	_storage: Table_.make(() => storageTable.Fields)("_storage", scope)
+});
+const systemTablesByScope = /* @__PURE__ */ new Map();
+const systemTablesForScope = (scope) => {
+	const cached = systemTablesByScope.get(scope);
+	if (cached !== void 0) return cached;
+	const tables = makeSystemTables(scope);
+	systemTablesByScope.set(scope, tables);
+	return tables;
+};
+//#endregion
+export { Table_exports, TypeId, isTable, isUnnamedTable, make, scheduledFunctionsTable, storageTable, systemTables, systemTablesForScope, tableDefinition };
+
+//# sourceMappingURL=Table.js.map

package/dist/Table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Table.js","names":[],"sources":["../src/Table.ts"],"sourcesContent":["import type * as IdScope from \"@confect/core/IdScope\";\nimport { compileTableSchema } from \"@confect/core/SchemaToValidator\";\nimport * as Table_ from \"@confect/core/Table\";\nimport * as Schema from \"effect/Schema\";\nimport { defineTable, type TableDefinition } from \"convex/server\";\n\nexport {\n  TypeId,\n  isTable,\n  isUnnamedTable,\n  make,\n  type Table,\n  type Any,\n  type AnyWithProps,\n  type UnnamedTable,\n  type UnnamedAny,\n  type UnnamedAnyWithProps,\n  type Name,\n  type TableSchema,\n  type TableValidator,\n  type Indexes,\n  type SearchIndexes,\n  type VectorIndexes,\n  type Doc,\n  type Fields,\n  type Scope,\n  type WithName,\n  type TablesRecord,\n} from \"@confect/core/Table\";\n\n// -----------------------------------------------------------------------------\n// tableDefinition\n// -----------------------------------------------------------------------------\n//\n// The deploy-time Convex `TableDefinition` is the part of a table that\n// belongs on the server: it value-imports `defineTable` from `convex/server`.\n// Specs and generated refs reach `Fields`/`Doc` through `@confect/core`,\n// so this helper is only called from `_generated/convexSchema.ts`.\n\nconst tableDefinitionCache = new WeakMap<\n  Table_.AnyWithProps,\n  TableDefinition<any, any, any, any>\n>();\n\nexport const tableDefinition = <Table extends Table_.AnyWithProps>(\n  table: Table,\n): TableDefinition<\n  Table_.TableValidator<Table>,\n  Table_.Indexes<Table>,\n  Table_.SearchIndexes<Table>,\n  Table_.VectorIndexes<Table>\n> => {\n  const cached = tableDefinitionCache.get(table);\n  if (cached !== undefined) {\n    return cached as TableDefinition<\n      Table_.TableValidator<Table>,\n      Table_.Indexes<Table>,\n      Table_.SearchIndexes<Table>,\n      Table_.VectorIndexes<Table>\n    >;\n  }\n\n  let definition: TableDefinition<any, any, any, any> = defineTable(\n    compileTableSchema(table.Fields, table.scope),\n  );\n  for (const [name, indexFields] of Object.entries(\n    table.indexes as Record<string, any>,\n  )) {\n    definition = definition.index(name, indexFields);\n  }\n  for (const [name, config] of Object.entries(\n    table.searchIndexes as Record<string, any>,\n  )) {\n    definition = definition.searchIndex(name, config);\n  }\n  for (const [name, config] of Object.entries(\n    table.vectorIndexes as Record<string, any>,\n  )) {\n    definition = definition.vectorIndex(name, config);\n  }\n\n  tableDefinitionCache.set(table, definition);\n  return definition as TableDefinition<\n    Table_.TableValidator<Table>,\n    Table_.Indexes<Table>,\n    Table_.SearchIndexes<Table>,\n    Table_.VectorIndexes<Table>\n  >;\n};\n\n// -----------------------------------------------------------------------------\n// System tables\n// -----------------------------------------------------------------------------\n\nexport const scheduledFunctionsTable = Table_.make(() =>\n  Schema.Struct({\n    name: Schema.String,\n    args: Schema.Array(Schema.Any),\n    scheduledTime: Schema.Finite,\n    completedTime: Schema.optionalKey(Schema.Finite),\n    state: Schema.Union([\n      Schema.Struct({ kind: Schema.Literal(\"pending\") }),\n      Schema.Struct({ kind: Schema.Literal(\"inProgress\") }),\n      Schema.Struct({ kind: Schema.Literal(\"success\") }),\n      Schema.Struct({\n        kind: Schema.Literal(\"failed\"),\n        error: Schema.String,\n      }),\n      Schema.Struct({ kind: Schema.Literal(\"canceled\") }),\n    ]),\n  }),\n)(\"_scheduled_functions\");\n\nexport const storageTable = Table_.make(() =>\n  Schema.Struct({\n    sha256: Schema.String,\n    size: Schema.Finite,\n    contentType: Schema.optionalKey(Schema.String),\n  }),\n)(\"_storage\");\n\nexport const systemTables = {\n  _scheduled_functions: scheduledFunctionsTable,\n  _storage: storageTable,\n} as const;\n\nconst makeSystemTables = <const Scope_ extends IdScope.IdScope>(\n  scope: Scope_,\n) => ({\n  _scheduled_functions: Table_.make(() => scheduledFunctionsTable.Fields)(\n    \"_scheduled_functions\",\n    scope,\n  ),\n  _storage: Table_.make(() => storageTable.Fields)(\"_storage\", scope),\n});\n\nconst systemTablesByScope = new Map<\n  IdScope.IdScope,\n  Record<keyof typeof systemTables, Table_.AnyWithProps>\n>();\n\nexport const systemTablesForScope = <const Scope_ extends IdScope.IdScope>(\n  scope: Scope_,\n): ReturnType<typeof makeSystemTables<Scope_>> => {\n  const cached = systemTablesByScope.get(scope);\n  if (cached !== undefined) {\n    // Each cache key is the scope used to construct both tables.\n    return cached as ReturnType<typeof makeSystemTables<Scope_>>;\n  }\n  const tables = makeSystemTables(scope);\n  systemTablesByScope.set(scope, tables);\n  return tables;\n};\n\nexport type SystemTables<Scope_ extends IdScope.IdScope = IdScope.App> =\n  ReturnType<typeof systemTablesForScope<Scope_>>[keyof typeof systemTables];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuCA,MAAM,uCAAuB,IAAI,QAG/B;AAEF,MAAa,mBACX,UAMG;CACH,MAAM,SAAS,qBAAqB,IAAI,KAAK;CAC7C,IAAI,WAAW,KAAA,GACb,OAAO;CAQT,IAAI,aAAkD,YACpD,mBAAmB,MAAM,QAAQ,MAAM,KAAK,CAC9C;CACA,KAAK,MAAM,CAAC,MAAM,gBAAgB,OAAO,QACvC,MAAM,OACR,GACE,aAAa,WAAW,MAAM,MAAM,WAAW;CAEjD,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAClC,MAAM,aACR,GACE,aAAa,WAAW,YAAY,MAAM,MAAM;CAElD,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAClC,MAAM,aACR,GACE,aAAa,WAAW,YAAY,MAAM,MAAM;CAGlD,qBAAqB,IAAI,OAAO,UAAU;CAC1C,OAAO;AAMT;AAMA,MAAa,0BAA0B,OAAO,WAC5C,OAAO,OAAO;CACZ,MAAM,OAAO;CACb,MAAM,OAAO,MAAM,OAAO,GAAG;CAC7B,eAAe,OAAO;CACtB,eAAe,OAAO,YAAY,OAAO,MAAM;CAC/C,OAAO,OAAO,MAAM;EAClB,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,SAAS,EAAE,CAAC;EACjD,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,YAAY,EAAE,CAAC;EACpD,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,SAAS,EAAE,CAAC;EACjD,OAAO,OAAO;GACZ,MAAM,OAAO,QAAQ,QAAQ;GAC7B,OAAO,OAAO;EAChB,CAAC;EACD,OAAO,OAAO,EAAE,MAAM,OAAO,QAAQ,UAAU,EAAE,CAAC;CACpD,CAAC;AACH,CAAC,CACH,CAAC,CAAC,sBAAsB;AAExB,MAAa,eAAe,OAAO,WACjC,OAAO,OAAO;CACZ,QAAQ,OAAO;CACf,MAAM,OAAO;CACb,aAAa,OAAO,YAAY,OAAO,MAAM;AAC/C,CAAC,CACH,CAAC,CAAC,UAAU;AAEZ,MAAa,eAAe;CAC1B,sBAAsB;CACtB,UAAU;AACZ;AAEA,MAAM,oBACJ,WACI;CACJ,sBAAsB,OAAO,WAAW,wBAAwB,MAAM,CAAC,CACrE,wBACA,KACF;CACA,UAAU,OAAO,WAAW,aAAa,MAAM,CAAC,CAAC,YAAY,KAAK;AACpE;AAEA,MAAM,sCAAsB,IAAI,IAG9B;AAEF,MAAa,wBACX,UACgD;CAChD,MAAM,SAAS,oBAAoB,IAAI,KAAK;CAC5C,IAAI,WAAW,KAAA,GAEb,OAAO;CAET,MAAM,SAAS,iBAAiB,KAAK;CACrC,oBAAoB,IAAI,OAAO,MAAM;CACrC,OAAO;AACT"}

package/dist/TableInfo.d.ts

@@ -0,0 +1,44 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { GenericDocument, GenericFieldPaths, GenericTableIndexes, GenericTableSearchIndexes, GenericTableVectorIndexes, IdField, SystemFields, SystemIndexes } from "convex/server";
+import type { GenericValidator } from "convex/values";
+import type { Schema, Types } from "effect";
+import type { WithSystemFields } from "@confect/core/SystemFields";
+import type * as Document_ from "./Document.js";
+import type * as Table from "./Table.js";
+export declare const TypeId: "~@confect/server/TableInfo";
+export type TypeId = typeof TypeId;
+export type TableInfo<Table_ extends Table.AnyWithProps> = Table_ extends Table.Table<infer TableName, infer TableSchema_, infer TableValidator, infer Indexes, infer SearchIndexes, infer VectorIndexes, infer Scope> ? {
+    readonly [TypeId]: TypeId;
+    readonly document: WithSystemFields<TableName, Schema.Schema.Type<TableSchema_>, Scope>;
+    readonly encodedDocument: WithSystemFields<TableName, Schema.Codec.Encoded<TableSchema_>, Scope>;
+    readonly convexDocument: ExtractConvexDocument<TableName, TableValidator, Scope>;
+    readonly fieldPaths: keyof IdField<TableName> | ExtractFieldPaths<TableValidator>;
+    readonly indexes: Types.Simplify<Indexes & SystemIndexes>;
+    readonly searchIndexes: SearchIndexes;
+    readonly vectorIndexes: VectorIndexes;
+} : never;
+export interface Any {
+    readonly [TypeId]: TypeId;
+}
+export interface AnyWithProps extends Any {
+    readonly document: Document_.Any;
+    readonly encodedDocument: Document_.AnyEncoded;
+    readonly convexDocument: GenericDocument;
+    readonly fieldPaths: GenericFieldPaths;
+    readonly indexes: GenericTableIndexes;
+    readonly searchIndexes: GenericTableSearchIndexes;
+    readonly vectorIndexes: GenericTableVectorIndexes;
+}
+export type ConvexTableInfo<TableInfo_ extends AnyWithProps> = {
+    document: TableInfo_["convexDocument"];
+    fieldPaths: TableInfo_["fieldPaths"];
+    indexes: TableInfo_["indexes"];
+    searchIndexes: TableInfo_["searchIndexes"];
+    vectorIndexes: TableInfo_["vectorIndexes"];
+};
+export type TableSchema<TableInfo_ extends AnyWithProps> = Schema.Codec<TableInfo_["document"], TableInfo_["encodedDocument"]>;
+export type Document<TableInfo_ extends AnyWithProps> = TableInfo_["document"];
+type ExtractFieldPaths<TableValidator extends GenericValidator> = TableValidator["fieldPaths"] | keyof SystemFields;
+type ExtractConvexDocument<TableName extends string, TableValidator extends GenericValidator, Scope extends IdScope.IdScope = IdScope.App> = WithSystemFields<TableName, TableValidator["type"], Scope> extends GenericDocument ? WithSystemFields<TableName, TableValidator["type"], Scope> : never;
+export {};
+//# sourceMappingURL=TableInfo.d.ts.map

package/dist/TableInfo.d.ts.map

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

package/dist/TableInfo.js

@@ -0,0 +1,7 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+//#region src/TableInfo.ts
+var TableInfo_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+export { TableInfo_exports };
+
+//# sourceMappingURL=TableInfo.js.map

package/dist/TableInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableInfo.js","names":[],"sources":["../src/TableInfo.ts"],"sourcesContent":["import type * as IdScope from \"@confect/core/IdScope\";\nimport type {\n  GenericDocument,\n  GenericFieldPaths,\n  GenericTableIndexes,\n  GenericTableSearchIndexes,\n  GenericTableVectorIndexes,\n  IdField,\n  SystemFields,\n  SystemIndexes,\n} from \"convex/server\";\nimport type { GenericValidator } from \"convex/values\";\nimport type { Schema, Types } from \"effect\";\nimport type { WithSystemFields } from \"@confect/core/SystemFields\";\nimport type * as Document_ from \"./Document.js\";\nimport type * as Table from \"./Table.js\";\n\nexport declare const TypeId: \"~@confect/server/TableInfo\";\nexport type TypeId = typeof TypeId;\n\nexport type TableInfo<Table_ extends Table.AnyWithProps> =\n  Table_ extends Table.Table<\n    infer TableName,\n    infer TableSchema_,\n    infer TableValidator,\n    infer Indexes,\n    infer SearchIndexes,\n    infer VectorIndexes,\n    infer Scope\n  >\n    ? {\n        readonly [TypeId]: TypeId;\n        readonly document: WithSystemFields<\n          TableName,\n          Schema.Schema.Type<TableSchema_>,\n          Scope\n        >;\n        readonly encodedDocument: WithSystemFields<\n          TableName,\n          Schema.Codec.Encoded<TableSchema_>,\n          Scope\n        >;\n        readonly convexDocument: ExtractConvexDocument<\n          TableName,\n          TableValidator,\n          Scope\n        >;\n        readonly fieldPaths:\n          | keyof IdField<TableName>\n          | ExtractFieldPaths<TableValidator>;\n        readonly indexes: Types.Simplify<Indexes & SystemIndexes>;\n        readonly searchIndexes: SearchIndexes;\n        readonly vectorIndexes: VectorIndexes;\n      }\n    : never;\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport interface AnyWithProps extends Any {\n  readonly document: Document_.Any;\n  readonly encodedDocument: Document_.AnyEncoded;\n  readonly convexDocument: GenericDocument;\n  readonly fieldPaths: GenericFieldPaths;\n  readonly indexes: GenericTableIndexes;\n  readonly searchIndexes: GenericTableSearchIndexes;\n  readonly vectorIndexes: GenericTableVectorIndexes;\n}\n\nexport type ConvexTableInfo<TableInfo_ extends AnyWithProps> = {\n  document: TableInfo_[\"convexDocument\"];\n  fieldPaths: TableInfo_[\"fieldPaths\"];\n  indexes: TableInfo_[\"indexes\"];\n  searchIndexes: TableInfo_[\"searchIndexes\"];\n  vectorIndexes: TableInfo_[\"vectorIndexes\"];\n};\n\nexport type TableSchema<TableInfo_ extends AnyWithProps> = Schema.Codec<\n  TableInfo_[\"document\"],\n  TableInfo_[\"encodedDocument\"]\n>;\n\nexport type Document<TableInfo_ extends AnyWithProps> = TableInfo_[\"document\"];\n\n// Vendored types from convex-js, partially modified.\n// See https://github.com/get-convex/convex-js/pull/14\n\ntype ExtractFieldPaths<TableValidator extends GenericValidator> =\n  | TableValidator[\"fieldPaths\"]\n  | keyof SystemFields;\n\ntype ExtractConvexDocument<\n  TableName extends string,\n  TableValidator extends GenericValidator,\n  Scope extends IdScope.IdScope = IdScope.App,\n> =\n  WithSystemFields<\n    TableName,\n    TableValidator[\"type\"],\n    Scope\n  > extends GenericDocument\n    ? WithSystemFields<TableName, TableValidator[\"type\"], Scope>\n    : never;\n\n// End of vendored types from convex-js, partially modified.\n"],"mappings":""}

package/dist/TransactionMetadata.d.ts

@@ -0,0 +1,12 @@
+import type { QueryMeta } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+export type { TransactionMetric, TransactionMetrics } from "convex/server";
+declare const TransactionMetadata_base: Context.ServiceClass<TransactionMetadata, "@confect/server/TransactionMetadata", {
+    getMetrics: () => Effect.Effect<import("convex/server").TransactionMetrics, never, never>;
+}>;
+export declare class TransactionMetadata extends TransactionMetadata_base {
+}
+export declare const layer: (meta: Pick<QueryMeta, "getTransactionMetrics">) => Layer.Layer<TransactionMetadata, never, never>;
+//# sourceMappingURL=TransactionMetadata.d.ts.map

package/dist/TransactionMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionMetadata.d.ts","sourceRoot":"","sources":["../src/TransactionMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;;;;AAQ3E,qBAAa,mBAAoB,SAAQ,wBAGC;CAAG;AAE7C,eAAO,MAAM,KAAK,SAAU,IAAI,CAAC,SAAS,EAAE,uBAAuB,CAAC,mDACpB,CAAC"}

package/dist/TransactionMetadata.js

@@ -0,0 +1,16 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+//#region src/TransactionMetadata.ts
+var TransactionMetadata_exports = /* @__PURE__ */ __exportAll({
+	TransactionMetadata: () => TransactionMetadata,
+	layer: () => layer
+});
+const make = (meta) => ({ getMetrics: Effect.fn("TransactionMetadata.getMetrics")(() => Effect.promise(() => meta.getTransactionMetrics())) });
+var TransactionMetadata = class extends Context.Service()("@confect/server/TransactionMetadata") {};
+const layer = (meta) => Layer.succeed(TransactionMetadata, make(meta));
+//#endregion
+export { TransactionMetadata, TransactionMetadata_exports, layer };
+
+//# sourceMappingURL=TransactionMetadata.js.map

package/dist/TransactionMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionMetadata.js","names":[],"sources":["../src/TransactionMetadata.ts"],"sourcesContent":["import type { QueryMeta } from \"convex/server\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\n\nexport type { TransactionMetric, TransactionMetrics } from \"convex/server\";\n\nconst make = (meta: Pick<QueryMeta, \"getTransactionMetrics\">) => ({\n  getMetrics: Effect.fn(\"TransactionMetadata.getMetrics\")(() =>\n    Effect.promise(() => meta.getTransactionMetrics()),\n  ),\n});\n\nexport class TransactionMetadata extends Context.Service<\n  TransactionMetadata,\n  ReturnType<typeof make>\n>()(\"@confect/server/TransactionMetadata\") {}\n\nexport const layer = (meta: Pick<QueryMeta, \"getTransactionMetrics\">) =>\n  Layer.succeed(TransactionMetadata, make(meta));\n"],"mappings":";;;;;;;;;AAOA,MAAM,QAAQ,UAAoD,EAChE,YAAY,OAAO,GAAG,gCAAgC,CAAC,OACrD,OAAO,cAAc,KAAK,sBAAsB,CAAC,CACnD,EACF;AAEA,IAAa,sBAAb,cAAyC,QAAQ,QAG/C,CAAC,CAAC,qCAAqC,CAAC,CAAC,CAAC;AAE5C,MAAa,SAAS,SACpB,MAAM,QAAQ,qBAAqB,KAAK,IAAI,CAAC"}

package/dist/VectorSearch.d.ts

@@ -0,0 +1,23 @@
+import type { Expand, GenericActionCtx, NamedTableInfo, VectorIndexNames, VectorSearchQuery } from "convex/server";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as DataModel from "./DataModel.js";
+type ConvexVectorSearch<DataModel_ extends DataModel.AnyWithProps> = GenericActionCtx<DataModel.ToConvex<DataModel_>>["vectorSearch"];
+/**
+ * The service shape backing the `VectorSearch` tag. Named so declaration emit
+ * references it instead of expanding the call signature at every usage.
+ */
+export interface VectorSearchService<DataModel_ extends DataModel.AnyWithProps> {
+    <TableName extends DataModel.TableNames<DataModel_>, IndexName extends VectorIndexNames<NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>>>(tableName: TableName, indexName: IndexName, query: Expand<VectorSearchQuery<NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>, IndexName>>): Effect.Effect<Array<{
+        _id: DataModel.Id<DataModel_, TableName>;
+        _score: number;
+    }>>;
+}
+export type VectorSearchTag<DataModel_ extends DataModel.AnyWithProps> = Context.Service<VectorSearchService<DataModel_>, VectorSearchService<DataModel_>>;
+export declare const make: <DataModel_ extends DataModel.AnyWithProps>(vectorSearch: ConvexVectorSearch<DataModel_>) => VectorSearchService<DataModel_>;
+export declare const VectorSearch: <DataModel_ extends DataModel.AnyWithProps>() => VectorSearchTag<DataModel_>;
+export type VectorSearch<DataModel_ extends DataModel.AnyWithProps> = VectorSearchService<DataModel_>;
+export declare const layer: <DataModel_ extends DataModel.AnyWithProps>(vectorSearch: ConvexVectorSearch<DataModel_>) => Layer.Layer<VectorSearchService<DataModel_>, never, never>;
+export {};
+//# sourceMappingURL=VectorSearch.d.ts.map

package/dist/VectorSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorSearch.d.ts","sourceRoot":"","sources":["../src/VectorSearch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAEjD,KAAK,kBAAkB,CAAC,UAAU,SAAS,SAAS,CAAC,YAAY,IAC/D,gBAAgB,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;AAEnE;;;GAGG;AACH,MAAM,WAAW,mBAAmB,CAClC,UAAU,SAAS,SAAS,CAAC,YAAY;IAEzC,CACE,SAAS,SAAS,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,EAClD,SAAS,SAAS,gBAAgB,CAChC,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC,CAC1D,EAED,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,CACX,iBAAiB,CACf,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,CAAC,EACzD,SAAS,CACV,CACF,GACA,MAAM,CAAC,MAAM,CACd,KAAK,CAAC;QAAE,GAAG,EAAE,SAAS,CAAC,EAAE,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CACpE,CAAC;CACH;AAED,MAAM,MAAM,eAAe,CAAC,UAAU,SAAS,SAAS,CAAC,YAAY,IACnE,OAAO,CAAC,OAAO,CACb,mBAAmB,CAAC,UAAU,CAAC,EAC/B,mBAAmB,CAAC,UAAU,CAAC,CAChC,CAAC;AAEJ,eAAO,MAAM,IAAI,GACd,UAAU,SAAS,SAAS,CAAC,YAAY,gBAC1B,kBAAkB,CAAC,UAAU,CAAC,KAC3C,mBAAmB,CAAC,UAAU,CAU9B,CAAC;AAEN,eAAO,MAAM,YAAY,GACvB,UAAU,SAAS,SAAS,CAAC,YAAY,OACtC,eAAe,CAAC,UAAU,CAG5B,CAAC;AAEJ,MAAM,MAAM,YAAY,CAAC,UAAU,SAAS,SAAS,CAAC,YAAY,IAChE,mBAAmB,CAAC,UAAU,CAAC,CAAC;AAElC,eAAO,MAAM,KAAK,GAAI,UAAU,SAAS,SAAS,CAAC,YAAY,gBAC/C,kBAAkB,CAAC,UAAU,CAAC,+DACoB,CAAC"}

package/dist/VectorSearch.js

@@ -0,0 +1,17 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+//#region src/VectorSearch.ts
+var VectorSearch_exports = /* @__PURE__ */ __exportAll({
+	VectorSearch: () => VectorSearch,
+	layer: () => layer,
+	make: () => make
+});
+const make = (vectorSearch) => (tableName, indexName, query) => Effect.promise(() => vectorSearch(tableName, indexName, query)).pipe(Effect.map((rows) => rows));
+const VectorSearch = () => Context.Service("@confect/server/VectorSearch");
+const layer = (vectorSearch) => Layer.succeed(VectorSearch(), make(vectorSearch));
+//#endregion
+export { VectorSearch, VectorSearch_exports, layer, make };
+
+//# sourceMappingURL=VectorSearch.js.map

package/dist/VectorSearch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VectorSearch.js","names":[],"sources":["../src/VectorSearch.ts"],"sourcesContent":["import type {\n  Expand,\n  GenericActionCtx,\n  NamedTableInfo,\n  VectorIndexNames,\n  VectorSearchQuery,\n} from \"convex/server\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport type * as DataModel from \"./DataModel.js\";\n\ntype ConvexVectorSearch<DataModel_ extends DataModel.AnyWithProps> =\n  GenericActionCtx<DataModel.ToConvex<DataModel_>>[\"vectorSearch\"];\n\n/**\n * The service shape backing the `VectorSearch` tag. Named so declaration emit\n * references it instead of expanding the call signature at every usage.\n */\nexport interface VectorSearchService<\n  DataModel_ extends DataModel.AnyWithProps,\n> {\n  <\n    TableName extends DataModel.TableNames<DataModel_>,\n    IndexName extends VectorIndexNames<\n      NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>\n    >,\n  >(\n    tableName: TableName,\n    indexName: IndexName,\n    query: Expand<\n      VectorSearchQuery<\n        NamedTableInfo<DataModel.ToConvex<DataModel_>, TableName>,\n        IndexName\n      >\n    >,\n  ): Effect.Effect<\n    Array<{ _id: DataModel.Id<DataModel_, TableName>; _score: number }>\n  >;\n}\n\nexport type VectorSearchTag<DataModel_ extends DataModel.AnyWithProps> =\n  Context.Service<\n    VectorSearchService<DataModel_>,\n    VectorSearchService<DataModel_>\n  >;\n\nexport const make =\n  <DataModel_ extends DataModel.AnyWithProps>(\n    vectorSearch: ConvexVectorSearch<DataModel_>,\n  ): VectorSearchService<DataModel_> =>\n  (tableName, indexName, query) =>\n    Effect.promise(() => vectorSearch(tableName, indexName, query)).pipe(\n      Effect.map(\n        (rows) =>\n          rows as unknown as Array<{\n            _id: DataModel.Id<DataModel_, typeof tableName>;\n            _score: number;\n          }>,\n      ),\n    );\n\nexport const VectorSearch = <\n  DataModel_ extends DataModel.AnyWithProps,\n>(): VectorSearchTag<DataModel_> =>\n  Context.Service<VectorSearchService<DataModel_>>(\n    \"@confect/server/VectorSearch\",\n  );\n\nexport type VectorSearch<DataModel_ extends DataModel.AnyWithProps> =\n  VectorSearchService<DataModel_>;\n\nexport const layer = <DataModel_ extends DataModel.AnyWithProps>(\n  vectorSearch: ConvexVectorSearch<DataModel_>,\n) => Layer.succeed(VectorSearch<DataModel_>(), make(vectorSearch));\n"],"mappings":";;;;;;;;;;AA+CA,MAAa,QAET,kBAED,WAAW,WAAW,UACrB,OAAO,cAAc,aAAa,WAAW,WAAW,KAAK,CAAC,CAAC,CAAC,KAC9D,OAAO,KACJ,SACC,IAIJ,CACF;AAEJ,MAAa,qBAGX,QAAQ,QACN,8BACF;AAKF,MAAa,SACX,iBACG,MAAM,QAAQ,aAAyB,GAAG,KAAK,YAAY,CAAC"}

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+export * as AiGatewayDecisionClient from "./AiGatewayDecisionClient.js";
+export * as AiGatewayDecisionModel from "./AiGatewayDecisionModel.js";
+export * as AiGatewayLanguageClient from "./AiGatewayLanguageClient.js";
+export * as AiGatewayLanguageModel from "./AiGatewayLanguageModel.js";
+export * as ActionCtx from "./ActionCtx.js";
+export * as ActionRunner from "./ActionRunner.js";
+export * as Auth from "./Auth.js";
+export * as BlobNotFoundError from "./BlobNotFoundError.js";
+export * as Callback from "./Callback.js";
+export * as ConvexConfigProvider from "./ConvexConfigProvider.js";
+export * as ConvexFunctionDefinitions from "./ConvexFunctionDefinitions.js";
+export * as ConvexLogger from "./ConvexLogger.js";
+export * as CronJob from "./CronJob.js";
+export * as CronJobs from "./CronJobs.js";
+export * as DatabaseReader from "./DatabaseReader.js";
+export * as DatabaseSchema from "./DatabaseSchema.js";
+export * as DatabaseWriter from "./DatabaseWriter.js";
+export * as DataModel from "./DataModel.js";
+export * as Document from "./Document.js";
+export * as ExecutionMetadata from "./ExecutionMetadata.js";
+export * as FunctionImpl from "./FunctionImpl.js";
+export * as FunctionRegistryItem from "./FunctionRegistryItem.js";
+export * as GroupImpl from "./GroupImpl.js";
+export * as Handler from "./Handler.js";
+export * as HttpRouter from "./HttpRouter.js";
+export * as MiddlewareImpl from "./MiddlewareImpl.js";
+export * as MiddlewareRegistryItem from "./MiddlewareRegistryItem.js";
+export * as MutationCtx from "./MutationCtx.js";
+export * as MutationRunner from "./MutationRunner.js";
+export * as MutationTransactionContext from "./MutationTransactionContext.js";
+export * as OrderedQuery from "./OrderedQuery.js";
+export * as QueryCtx from "./QueryCtx.js";
+export * as QueryInitializer from "./QueryInitializer.js";
+export * as QueryRunner from "./QueryRunner.js";
+export * as QueryTransactionContext from "./QueryTransactionContext.js";
+/**
+ * @experimental
+ */
+export * as QueryStream from "./QueryStream.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamCursor from "./QueryStreamCursor.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyLabels from "./QueryStreamKeyLabels.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyLayout from "./QueryStreamKeyLayout.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamOrderDirection from "./QueryStreamOrderDirection.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyValues from "./QueryStreamKeyValues.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamKeyBounds from "./QueryStreamKeyBounds.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamIndexRange from "./QueryStreamIndexRange.js";
+/**
+ * @experimental
+ */
+export * as QueryStreamReadBudget from "./QueryStreamReadBudget.js";
+export * as RegisteredConvexFunction from "./RegisteredConvexFunction.js";
+export * as RegisteredFunction from "./RegisteredFunction.js";
+export * as RegisteredFunctions from "./RegisteredFunctions.js";
+export * as Registry from "./Registry.js";
+export * as RegistryItems from "./RegistryItems.js";
+export * as ResolvedMiddleware from "./ResolvedMiddleware.js";
+export * as RequestMetadata from "./RequestMetadata.js";
+export * as Scheduler from "./Scheduler.js";
+export * as Storage from "./Storage.js";
+export * as StorageActionWriter from "./StorageActionWriter.js";
+export * as StorageReader from "./StorageReader.js";
+export * as StorageWriter from "./StorageWriter.js";
+export * as Table from "./Table.js";
+export * as TableInfo from "./TableInfo.js";
+export * as TransactionMetadata from "./TransactionMetadata.js";
+export * as VectorSearch from "./VectorSearch.js";
+//# sourceMappingURL=index.d.ts.map