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

package/dist/Callback.js

@@ -0,0 +1,182 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Ref from "@confect/core/Ref";
+import * as Effect from "effect/Effect";
+import { createFunctionHandle } from "convex/server";
+import * as Schema from "effect/Schema";
+import { pipe } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Callback from "@confect/core/Callback";
+import * as MiddlewareSpec from "@confect/core/MiddlewareSpec";
+import { UnsupportedPropertySignatureKeyTypeError, compileAst } from "@confect/core/SchemaToValidator";
+import { convexToJson, v } from "convex/values";
+import * as Array from "effect/Array";
+import * as Number from "effect/Number";
+import * as Order from "effect/Order";
+import * as Predicate from "effect/Predicate";
+import * as Result from "effect/Result";
+import * as SchemaAST from "effect/SchemaAST";
+//#region src/Callback.ts
+var Callback_exports = /* @__PURE__ */ __exportAll({
+	CallbackContractMismatch: () => CallbackContractMismatch,
+	create: () => create
+});
+/**
+* The host function does not satisfy the contract on one side. `expected` and
+* `actual` describe the contract's and the host's validators, with union
+* members in a fixed order, or the reason a schema is unsupported.
+*/
+var CallbackContractMismatch = class extends Schema.TaggedError()("CallbackContractMismatch", {
+	contract: Schema.String,
+	side: Schema.Literals([
+		"args",
+		"returns",
+		"error"
+	]),
+	expected: Schema.Json,
+	actual: Schema.Json
+}) {
+	get message() {
+		return `The host function does not satisfy callback contract "${this.contract}": its ${this.side === "error" ? "errors" : this.side} compile to ${JSON.stringify(this.actual)}, the contract's to ${JSON.stringify(this.expected)}.`;
+	}
+};
+const alternatives = (validator) => validator.kind === "union" ? validator.members.flatMap(alternatives) : [validator];
+const literalKinds = {
+	string: "string",
+	number: "float64",
+	bigint: "int64",
+	boolean: "boolean"
+};
+/**
+* The alternatives `validators` accept, without those another alternative
+* already covers: everything under `v.any()`, and a literal under its base
+* kind. `true` and `false` together are `v.boolean()`.
+*/
+const alternativesOf = (validators) => {
+	const flat = validators.flatMap(alternatives);
+	if (flat.some(({ kind }) => kind === "any")) return [v.any()];
+	const booleans = new Set(flat.flatMap((validator) => validator.kind === "literal" && typeof validator.value === "boolean" ? [validator.value] : []));
+	const widened = booleans.has(true) && booleans.has(false) ? [...flat, v.boolean()] : flat;
+	const kinds = new Set(widened.map(({ kind }) => kind));
+	return widened.filter((validator) => validator.kind !== "literal" || !kinds.has(literalKinds[typeof validator.value] ?? ""));
+};
+const keyed = (described) => pipe(described, Array.map((json) => [JSON.stringify(json), json]), Array.dedupeWith(([a], [b]) => a === b), Array.sortWith(([key]) => key, Order.String));
+/**
+* The distinct alternatives `validators` accept, keyed by their description and
+* sorted by it, so union order and repetition do not count as differences.
+*/
+const membersOf = (validators) => keyed(alternativesOf(validators).map(describe));
+const unionOf = (members) => {
+	const [only, ...rest] = members;
+	return only !== void 0 && rest.length === 0 ? only[1] : {
+		kind: "union",
+		members: members.map(([, described]) => described)
+	};
+};
+const describe = (validator) => {
+	switch (validator.kind) {
+		case "id": return {
+			kind: "id",
+			tableName: validator.tableName
+		};
+		case "literal": return {
+			kind: "literal",
+			value: convexToJson(validator.value)
+		};
+		case "array": return {
+			kind: "array",
+			element: describe(validator.element)
+		};
+		case "record": return {
+			kind: "record",
+			key: describe(validator.key),
+			value: describe(validator.value)
+		};
+		case "object": return {
+			kind: "object",
+			fields: Object.fromEntries(pipe(Object.entries(validator.fields), Array.sortWith(([name]) => name, Order.String), Array.map(([name, field]) => [name, field.isOptional === "optional" ? {
+				kind: "optional",
+				value: describe(field)
+			} : describe(field)])))
+		};
+		case "union": return unionOf(membersOf([validator]));
+		default: return { kind: validator.kind };
+	}
+};
+const ownError = (provenance) => "error" in provenance && provenance.error !== void 0 ? [provenance.error] : [];
+const errorAlternatives = (schema) => SchemaAST.isUnion(schema.ast) && Predicate.hasProperty(schema, "members") && Array.isArray(schema.members) ? schema.members.flatMap((member) => Schema.isSchema(member) ? errorAlternatives(member) : []) : [schema];
+/**
+* Compile args field by field, as registration does, so a recursive field does
+* not widen the entire args object to `v.any()`.
+*/
+const compileArgs = (ast) => Effect.forEach(ast.propertySignatures, ({ name, type }) => {
+	if (typeof name !== "string") return Effect.fail(new UnsupportedPropertySignatureKeyTypeError({ propertyKey: name }));
+	return Option.match(Number.parse(name), {
+		onSome: (propertyKey) => Effect.fail(new UnsupportedPropertySignatureKeyTypeError({ propertyKey })),
+		onNone: () => {
+			const optional = SchemaAST.isOptional(type);
+			return compileAst(type, optional).pipe(Effect.map((validator) => [name, optional ? v.optional(validator) : validator]));
+		}
+	});
+}).pipe(Effect.map((fields) => v.object(Object.fromEntries(fields))));
+const compileSchema = (schema, side) => {
+	const ast = Schema.toEncoded(schema).ast;
+	return Effect.runSync(Effect.result(side === "args" && SchemaAST.isObjects(ast) ? compileArgs(ast) : compileAst(ast)));
+};
+const describeCompiled = (compiled) => unionOf(keyed([...membersOf(Array.getSuccesses(compiled)).map(([, json]) => json), ...Array.getFailures(compiled).map((error) => ({
+	kind: "unsupported",
+	reason: error.message
+}))]));
+/**
+* Compare the validators Convex would compile for the contract and for the host
+* function, both in the application's ID scope, so a component's IDs are
+* strings on both sides and the host's own IDs stay `v.id`. A host that is
+* itself a component registers its own IDs as `v.id` in its scope, which this
+* check cannot see and compares as strings. Args and returns must be equal.
+* Every error the host may fail with, its middleware's included, must be one
+* the contract declares: the same schema, or one compiling to the same
+* validator. The host may declare fewer errors.
+*/
+const verify = (contract, ref) => {
+	const mismatch = (side, expected, actual) => Result.fail(new CallbackContractMismatch({
+		contract: contract.id,
+		side,
+		expected,
+		actual
+	}));
+	const provenance = contract.functionProvenance;
+	for (const side of ["args", "returns"]) {
+		const expected = compileSchema(provenance[side], side);
+		const actual = compileSchema(ref[side], side);
+		const expectedDescription = describeCompiled([expected]);
+		const actualDescription = describeCompiled([actual]);
+		if (Result.isFailure(expected) || Result.isFailure(actual) || JSON.stringify(expectedDescription) !== JSON.stringify(actualDescription)) return mismatch(side, expectedDescription, actualDescription);
+	}
+	const declared = ownError(provenance).flatMap(errorAlternatives);
+	const undeclared = [...ownError(ref), ...MiddlewareSpec.errorSchemas(ref.middlewareSpecs)].flatMap(errorAlternatives).filter((schema) => !declared.includes(schema));
+	if (undeclared.length > 0) {
+		const expectedErrors = declared.map((schema) => compileSchema(schema));
+		const actualErrors = undeclared.map((schema) => compileSchema(schema));
+		const keys = new Set(membersOf(Array.getSuccesses(expectedErrors)).map(([key]) => key));
+		if (Array.getFailures(actualErrors).length > 0 || !membersOf(Array.getSuccesses(actualErrors)).every(([key]) => keys.has(key))) return mismatch("error", describeCompiled(expectedErrors), describeCompiled(actualErrors));
+	}
+	return Result.void;
+};
+/**
+* Create a handle a component can store and run to call `ref` under `contract`.
+* A ref whose function type, args or returns visibly differ from the contract
+* on the wire, or whose errors are undeclared, is a type error. The host may
+* declare fewer errors. Before asking Convex for the handle, a Confect ref's
+* compiled validators are checked against the contract's. A mismatch or an
+* unsupported schema fails with `CallbackContractMismatch`. A plain Convex ref
+* has no codecs to compile, so only the type check applies to it. A ref to a
+* function that is not deployed is a defect.
+*/
+const create = Effect.fn("Callback.create")(function* (contract, ref) {
+	if (ref._tag === "Confect") yield* Effect.fromResult(verify(contract, ref));
+	const text = yield* Effect.promise(() => createFunctionHandle(Ref.getFunctionReference(ref)));
+	return yield* Schema.decodeEffect(Callback.handle(contract))(text).pipe(Effect.orDie);
+});
+//#endregion
+export { CallbackContractMismatch, Callback_exports, create };
+
+//# sourceMappingURL=Callback.js.map

package/dist/Callback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Callback.js","names":[],"sources":["../src/Callback.ts"],"sourcesContent":["import * as Callback from \"@confect/core/Callback\";\nimport * as MiddlewareSpec from \"@confect/core/MiddlewareSpec\";\nimport * as Ref from \"@confect/core/Ref\";\nimport {\n  compileAst,\n  UnsupportedPropertySignatureKeyTypeError,\n} from \"@confect/core/SchemaToValidator\";\nimport { createFunctionHandle } from \"convex/server\";\nimport { convexToJson, v, type GenericValidator } from \"convex/values\";\nimport * as Array from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport { pipe } from \"effect/Function\";\nimport * as Number from \"effect/Number\";\nimport * as Option from \"effect/Option\";\nimport * as Order from \"effect/Order\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Result from \"effect/Result\";\nimport * as Schema from \"effect/Schema\";\nimport * as SchemaAST from \"effect/SchemaAST\";\n\n/**\n * The host function does not satisfy the contract on one side. `expected` and\n * `actual` describe the contract's and the host's validators, with union\n * members in a fixed order, or the reason a schema is unsupported.\n */\nexport class CallbackContractMismatch extends Schema.TaggedError<CallbackContractMismatch>()(\n  \"CallbackContractMismatch\",\n  {\n    contract: Schema.String,\n    side: Schema.Literals([\"args\", \"returns\", \"error\"]),\n    expected: Schema.Json,\n    actual: Schema.Json,\n  },\n) {\n  override get message(): string {\n    return `The host function does not satisfy callback contract \"${this.contract}\": its ${this.side === \"error\" ? \"errors\" : this.side} compile to ${JSON.stringify(this.actual)}, the contract's to ${JSON.stringify(this.expected)}.`;\n  }\n}\n\nconst alternatives = (\n  validator: GenericValidator,\n): ReadonlyArray<GenericValidator> =>\n  validator.kind === \"union\"\n    ? validator.members.flatMap(alternatives)\n    : [validator];\n\nconst literalKinds: Record<string, string> = {\n  string: \"string\",\n  number: \"float64\",\n  bigint: \"int64\",\n  boolean: \"boolean\",\n};\n\n/**\n * The alternatives `validators` accept, without those another alternative\n * already covers: everything under `v.any()`, and a literal under its base\n * kind. `true` and `false` together are `v.boolean()`.\n */\nconst alternativesOf = (\n  validators: ReadonlyArray<GenericValidator>,\n): ReadonlyArray<GenericValidator> => {\n  const flat = validators.flatMap(alternatives);\n  if (flat.some(({ kind }) => kind === \"any\")) {\n    return [v.any()];\n  }\n  const booleans = new Set(\n    flat.flatMap((validator) =>\n      validator.kind === \"literal\" && typeof validator.value === \"boolean\"\n        ? [validator.value]\n        : [],\n    ),\n  );\n  const widened =\n    booleans.has(true) && booleans.has(false) ? [...flat, v.boolean()] : flat;\n  const kinds = new Set<string>(widened.map(({ kind }) => kind));\n  return widened.filter(\n    (validator) =>\n      validator.kind !== \"literal\" ||\n      !kinds.has(literalKinds[typeof validator.value] ?? \"\"),\n  );\n};\n\nconst keyed = (\n  described: ReadonlyArray<Schema.Json>,\n): ReadonlyArray<readonly [string, Schema.Json]> =>\n  pipe(\n    described,\n    Array.map((json) => [JSON.stringify(json), json] as const),\n    Array.dedupeWith(([a], [b]) => a === b),\n    Array.sortWith(([key]) => key, Order.String),\n  );\n\n/**\n * The distinct alternatives `validators` accept, keyed by their description and\n * sorted by it, so union order and repetition do not count as differences.\n */\nconst membersOf = (validators: ReadonlyArray<GenericValidator>) =>\n  keyed(alternativesOf(validators).map(describe));\n\nconst unionOf = (\n  members: ReadonlyArray<readonly [string, Schema.Json]>,\n): Schema.Json => {\n  const [only, ...rest] = members;\n  return only !== undefined && rest.length === 0\n    ? only[1]\n    : { kind: \"union\", members: members.map(([, described]) => described) };\n};\n\nconst describe = (validator: GenericValidator): Schema.Json => {\n  switch (validator.kind) {\n    case \"id\":\n      return { kind: \"id\", tableName: validator.tableName };\n    case \"literal\":\n      return { kind: \"literal\", value: convexToJson(validator.value) };\n    case \"array\":\n      return { kind: \"array\", element: describe(validator.element) };\n    case \"record\":\n      return {\n        kind: \"record\",\n        key: describe(validator.key),\n        value: describe(validator.value),\n      };\n    case \"object\":\n      return {\n        kind: \"object\",\n        fields: Object.fromEntries(\n          pipe(\n            Object.entries(validator.fields),\n            Array.sortWith(([name]) => name, Order.String),\n            Array.map(([name, field]) => [\n              name,\n              field.isOptional === \"optional\"\n                ? { kind: \"optional\", value: describe(field) }\n                : describe(field),\n            ]),\n          ),\n        ),\n      };\n    case \"union\":\n      return unionOf(membersOf([validator]));\n    default:\n      return { kind: validator.kind };\n  }\n};\n\nconst ownError = (provenance: {\n  readonly error?: Schema.Codec<any, any>;\n}): ReadonlyArray<Schema.Codec<any, any>> =>\n  \"error\" in provenance && provenance.error !== undefined\n    ? [provenance.error]\n    : [];\n\nconst errorAlternatives = (schema: Schema.Top): ReadonlyArray<Schema.Top> =>\n  SchemaAST.isUnion(schema.ast) &&\n  Predicate.hasProperty(schema, \"members\") &&\n  Array.isArray(schema.members)\n    ? schema.members.flatMap((member) =>\n        Schema.isSchema(member) ? errorAlternatives(member) : [],\n      )\n    : [schema];\n\n/**\n * Compile args field by field, as registration does, so a recursive field does\n * not widen the entire args object to `v.any()`.\n */\nconst compileArgs = (ast: SchemaAST.Objects): ReturnType<typeof compileAst> =>\n  Effect.forEach(ast.propertySignatures, ({ name, type }) => {\n    if (typeof name !== \"string\") {\n      return Effect.fail(\n        new UnsupportedPropertySignatureKeyTypeError({ propertyKey: name }),\n      );\n    }\n    return Option.match(Number.parse(name), {\n      onSome: (propertyKey) =>\n        Effect.fail(\n          new UnsupportedPropertySignatureKeyTypeError({ propertyKey }),\n        ),\n      onNone: () => {\n        const optional = SchemaAST.isOptional(type);\n        return compileAst(type, optional).pipe(\n          Effect.map(\n            (validator) =>\n              [name, optional ? v.optional(validator) : validator] as const,\n          ),\n        );\n      },\n    });\n  }).pipe(Effect.map((fields) => v.object(Object.fromEntries(fields))));\n\nconst compileSchema = (schema: Schema.Top, side?: \"args\" | \"returns\") => {\n  const ast = Schema.toEncoded(schema).ast;\n  return Effect.runSync(\n    Effect.result(\n      side === \"args\" && SchemaAST.isObjects(ast)\n        ? compileArgs(ast)\n        : compileAst(ast),\n    ),\n  );\n};\n\nconst describeCompiled = (\n  compiled: ReadonlyArray<ReturnType<typeof compileSchema>>,\n): Schema.Json =>\n  unionOf(\n    keyed([\n      ...membersOf(Array.getSuccesses(compiled)).map(([, json]) => json),\n      ...Array.getFailures(compiled).map((error) => ({\n        kind: \"unsupported\",\n        reason: error.message,\n      })),\n    ]),\n  );\n\n/**\n * Compare the validators Convex would compile for the contract and for the host\n * function, both in the application's ID scope, so a component's IDs are\n * strings on both sides and the host's own IDs stay `v.id`. A host that is\n * itself a component registers its own IDs as `v.id` in its scope, which this\n * check cannot see and compares as strings. Args and returns must be equal.\n * Every error the host may fail with, its middleware's included, must be one\n * the contract declares: the same schema, or one compiling to the same\n * validator. The host may declare fewer errors.\n */\nconst verify = (\n  contract: Callback.Any,\n  ref: Ref.AnyConfect,\n): Result.Result<void, CallbackContractMismatch> => {\n  const mismatch = (\n    side: CallbackContractMismatch[\"side\"],\n    expected: Schema.Json,\n    actual: Schema.Json,\n  ) =>\n    Result.fail(\n      new CallbackContractMismatch({\n        contract: contract.id,\n        side,\n        expected,\n        actual,\n      }),\n    );\n  const provenance = contract.functionProvenance;\n\n  for (const side of [\"args\", \"returns\"] as const) {\n    const expected = compileSchema(provenance[side], side);\n    const actual = compileSchema(ref[side], side);\n    const expectedDescription = describeCompiled([expected]);\n    const actualDescription = describeCompiled([actual]);\n    if (\n      Result.isFailure(expected) ||\n      Result.isFailure(actual) ||\n      JSON.stringify(expectedDescription) !== JSON.stringify(actualDescription)\n    ) {\n      return mismatch(side, expectedDescription, actualDescription);\n    }\n  }\n\n  const declared = ownError(provenance).flatMap(errorAlternatives);\n  const undeclared = [\n    ...ownError(ref),\n    ...MiddlewareSpec.errorSchemas(ref.middlewareSpecs),\n  ]\n    .flatMap(errorAlternatives)\n    .filter((schema) => !declared.includes(schema));\n  if (undeclared.length > 0) {\n    const expectedErrors = declared.map((schema) => compileSchema(schema));\n    const actualErrors = undeclared.map((schema) => compileSchema(schema));\n    const keys = new Set(\n      membersOf(Array.getSuccesses(expectedErrors)).map(([key]) => key),\n    );\n    if (\n      Array.getFailures(actualErrors).length > 0 ||\n      !membersOf(Array.getSuccesses(actualErrors)).every(([key]) =>\n        keys.has(key),\n      )\n    ) {\n      return mismatch(\n        \"error\",\n        describeCompiled(expectedErrors),\n        describeCompiled(actualErrors),\n      );\n    }\n  }\n\n  return Result.void;\n};\n\n/**\n * Create a handle a component can store and run to call `ref` under `contract`.\n * A ref whose function type, args or returns visibly differ from the contract\n * on the wire, or whose errors are undeclared, is a type error. The host may\n * declare fewer errors. Before asking Convex for the handle, a Confect ref's\n * compiled validators are checked against the contract's. A mismatch or an\n * unsupported schema fails with `CallbackContractMismatch`. A plain Convex ref\n * has no codecs to compile, so only the type check applies to it. A ref to a\n * function that is not deployed is a defect.\n */\nexport const create = Effect.fn(\"Callback.create\")(function* <\n  Contract_ extends Callback.Any,\n  Ref_ extends Ref.Any,\n>(\n  contract: Contract_,\n  ref: Ref_ & Callback.Check<Contract_, Ref_>,\n): Effect.fn.Return<Callback.Handle<Contract_>, CallbackContractMismatch> {\n  if (ref._tag === \"Confect\") {\n    yield* Effect.fromResult(verify(contract, ref));\n  }\n  const text = yield* Effect.promise(() =>\n    createFunctionHandle(Ref.getFunctionReference(ref)),\n  );\n  return yield* Schema.decodeEffect(Callback.handle(contract))(text).pipe(\n    Effect.orDie,\n  );\n});\n"],"mappings":"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"}

package/dist/ComponentCtx.d.ts

@@ -0,0 +1,71 @@
+import type * as IdScope from "@confect/core/IdScope";
+import type { GenericId, Rebase } from "@confect/core/GenericId";
+import type { DocumentByName, GenericActionCtx, GenericDataModel, GenericMutationCtx, GenericQueryCtx, QueryInitializer, NamedTableInfo, TableNamesInDataModel, SystemDataModel, WithoutSystemFields, WithOptionalSystemFields, SchedulableFunctionReference, OptionalRestArgs, VectorIndexNames, VectorSearchQuery } from "convex/server";
+import type { PatchValue } from "./DatabaseWriter";
+/**
+ * Distinguishes raw component services from structurally compatible app ctxs.
+ */
+export interface Identifier<Kind extends string, DataModel, Scope extends IdScope.IdScope> {
+    readonly "~@confect/server/ComponentCtx": {
+        readonly kind: Kind;
+        readonly dataModel: DataModel;
+        readonly scope: Scope;
+    };
+}
+interface Reader<DataModel extends GenericDataModel, Scope extends IdScope.IdScope> {
+    get<TableName extends TableNamesInDataModel<DataModel>>(table: TableName, id: GenericId<NoInfer<TableName>, Scope>): Promise<DocumentByName<DataModel, TableName> | null>;
+    get<TableName extends TableNamesInDataModel<DataModel>>(id: GenericId<TableName, Scope>): Promise<DocumentByName<DataModel, TableName> | null>;
+    normalizeId<TableName extends TableNamesInDataModel<DataModel>>(table: TableName, id: string): GenericId<TableName, Scope> | null;
+    query<TableName extends TableNamesInDataModel<DataModel>>(table: TableName): QueryInitializer<NamedTableInfo<DataModel, TableName>>;
+}
+type ScopedSystem<Scope extends IdScope.IdScope> = Rebase<SystemDataModel, IdScope.App, Scope>;
+export interface DatabaseReader<DataModel extends GenericDataModel, Scope extends IdScope.IdScope> extends Reader<DataModel, Scope> {
+    readonly system: Reader<ScopedSystem<Scope>, Scope>;
+}
+export interface DatabaseWriter<DataModel extends GenericDataModel, Scope extends IdScope.IdScope> extends DatabaseReader<DataModel, Scope> {
+    insert<TableName extends TableNamesInDataModel<DataModel>>(table: TableName, value: WithoutSystemFields<DocumentByName<DataModel, TableName>>): Promise<GenericId<TableName, Scope>>;
+    patch<TableName extends TableNamesInDataModel<DataModel>>(table: TableName, id: GenericId<NoInfer<TableName>, Scope>, value: PatchValue<WithoutSystemFields<DocumentByName<DataModel, TableName>>>): Promise<void>;
+    patch<TableName extends TableNamesInDataModel<DataModel>>(id: GenericId<TableName, Scope>, value: PatchValue<WithoutSystemFields<DocumentByName<DataModel, TableName>>>): Promise<void>;
+    replace<TableName extends TableNamesInDataModel<DataModel>>(table: TableName, id: GenericId<NoInfer<TableName>, Scope>, value: WithOptionalSystemFields<DocumentByName<DataModel, TableName>>): Promise<void>;
+    replace<TableName extends TableNamesInDataModel<DataModel>>(id: GenericId<TableName, Scope>, value: WithOptionalSystemFields<DocumentByName<DataModel, TableName>>): Promise<void>;
+    delete<TableName extends TableNamesInDataModel<DataModel>>(table: TableName, id: GenericId<NoInfer<TableName>, Scope>): Promise<void>;
+    delete<TableName extends TableNamesInDataModel<DataModel>>(id: GenericId<TableName, Scope>): Promise<void>;
+}
+export interface StorageReader<Scope extends IdScope.IdScope> {
+    getUrl(id: GenericId<"_storage", Scope>): Promise<string | null>;
+    getMetadata(id: GenericId<"_storage", Scope>): Promise<Rebase<Awaited<ReturnType<GenericQueryCtx<GenericDataModel>["storage"]["getMetadata"]>>, IdScope.App, Scope>>;
+}
+export interface StorageWriter<Scope extends IdScope.IdScope> extends StorageReader<Scope> {
+    generateUploadUrl(): Promise<string>;
+    delete(id: GenericId<"_storage", Scope>): Promise<void>;
+}
+export interface StorageActionWriter<Scope extends IdScope.IdScope> extends StorageWriter<Scope> {
+    get(id: GenericId<"_storage", Scope>): Promise<Blob | null>;
+    store(blob: Blob, options?: {
+        sha256?: string;
+    }): Promise<GenericId<"_storage", Scope>>;
+}
+export interface Scheduler<Scope extends IdScope.IdScope> {
+    runAfter<FunctionReference extends SchedulableFunctionReference>(delayMs: number, ref: FunctionReference, ...args: OptionalRestArgs<FunctionReference>): Promise<GenericId<"_scheduled_functions", Scope>>;
+    runAt<FunctionReference extends SchedulableFunctionReference>(timestamp: number | Date, ref: FunctionReference, ...args: OptionalRestArgs<FunctionReference>): Promise<GenericId<"_scheduled_functions", Scope>>;
+    cancel(id: GenericId<"_scheduled_functions", Scope>): Promise<void>;
+}
+export type Query<DataModel extends GenericDataModel, Scope extends IdScope.IdScope> = Omit<GenericQueryCtx<DataModel>, "auth" | "db" | "storage"> & {
+    readonly db: DatabaseReader<DataModel, Scope>;
+    readonly storage: StorageReader<Scope>;
+};
+export type Mutation<DataModel extends GenericDataModel, Scope extends IdScope.IdScope> = Omit<GenericMutationCtx<DataModel>, "auth" | "db" | "storage" | "scheduler"> & {
+    readonly db: DatabaseWriter<DataModel, Scope>;
+    readonly storage: StorageWriter<Scope>;
+    readonly scheduler: Scheduler<Scope>;
+};
+export type Action<DataModel extends GenericDataModel, Scope extends IdScope.IdScope> = Omit<GenericActionCtx<DataModel>, "auth" | "storage" | "vectorSearch" | "scheduler"> & {
+    readonly storage: StorageActionWriter<Scope>;
+    readonly scheduler: Scheduler<Scope>;
+    readonly vectorSearch: <TableName extends TableNamesInDataModel<DataModel>, IndexName extends VectorIndexNames<NamedTableInfo<DataModel, TableName>>>(table: TableName, index: IndexName, query: VectorSearchQuery<NamedTableInfo<DataModel, TableName>, IndexName>) => Promise<Array<{
+        _id: GenericId<TableName, Scope>;
+        _score: number;
+    }>>;
+};
+export {};
+//# sourceMappingURL=ComponentCtx.d.ts.map

package/dist/ComponentCtx.d.ts.map

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

package/dist/ConvexConfigProvider.d.ts

@@ -0,0 +1,21 @@
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Layer from "effect/Layer";
+/**
+ * A `ConfigProvider` that reads configuration directly from `process.env` by
+ * exact path lookup.
+ *
+ * The Convex runtime exposes `process.env` for direct key access but does not
+ * make it enumerable, so the built-in `ConfigProvider.fromEnv` (which builds a
+ * trie over the environment to resolve and enumerate config paths) cannot be
+ * used. This provider resolves each requested path to a single environment
+ * variable, joining the path segments with `"_"` to match the key convention
+ * `fromEnv` uses. As with the built-in providers, an empty string is treated as
+ * a missing value, so `Config.withDefault` and `Config.option` recover from
+ * it.
+ */
+export declare const make: () => ConfigProvider.ConfigProvider;
+/**
+ * Installs the Convex-aware `ConfigProvider` as the ambient provider.
+ */
+export declare const layer: Layer.Layer<never>;
+//# sourceMappingURL=ConvexConfigProvider.d.ts.map

package/dist/ConvexConfigProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexConfigProvider.d.ts","sourceRoot":"","sources":["../src/ConvexConfigProvider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,cAAc,MAAM,uBAAuB,CAAC;AAExD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,QAAO,cAAc,CAAC,cASnC,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAGpC,CAAC"}

package/dist/ConvexConfigProvider.js

@@ -0,0 +1,36 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as ConfigProvider from "effect/ConfigProvider";
+//#region src/ConvexConfigProvider.ts
+var ConvexConfigProvider_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	make: () => make
+});
+/**
+* A `ConfigProvider` that reads configuration directly from `process.env` by
+* exact path lookup.
+*
+* The Convex runtime exposes `process.env` for direct key access but does not
+* make it enumerable, so the built-in `ConfigProvider.fromEnv` (which builds a
+* trie over the environment to resolve and enumerate config paths) cannot be
+* used. This provider resolves each requested path to a single environment
+* variable, joining the path segments with `"_"` to match the key convention
+* `fromEnv` uses. As with the built-in providers, an empty string is treated as
+* a missing value, so `Config.withDefault` and `Config.option` recover from
+* it.
+*/
+const make = () => ConfigProvider.make((path) => {
+	const value = process.env[pipe(path, Array.map(String), Array.join("_"))];
+	return Effect.succeed(value === void 0 || value === "" ? void 0 : ConfigProvider.makeValue(value));
+});
+/**
+* Installs the Convex-aware `ConfigProvider` as the ambient provider.
+*/
+const layer = Layer.succeed(ConfigProvider.ConfigProvider, make());
+//#endregion
+export { ConvexConfigProvider_exports, layer, make };
+
+//# sourceMappingURL=ConvexConfigProvider.js.map

package/dist/ConvexConfigProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexConfigProvider.js","names":[],"sources":["../src/ConvexConfigProvider.ts"],"sourcesContent":["import { pipe } from \"effect/Function\";\nimport * as Array from \"effect/Array\";\nimport * as ConfigProvider from \"effect/ConfigProvider\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\n\ndeclare const process: { env: Record<string, string | undefined> };\n\n/**\n * A `ConfigProvider` that reads configuration directly from `process.env` by\n * exact path lookup.\n *\n * The Convex runtime exposes `process.env` for direct key access but does not\n * make it enumerable, so the built-in `ConfigProvider.fromEnv` (which builds a\n * trie over the environment to resolve and enumerate config paths) cannot be\n * used. This provider resolves each requested path to a single environment\n * variable, joining the path segments with `\"_\"` to match the key convention\n * `fromEnv` uses. As with the built-in providers, an empty string is treated as\n * a missing value, so `Config.withDefault` and `Config.option` recover from\n * it.\n */\nexport const make = (): ConfigProvider.ConfigProvider =>\n  ConfigProvider.make((path) => {\n    const value = process.env[pipe(path, Array.map(String), Array.join(\"_\"))];\n\n    return Effect.succeed(\n      value === undefined || value === \"\"\n        ? undefined\n        : ConfigProvider.makeValue(value),\n    );\n  });\n\n/**\n * Installs the Convex-aware `ConfigProvider` as the ambient provider.\n */\nexport const layer: Layer.Layer<never> = Layer.succeed(\n  ConfigProvider.ConfigProvider,\n  make(),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,aACX,eAAe,MAAM,SAAS;CAC5B,MAAM,QAAQ,QAAQ,IAAI,KAAK,MAAM,MAAM,IAAI,MAAM,GAAG,MAAM,KAAK,GAAG,CAAC;CAEvE,OAAO,OAAO,QACZ,UAAU,KAAA,KAAa,UAAU,KAC7B,KAAA,IACA,eAAe,UAAU,KAAK,CACpC;AACF,CAAC;;;;AAKH,MAAa,QAA4B,MAAM,QAC7C,eAAe,gBACf,KAAK,CACP"}

package/dist/ConvexFunctionDefinitions.d.ts

@@ -0,0 +1,25 @@
+import type * as Layer from "effect/Layer";
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as GroupImpl from "./GroupImpl";
+import * as RegisteredConvexFunction from "./RegisteredConvexFunction";
+import type * as RegisteredFunctions from "./RegisteredFunctions";
+export interface Definitions {
+    readonly [name: string]: RegisteredConvexFunction.Definition | Definitions;
+}
+type DefinitionTag<Function extends FunctionSpec.AnyWithProps, Provenance = Function["functionProvenance"]> = Provenance extends {
+    readonly _tag: "Convex";
+} ? "Registered" : `${Capitalize<Function["functionVisibility"]>}${Capitalize<Function["runtimeAndFunctionType"]["functionType"]>}`;
+export type ForGroup<Group extends GroupSpec.AnyWithProps> = {
+    readonly [Name in FunctionSpec.Name<GroupSpec.Functions<Group>>]: Extract<RegisteredConvexFunction.Definition, {
+        readonly _tag: DefinitionTag<FunctionSpec.WithName<GroupSpec.Functions<Group>, Name>>;
+    }>;
+} & {
+    readonly [Name in GroupSpec.Name<GroupSpec.Groups<Group>>]: ForGroup<GroupSpec.WithName<GroupSpec.Groups<Group>, Name>>;
+};
+export declare const isDefinition: (value: RegisteredConvexFunction.Definition | Definitions) => value is RegisteredConvexFunction.Definition;
+export declare const register: <Group extends GroupSpec.AnyWithProps>(definitions: Definitions) => RegisteredFunctions.RegisteredFunctionsForGroupSpec<Group>;
+export declare const buildForGroup: <Group extends GroupSpec.AnyWithProps>(databaseSchema: DatabaseSchema.AnyWithProps, groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>) => ForGroup<Group>;
+export {};
+//# sourceMappingURL=ConvexFunctionDefinitions.d.ts.map

package/dist/ConvexFunctionDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexFunctionDefinitions.d.ts","sourceRoot":"","sources":["../src/ConvexFunctionDefinitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAG3C,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAG9C,OAAO,KAAK,wBAAwB,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,KAAK,mBAAmB,MAAM,uBAAuB,CAAC;AAIlE,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,wBAAwB,CAAC,UAAU,GAAG,WAAW,CAAC;CAC5E;AAED,KAAK,aAAa,CAChB,QAAQ,SAAS,YAAY,CAAC,YAAY,EAC1C,UAAU,GAAG,QAAQ,CAAC,oBAAoB,CAAC,IACzC,UAAU,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC9C,YAAY,GACZ,GAAG,UAAU,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,wBAAwB,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC;AAErH,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;IAC3D,QAAQ,EAAE,IAAI,IAAI,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,OAAO,CACvE,wBAAwB,CAAC,UAAU,EACnC;QACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAC1B,YAAY,CAAC,QAAQ,CAAC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CACxD,CAAC;KACH,CACF;CACF,GAAG;IACF,QAAQ,EAAE,IAAI,IAAI,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,QAAQ,CAClE,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAClD;CACF,CAAC;AAEF,eAAO,MAAM,YAAY,UAChB,wBAAwB,CAAC,UAAU,GAAG,WAAW,KACvD,KAAK,IAAI,wBAAwB,CAAC,UACL,CAAC;AAWjC,eAAO,MAAM,QAAQ,GAAI,KAAK,SAAS,SAAS,CAAC,YAAY,eAC9C,WAAW,KACvB,mBAAmB,CAAC,+BAA+B,CAAC,KAAK,CAGK,CAAC;AAElE,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,SAAS,CAAC,YAAY,kBAChD,cAAc,CAAC,YAAY,cAC/B,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,KACxD,QAAQ,CAAC,KAAK,CA0BhB,CAAC"}

package/dist/ConvexFunctionDefinitions.js

@@ -0,0 +1,25 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { make } from "./GroupRegistry.js";
+import { isFunctionRegistryItem } from "./FunctionRegistryItem.js";
+import { Definition, prepare, register as register$1 } from "./RegisteredConvexFunction.js";
+import { resolve } from "./ResolvedMiddleware.js";
+import { mapLeaves } from "./internal/utils.js";
+import * as Match from "effect/Match";
+import * as Record from "effect/Record";
+//#region src/ConvexFunctionDefinitions.ts
+var ConvexFunctionDefinitions_exports = /* @__PURE__ */ __exportAll({
+	buildForGroup: () => buildForGroup,
+	isDefinition: () => isDefinition,
+	register: () => register
+});
+const isDefinition = (value) => typeof value._tag === "string";
+const registerDefinitions = (definitions) => Record.map(definitions, (value) => isDefinition(value) ? register$1(value) : registerDefinitions(value));
+const register = (definitions) => registerDefinitions(definitions);
+const buildForGroup = (databaseSchema, groupLayer) => {
+	const { functionRegistryItems, middlewareRegistryItems } = make(groupLayer);
+	return mapLeaves(functionRegistryItems, isFunctionRegistryItem, (item) => Match.value(item).pipe(Match.tag("Convex", ({ handler }) => Definition.Registered({ handler })), Match.tag("Confect", (confect) => prepare(databaseSchema, confect, resolve(confect, middlewareRegistryItems))), Match.exhaustive));
+};
+//#endregion
+export { ConvexFunctionDefinitions_exports, buildForGroup, isDefinition, register };
+
+//# sourceMappingURL=ConvexFunctionDefinitions.js.map

package/dist/ConvexFunctionDefinitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexFunctionDefinitions.js","names":["RegisteredConvexFunction.register","GroupRegistry.make","FunctionRegistryItem.isFunctionRegistryItem","RegisteredConvexFunction.prepare","ResolvedMiddleware.resolve"],"sources":["../src/ConvexFunctionDefinitions.ts"],"sourcesContent":["import type * as Layer from \"effect/Layer\";\nimport * as Match from \"effect/Match\";\nimport * as Record from \"effect/Record\";\nimport type * as GroupSpec from \"@confect/core/GroupSpec\";\nimport type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as GroupImpl from \"./GroupImpl\";\nimport * as GroupRegistry from \"./GroupRegistry\";\nimport * as FunctionRegistryItem from \"./FunctionRegistryItem\";\nimport * as RegisteredConvexFunction from \"./RegisteredConvexFunction\";\nimport type * as RegisteredFunctions from \"./RegisteredFunctions\";\nimport * as ResolvedMiddleware from \"./ResolvedMiddleware\";\nimport { mapLeaves } from \"./internal/utils\";\n\nexport interface Definitions {\n  readonly [name: string]: RegisteredConvexFunction.Definition | Definitions;\n}\n\ntype DefinitionTag<\n  Function extends FunctionSpec.AnyWithProps,\n  Provenance = Function[\"functionProvenance\"],\n> = Provenance extends { readonly _tag: \"Convex\" }\n  ? \"Registered\"\n  : `${Capitalize<Function[\"functionVisibility\"]>}${Capitalize<Function[\"runtimeAndFunctionType\"][\"functionType\"]>}`;\n\nexport type ForGroup<Group extends GroupSpec.AnyWithProps> = {\n  readonly [Name in FunctionSpec.Name<GroupSpec.Functions<Group>>]: Extract<\n    RegisteredConvexFunction.Definition,\n    {\n      readonly _tag: DefinitionTag<\n        FunctionSpec.WithName<GroupSpec.Functions<Group>, Name>\n      >;\n    }\n  >;\n} & {\n  readonly [Name in GroupSpec.Name<GroupSpec.Groups<Group>>]: ForGroup<\n    GroupSpec.WithName<GroupSpec.Groups<Group>, Name>\n  >;\n};\n\nexport const isDefinition = (\n  value: RegisteredConvexFunction.Definition | Definitions,\n): value is RegisteredConvexFunction.Definition =>\n  typeof value._tag === \"string\";\n\nconst registerDefinitions = (\n  definitions: Definitions,\n): RegisteredFunctions.AnyWithProps =>\n  Record.map(definitions, (value) =>\n    isDefinition(value)\n      ? RegisteredConvexFunction.register(value)\n      : registerDefinitions(value),\n  );\n\nexport const register = <Group extends GroupSpec.AnyWithProps>(\n  definitions: Definitions,\n): RegisteredFunctions.RegisteredFunctionsForGroupSpec<Group> =>\n  registerDefinitions(\n    definitions,\n  ) as RegisteredFunctions.RegisteredFunctionsForGroupSpec<Group>;\n\nexport const buildForGroup = <Group extends GroupSpec.AnyWithProps>(\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  groupLayer: Layer.Layer<GroupImpl.GroupImpl<\"Finalized\">>,\n): ForGroup<Group> => {\n  const { functionRegistryItems, middlewareRegistryItems } =\n    GroupRegistry.make(groupLayer);\n  return mapLeaves<\n    FunctionRegistryItem.AnyWithProps,\n    RegisteredConvexFunction.Definition\n  >(\n    functionRegistryItems as {\n      [key: string]: FunctionRegistryItem.AnyWithProps;\n    },\n    FunctionRegistryItem.isFunctionRegistryItem,\n    (item) =>\n      Match.value(item).pipe(\n        Match.tag(\"Convex\", ({ handler }) =>\n          RegisteredConvexFunction.Definition.Registered({ handler }),\n        ),\n        Match.tag(\"Confect\", (confect) =>\n          RegisteredConvexFunction.prepare(\n            databaseSchema,\n            confect,\n            ResolvedMiddleware.resolve(confect, middlewareRegistryItems),\n          ),\n        ),\n        Match.exhaustive,\n      ),\n  ) as ForGroup<Group>;\n};\n"],"mappings":";;;;;;;;;;;;;;AAwCA,MAAa,gBACX,UAEA,OAAO,MAAM,SAAS;AAExB,MAAM,uBACJ,gBAEA,OAAO,IAAI,cAAc,UACvB,aAAa,KAAK,IACdA,WAAkC,KAAK,IACvC,oBAAoB,KAAK,CAC/B;AAEF,MAAa,YACX,gBAEA,oBACE,WACF;AAEF,MAAa,iBACX,gBACA,eACoB;CACpB,MAAM,EAAE,uBAAuB,4BAC7BC,KAAmB,UAAU;CAC/B,OAAO,UAIL,uBAGAC,yBACC,SACC,MAAM,MAAM,IAAI,CAAC,CAAC,KAChB,MAAM,IAAI,WAAW,EAAE,cAAA,WACe,WAAW,EAAE,QAAQ,CAAC,CAC5D,GACA,MAAM,IAAI,YAAY,YACpBC,QACE,gBACA,SACAC,QAA2B,SAAS,uBAAuB,CAC7D,CACF,GACA,MAAM,UACR,CACJ;AACF"}

package/dist/ConvexLogger.d.ts

@@ -0,0 +1,17 @@
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+/**
+ * Writes structured Effect logs through Convex's severity-aware console
+ * methods. Trace and Debug use `console.debug`, Info uses `console.info`, Warn
+ * uses `console.warn`, and Error and Fatal use `console.error`. The payload
+ * retains the original Effect level, cause, annotations, spans, timestamp, and
+ * fiber ID.
+ */
+export declare const logger: Logger.Logger<unknown, void>;
+/**
+ * Replaces Effect's default console logger without changing custom loggers,
+ * tracing, or the minimum log level. Confect installs this layer automatically
+ * for function handlers and HTTP routes.
+ */
+export declare const layer: Layer.Layer<never>;
+//# sourceMappingURL=ConvexLogger.d.ts.map

package/dist/ConvexLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexLogger.d.ts","sourceRoot":"","sources":["../src/ConvexLogger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAW9C,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAWpC,CAAC"}

package/dist/ConvexLogger.js

@@ -0,0 +1,33 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Console from "effect/Console";
+import * as Logger from "effect/Logger";
+//#region src/ConvexLogger.ts
+var ConvexLogger_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	logger: () => logger
+});
+/**
+* Writes structured Effect logs through Convex's severity-aware console
+* methods. Trace and Debug use `console.debug`, Info uses `console.info`, Warn
+* uses `console.warn`, and Error and Fatal use `console.error`. The payload
+* retains the original Effect level, cause, annotations, spans, timestamp, and
+* fiber ID.
+*/
+const logger = Logger.make((options) => {
+	const console = options.fiber.getRef(Console.Console);
+	const output = Logger.formatStructured.log(options);
+	return Match.value(options.logLevel).pipe(Match.whenOr("Trace", "Debug", () => console.debug(output)), Match.when("Info", () => console.info(output)), Match.when("Warn", () => console.warn(output)), Match.whenOr("Error", "Fatal", () => console.error(output)), Match.whenOr("All", "None", () => console.log(output)), Match.exhaustive);
+});
+/**
+* Replaces Effect's default console logger without changing custom loggers,
+* tracing, or the minimum log level. Confect installs this layer automatically
+* for function handlers and HTTP routes.
+*/
+const layer = Layer.effect(Logger.CurrentLoggers, Effect.map(Logger.CurrentLoggers, (loggers) => new Set(Array.from(loggers, (current) => current === Logger.defaultLogger ? logger : current))));
+//#endregion
+export { ConvexLogger_exports, layer, logger };
+
+//# sourceMappingURL=ConvexLogger.js.map

package/dist/ConvexLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvexLogger.js","names":[],"sources":["../src/ConvexLogger.ts"],"sourcesContent":["import * as Console from \"effect/Console\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Logger from \"effect/Logger\";\nimport * as Match from \"effect/Match\";\n\n/**\n * Writes structured Effect logs through Convex's severity-aware console\n * methods. Trace and Debug use `console.debug`, Info uses `console.info`, Warn\n * uses `console.warn`, and Error and Fatal use `console.error`. The payload\n * retains the original Effect level, cause, annotations, spans, timestamp, and\n * fiber ID.\n */\nexport const logger: Logger.Logger<unknown, void> = Logger.make((options) => {\n  const console = options.fiber.getRef(Console.Console);\n  const output = Logger.formatStructured.log(options);\n  return Match.value(options.logLevel).pipe(\n    Match.whenOr(\"Trace\", \"Debug\", () => console.debug(output)),\n    Match.when(\"Info\", () => console.info(output)),\n    Match.when(\"Warn\", () => console.warn(output)),\n    Match.whenOr(\"Error\", \"Fatal\", () => console.error(output)),\n    Match.whenOr(\"All\", \"None\", () => console.log(output)),\n    Match.exhaustive,\n  );\n});\n\n/**\n * Replaces Effect's default console logger without changing custom loggers,\n * tracing, or the minimum log level. Confect installs this layer automatically\n * for function handlers and HTTP routes.\n */\nexport const layer: Layer.Layer<never> = Layer.effect(\n  Logger.CurrentLoggers,\n  Effect.map(\n    Logger.CurrentLoggers,\n    (loggers) =>\n      new Set(\n        Array.from(loggers, (current) =>\n          current === Logger.defaultLogger ? logger : current,\n        ),\n      ),\n  ),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAaA,MAAa,SAAuC,OAAO,MAAM,YAAY;CAC3E,MAAM,UAAU,QAAQ,MAAM,OAAO,QAAQ,OAAO;CACpD,MAAM,SAAS,OAAO,iBAAiB,IAAI,OAAO;CAClD,OAAO,MAAM,MAAM,QAAQ,QAAQ,CAAC,CAAC,KACnC,MAAM,OAAO,SAAS,eAAe,QAAQ,MAAM,MAAM,CAAC,GAC1D,MAAM,KAAK,cAAc,QAAQ,KAAK,MAAM,CAAC,GAC7C,MAAM,KAAK,cAAc,QAAQ,KAAK,MAAM,CAAC,GAC7C,MAAM,OAAO,SAAS,eAAe,QAAQ,MAAM,MAAM,CAAC,GAC1D,MAAM,OAAO,OAAO,cAAc,QAAQ,IAAI,MAAM,CAAC,GACrD,MAAM,UACR;AACF,CAAC;;;;;;AAOD,MAAa,QAA4B,MAAM,OAC7C,OAAO,gBACP,OAAO,IACL,OAAO,iBACN,YACC,IAAI,IACF,MAAM,KAAK,UAAU,YACnB,YAAY,OAAO,gBAAgB,SAAS,OAC9C,CACF,CACJ,CACF"}

package/dist/CronJob.d.ts

@@ -0,0 +1,14 @@
+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>;
+}
+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

@@ -0,0 +1 @@
+{"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,6BAA6B,CAAC;AACjD,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,MAAO,OAAO,KAAG,CAAC,IAAI,OACV,CAAC;AAmBnC,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,GAAG,CAAC,WAAW,GAAG,GAAG,CAAC,SAAS,cAChD,MAAM,YACR,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,QAAQ,OAClC,CAAC,WACG,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,KAC3B,OAA8D,CAAC"}

package/dist/CronJob.js

@@ -0,0 +1,22 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Predicate from "effect/Predicate";
+//#region src/CronJob.ts
+var CronJob_exports = /* @__PURE__ */ __exportAll({
+	TypeId: () => TypeId,
+	isCronJob: () => isCronJob,
+	make: () => make
+});
+const TypeId = "~@confect/server/CronJob";
+const isCronJob = (u) => Predicate.hasProperty(u, TypeId);
+const Proto = { [TypeId]: TypeId };
+const makeProto = (identifier, schedule, ref, args) => Object.assign(Object.create(Proto), {
+	identifier,
+	schedule,
+	ref,
+	args
+});
+const make = (identifier, schedule, ref, ...args) => makeProto(identifier, schedule, ref, args[0] ?? {});
+//#endregion
+export { CronJob_exports, TypeId, isCronJob, make };
+
+//# sourceMappingURL=CronJob.js.map

package/dist/CronJob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CronJob.js","names":[],"sources":["../src/CronJob.ts"],"sourcesContent":["import type { Ref } from \"@confect/core\";\nimport type { Cron, Duration } from \"effect\";\nimport * as Predicate from \"effect/Predicate\";\n\nexport const TypeId = \"~@confect/server/CronJob\";\nexport type TypeId = typeof TypeId;\n\nexport interface CronJob {\n  readonly [TypeId]: TypeId;\n\n  readonly identifier: string;\n  readonly schedule: Cron.Cron | Duration.Duration;\n  readonly ref: Ref.AnyMutation | Ref.AnyAction;\n  readonly args: Record<string, unknown>;\n}\n\nexport const isCronJob = (u: unknown): u is CronJob =>\n  Predicate.hasProperty(u, TypeId);\n\nconst Proto = {\n  [TypeId]: TypeId,\n};\n\nconst makeProto = (\n  identifier: string,\n  schedule: Cron.Cron | Duration.Duration,\n  ref: Ref.AnyMutation | Ref.AnyAction,\n  args: Record<string, unknown>,\n): CronJob =>\n  Object.assign(Object.create(Proto), {\n    identifier,\n    schedule,\n    ref,\n    args,\n  });\n\nexport const make = <R extends Ref.AnyMutation | Ref.AnyAction>(\n  identifier: string,\n  schedule: Cron.Cron | Duration.Duration,\n  ref: R,\n  ...args: Ref.OptionalArgs<R>\n): CronJob => makeProto(identifier, schedule, ref, args[0] ?? {});\n"],"mappings":";;;;;;;;AAIA,MAAa,SAAS;AAYtB,MAAa,aAAa,MACxB,UAAU,YAAY,GAAG,MAAM;AAEjC,MAAM,QAAQ,GACX,SAAS,OACZ;AAEA,MAAM,aACJ,YACA,UACA,KACA,SAEA,OAAO,OAAO,OAAO,OAAO,KAAK,GAAG;CAClC;CACA;CACA;CACA;AACF,CAAC;AAEH,MAAa,QACX,YACA,UACA,KACA,GAAG,SACS,UAAU,YAAY,UAAU,KAAK,KAAK,MAAM,CAAC,CAAC"}

package/dist/CronJobs.d.ts

@@ -0,0 +1,22 @@
+import type { CronJob as ConvexCronJob } from "convex/server";
+import { type Crons } from "convex/server";
+import * as Cron from "effect/Cron";
+import * as Duration from "effect/Duration";
+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;
+}
+export declare const isCronJobs: (u: unknown) => u is CronJobs;
+export declare const make: () => CronJobs;
+export declare const cronToConvexCronString: (cron: Cron.Cron) => string;
+export declare const durationToConvexIntervalSchedule: (duration: Duration.Duration) => IntervalSchedule;
+type IntervalSchedule = Extract<ConvexCronJob["schedule"], {
+    type: "interval";
+}>;
+export {};
+//# sourceMappingURL=CronJobs.d.ts.map

package/dist/CronJobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CronJobs.d.ts","sourceRoot":"","sources":["../src/CronJobs.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAA+B,KAAK,KAAK,EAAE,MAAM,eAAe,CAAC;AAGxE,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAM5C,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,CAAC;AAE1C,eAAO,MAAM,MAAM,8BAA8B,CAAC;AAClD,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,MAAO,OAAO,KAAG,CAAC,IAAI,QACX,CAAC;AAiDnC,eAAO,MAAM,IAAI,QAAO,QAA4C,CAAC;AAErE,eAAO,MAAM,sBAAsB,SAAU,IAAI,CAAC,IAAI,KAAG,MAwCxD,CAAC;AAYF,eAAO,MAAM,gCAAgC,aACjC,QAAQ,CAAC,QAAQ,KAC1B,gBA2BF,CAAC;AAEF,KAAK,gBAAgB,GAAG,OAAO,CAC7B,aAAa,CAAC,UAAU,CAAC,EACzB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CACrB,CAAC"}