@confect/server 4.0.0 → 5.0.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @confect/server
 
+## 5.0.0
+
+### Minor Changes
+
+- 8853cbf: Update `Scheduler` to accept Confect `Ref`s instead of Convex `SchedulableFunctionReference` values. `runAfter` and `runAt` now take a `Ref` to a mutation or action with typed args, aligning the Scheduler API with all other Confect function-calling APIs.
+
+### Patch Changes
+
+- @confect/core@5.0.0
+
 ## 4.0.0
 
 ### Major Changes

package/dist/ActionRunner.d.ts

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

package/dist/ActionRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionRunner.d.ts","names":[],"sources":["../src/ActionRunner.ts"],"mappings":";;;;;;;;cAoCa,YAAA,EAAY,OAAA,CAAA,GAAA,kBA7BP,KAAA,CAAI,SAAA,EAAS,MAAA,EACnB,MAAA,EAAM,IAAA,EACR,KAAA,CAAI,IAAA,CAAK,MAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,MAAA,GAAS,WAAA,CAAY,UAAA,oBAHlC,KAAA,CAAI,SAAA,EAAS,MAAA,EACnB,MAAA,EAAM,IAAA,EACR,KAAA,CAAI,IAAA,CAAK,MAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,MAAA,GAAS,WAAA,CAAY,UAAA;AAAA,KA6BxC,YAAA,UAAsB,YAAA,CAAa,UAAA;AAAA,cAElC,KAAA,GAAS,SAAA,EAAW,gBAAA,uBAAkC,KAAA,CAAA,KAAA,kBAlCjD,KAAA,CAAI,SAAA,EAAS,MAAA,EACnB,MAAA,EAAM,IAAA,EACR,KAAA,CAAI,IAAA,CAAK,MAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,MAAA,GAAS,WAAA,CAAY,UAAA"}
+{"version":3,"file":"ActionRunner.d.ts","names":[],"sources":["../src/ActionRunner.ts"],"mappings":";;;;;;;;;;cAWa,YAAA,EAAY,OAAA,CAAA,GAAA,kBALP,KAAA,CAAI,SAAA,EAAS,MAAA,EAAU,MAAA,EAAM,IAAA,EAAQ,KAAA,CAAI,IAAA,CAAK,MAAA,MAAO,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,MAAA,GAAA,mBAAA,CAAA,UAAA,2BAArD,KAAA,CAAI,SAAA,EAAS,MAAA,EAAU,MAAA,EAAM,IAAA,EAAQ,KAAA,CAAI,IAAA,CAAK,MAAA,MAAO,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,MAAA,GAAA,mBAAA,CAAA,UAAA;AAAA,KAQ3D,YAAA,UAAsB,YAAA,CAAa,UAAA;AAAA,cAElC,KAAA,GAAS,SAAA,EAAW,gBAAA,uBAAkC,KAAA,CAAA,KAAA,kBAVjD,KAAA,CAAI,SAAA,EAAS,MAAA,EAAU,MAAA,EAAM,IAAA,EAAQ,KAAA,CAAI,IAAA,CAAK,MAAA,MAAO,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,MAAA,GAAA,mBAAA,CAAA,UAAA"}

package/dist/ActionRunner.js

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer } from "effect";
 import * as Ref$1 from "@confect/core/Ref";
 import "convex/server";
 
@@ -8,15 +8,7 @@ var ActionRunner_exports = /* @__PURE__ */ __exportAll({
 	ActionRunner: () => ActionRunner,
 	layer: () => layer
 });
-const make = (runAction) => (action, args) => Effect.gen(function* () {
-	const functionSpec = Ref$1.getFunctionSpec(action);
-	const functionName = Ref$1.getConvexFunctionName(action);
-	return yield* Match.value(functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionSpec) => Effect.gen(function* () {
-		const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(args);
-		const encodedReturns = yield* Effect.promise(() => runAction(functionName, encodedArgs));
-		return yield* Schema.decode(confectFunctionSpec.returns)(encodedReturns);
-	})), Match.tag("Convex", () => Effect.promise(() => runAction(functionName, args))), Match.exhaustive);
-});
+const make = (runAction) => (action, args) => Ref$1.runWithCodec(action, args, (functionReference, encodedArgs) => runAction(functionReference, encodedArgs));
 const ActionRunner = Context.GenericTag("@confect/server/ActionRunner");
 const layer = (runAction) => Layer.succeed(ActionRunner, make(runAction));
 

package/dist/ActionRunner.js.map

@@ -1 +1 @@
-{"version":3,"file":"ActionRunner.js","names":["Ref"],"sources":["../src/ActionRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericActionCtx } from \"convex/server\";\nimport type { ParseResult } from \"effect\";\nimport { Context, Effect, Layer, Match, Schema } from \"effect\";\n\nconst make =\n  (runAction: GenericActionCtx<any>[\"runAction\"]) =>\n  <Action extends Ref.AnyAction>(\n    action: Action,\n    args: Ref.Args<Action>,\n  ): Effect.Effect<Ref.Returns<Action>, ParseResult.ParseError> =>\n    Effect.gen(function* () {\n      const functionSpec = Ref.getFunctionSpec(action);\n      const functionName = Ref.getConvexFunctionName(action);\n\n      return yield* Match.value(functionSpec.functionProvenance).pipe(\n        Match.tag(\"Confect\", (confectFunctionSpec) =>\n          Effect.gen(function* () {\n            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(\n              args,\n            );\n            const encodedReturns = yield* Effect.promise(() =>\n              runAction(functionName as any, encodedArgs),\n            );\n            return yield* Schema.decode(confectFunctionSpec.returns)(\n              encodedReturns,\n            );\n          }),\n        ),\n        Match.tag(\"Convex\", () =>\n          Effect.promise(() => runAction(functionName as any, args as any)),\n        ),\n        Match.exhaustive,\n      );\n    });\n\nexport const ActionRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/ActionRunner\",\n);\nexport type ActionRunner = typeof ActionRunner.Identifier;\n\nexport const layer = (runAction: GenericActionCtx<any>[\"runAction\"]) =>\n  Layer.succeed(ActionRunner, make(runAction));\n"],"mappings":";;;;;;;;;;AAKA,MAAM,QACH,eAEC,QACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,eAAeA,MAAI,gBAAgB,OAAO;CAChD,MAAM,eAAeA,MAAI,sBAAsB,OAAO;AAEtD,QAAO,OAAO,MAAM,MAAM,aAAa,mBAAmB,CAAC,KACzD,MAAM,IAAI,YAAY,wBACpB,OAAO,IAAI,aAAa;EACtB,MAAM,cAAc,OAAO,OAAO,OAAO,oBAAoB,KAAK,CAChE,KACD;EACD,MAAM,iBAAiB,OAAO,OAAO,cACnC,UAAU,cAAqB,YAAY,CAC5C;AACD,SAAO,OAAO,OAAO,OAAO,oBAAoB,QAAQ,CACtD,eACD;GACD,CACH,EACD,MAAM,IAAI,gBACR,OAAO,cAAc,UAAU,cAAqB,KAAY,CAAC,CAClE,EACD,MAAM,WACP;EACD;AAEN,MAAa,eAAe,QAAQ,WAClC,+BACD;AAGD,MAAa,SAAS,cACpB,MAAM,QAAQ,cAAc,KAAK,UAAU,CAAC"}
+{"version":3,"file":"ActionRunner.js","names":["Ref"],"sources":["../src/ActionRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericActionCtx } from \"convex/server\";\nimport { Context, Layer } from \"effect\";\n\nconst make =\n  (runAction: GenericActionCtx<any>[\"runAction\"]) =>\n  <Action extends Ref.AnyAction>(action: Action, args: Ref.Args<Action>) =>\n    Ref.runWithCodec(action, args, (functionReference, encodedArgs) =>\n      runAction(functionReference, encodedArgs),\n    );\n\nexport const ActionRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/ActionRunner\",\n);\nexport type ActionRunner = typeof ActionRunner.Identifier;\n\nexport const layer = (runAction: GenericActionCtx<any>[\"runAction\"]) =>\n  Layer.succeed(ActionRunner, make(runAction));\n"],"mappings":";;;;;;;;;;AAIA,MAAM,QACH,eAC8B,QAAgB,SAC7CA,MAAI,aAAa,QAAQ,OAAO,mBAAmB,gBACjD,UAAU,mBAAmB,YAAY,CAC1C;AAEL,MAAa,eAAe,QAAQ,WAClC,+BACD;AAGD,MAAa,SAAS,cACpB,MAAM,QAAQ,cAAc,KAAK,UAAU,CAAC"}

package/dist/CronJobs.d.ts

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

package/dist/CronJobs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CronJobs.d.ts","names":[],"sources":["../src/CronJobs.ts"],"mappings":";;;;;;;;cAmBa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,QAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,QAAA,EAAU,MAAA,SAAe,SAAA;EAAA,SACzB,cAAA,EAAgB,KAAA;EAEzB,GAAA,CAAI,IAAA,EAAM,SAAA,GAAkB,QAAA;AAAA;AAAA,cAGjB,UAAA,GAAc,CAAA,cAAa,CAAA,IAAK,QAAA;AAAA,cA4DhC,IAAA,QAAW,QAAA;AAvExB;AAAA,cA0Ea,sBAAA,GAA0B,IAAA,EAAM,IAAA,CAAK,IAAA;;cAiCrC,gCAAA,GACX,QAAA,EAAU,QAAA,CAAS,QAAA,KAClB,gBAAA;AAAA,KA6BE,gBAAA,GAAmB,OAAA,CACtB,OAAA;EACE,IAAA;AAAA"}
+{"version":3,"file":"CronJobs.d.ts","names":[],"sources":["../src/CronJobs.ts"],"mappings":";;;;;;;cAea,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,UAEX,QAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,QAAA,EAAU,MAAA,SAAe,OAAA;EAAA,SACzB,cAAA,EAAgB,KAAA;EAEzB,GAAA,CAAI,IAAA,EAAM,OAAA,GAAkB,QAAA;AAAA;AAAA,cAGjB,UAAA,GAAc,CAAA,cAAa,CAAA,IAAK,QAAA;AAAA,cAkDhC,IAAA,QAAW,QAAA"}

package/dist/CronJobs.js

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Array, Cron, Duration, Match, Order, Predicate, Record, Schema, pipe } from "effect";
+import { Array, Cron, Duration, Match, Order, Predicate, Record, pipe } from "effect";
 import { cronJobs } from "convex/server";
 import { Ref as Ref$1 } from "@confect/core";
 
@@ -17,13 +17,12 @@ const Proto = {
 	[TypeId]: TypeId,
 	add(cronJob) {
 		const newConvexCrons = Object.assign(cronJobs(), { crons: { ...this.convexCronJobs.crons } });
-		const schedulableFunctionReference = Ref$1.getConvexFunctionName(cronJob.ref);
-		const functionSpec = Ref$1.getFunctionSpec(cronJob.ref);
-		const encodedArgs = Match.value(functionSpec.functionProvenance).pipe(Match.tag("Confect", (confect) => Schema.encodeSync(confect.args)(cronJob.args)), Match.tag("Convex", () => cronJob.args), Match.exhaustive);
+		const functionReference = Ref$1.getFunctionReference(cronJob.ref);
+		const encodedArgs = Ref$1.encodeArgsSync(cronJob.ref, cronJob.args);
 		Match.value(cronJob.schedule).pipe(Match.when(Cron.isCron, (cron) => {
-			newConvexCrons.cron(cronJob.identifier, cronToConvexCronString(cron), schedulableFunctionReference, encodedArgs);
+			newConvexCrons.cron(cronJob.identifier, cronToConvexCronString(cron), functionReference, encodedArgs);
 		}), Match.when(Duration.isDuration, (duration) => {
-			newConvexCrons.interval(cronJob.identifier, durationToConvexIntervalSchedule(duration), schedulableFunctionReference, encodedArgs);
+			newConvexCrons.interval(cronJob.identifier, durationToConvexIntervalSchedule(duration), functionReference, encodedArgs);
 		}), Match.exhaustive);
 		return makeProto(Record.set(this.cronJobs, cronJob.identifier, cronJob), newConvexCrons);
 	}

package/dist/CronJobs.js.map

@@ -1 +1 @@
-{"version":3,"file":"CronJobs.js","names":["makeConvexCrons","Ref"],"sources":["../src/CronJobs.ts"],"sourcesContent":["import { Ref } from \"@confect/core\";\nimport type {\n  CronJob as ConvexCronJob,\n  SchedulableFunctionReference,\n} from \"convex/server\";\nimport { cronJobs as makeConvexCrons, type Crons } from \"convex/server\";\nimport {\n  Array,\n  Cron,\n  Duration,\n  Match,\n  Order,\n  pipe,\n  Predicate,\n  Record,\n  Schema,\n} from \"effect\";\nimport type * as CronJob from \"./CronJob\";\n\nexport const TypeId = \"@confect/server/CronJobs\";\nexport type TypeId = typeof TypeId;\n\nexport interface CronJobs {\n  readonly [TypeId]: TypeId;\n  readonly cronJobs: Record<string, CronJob.CronJob>;\n  readonly convexCronJobs: Crons;\n\n  add(cron: CronJob.CronJob): CronJobs;\n}\n\nexport const isCronJobs = (u: unknown): u is CronJobs =>\n  Predicate.hasProperty(u, TypeId);\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  add(this: CronJobs, cronJob: CronJob.CronJob) {\n    const newConvexCrons = Object.assign(makeConvexCrons(), {\n      crons: { ...this.convexCronJobs.crons },\n    });\n\n    const schedulableFunctionReference = Ref.getConvexFunctionName(\n      cronJob.ref,\n    ) as unknown as SchedulableFunctionReference;\n\n    const functionSpec = Ref.getFunctionSpec(cronJob.ref);\n    const encodedArgs = Match.value(functionSpec.functionProvenance).pipe(\n      Match.tag(\"Confect\", (confect) =>\n        Schema.encodeSync(confect.args)(cronJob.args),\n      ),\n      Match.tag(\"Convex\", () => cronJob.args),\n      Match.exhaustive,\n    );\n\n    Match.value(cronJob.schedule).pipe(\n      Match.when(Cron.isCron, (cron) => {\n        newConvexCrons.cron(\n          cronJob.identifier,\n          cronToConvexCronString(cron),\n          schedulableFunctionReference,\n          encodedArgs,\n        );\n      }),\n      Match.when(Duration.isDuration, (duration) => {\n        newConvexCrons.interval(\n          cronJob.identifier,\n          durationToConvexIntervalSchedule(duration),\n          schedulableFunctionReference,\n          encodedArgs,\n        );\n      }),\n      Match.exhaustive,\n    );\n\n    return makeProto(\n      Record.set(this.cronJobs, cronJob.identifier, cronJob),\n      newConvexCrons,\n    );\n  },\n};\n\nconst makeProto = (\n  cronJobs: Record<string, CronJob.CronJob>,\n  convexCronJobs: Crons,\n): CronJobs =>\n  Object.assign(Object.create(Proto), {\n    cronJobs,\n    convexCronJobs,\n  });\n\nexport const make = (): CronJobs => makeProto({}, makeConvexCrons());\n\n/** @internal */\nexport const cronToConvexCronString = (cron: Cron.Cron): string => {\n  const hasNonDefaultSeconds = cron.seconds.size !== 1 || !cron.seconds.has(0);\n  if (hasNonDefaultSeconds) {\n    throw new Error(\n      \"Convex cron expressions do not support a seconds field. \" +\n        \"The seconds field must be the default {0}. \" +\n        \"Sub-minute scheduling is supported only by interval schedules defined using a Duration.\",\n    );\n  }\n\n  return Array.join(\n    [\n      setToField(cron.minutes),\n      setToField(cron.hours),\n      setToField(cron.days),\n      setToField(cron.months),\n      setToField(cron.weekdays),\n    ],\n    \" \",\n  );\n};\n\nconst setToField = (set: ReadonlySet<number>): string => {\n  if (set.size === 0) return \"*\";\n  return pipe(\n    set,\n    Array.sort(Order.number),\n    Array.map((n) => n.toString()),\n    Array.join(\",\"),\n  );\n};\n\n/** @internal */\nexport const durationToConvexIntervalSchedule = (\n  duration: Duration.Duration,\n): IntervalSchedule => {\n  const millis = Duration.toMillis(duration);\n  if (millis <= 0) {\n    throw new Error(\"Interval must be a positive duration.\");\n  }\n\n  const oneHourInMillis = Duration.hours(1).pipe(Duration.toMillis);\n  const hours = millis / oneHourInMillis;\n  if (Number.isInteger(hours)) {\n    return { type: \"interval\", hours };\n  }\n\n  const oneMinuteInMillis = Duration.minutes(1).pipe(Duration.toMillis);\n  const minutes = millis / oneMinuteInMillis;\n  if (Number.isInteger(minutes)) {\n    return { type: \"interval\", minutes };\n  }\n\n  const oneSecondInMillis = Duration.seconds(1).pipe(Duration.toMillis);\n  const seconds = millis / oneSecondInMillis;\n  if (Number.isInteger(seconds)) {\n    return { type: \"interval\", seconds };\n  }\n\n  throw new Error(\n    \"Interval must be a whole number of seconds, minutes, or hours.\",\n  );\n};\n\ntype IntervalSchedule = Extract<\n  ConvexCronJob[\"schedule\"],\n  { type: \"interval\" }\n>;\n"],"mappings":";;;;;;;;;;;;;AAmBA,MAAa,SAAS;AAWtB,MAAa,cAAc,MACzB,UAAU,YAAY,GAAG,OAAO;AAElC,MAAM,QAAQ;EACX,SAAS;CAEV,IAAoB,SAA0B;EAC5C,MAAM,iBAAiB,OAAO,OAAOA,UAAiB,EAAE,EACtD,OAAO,EAAE,GAAG,KAAK,eAAe,OAAO,EACxC,CAAC;EAEF,MAAM,+BAA+BC,MAAI,sBACvC,QAAQ,IACT;EAED,MAAM,eAAeA,MAAI,gBAAgB,QAAQ,IAAI;EACrD,MAAM,cAAc,MAAM,MAAM,aAAa,mBAAmB,CAAC,KAC/D,MAAM,IAAI,YAAY,YACpB,OAAO,WAAW,QAAQ,KAAK,CAAC,QAAQ,KAAK,CAC9C,EACD,MAAM,IAAI,gBAAgB,QAAQ,KAAK,EACvC,MAAM,WACP;AAED,QAAM,MAAM,QAAQ,SAAS,CAAC,KAC5B,MAAM,KAAK,KAAK,SAAS,SAAS;AAChC,kBAAe,KACb,QAAQ,YACR,uBAAuB,KAAK,EAC5B,8BACA,YACD;IACD,EACF,MAAM,KAAK,SAAS,aAAa,aAAa;AAC5C,kBAAe,SACb,QAAQ,YACR,iCAAiC,SAAS,EAC1C,8BACA,YACD;IACD,EACF,MAAM,WACP;AAED,SAAO,UACL,OAAO,IAAI,KAAK,UAAU,QAAQ,YAAY,QAAQ,EACtD,eACD;;CAEJ;AAED,MAAM,aACJ,UACA,mBAEA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACD,CAAC;AAEJ,MAAa,aAAuB,UAAU,EAAE,EAAED,UAAiB,CAAC;;AAGpE,MAAa,0BAA0B,SAA4B;AAEjE,KAD6B,KAAK,QAAQ,SAAS,KAAK,CAAC,KAAK,QAAQ,IAAI,EAAE,CAE1E,OAAM,IAAI,MACR,6LAGD;AAGH,QAAO,MAAM,KACX;EACE,WAAW,KAAK,QAAQ;EACxB,WAAW,KAAK,MAAM;EACtB,WAAW,KAAK,KAAK;EACrB,WAAW,KAAK,OAAO;EACvB,WAAW,KAAK,SAAS;EAC1B,EACD,IACD;;AAGH,MAAM,cAAc,QAAqC;AACvD,KAAI,IAAI,SAAS,EAAG,QAAO;AAC3B,QAAO,KACL,KACA,MAAM,KAAK,MAAM,OAAO,EACxB,MAAM,KAAK,MAAM,EAAE,UAAU,CAAC,EAC9B,MAAM,KAAK,IAAI,CAChB;;;AAIH,MAAa,oCACX,aACqB;CACrB,MAAM,SAAS,SAAS,SAAS,SAAS;AAC1C,KAAI,UAAU,EACZ,OAAM,IAAI,MAAM,wCAAwC;CAI1D,MAAM,QAAQ,SADU,SAAS,MAAM,EAAE,CAAC,KAAK,SAAS,SAAS;AAEjE,KAAI,OAAO,UAAU,MAAM,CACzB,QAAO;EAAE,MAAM;EAAY;EAAO;CAIpC,MAAM,UAAU,SADU,SAAS,QAAQ,EAAE,CAAC,KAAK,SAAS,SAAS;AAErE,KAAI,OAAO,UAAU,QAAQ,CAC3B,QAAO;EAAE,MAAM;EAAY;EAAS;CAItC,MAAM,UAAU,SADU,SAAS,QAAQ,EAAE,CAAC,KAAK,SAAS,SAAS;AAErE,KAAI,OAAO,UAAU,QAAQ,CAC3B,QAAO;EAAE,MAAM;EAAY;EAAS;AAGtC,OAAM,IAAI,MACR,iEACD"}
+{"version":3,"file":"CronJobs.js","names":["makeConvexCrons","Ref"],"sources":["../src/CronJobs.ts"],"sourcesContent":["import { Ref } from \"@confect/core\";\nimport type { CronJob as ConvexCronJob } from \"convex/server\";\nimport { cronJobs as makeConvexCrons, type Crons } from \"convex/server\";\nimport {\n  Array,\n  Cron,\n  Duration,\n  Match,\n  Order,\n  pipe,\n  Predicate,\n  Record,\n} from \"effect\";\nimport type * as CronJob from \"./CronJob\";\n\nexport const TypeId = \"@confect/server/CronJobs\";\nexport type TypeId = typeof TypeId;\n\nexport interface CronJobs {\n  readonly [TypeId]: TypeId;\n  readonly cronJobs: Record<string, CronJob.CronJob>;\n  readonly convexCronJobs: Crons;\n\n  add(cron: CronJob.CronJob): CronJobs;\n}\n\nexport const isCronJobs = (u: unknown): u is CronJobs =>\n  Predicate.hasProperty(u, TypeId);\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  add(this: CronJobs, cronJob: CronJob.CronJob) {\n    const newConvexCrons = Object.assign(makeConvexCrons(), {\n      crons: { ...this.convexCronJobs.crons },\n    });\n\n    const functionReference = Ref.getFunctionReference(cronJob.ref);\n    const encodedArgs = Ref.encodeArgsSync(cronJob.ref, cronJob.args);\n\n    Match.value(cronJob.schedule).pipe(\n      Match.when(Cron.isCron, (cron) => {\n        newConvexCrons.cron(\n          cronJob.identifier,\n          cronToConvexCronString(cron),\n          functionReference,\n          encodedArgs,\n        );\n      }),\n      Match.when(Duration.isDuration, (duration) => {\n        newConvexCrons.interval(\n          cronJob.identifier,\n          durationToConvexIntervalSchedule(duration),\n          functionReference,\n          encodedArgs,\n        );\n      }),\n      Match.exhaustive,\n    );\n\n    return makeProto(\n      Record.set(this.cronJobs, cronJob.identifier, cronJob),\n      newConvexCrons,\n    );\n  },\n};\n\nconst makeProto = (\n  cronJobs: Record<string, CronJob.CronJob>,\n  convexCronJobs: Crons,\n): CronJobs =>\n  Object.assign(Object.create(Proto), {\n    cronJobs,\n    convexCronJobs,\n  });\n\nexport const make = (): CronJobs => makeProto({}, makeConvexCrons());\n\n/** @internal */\nexport const cronToConvexCronString = (cron: Cron.Cron): string => {\n  const hasNonDefaultSeconds = cron.seconds.size !== 1 || !cron.seconds.has(0);\n  if (hasNonDefaultSeconds) {\n    throw new Error(\n      \"Convex cron expressions do not support a seconds field. \" +\n        \"The seconds field must be the default {0}. \" +\n        \"Sub-minute scheduling is supported only by interval schedules defined using a Duration.\",\n    );\n  }\n\n  return Array.join(\n    [\n      setToField(cron.minutes),\n      setToField(cron.hours),\n      setToField(cron.days),\n      setToField(cron.months),\n      setToField(cron.weekdays),\n    ],\n    \" \",\n  );\n};\n\nconst setToField = (set: ReadonlySet<number>): string => {\n  if (set.size === 0) return \"*\";\n  return pipe(\n    set,\n    Array.sort(Order.number),\n    Array.map((n) => n.toString()),\n    Array.join(\",\"),\n  );\n};\n\n/** @internal */\nexport const durationToConvexIntervalSchedule = (\n  duration: Duration.Duration,\n): IntervalSchedule => {\n  const millis = Duration.toMillis(duration);\n  if (millis <= 0) {\n    throw new Error(\"Interval must be a positive duration.\");\n  }\n\n  const oneHourInMillis = Duration.hours(1).pipe(Duration.toMillis);\n  const hours = millis / oneHourInMillis;\n  if (Number.isInteger(hours)) {\n    return { type: \"interval\", hours };\n  }\n\n  const oneMinuteInMillis = Duration.minutes(1).pipe(Duration.toMillis);\n  const minutes = millis / oneMinuteInMillis;\n  if (Number.isInteger(minutes)) {\n    return { type: \"interval\", minutes };\n  }\n\n  const oneSecondInMillis = Duration.seconds(1).pipe(Duration.toMillis);\n  const seconds = millis / oneSecondInMillis;\n  if (Number.isInteger(seconds)) {\n    return { type: \"interval\", seconds };\n  }\n\n  throw new Error(\n    \"Interval must be a whole number of seconds, minutes, or hours.\",\n  );\n};\n\ntype IntervalSchedule = Extract<\n  ConvexCronJob[\"schedule\"],\n  { type: \"interval\" }\n>;\n"],"mappings":";;;;;;;;;;;;;AAeA,MAAa,SAAS;AAWtB,MAAa,cAAc,MACzB,UAAU,YAAY,GAAG,OAAO;AAElC,MAAM,QAAQ;EACX,SAAS;CAEV,IAAoB,SAA0B;EAC5C,MAAM,iBAAiB,OAAO,OAAOA,UAAiB,EAAE,EACtD,OAAO,EAAE,GAAG,KAAK,eAAe,OAAO,EACxC,CAAC;EAEF,MAAM,oBAAoBC,MAAI,qBAAqB,QAAQ,IAAI;EAC/D,MAAM,cAAcA,MAAI,eAAe,QAAQ,KAAK,QAAQ,KAAK;AAEjE,QAAM,MAAM,QAAQ,SAAS,CAAC,KAC5B,MAAM,KAAK,KAAK,SAAS,SAAS;AAChC,kBAAe,KACb,QAAQ,YACR,uBAAuB,KAAK,EAC5B,mBACA,YACD;IACD,EACF,MAAM,KAAK,SAAS,aAAa,aAAa;AAC5C,kBAAe,SACb,QAAQ,YACR,iCAAiC,SAAS,EAC1C,mBACA,YACD;IACD,EACF,MAAM,WACP;AAED,SAAO,UACL,OAAO,IAAI,KAAK,UAAU,QAAQ,YAAY,QAAQ,EACtD,eACD;;CAEJ;AAED,MAAM,aACJ,UACA,mBAEA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACD,CAAC;AAEJ,MAAa,aAAuB,UAAU,EAAE,EAAED,UAAiB,CAAC;;AAGpE,MAAa,0BAA0B,SAA4B;AAEjE,KAD6B,KAAK,QAAQ,SAAS,KAAK,CAAC,KAAK,QAAQ,IAAI,EAAE,CAE1E,OAAM,IAAI,MACR,6LAGD;AAGH,QAAO,MAAM,KACX;EACE,WAAW,KAAK,QAAQ;EACxB,WAAW,KAAK,MAAM;EACtB,WAAW,KAAK,KAAK;EACrB,WAAW,KAAK,OAAO;EACvB,WAAW,KAAK,SAAS;EAC1B,EACD,IACD;;AAGH,MAAM,cAAc,QAAqC;AACvD,KAAI,IAAI,SAAS,EAAG,QAAO;AAC3B,QAAO,KACL,KACA,MAAM,KAAK,MAAM,OAAO,EACxB,MAAM,KAAK,MAAM,EAAE,UAAU,CAAC,EAC9B,MAAM,KAAK,IAAI,CAChB;;;AAIH,MAAa,oCACX,aACqB;CACrB,MAAM,SAAS,SAAS,SAAS,SAAS;AAC1C,KAAI,UAAU,EACZ,OAAM,IAAI,MAAM,wCAAwC;CAI1D,MAAM,QAAQ,SADU,SAAS,MAAM,EAAE,CAAC,KAAK,SAAS,SAAS;AAEjE,KAAI,OAAO,UAAU,MAAM,CACzB,QAAO;EAAE,MAAM;EAAY;EAAO;CAIpC,MAAM,UAAU,SADU,SAAS,QAAQ,EAAE,CAAC,KAAK,SAAS,SAAS;AAErE,KAAI,OAAO,UAAU,QAAQ,CAC3B,QAAO;EAAE,MAAM;EAAY;EAAS;CAItC,MAAM,UAAU,SADU,SAAS,QAAQ,EAAE,CAAC,KAAK,SAAS,SAAS;AAErE,KAAI,OAAO,UAAU,QAAQ,CAC3B,QAAO;EAAE,MAAM;EAAY;EAAS;AAGtC,OAAM,IAAI,MACR,iEACD"}

package/dist/DatabaseReader.d.ts

@@ -9,8 +9,8 @@ import { Context, Layer } from "effect";
 import * as convex_server0 from "convex/server";
 import { GenericDatabaseReader } from "convex/server";
 import * as convex_values0 from "convex/values";
-import * as _confect_core_Types0 from "@confect/core/Types";
 import * as effect_Effect0 from "effect/Effect";
+import * as _confect_core_Types0 from "@confect/core/Types";
 
 //#region src/DatabaseReader.d.ts
 declare namespace DatabaseReader_d_exports {
@@ -19,7 +19,7 @@ declare namespace DatabaseReader_d_exports {
 declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<ToConvex<FromSchema<DatabaseSchema_>>>) => {
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {
@@ -32,7 +32,7 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
 declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {
@@ -44,7 +44,7 @@ declare const DatabaseReader: <DatabaseSchema_ extends AnyWithProps>() => Contex
 }, {
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {
@@ -58,7 +58,7 @@ type DatabaseReader<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof Da
 declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseReader: GenericDatabaseReader<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
   table: <const TableName extends Name<IncludeSystemTables<Tables<DatabaseSchema_>>>>(tableName: TableName) => {
     readonly get: {
-      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIdFailure, never>;
+      (id: convex_values0.GenericId<TableName>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
       <IndexName extends keyof TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"]>(indexName: IndexName, ...indexFieldValues: _confect_core_Types0.IndexFieldTypesForEq<ToConvex<DataModel<IncludeSystemTables<Tables<DatabaseSchema_>>>>, TableName, TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["indexes"][IndexName]>): effect_Effect0.Effect<TableInfo<WithName<IncludeSystemTables<Tables<DatabaseSchema_>>, TableName>>["document"], DocumentDecodeError | GetByIndexFailure, never>;
     };
     readonly index: {

package/dist/DatabaseWriter.d.ts

@@ -13,7 +13,7 @@ declare namespace DatabaseWriter_d_exports {
 declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => {
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: WithoutSystemFields<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
@@ -21,14 +21,14 @@ declare const make: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: Datab
 declare const DatabaseWriter: <DatabaseSchema_ extends AnyWithProps>() => Context.Tag<{
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
 }, {
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
@@ -37,7 +37,7 @@ type DatabaseWriter<DatabaseSchema_ extends AnyWithProps> = ReturnType<typeof Da
 declare const layer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, convexDatabaseWriter: GenericDatabaseWriter<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<{
   table: <const TableName extends TableNames<FromSchema<DatabaseSchema_>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<DatabaseSchema_>, TableName>>) => Effect.Effect<GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: GenericId<TableName>, patchedValues: Partial<Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: GenericId<TableName>, value: Expand<BetterOmit<DocumentByName<FromSchema<DatabaseSchema_>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: GenericId<TableName>) => Effect.Effect<void, never, never>;
   };

package/dist/DatabaseWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;cAiBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAMH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,mBAAA,GAAA,cAAA,GAAA,mBAAA;kBAiCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCA7GrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAmHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA3H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}
+{"version":3,"file":"DatabaseWriter.d.ts","names":[],"sources":["../src/DatabaseWriter.ts"],"mappings":";;;;;;;;;;;;cAiBa,IAAA,2BAAgC,YAAA,EAC3C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA;kCAMH,UAAA,CAAoB,UAAA,CAAA,eAAA,IAAY,SAAA,EAC1D,SAAA;uBAQC,qBAAA,CACR,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAC7B,MAAA,CAAA,MAAA,CAAA,SAAA,CAAA,SAAA,GAAA,mBAAA;gBAsBG,SAAA,CAAU,SAAA,GAAU,aAAA,EACT,OAAA,CACb,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,QACjD,MAAA,CAAA,MAAA,OAAA,cAAA,GAAA,mBAAA,GAAA,mBAAA;kBAiCG,SAAA,CAAU,SAAA,GAAU,KAAA,EACjB,mBAAA,CAAoB,cAAA,CAAe,UAAA,CAAA,eAAA,GAAa,SAAA,OAAW,MAAA,CAAA,MAAA,OAAA,mBAAA;iBAsB/C,SAAA,CAAU,SAAA,MAAU,MAAA,CAAA,MAAA;EAAA;AAAA;AAAA,cAgBhC,cAAA,2BACa,YAAA,OAA2B,OAAA,CAAA,GAAA;kCA7GrB,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;kCAAA,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA;;;;;;;KAmHpB,cAAA,yBACc,YAAA,IACtB,UAAA,QAAkB,cAAA,CAAe,eAAA;AAAA,cAExB,KAAA,2BAAiC,YAAA,EAC5C,cAAA,EAAgB,eAAA,EAChB,oBAAA,EAAsB,qBAAA,CACpB,QAAA,CAAmB,UAAA,CAAqB,eAAA,QACzC,KAAA,CAAA,KAAA;kCA3H6B,UAAA,CAAA,UAAA,CAAA,eAAA,IAAA,SAAA,EAAA,SAAA"}

package/dist/MutationRunner.d.ts

@@ -1,14 +1,16 @@
-import { Context, Effect, Layer, ParseResult, Schema } from "effect";
+import { Context, Layer, Schema } from "effect";
 import * as Ref$1 from "@confect/core/Ref";
 import { GenericMutationCtx } from "convex/server";
+import * as effect_ParseResult0 from "effect/ParseResult";
+import * as effect_Effect0 from "effect/Effect";
 
 //#region src/MutationRunner.d.ts
 declare namespace MutationRunner_d_exports {
   export { MutationRollback, MutationRunner, layer };
 }
-declare const MutationRunner: Context.Tag<(<Mutation extends Ref$1.AnyMutation>(mutation: Mutation, args: Ref$1.Args<Mutation>) => Effect.Effect<Ref$1.Returns<Mutation>, ParseResult.ParseError>), <Mutation extends Ref$1.AnyMutation>(mutation: Mutation, args: Ref$1.Args<Mutation>) => Effect.Effect<Ref$1.Returns<Mutation>, ParseResult.ParseError>>;
+declare const MutationRunner: Context.Tag<(<Mutation extends Ref$1.AnyMutation>(mutation: Mutation, args: Ref$1.Args<Mutation>) => effect_Effect0.Effect<Ref$1.Ref_d_exports.Returns<Mutation>, effect_ParseResult0.ParseError, never>), <Mutation extends Ref$1.AnyMutation>(mutation: Mutation, args: Ref$1.Args<Mutation>) => effect_Effect0.Effect<Ref$1.Ref_d_exports.Returns<Mutation>, effect_ParseResult0.ParseError, never>>;
 type MutationRunner = typeof MutationRunner.Identifier;
-declare const layer: (runMutation: GenericMutationCtx<any>["runMutation"]) => Layer.Layer<(<Mutation extends Ref$1.AnyMutation>(mutation: Mutation, args: Ref$1.Args<Mutation>) => Effect.Effect<Ref$1.Returns<Mutation>, ParseResult.ParseError>), never, never>;
+declare const layer: (runMutation: GenericMutationCtx<any>["runMutation"]) => Layer.Layer<(<Mutation extends Ref$1.AnyMutation>(mutation: Mutation, args: Ref$1.Args<Mutation>) => effect_Effect0.Effect<Ref$1.Ref_d_exports.Returns<Mutation>, effect_ParseResult0.ParseError, never>), never, never>;
 declare const MutationRollback_base: Schema.TaggedErrorClass<MutationRollback, "MutationRollback", {
   readonly _tag: Schema.tag<"MutationRollback">;
 } & {

package/dist/MutationRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MutationRunner.d.ts","names":[],"sources":["../src/MutationRunner.ts"],"mappings":";;;;;;;;cAoCa,cAAA,EAAc,OAAA,CAAA,GAAA,oBA7BP,KAAA,CAAI,WAAA,EAAW,QAAA,EACrB,QAAA,EAAQ,IAAA,EACZ,KAAA,CAAI,IAAA,CAAK,QAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,QAAA,GAAW,WAAA,CAAY,UAAA,sBAHlC,KAAA,CAAI,WAAA,EAAW,QAAA,EACrB,QAAA,EAAQ,IAAA,EACZ,KAAA,CAAI,IAAA,CAAK,QAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,QAAA,GAAW,WAAA,CAAY,UAAA;AAAA,KA6B1C,cAAA,UAAwB,cAAA,CAAe,UAAA;AAAA,cAEtC,KAAA,GAAS,WAAA,EAAa,kBAAA,yBAAsC,KAAA,CAAA,KAAA,oBAlCrD,KAAA,CAAI,WAAA,EAAW,QAAA,EACrB,QAAA,EAAQ,IAAA,EACZ,KAAA,CAAI,IAAA,CAAK,QAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,QAAA,GAAW,WAAA,CAAY,UAAA;AAAA,cAgCH,qBAAA;;;;;;cAEtC,gBAAA,SAAyB,qBAAA;EAAA,IAQvB,OAAA,CAAA;AAAA"}
+{"version":3,"file":"MutationRunner.d.ts","names":[],"sources":["../src/MutationRunner.ts"],"mappings":";;;;;;;;;;cAca,cAAA,EAAc,OAAA,CAAA,GAAA,oBARP,KAAA,CAAI,WAAA,EAAW,QAAA,EACrB,QAAA,EAAQ,IAAA,EACZ,KAAA,CAAI,IAAA,CAAK,QAAA,MAAS,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,QAAA,GAAA,mBAAA,CAAA,UAAA,6BAFR,KAAA,CAAI,WAAA,EAAW,QAAA,EACrB,QAAA,EAAQ,IAAA,EACZ,KAAA,CAAI,IAAA,CAAK,QAAA,MAAS,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,QAAA,GAAA,mBAAA,CAAA,UAAA;AAAA,KAShB,cAAA,UAAwB,cAAA,CAAe,UAAA;AAAA,cAEtC,KAAA,GAAS,WAAA,EAAa,kBAAA,yBAAsC,KAAA,CAAA,KAAA,oBAbrD,KAAA,CAAI,WAAA,EAAW,QAAA,EACrB,QAAA,EAAQ,IAAA,EACZ,KAAA,CAAI,IAAA,CAAK,QAAA,MAAS,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,QAAA,GAAA,mBAAA,CAAA,UAAA;AAAA,cAYuB,qBAAA;;;;;;cAEtC,gBAAA,SAAyB,qBAAA;EAAA,IAQvB,OAAA,CAAA;AAAA"}

package/dist/MutationRunner.js

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer, Schema } from "effect";
 import * as Ref$1 from "@confect/core/Ref";
 import "convex/server";
 
@@ -9,15 +9,7 @@ var MutationRunner_exports = /* @__PURE__ */ __exportAll({
 	MutationRunner: () => MutationRunner,
 	layer: () => layer
 });
-const make = (runMutation) => (mutation, args) => Effect.gen(function* () {
-	const functionSpec = Ref$1.getFunctionSpec(mutation);
-	const functionName = Ref$1.getConvexFunctionName(mutation);
-	return yield* Match.value(functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionSpec) => Effect.gen(function* () {
-		const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(args);
-		const encodedReturns = yield* Effect.promise(() => runMutation(functionName, encodedArgs));
-		return yield* Schema.decode(confectFunctionSpec.returns)(encodedReturns);
-	})), Match.tag("Convex", () => Effect.promise(() => runMutation(functionName, args))), Match.exhaustive);
-});
+const make = (runMutation) => (mutation, args) => Ref$1.runWithCodec(mutation, args, (functionReference, encodedArgs) => runMutation(functionReference, encodedArgs));
 const MutationRunner = Context.GenericTag("@confect/server/MutationRunner");
 const layer = (runMutation) => Layer.succeed(MutationRunner, make(runMutation));
 var MutationRollback = class extends Schema.TaggedError()("MutationRollback", {

package/dist/MutationRunner.js.map

@@ -1 +1 @@
-{"version":3,"file":"MutationRunner.js","names":["Ref"],"sources":["../src/MutationRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericMutationCtx } from \"convex/server\";\nimport type { ParseResult } from \"effect\";\nimport { Context, Effect, Layer, Match, Schema } from \"effect\";\n\nconst make =\n  (runMutation: GenericMutationCtx<any>[\"runMutation\"]) =>\n  <Mutation extends Ref.AnyMutation>(\n    mutation: Mutation,\n    args: Ref.Args<Mutation>,\n  ): Effect.Effect<Ref.Returns<Mutation>, ParseResult.ParseError> =>\n    Effect.gen(function* () {\n      const functionSpec = Ref.getFunctionSpec(mutation);\n      const functionName = Ref.getConvexFunctionName(mutation);\n\n      return yield* Match.value(functionSpec.functionProvenance).pipe(\n        Match.tag(\"Confect\", (confectFunctionSpec) =>\n          Effect.gen(function* () {\n            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(\n              args,\n            );\n            const encodedReturns = yield* Effect.promise(() =>\n              runMutation(functionName as any, encodedArgs),\n            );\n            return yield* Schema.decode(confectFunctionSpec.returns)(\n              encodedReturns,\n            );\n          }),\n        ),\n        Match.tag(\"Convex\", () =>\n          Effect.promise(() => runMutation(functionName as any, args as any)),\n        ),\n        Match.exhaustive,\n      );\n    });\n\nexport const MutationRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/MutationRunner\",\n);\nexport type MutationRunner = typeof MutationRunner.Identifier;\n\nexport const layer = (runMutation: GenericMutationCtx<any>[\"runMutation\"]) =>\n  Layer.succeed(MutationRunner, make(runMutation));\n\nexport class MutationRollback extends Schema.TaggedError<MutationRollback>()(\n  \"MutationRollback\",\n  {\n    mutationName: Schema.String,\n    error: Schema.Unknown,\n  },\n) {\n  /* v8 ignore start */\n  override get message(): string {\n    return `Mutation ${this.mutationName} failed and was rolled back.\\n\\n${this.error}`;\n  }\n  /* v8 ignore stop */\n}\n"],"mappings":";;;;;;;;;;;AAKA,MAAM,QACH,iBAEC,UACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,eAAeA,MAAI,gBAAgB,SAAS;CAClD,MAAM,eAAeA,MAAI,sBAAsB,SAAS;AAExD,QAAO,OAAO,MAAM,MAAM,aAAa,mBAAmB,CAAC,KACzD,MAAM,IAAI,YAAY,wBACpB,OAAO,IAAI,aAAa;EACtB,MAAM,cAAc,OAAO,OAAO,OAAO,oBAAoB,KAAK,CAChE,KACD;EACD,MAAM,iBAAiB,OAAO,OAAO,cACnC,YAAY,cAAqB,YAAY,CAC9C;AACD,SAAO,OAAO,OAAO,OAAO,oBAAoB,QAAQ,CACtD,eACD;GACD,CACH,EACD,MAAM,IAAI,gBACR,OAAO,cAAc,YAAY,cAAqB,KAAY,CAAC,CACpE,EACD,MAAM,WACP;EACD;AAEN,MAAa,iBAAiB,QAAQ,WACpC,iCACD;AAGD,MAAa,SAAS,gBACpB,MAAM,QAAQ,gBAAgB,KAAK,YAAY,CAAC;AAElD,IAAa,mBAAb,cAAsC,OAAO,aAA+B,CAC1E,oBACA;CACE,cAAc,OAAO;CACrB,OAAO,OAAO;CACf,CACF,CAAC;;CAEA,IAAa,UAAkB;AAC7B,SAAO,YAAY,KAAK,aAAa,kCAAkC,KAAK"}
+{"version":3,"file":"MutationRunner.js","names":["Ref"],"sources":["../src/MutationRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericMutationCtx } from \"convex/server\";\nimport { Context, Layer, Schema } from \"effect\";\n\nconst make =\n  (runMutation: GenericMutationCtx<any>[\"runMutation\"]) =>\n  <Mutation extends Ref.AnyMutation>(\n    mutation: Mutation,\n    args: Ref.Args<Mutation>,\n  ) =>\n    Ref.runWithCodec(mutation, args, (functionReference, encodedArgs) =>\n      runMutation(functionReference, encodedArgs),\n    );\n\nexport const MutationRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/MutationRunner\",\n);\nexport type MutationRunner = typeof MutationRunner.Identifier;\n\nexport const layer = (runMutation: GenericMutationCtx<any>[\"runMutation\"]) =>\n  Layer.succeed(MutationRunner, make(runMutation));\n\nexport class MutationRollback extends Schema.TaggedError<MutationRollback>()(\n  \"MutationRollback\",\n  {\n    mutationName: Schema.String,\n    error: Schema.Unknown,\n  },\n) {\n  /* v8 ignore start */\n  override get message(): string {\n    return `Mutation ${this.mutationName} failed and was rolled back.\\n\\n${this.error}`;\n  }\n  /* v8 ignore stop */\n}\n"],"mappings":";;;;;;;;;;;AAIA,MAAM,QACH,iBAEC,UACA,SAEAA,MAAI,aAAa,UAAU,OAAO,mBAAmB,gBACnD,YAAY,mBAAmB,YAAY,CAC5C;AAEL,MAAa,iBAAiB,QAAQ,WACpC,iCACD;AAGD,MAAa,SAAS,gBACpB,MAAM,QAAQ,gBAAgB,KAAK,YAAY,CAAC;AAElD,IAAa,mBAAb,cAAsC,OAAO,aAA+B,CAC1E,oBACA;CACE,cAAc,OAAO;CACrB,OAAO,OAAO;CACf,CACF,CAAC;;CAEA,IAAa,UAAkB;AAC7B,SAAO,YAAY,KAAK,aAAa,kCAAkC,KAAK"}

package/dist/QueryRunner.d.ts

@@ -1,14 +1,16 @@
-import { Context, Effect, Layer, ParseResult } from "effect";
+import { Context, Layer } from "effect";
 import * as Ref$1 from "@confect/core/Ref";
 import { GenericQueryCtx } from "convex/server";
+import * as effect_ParseResult0 from "effect/ParseResult";
+import * as effect_Effect0 from "effect/Effect";
 
 //#region src/QueryRunner.d.ts
 declare namespace QueryRunner_d_exports {
   export { QueryRunner, layer };
 }
-declare const QueryRunner: Context.Tag<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => Effect.Effect<Ref$1.Returns<Query>, ParseResult.ParseError>), <Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => Effect.Effect<Ref$1.Returns<Query>, ParseResult.ParseError>>;
+declare const QueryRunner: Context.Tag<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => effect_Effect0.Effect<Ref$1.Ref_d_exports.Returns<Query>, effect_ParseResult0.ParseError, never>), <Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => effect_Effect0.Effect<Ref$1.Ref_d_exports.Returns<Query>, effect_ParseResult0.ParseError, never>>;
 type QueryRunner = typeof QueryRunner.Identifier;
-declare const layer: (runQuery: GenericQueryCtx<any>["runQuery"]) => Layer.Layer<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => Effect.Effect<Ref$1.Returns<Query>, ParseResult.ParseError>), never, never>;
+declare const layer: (runQuery: GenericQueryCtx<any>["runQuery"]) => Layer.Layer<(<Query extends Ref$1.AnyQuery>(query: Query, args: Ref$1.Args<Query>) => effect_Effect0.Effect<Ref$1.Ref_d_exports.Returns<Query>, effect_ParseResult0.ParseError, never>), never, never>;
 //#endregion
 export { QueryRunner, QueryRunner_d_exports, layer };
 //# sourceMappingURL=QueryRunner.d.ts.map

package/dist/QueryRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryRunner.d.ts","names":[],"sources":["../src/QueryRunner.ts"],"mappings":";;;;;;;;cAoCa,WAAA,EAAW,OAAA,CAAA,GAAA,iBA7BP,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,GAAQ,WAAA,CAAY,UAAA,mBAHlC,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,GAAQ,WAAA,CAAY,UAAA;AAAA,KA6BvC,WAAA,UAAqB,WAAA,CAAY,UAAA;AAAA,cAEhC,KAAA,GAAS,QAAA,EAAU,eAAA,sBAAgC,KAAA,CAAA,KAAA,iBAlC/C,KAAA,CAAI,QAAA,EAAQ,KAAA,EAClB,KAAA,EAAK,IAAA,EACN,KAAA,CAAI,IAAA,CAAK,KAAA,MACd,MAAA,CAAO,MAAA,CAAO,KAAA,CAAI,OAAA,CAAQ,KAAA,GAAQ,WAAA,CAAY,UAAA"}
+{"version":3,"file":"QueryRunner.d.ts","names":[],"sources":["../src/QueryRunner.ts"],"mappings":";;;;;;;;;;cAWa,WAAA,EAAW,OAAA,CAAA,GAAA,iBALP,KAAA,CAAI,QAAA,EAAQ,KAAA,EAAS,KAAA,EAAK,IAAA,EAAQ,KAAA,CAAI,IAAA,CAAK,KAAA,MAAM,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,KAAA,GAAA,mBAAA,CAAA,UAAA,0BAAjD,KAAA,CAAI,QAAA,EAAQ,KAAA,EAAS,KAAA,EAAK,IAAA,EAAQ,KAAA,CAAI,IAAA,CAAK,KAAA,MAAM,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,KAAA,GAAA,mBAAA,CAAA,UAAA;AAAA,KAQtD,WAAA,UAAqB,WAAA,CAAY,UAAA;AAAA,cAEhC,KAAA,GAAS,QAAA,EAAU,eAAA,sBAAgC,KAAA,CAAA,KAAA,iBAV/C,KAAA,CAAI,QAAA,EAAQ,KAAA,EAAS,KAAA,EAAK,IAAA,EAAQ,KAAA,CAAI,IAAA,CAAK,KAAA,MAAM,cAAA,CAAA,MAAA,CAAA,KAAA,CAAA,aAAA,CAAA,OAAA,CAAA,KAAA,GAAA,mBAAA,CAAA,UAAA"}

package/dist/QueryRunner.js

@@ -1,5 +1,5 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer } from "effect";
 import * as Ref$1 from "@confect/core/Ref";
 import "convex/server";
 
@@ -8,15 +8,7 @@ var QueryRunner_exports = /* @__PURE__ */ __exportAll({
 	QueryRunner: () => QueryRunner,
 	layer: () => layer
 });
-const make = (runQuery) => (query, args) => Effect.gen(function* () {
-	const functionSpec = Ref$1.getFunctionSpec(query);
-	const functionName = Ref$1.getConvexFunctionName(query);
-	return yield* Match.value(functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionSpec) => Effect.gen(function* () {
-		const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(args);
-		const encodedReturns = yield* Effect.promise(() => runQuery(functionName, encodedArgs));
-		return yield* Schema.decode(confectFunctionSpec.returns)(encodedReturns);
-	})), Match.tag("Convex", () => Effect.promise(() => runQuery(functionName, args))), Match.exhaustive);
-});
+const make = (runQuery) => (query, args) => Ref$1.runWithCodec(query, args, (functionReference, encodedArgs) => runQuery(functionReference, encodedArgs));
 const QueryRunner = Context.GenericTag("@confect/server/QueryRunner");
 const layer = (runQuery) => Layer.succeed(QueryRunner, make(runQuery));
 

package/dist/QueryRunner.js.map

@@ -1 +1 @@
-{"version":3,"file":"QueryRunner.js","names":["Ref"],"sources":["../src/QueryRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericQueryCtx } from \"convex/server\";\nimport type { ParseResult } from \"effect\";\nimport { Context, Effect, Layer, Match, Schema } from \"effect\";\n\nconst make =\n  (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  <Query extends Ref.AnyQuery>(\n    query: Query,\n    args: Ref.Args<Query>,\n  ): Effect.Effect<Ref.Returns<Query>, ParseResult.ParseError> =>\n    Effect.gen(function* () {\n      const functionSpec = Ref.getFunctionSpec(query);\n      const functionName = Ref.getConvexFunctionName(query);\n\n      return yield* Match.value(functionSpec.functionProvenance).pipe(\n        Match.tag(\"Confect\", (confectFunctionSpec) =>\n          Effect.gen(function* () {\n            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(\n              args,\n            );\n            const encodedReturns = yield* Effect.promise(() =>\n              runQuery(functionName as any, encodedArgs),\n            );\n            return yield* Schema.decode(confectFunctionSpec.returns)(\n              encodedReturns,\n            );\n          }),\n        ),\n        Match.tag(\"Convex\", () =>\n          Effect.promise(() => runQuery(functionName as any, args as any)),\n        ),\n        Match.exhaustive,\n      );\n    });\n\nexport const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/QueryRunner\",\n);\nexport type QueryRunner = typeof QueryRunner.Identifier;\n\nexport const layer = (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  Layer.succeed(QueryRunner, make(runQuery));\n"],"mappings":";;;;;;;;;;AAKA,MAAM,QACH,cAEC,OACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,eAAeA,MAAI,gBAAgB,MAAM;CAC/C,MAAM,eAAeA,MAAI,sBAAsB,MAAM;AAErD,QAAO,OAAO,MAAM,MAAM,aAAa,mBAAmB,CAAC,KACzD,MAAM,IAAI,YAAY,wBACpB,OAAO,IAAI,aAAa;EACtB,MAAM,cAAc,OAAO,OAAO,OAAO,oBAAoB,KAAK,CAChE,KACD;EACD,MAAM,iBAAiB,OAAO,OAAO,cACnC,SAAS,cAAqB,YAAY,CAC3C;AACD,SAAO,OAAO,OAAO,OAAO,oBAAoB,QAAQ,CACtD,eACD;GACD,CACH,EACD,MAAM,IAAI,gBACR,OAAO,cAAc,SAAS,cAAqB,KAAY,CAAC,CACjE,EACD,MAAM,WACP;EACD;AAEN,MAAa,cAAc,QAAQ,WACjC,8BACD;AAGD,MAAa,SAAS,aACpB,MAAM,QAAQ,aAAa,KAAK,SAAS,CAAC"}
+{"version":3,"file":"QueryRunner.js","names":["Ref"],"sources":["../src/QueryRunner.ts"],"sourcesContent":["import * as Ref from \"@confect/core/Ref\";\nimport { type GenericQueryCtx } from \"convex/server\";\nimport { Context, Layer } from \"effect\";\n\nconst make =\n  (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  <Query extends Ref.AnyQuery>(query: Query, args: Ref.Args<Query>) =>\n    Ref.runWithCodec(query, args, (functionReference, encodedArgs) =>\n      runQuery(functionReference, encodedArgs),\n    );\n\nexport const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/QueryRunner\",\n);\nexport type QueryRunner = typeof QueryRunner.Identifier;\n\nexport const layer = (runQuery: GenericQueryCtx<any>[\"runQuery\"]) =>\n  Layer.succeed(QueryRunner, make(runQuery));\n"],"mappings":";;;;;;;;;;AAIA,MAAM,QACH,cAC4B,OAAc,SACzCA,MAAI,aAAa,OAAO,OAAO,mBAAmB,gBAChD,SAAS,mBAAmB,YAAY,CACzC;AAEL,MAAa,cAAc,QAAQ,WACjC,8BACD;AAGD,MAAa,SAAS,aACpB,MAAM,QAAQ,aAAa,KAAK,SAAS,CAAC"}

package/dist/RegisteredConvexFunction.d.ts

@@ -22,8 +22,8 @@ import * as _confect_core_Ref0 from "@confect/core/Ref";
 import * as convex_server0 from "convex/server";
 import { GenericMutationCtx } from "convex/server";
 import * as convex_values0 from "convex/values";
-import * as _confect_core_Types0 from "@confect/core/Types";
 import * as effect_ParseResult0 from "effect/ParseResult";
+import * as _confect_core_Types0 from "@confect/core/Types";
 import * as effect_Duration0 from "effect/Duration";
 import * as effect_DateTime0 from "effect/DateTime";
 
@@ -35,7 +35,7 @@ declare const make: <Api_ extends AnyWithPropsWithRuntime<"Convex">>(api: Api_,
   functionSpec,
   handler
 }: AnyWithProps$1) => Any;
-declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<Auth$1 | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, effect_ParseResult0.ParseError>) | GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
+declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx: GenericMutationCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<GenericMutationCtx<ToConvex<FromSchema<Schema>>> | {
   table: <const TableName extends Name<IncludeSystemTables<Tables<Schema>>>>(tableName: TableName) => {
     readonly get: {
       (id: convex_values0.GenericId<TableName>): Effect.Effect<TableInfo<WithName<IncludeSystemTables<Tables<Schema>>, TableName>>["document"], GetByIdFailure | DocumentDecodeError, never>;
@@ -50,14 +50,14 @@ declare const mutationLayer: <Schema extends AnyWithProps>(schema: Schema, ctx:
 } | {
   table: <const TableName extends TableNames<FromSchema<Schema>>>(tableName: TableName) => {
     insert: (document: WithoutSystemFields$1<DocumentByName<FromSchema<Schema>, TableName>>) => Effect.Effect<convex_values0.GenericId<TableName>, DocumentEncodeError, never>;
-    patch: (id: convex_values0.GenericId<TableName>, patchedValues: Partial<convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, DocumentEncodeError | GetByIdFailure | DocumentDecodeError, never>;
+    patch: (id: convex_values0.GenericId<TableName>, patchedValues: Partial<convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>>) => Effect.Effect<void, GetByIdFailure | DocumentDecodeError | DocumentEncodeError, never>;
     replace: (id: convex_values0.GenericId<TableName>, value: convex_server0.Expand<convex_server0.BetterOmit<DocumentByName<FromSchema<Schema>, TableName>, "_id" | "_creationTime">>) => Effect.Effect<void, DocumentEncodeError, never>;
     delete: (id: convex_values0.GenericId<TableName>) => Effect.Effect<void, never, never>;
   };
-} | {
-  runAfter: <FuncRef extends convex_server0.SchedulableFunctionReference>(delay: effect_Duration0.Duration, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-  runAt: <FuncRef extends convex_server0.SchedulableFunctionReference>(dateTime: effect_DateTime0.DateTime, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, effect_ParseResult0.ParseError>), never, never>;
+} | Auth$1 | {
+  runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: keyof _confect_core_Ref0.Args<Ref_> extends never ? [args?: _confect_core_Ref0.Args<Ref_>] : [args: _confect_core_Ref0.Args<Ref_>]) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: keyof _confect_core_Ref0.Args<Ref_> extends never ? [args?: _confect_core_Ref0.Args<Ref_>] : [args: _confect_core_Ref0.Args<Ref_>]) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+} | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, effect_ParseResult0.ParseError, never>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, effect_ParseResult0.ParseError, never>), never, never>;
 type MutationServices<Schema extends AnyWithProps> = DatabaseReader<Schema> | DatabaseWriter<Schema> | Auth$1 | Scheduler$1 | StorageReader$1 | StorageWriter$1 | QueryRunner | MutationRunner | MutationCtx<ToConvex<FromSchema<Schema>>>;
 //#endregion
 export { MutationServices, RegisteredConvexFunction_d_exports, make, mutationLayer };

package/dist/RegisteredConvexFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCa,IAAA,gBAAqB,uBAAA,YAChC,GAAA,EAAK,IAAA;EACL,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAiIU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,CAAA,MAAA,sBAAA,kBAAA,CAAA,WAAA,EAAA,QAAA,EAAA,QAAA,EAAA,IAAA,EAAA,kBAAA,CAAA,IAAA,CAAA,QAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,QAAA,GAAA,mBAAA,CAAA,UAAA,KAAA,kBAAA,CAAA,QAAA,CAAA,UAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;KAoB/D,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}
+{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCa,IAAA,gBAAqB,uBAAA,YAChC,GAAA,EAAK,IAAA;EACL,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAiIU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,CAAA,kBAAA,CAAA,QAAA,CAAA,UAAA,CAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;KAoB/D,gBAAA,gBAAgC,YAAA,IACxC,cAAA,CAA8B,MAAA,IAC9B,cAAA,CAA8B,MAAA,IAC9B,MAAA,GACA,WAAA,GACA,eAAA,GACA,eAAA,GACA,WAAA,GACA,cAAA,GACA,WAAA,CAAwB,QAAA,CAAmB,UAAA,CAAqB,MAAA"}

package/dist/RegisteredFunction.d.ts

@@ -16,8 +16,8 @@ import * as convex_server0 from "convex/server";
 import { DefaultFunctionArgs, FunctionVisibility, GenericActionCtx, RegisteredAction, RegisteredMutation, RegisteredQuery } from "convex/server";
 import { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
 import * as convex_values0 from "convex/values";
-import * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import * as effect_ParseResult0 from "effect/ParseResult";
+import * as FunctionProvenance from "@confect/core/FunctionProvenance";
 import * as effect_Duration0 from "effect/Duration";
 import * as effect_DateTime0 from "effect/DateTime";
 
@@ -51,10 +51,10 @@ declare const actionFunctionBase: <Schema extends AnyWithProps, Args, ConvexArgs
   handler: (ctx: GenericActionCtx<ToConvex<FromSchema<Schema>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
 };
 type ActionServices<DatabaseSchema_ extends AnyWithProps> = Scheduler$1 | Auth$1 | StorageReader$1 | StorageWriter$1 | StorageActionWriter$1 | QueryRunner | MutationRunner | ActionRunner | VectorSearch<FromSchema<DatabaseSchema_>> | ActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>;
-declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<Auth$1 | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, effect_ParseResult0.ParseError>) | StorageActionWriter$1 | {
-  runAfter: <FuncRef extends convex_server0.SchedulableFunctionReference>(delay: effect_Duration0.Duration, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-  runAt: <FuncRef extends convex_server0.SchedulableFunctionReference>(dateTime: effect_DateTime0.DateTime, functionReference: FuncRef, ...args: convex_server0.OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | StorageReader$1 | StorageWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, effect_ParseResult0.ParseError>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | (<Action extends _confect_core_Ref0.AnyAction>(action: Action, args: _confect_core_Ref0.Args<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, effect_ParseResult0.ParseError>) | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
+declare const actionLayer: <DatabaseSchema_ extends AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>>) => Layer.Layer<GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | {
+  runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: keyof _confect_core_Ref0.Args<Ref_> extends never ? [args?: _confect_core_Ref0.Args<Ref_>] : [args: _confect_core_Ref0.Args<Ref_>]) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(dateTime: effect_DateTime0.DateTime, ref: Ref_, ...args: keyof _confect_core_Ref0.Args<Ref_> extends never ? [args?: _confect_core_Ref0.Args<Ref_>] : [args: _confect_core_Ref0.Args<Ref_>]) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+} | Auth$1 | StorageReader$1 | StorageWriter$1 | StorageActionWriter$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, args: _confect_core_Ref0.Args<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, effect_ParseResult0.ParseError, never>) | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, args: _confect_core_Ref0.Args<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, effect_ParseResult0.ParseError, never>) | (<Action extends _confect_core_Ref0.AnyAction>(action: Action, args: _confect_core_Ref0.Args<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, effect_ParseResult0.ParseError, never>) | (<TableName extends TableNames<FromSchema<DatabaseSchema_>>, IndexName extends keyof convex_server0.VectorIndexes<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
   vector: number[];
   limit?: number;
   filter?: (q: convex_server0.VectorFilterBuilder<convex_server0.DocumentByInfo<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>>, convex_server0.NamedVectorIndex<convex_server0.NamedTableInfo<ToConvex<FromSchema<DatabaseSchema_>>, TableName>, IndexName>>) => convex_server0.FilterExpression<boolean>;

package/dist/RegisteredFunction.d.ts.map

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

package/dist/Scheduler.d.ts

@@ -1,22 +1,24 @@
 import { Context, DateTime, Duration, Effect, Layer } from "effect";
-import { OptionalRestArgs, SchedulableFunctionReference, Scheduler as Scheduler$1 } from "convex/server";
+import { Scheduler as Scheduler$1 } from "convex/server";
+import { Ref as Ref$1 } from "@confect/core";
 import * as convex_values0 from "convex/values";
 
 //#region src/Scheduler.d.ts
 declare namespace Scheduler_d_exports {
   export { Scheduler, layer };
 }
+type OptionalArgs<Ref_ extends Ref$1.AnyMutation | Ref$1.AnyAction> = keyof Ref$1.Args<Ref_> extends never ? [args?: Ref$1.Args<Ref_>] : [args: Ref$1.Args<Ref_>];
 declare const Scheduler: Context.Tag<{
-  runAfter: <FuncRef extends SchedulableFunctionReference>(delay: Duration.Duration, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-  runAt: <FuncRef extends SchedulableFunctionReference>(dateTime: DateTime.DateTime, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAfter: <Ref_ extends Ref$1.AnyMutation | Ref$1.AnyAction>(delay: Duration.Duration, ref: Ref_, ...args: OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <Ref_ extends Ref$1.AnyMutation | Ref$1.AnyAction>(dateTime: DateTime.DateTime, ref: Ref_, ...args: OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
 }, {
-  runAfter: <FuncRef extends SchedulableFunctionReference>(delay: Duration.Duration, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-  runAt: <FuncRef extends SchedulableFunctionReference>(dateTime: DateTime.DateTime, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAfter: <Ref_ extends Ref$1.AnyMutation | Ref$1.AnyAction>(delay: Duration.Duration, ref: Ref_, ...args: OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <Ref_ extends Ref$1.AnyMutation | Ref$1.AnyAction>(dateTime: DateTime.DateTime, ref: Ref_, ...args: OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
 }>;
 type Scheduler = typeof Scheduler.Identifier;
 declare const layer: (scheduler: Scheduler$1) => Layer.Layer<{
-  runAfter: <FuncRef extends SchedulableFunctionReference>(delay: Duration.Duration, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-  runAt: <FuncRef extends SchedulableFunctionReference>(dateTime: DateTime.DateTime, functionReference: FuncRef, ...args: OptionalRestArgs<FuncRef>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAfter: <Ref_ extends Ref$1.AnyMutation | Ref$1.AnyAction>(delay: Duration.Duration, ref: Ref_, ...args: OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
+  runAt: <Ref_ extends Ref$1.AnyMutation | Ref$1.AnyAction>(dateTime: DateTime.DateTime, ref: Ref_, ...args: OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
 }, never, never>;
 //#endregion
 export { Scheduler, Scheduler_d_exports, layer };

package/dist/Scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Scheduler.d.ts","names":[],"sources":["../src/Scheduler.ts"],"mappings":";;;;;;;;cAgCa,SAAA,EAAS,OAAA,CAAA,GAAA;6BAxBO,4BAAA,EAA4B,KAAA,EAC9C,QAAA,CAAS,QAAA,EAAQ,iBAAA,EACL,OAAA,KAAO,IAAA,EACjB,gBAAA,CAAiB,OAAA,MAAQ,MAAA,CAAA,MAAA,CAAT,cAAA,CAAS,SAAA;0BAQZ,4BAAA,EAA4B,QAAA,EACxC,QAAA,CAAS,QAAA,EAAQ,iBAAA,EACR,OAAA,KAAO,IAAA,EACjB,gBAAA,CAAiB,OAAA,MAAQ,MAAA,CAAA,MAAA,CAAT,cAAA,CAAS,SAAA;AAAA;6BAdT,4BAAA,EAA4B,KAAA,EAC9C,QAAA,CAAS,QAAA,EAAQ,iBAAA,EACL,OAAA,KAAO,IAAA,EACjB,gBAAA,CAAiB,OAAA,MAAQ,MAAA,CAAA,MAAA,CAAT,cAAA,CAAS,SAAA;0BAQZ,4BAAA,EAA4B,QAAA,EACxC,QAAA,CAAS,QAAA,EAAQ,iBAAA,EACR,OAAA,KAAO,IAAA,EACjB,gBAAA,CAAiB,OAAA,MAAQ,MAAA,CAAA,MAAA,CAAT,cAAA,CAAS,SAAA;AAAA;AAAA,KAa1B,SAAA,UAAmB,SAAA,CAAU,UAAA;AAAA,cAE5B,KAAA,GAAS,SAAA,EAAW,WAAA,KAAe,KAAA,CAAA,KAAA;6BA7BnB,4BAAA,EAA4B,KAAA,EAC9C,QAAA,CAAS,QAAA,EAAQ,iBAAA,EACL,OAAA,KAAO,IAAA,EACjB,gBAAA,CAAiB,OAAA,MAAQ,MAAA,CAAA,MAAA,CAAT,cAAA,CAAS,SAAA;0BAQZ,4BAAA,EAA4B,QAAA,EACxC,QAAA,CAAS,QAAA,EAAQ,iBAAA,EACR,OAAA,KAAO,IAAA,EACjB,gBAAA,CAAiB,OAAA,MAAQ,MAAA,CAAA,MAAA,CAAT,cAAA,CAAS,SAAA;AAAA"}
+{"version":3,"file":"Scheduler.d.ts","names":[],"sources":["../src/Scheduler.ts"],"mappings":";;;;;;;;;KAIK,YAAA,cAA0B,KAAA,CAAI,WAAA,GAAc,KAAA,CAAI,SAAA,UAC7C,KAAA,CAAI,IAAA,CAAK,IAAA,mBACV,IAAA,GAAO,KAAA,CAAI,IAAA,CAAK,IAAA,MAChB,IAAA,EAAM,KAAA,CAAI,IAAA,CAAK,IAAA;AAAA,cAqCT,SAAA,EAAS,OAAA,CAAA,GAAA;0BAlCI,KAAA,CAAI,WAAA,GAAc,KAAA,CAAI,SAAA,EAAS,KAAA,EAC9C,QAAA,CAAS,QAAA,EAAQ,GAAA,EACnB,IAAA,KAAI,IAAA,EACA,YAAA,CAAa,IAAA,MAAK,MAAA,CAAA,MAAA,CAAN,cAAA,CAAM,SAAA;uBAaR,KAAA,CAAI,WAAA,GAAc,KAAA,CAAI,SAAA,EAAS,QAAA,EACxC,QAAA,CAAS,QAAA,EAAQ,GAAA,EACtB,IAAA,KAAI,IAAA,EACA,YAAA,CAAa,IAAA,MAAK,MAAA,CAAA,MAAA,CAAN,cAAA,CAAM,SAAA;AAAA;0BAnBL,KAAA,CAAI,WAAA,GAAc,KAAA,CAAI,SAAA,EAAS,KAAA,EAC9C,QAAA,CAAS,QAAA,EAAQ,GAAA,EACnB,IAAA,KAAI,IAAA,EACA,YAAA,CAAa,IAAA,MAAK,MAAA,CAAA,MAAA,CAAN,cAAA,CAAM,SAAA;uBAaR,KAAA,CAAI,WAAA,GAAc,KAAA,CAAI,SAAA,EAAS,QAAA,EACxC,QAAA,CAAS,QAAA,EAAQ,GAAA,EACtB,IAAA,KAAI,IAAA,EACA,YAAA,CAAa,IAAA,MAAK,MAAA,CAAA,MAAA,CAAN,cAAA,CAAM,SAAA;AAAA;AAAA,KAkBnB,SAAA,UAAmB,SAAA,CAAU,UAAA;AAAA,cAE5B,KAAA,GAAS,SAAA,EAAW,WAAA,KAAe,KAAA,CAAA,KAAA;0BAvCtB,KAAA,CAAI,WAAA,GAAc,KAAA,CAAI,SAAA,EAAS,KAAA,EAC9C,QAAA,CAAS,QAAA,EAAQ,GAAA,EACnB,IAAA,KAAI,IAAA,EACA,YAAA,CAAa,IAAA,MAAK,MAAA,CAAA,MAAA,CAAN,cAAA,CAAM,SAAA;uBAaR,KAAA,CAAI,WAAA,GAAc,KAAA,CAAI,SAAA,EAAS,QAAA,EACxC,QAAA,CAAS,QAAA,EAAQ,GAAA,EACtB,IAAA,KAAI,IAAA,EACA,YAAA,CAAa,IAAA,MAAK,MAAA,CAAA,MAAA,CAAN,cAAA,CAAM,SAAA;AAAA"}

package/dist/Scheduler.js

@@ -1,5 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { Context, DateTime, Duration, Effect, Layer } from "effect";
+import { Ref as Ref$1 } from "@confect/core";
 
 //#region src/Scheduler.ts
 var Scheduler_exports = /* @__PURE__ */ __exportAll({
@@ -7,13 +8,17 @@ var Scheduler_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer
 });
 const make = (scheduler) => ({
-	runAfter: (delay, functionReference, ...args) => {
+	runAfter: (delay, ref, ...args) => {
 		const delayMs = Duration.toMillis(delay);
-		return Effect.promise(() => scheduler.runAfter(delayMs, functionReference, ...args));
+		const functionReference = Ref$1.getFunctionReference(ref);
+		const encodedArgs = Ref$1.encodeArgsSync(ref, args[0] ?? {});
+		return Effect.promise(() => scheduler.runAfter(delayMs, functionReference, encodedArgs));
 	},
-	runAt: (dateTime, functionReference, ...args) => {
+	runAt: (dateTime, ref, ...args) => {
 		const timestamp = DateTime.toEpochMillis(dateTime);
-		return Effect.promise(() => scheduler.runAt(timestamp, functionReference, ...args));
+		const functionReference = Ref$1.getFunctionReference(ref);
+		const encodedArgs = Ref$1.encodeArgsSync(ref, args[0] ?? {});
+		return Effect.promise(() => scheduler.runAt(timestamp, functionReference, encodedArgs));
 	}
 });
 const Scheduler = Context.GenericTag("@confect/server/Scheduler");

package/dist/Scheduler.js.map

@@ -1 +1 @@
-{"version":3,"file":"Scheduler.js","names":[],"sources":["../src/Scheduler.ts"],"sourcesContent":["import type {\n  OptionalRestArgs,\n  SchedulableFunctionReference,\n  Scheduler as ConvexScheduler,\n} from \"convex/server\";\nimport { Context, DateTime, Duration, Effect, Layer } from \"effect\";\n\nconst make = (scheduler: ConvexScheduler) => ({\n  runAfter: <FuncRef extends SchedulableFunctionReference>(\n    delay: Duration.Duration,\n    functionReference: FuncRef,\n    ...args: OptionalRestArgs<FuncRef>\n  ) => {\n    const delayMs = Duration.toMillis(delay);\n\n    return Effect.promise(() =>\n      scheduler.runAfter(delayMs, functionReference, ...args),\n    );\n  },\n  runAt: <FuncRef extends SchedulableFunctionReference>(\n    dateTime: DateTime.DateTime,\n    functionReference: FuncRef,\n    ...args: OptionalRestArgs<FuncRef>\n  ) => {\n    const timestamp = DateTime.toEpochMillis(dateTime);\n\n    return Effect.promise(() =>\n      scheduler.runAt(timestamp, functionReference, ...args),\n    );\n  },\n});\n\nexport const Scheduler = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/Scheduler\",\n);\nexport type Scheduler = typeof Scheduler.Identifier;\n\nexport const layer = (scheduler: ConvexScheduler) =>\n  Layer.succeed(Scheduler, make(scheduler));\n"],"mappings":";;;;;;;;AAOA,MAAM,QAAQ,eAAgC;CAC5C,WACE,OACA,mBACA,GAAG,SACA;EACH,MAAM,UAAU,SAAS,SAAS,MAAM;AAExC,SAAO,OAAO,cACZ,UAAU,SAAS,SAAS,mBAAmB,GAAG,KAAK,CACxD;;CAEH,QACE,UACA,mBACA,GAAG,SACA;EACH,MAAM,YAAY,SAAS,cAAc,SAAS;AAElD,SAAO,OAAO,cACZ,UAAU,MAAM,WAAW,mBAAmB,GAAG,KAAK,CACvD;;CAEJ;AAED,MAAa,YAAY,QAAQ,WAC/B,4BACD;AAGD,MAAa,SAAS,cACpB,MAAM,QAAQ,WAAW,KAAK,UAAU,CAAC"}
+{"version":3,"file":"Scheduler.js","names":["Ref"],"sources":["../src/Scheduler.ts"],"sourcesContent":["import { Ref } from \"@confect/core\";\nimport type { Scheduler as ConvexScheduler } from \"convex/server\";\nimport { Context, DateTime, Duration, Effect, Layer } from \"effect\";\n\ntype OptionalArgs<Ref_ extends Ref.AnyMutation | Ref.AnyAction> =\n  keyof Ref.Args<Ref_> extends never\n    ? [args?: Ref.Args<Ref_>]\n    : [args: Ref.Args<Ref_>];\n\nconst make = (scheduler: ConvexScheduler) => ({\n  runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(\n    delay: Duration.Duration,\n    ref: Ref_,\n    ...args: OptionalArgs<Ref_>\n  ) => {\n    const delayMs = Duration.toMillis(delay);\n    const functionReference = Ref.getFunctionReference(ref);\n    const encodedArgs = Ref.encodeArgsSync(\n      ref,\n      (args[0] ?? {}) as Ref.Args<Ref_>,\n    );\n\n    return Effect.promise(() =>\n      scheduler.runAfter(delayMs, functionReference, encodedArgs),\n    );\n  },\n  runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(\n    dateTime: DateTime.DateTime,\n    ref: Ref_,\n    ...args: OptionalArgs<Ref_>\n  ) => {\n    const timestamp = DateTime.toEpochMillis(dateTime);\n    const functionReference = Ref.getFunctionReference(ref);\n    const encodedArgs = Ref.encodeArgsSync(\n      ref,\n      (args[0] ?? {}) as Ref.Args<Ref_>,\n    );\n\n    return Effect.promise(() =>\n      scheduler.runAt(timestamp, functionReference, encodedArgs),\n    );\n  },\n});\n\nexport const Scheduler = Context.GenericTag<ReturnType<typeof make>>(\n  \"@confect/server/Scheduler\",\n);\nexport type Scheduler = typeof Scheduler.Identifier;\n\nexport const layer = (scheduler: ConvexScheduler) =>\n  Layer.succeed(Scheduler, make(scheduler));\n"],"mappings":";;;;;;;;;AASA,MAAM,QAAQ,eAAgC;CAC5C,WACE,OACA,KACA,GAAG,SACA;EACH,MAAM,UAAU,SAAS,SAAS,MAAM;EACxC,MAAM,oBAAoBA,MAAI,qBAAqB,IAAI;EACvD,MAAM,cAAcA,MAAI,eACtB,KACC,KAAK,MAAM,EAAE,CACf;AAED,SAAO,OAAO,cACZ,UAAU,SAAS,SAAS,mBAAmB,YAAY,CAC5D;;CAEH,QACE,UACA,KACA,GAAG,SACA;EACH,MAAM,YAAY,SAAS,cAAc,SAAS;EAClD,MAAM,oBAAoBA,MAAI,qBAAqB,IAAI;EACvD,MAAM,cAAcA,MAAI,eACtB,KACC,KAAK,MAAM,EAAE,CACf;AAED,SAAO,OAAO,cACZ,UAAU,MAAM,WAAW,mBAAmB,YAAY,CAC3D;;CAEJ;AAED,MAAa,YAAY,QAAQ,WAC/B,4BACD;AAGD,MAAa,SAAS,cACpB,MAAM,QAAQ,WAAW,KAAK,UAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@confect/server",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "description": "Backend bindings to the Convex platform",
   "repository": {
     "type": "git",
@@ -67,15 +67,15 @@
     "vite": "7.3.1",
     "vite-tsconfig-paths": "6.1.1",
     "vitest": "3.2.4",
-    "@confect/cli": "4.0.0",
-    "@confect/test": "4.0.0"
+    "@confect/cli": "5.0.0",
+    "@confect/test": "5.0.0"
   },
   "peerDependencies": {
     "@effect/platform": "^0.94.5",
     "@effect/platform-node": "^0.104.1",
     "convex": "^1.30.0",
     "effect": "^3.19.16",
-    "@confect/core": "4.0.0"
+    "@confect/core": "5.0.0"
   },
   "engines": {
     "node": ">=22",

package/src/ActionRunner.ts

@@ -1,38 +1,13 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericActionCtx } from "convex/server";
-import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer } from "effect";
 
 const make =
   (runAction: GenericActionCtx<any>["runAction"]) =>
-  <Action extends Ref.AnyAction>(
-    action: Action,
-    args: Ref.Args<Action>,
-  ): Effect.Effect<Ref.Returns<Action>, ParseResult.ParseError> =>
-    Effect.gen(function* () {
-      const functionSpec = Ref.getFunctionSpec(action);
-      const functionName = Ref.getConvexFunctionName(action);
-
-      return yield* Match.value(functionSpec.functionProvenance).pipe(
-        Match.tag("Confect", (confectFunctionSpec) =>
-          Effect.gen(function* () {
-            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
-              args,
-            );
-            const encodedReturns = yield* Effect.promise(() =>
-              runAction(functionName as any, encodedArgs),
-            );
-            return yield* Schema.decode(confectFunctionSpec.returns)(
-              encodedReturns,
-            );
-          }),
-        ),
-        Match.tag("Convex", () =>
-          Effect.promise(() => runAction(functionName as any, args as any)),
-        ),
-        Match.exhaustive,
-      );
-    });
+  <Action extends Ref.AnyAction>(action: Action, args: Ref.Args<Action>) =>
+    Ref.runWithCodec(action, args, (functionReference, encodedArgs) =>
+      runAction(functionReference, encodedArgs),
+    );
 
 export const ActionRunner = Context.GenericTag<ReturnType<typeof make>>(
   "@confect/server/ActionRunner",

package/src/CronJobs.ts

@@ -1,8 +1,5 @@
 import { Ref } from "@confect/core";
-import type {
-  CronJob as ConvexCronJob,
-  SchedulableFunctionReference,
-} from "convex/server";
+import type { CronJob as ConvexCronJob } from "convex/server";
 import { cronJobs as makeConvexCrons, type Crons } from "convex/server";
 import {
   Array,
@@ -13,7 +10,6 @@ import {
   pipe,
   Predicate,
   Record,
-  Schema,
 } from "effect";
 import type * as CronJob from "./CronJob";
 
@@ -39,25 +35,15 @@ const Proto = {
       crons: { ...this.convexCronJobs.crons },
     });
 
-    const schedulableFunctionReference = Ref.getConvexFunctionName(
-      cronJob.ref,
-    ) as unknown as SchedulableFunctionReference;
-
-    const functionSpec = Ref.getFunctionSpec(cronJob.ref);
-    const encodedArgs = Match.value(functionSpec.functionProvenance).pipe(
-      Match.tag("Confect", (confect) =>
-        Schema.encodeSync(confect.args)(cronJob.args),
-      ),
-      Match.tag("Convex", () => cronJob.args),
-      Match.exhaustive,
-    );
+    const functionReference = Ref.getFunctionReference(cronJob.ref);
+    const encodedArgs = Ref.encodeArgsSync(cronJob.ref, cronJob.args);
 
     Match.value(cronJob.schedule).pipe(
       Match.when(Cron.isCron, (cron) => {
         newConvexCrons.cron(
           cronJob.identifier,
           cronToConvexCronString(cron),
-          schedulableFunctionReference,
+          functionReference,
           encodedArgs,
         );
       }),
@@ -65,7 +51,7 @@ const Proto = {
         newConvexCrons.interval(
           cronJob.identifier,
           durationToConvexIntervalSchedule(duration),
-          schedulableFunctionReference,
+          functionReference,
           encodedArgs,
         );
       }),

package/src/MutationRunner.ts

@@ -1,38 +1,16 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericMutationCtx } from "convex/server";
-import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer, Schema } from "effect";
 
 const make =
   (runMutation: GenericMutationCtx<any>["runMutation"]) =>
   <Mutation extends Ref.AnyMutation>(
     mutation: Mutation,
     args: Ref.Args<Mutation>,
-  ): Effect.Effect<Ref.Returns<Mutation>, ParseResult.ParseError> =>
-    Effect.gen(function* () {
-      const functionSpec = Ref.getFunctionSpec(mutation);
-      const functionName = Ref.getConvexFunctionName(mutation);
-
-      return yield* Match.value(functionSpec.functionProvenance).pipe(
-        Match.tag("Confect", (confectFunctionSpec) =>
-          Effect.gen(function* () {
-            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
-              args,
-            );
-            const encodedReturns = yield* Effect.promise(() =>
-              runMutation(functionName as any, encodedArgs),
-            );
-            return yield* Schema.decode(confectFunctionSpec.returns)(
-              encodedReturns,
-            );
-          }),
-        ),
-        Match.tag("Convex", () =>
-          Effect.promise(() => runMutation(functionName as any, args as any)),
-        ),
-        Match.exhaustive,
-      );
-    });
+  ) =>
+    Ref.runWithCodec(mutation, args, (functionReference, encodedArgs) =>
+      runMutation(functionReference, encodedArgs),
+    );
 
 export const MutationRunner = Context.GenericTag<ReturnType<typeof make>>(
   "@confect/server/MutationRunner",

package/src/QueryRunner.ts

@@ -1,38 +1,13 @@
 import * as Ref from "@confect/core/Ref";
 import { type GenericQueryCtx } from "convex/server";
-import type { ParseResult } from "effect";
-import { Context, Effect, Layer, Match, Schema } from "effect";
+import { Context, Layer } from "effect";
 
 const make =
   (runQuery: GenericQueryCtx<any>["runQuery"]) =>
-  <Query extends Ref.AnyQuery>(
-    query: Query,
-    args: Ref.Args<Query>,
-  ): Effect.Effect<Ref.Returns<Query>, ParseResult.ParseError> =>
-    Effect.gen(function* () {
-      const functionSpec = Ref.getFunctionSpec(query);
-      const functionName = Ref.getConvexFunctionName(query);
-
-      return yield* Match.value(functionSpec.functionProvenance).pipe(
-        Match.tag("Confect", (confectFunctionSpec) =>
-          Effect.gen(function* () {
-            const encodedArgs = yield* Schema.encode(confectFunctionSpec.args)(
-              args,
-            );
-            const encodedReturns = yield* Effect.promise(() =>
-              runQuery(functionName as any, encodedArgs),
-            );
-            return yield* Schema.decode(confectFunctionSpec.returns)(
-              encodedReturns,
-            );
-          }),
-        ),
-        Match.tag("Convex", () =>
-          Effect.promise(() => runQuery(functionName as any, args as any)),
-        ),
-        Match.exhaustive,
-      );
-    });
+  <Query extends Ref.AnyQuery>(query: Query, args: Ref.Args<Query>) =>
+    Ref.runWithCodec(query, args, (functionReference, encodedArgs) =>
+      runQuery(functionReference, encodedArgs),
+    );
 
 export const QueryRunner = Context.GenericTag<ReturnType<typeof make>>(
   "@confect/server/QueryRunner",

package/src/Scheduler.ts

@@ -1,31 +1,43 @@
-import type {
-  OptionalRestArgs,
-  SchedulableFunctionReference,
-  Scheduler as ConvexScheduler,
-} from "convex/server";
+import { Ref } from "@confect/core";
+import type { Scheduler as ConvexScheduler } from "convex/server";
 import { Context, DateTime, Duration, Effect, Layer } from "effect";
 
+type OptionalArgs<Ref_ extends Ref.AnyMutation | Ref.AnyAction> =
+  keyof Ref.Args<Ref_> extends never
+    ? [args?: Ref.Args<Ref_>]
+    : [args: Ref.Args<Ref_>];
+
 const make = (scheduler: ConvexScheduler) => ({
-  runAfter: <FuncRef extends SchedulableFunctionReference>(
+  runAfter: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
     delay: Duration.Duration,
-    functionReference: FuncRef,
-    ...args: OptionalRestArgs<FuncRef>
+    ref: Ref_,
+    ...args: OptionalArgs<Ref_>
   ) => {
     const delayMs = Duration.toMillis(delay);
+    const functionReference = Ref.getFunctionReference(ref);
+    const encodedArgs = Ref.encodeArgsSync(
+      ref,
+      (args[0] ?? {}) as Ref.Args<Ref_>,
+    );
 
     return Effect.promise(() =>
-      scheduler.runAfter(delayMs, functionReference, ...args),
+      scheduler.runAfter(delayMs, functionReference, encodedArgs),
     );
   },
-  runAt: <FuncRef extends SchedulableFunctionReference>(
+  runAt: <Ref_ extends Ref.AnyMutation | Ref.AnyAction>(
     dateTime: DateTime.DateTime,
-    functionReference: FuncRef,
-    ...args: OptionalRestArgs<FuncRef>
+    ref: Ref_,
+    ...args: OptionalArgs<Ref_>
   ) => {
     const timestamp = DateTime.toEpochMillis(dateTime);
+    const functionReference = Ref.getFunctionReference(ref);
+    const encodedArgs = Ref.encodeArgsSync(
+      ref,
+      (args[0] ?? {}) as Ref.Args<Ref_>,
+    );
 
     return Effect.promise(() =>
-      scheduler.runAt(timestamp, functionReference, ...args),
+      scheduler.runAt(timestamp, functionReference, encodedArgs),
     );
   },
 });