@confect/server 9.0.0-next.9 → 9.0.0

package/dist/RegisteredConvexFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.d.ts","names":[],"sources":["../src/RegisteredConvexFunction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA;AAAA,cAkLU,aAAA,kBAAgC,YAAA,EAC3C,MAAA,EAAQ,MAAA,EACR,GAAA,EAAK,kBAAA,CAAmB,QAAA,CAAmB,UAAA,CAAqB,MAAA,QAAS,KAAA,CAAA,KAAA,CAAA,MAAA,mBAAA,kBAAA,CAAA,QAAA,EAAA,KAAA,EAAA,KAAA,KAAA,IAAA,EAAA,kBAAA,CAAA,YAAA,CAAA,KAAA,MAAA,MAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,OAAA,CAAA,KAAA,GAAA,kBAAA,CAAA,KAAA,CAAA,KAAA,IAAA,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","sourceRoot":"","sources":["../src/RegisteredConvexFunction.ts"],"names":[],"mappings":"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"}

package/dist/RegisteredConvexFunction.js

@@ -7,8 +7,8 @@ import { layer as layer$2 } from "./DatabaseWriter.js";
 import { layer as layer$3 } from "./MutationRunner.js";
 import { layer as layer$4 } from "./QueryRunner.js";
 import { layer as layer$5 } from "./Scheduler.js";
-import { StorageReader as StorageReader$1 } from "./StorageReader.js";
-import { StorageWriter as StorageWriter$1 } from "./StorageWriter.js";
+import { StorageReader } from "./StorageReader.js";
+import { StorageWriter } from "./StorageWriter.js";
 import { MutationCtx } from "./MutationCtx.js";
 import { QueryCtx } from "./QueryCtx.js";
 import { actionFunctionBase, actionLayer, runHandlerPromise } from "./RegisteredFunction.js";
@@ -89,10 +89,10 @@ const queryFunction = ({ databaseSchema, args, returns, error, handler }) => ({
 	args: compileArgsSchema(args),
 	returns: compileReturnsSchema(returns),
 	handler: (ctx, actualArgs) => withStubbedDateNow((clock) => Effect.gen(function* () {
-		return yield* pipe(yield* handler(yield* pipe(actualArgs, Schema.decode(args), Effect.orDie)).pipe(Effect.provide(Layer.mergeAll(layer$1(databaseSchema, ctx.db), layer(ctx.auth), StorageReader$1.layer(ctx.storage), layer$4(ctx.runQuery), Layer.succeed(QueryCtx(), ctx), Layer.setConfigProvider(make$1())))), Schema.encode(returns), Effect.orDie);
+		return yield* pipe(yield* handler(yield* pipe(actualArgs, Schema.decode(args), Effect.orDie)).pipe(Effect.provide(Layer.mergeAll(layer$1(databaseSchema, ctx.db), layer(ctx.auth), StorageReader.layer(ctx.storage), layer$4(ctx.runQuery), Layer.succeed(QueryCtx(), ctx), Layer.setConfigProvider(make$1())))), Schema.encode(returns), Effect.orDie);
 	}).pipe(Effect.withClock(clock), runHandlerPromise(error)))
 });
-const mutationLayer = (schema, ctx) => Layer.mergeAll(layer$1(schema, ctx.db), layer$2(schema, ctx.db), layer(ctx.auth), layer$5(ctx.scheduler), StorageReader$1.layer(ctx.storage), StorageWriter$1.layer(ctx.storage), layer$4(ctx.runQuery), layer$3(ctx.runMutation), Layer.succeed(MutationCtx(), ctx), Layer.setConfigProvider(make$1()));
+const mutationLayer = (schema, ctx) => Layer.mergeAll(layer$1(schema, ctx.db), layer$2(schema, ctx.db), layer(ctx.auth), layer$5(ctx.scheduler), StorageReader.layer(ctx.storage), StorageWriter.layer(ctx.storage), layer$4(ctx.runQuery), layer$3(ctx.runMutation), Layer.succeed(MutationCtx(), ctx), Layer.setConfigProvider(make$1()));
 const mutationFunction = ({ databaseSchema, args, returns, error, handler }) => ({
 	args: compileArgsSchema(args),
 	returns: compileReturnsSchema(returns),

package/dist/RegisteredConvexFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredConvexFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","StorageReader","QueryRunner.layer","QueryCtx.QueryCtx","ConvexConfigProvider.make","RegisteredFunction.runHandlerPromise","DatabaseWriter.layer","Scheduler.layer","StorageWriter","MutationRunner.layer","MutationCtx.MutationCtx","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredConvexFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Clock from \"effect/Clock\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Match from \"effect/Match\";\nimport * as Schema from \"effect/Schema\";\nimport * as Auth from \"./Auth\";\nimport * as ConvexConfigProvider from \"./ConvexConfigProvider\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport type * as Handler from \"./Handler\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageReader } from \"./StorageReader\";\nimport { StorageWriter } from \"./StorageWriter\";\n\nexport const make = (\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(\n        Match.when(\"query\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => queryGeneric),\n            Match.when(\"internal\", () => internalQueryGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            queryFunction({\n              databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"mutation\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => mutationGeneric),\n            Match.when(\"internal\", () => internalMutationGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            mutationFunction({\n              databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"action\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => actionGeneric),\n            Match.when(\"internal\", () => internalActionGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            convexActionFunction(databaseSchema, {\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.exhaustive,\n      );\n    }),\n    Match.exhaustive,\n  );\n\n/**\n * Convex's query cache is invalidated by any Date.now() call during handler\n * execution. Effect's unsafeFork calls Date.now() when constructing a\n * FiberId.Runtime, which trips the cache for every confect-wrapped query. We\n * stub Date.now to 0 for the span of the handler; queries are forbidden from\n * relying on real time for correctness anyway.\n *\n * Users who explicitly want the real timestamp can still reach it via Effect's\n * Clock service (Clock.currentTimeMillis/Clock.currentTimeNanos). We provide a\n * Clock whose user-facing Effects call realDateNow (Convex's tracker) directly,\n * making Clock an explicit opt-in to cache invalidation. The unsafe methods\n * used internally by Effect (logging, span events, scheduler) return constants\n * so they never touch the tracker—caching is not broken by default.\n */\nconst unpatchedClock = (realDateNow: () => number): Clock.Clock => {\n  const defaultClock = Clock.make();\n  return {\n    ...defaultClock,\n    unsafeCurrentTimeMillis: () => 0,\n    unsafeCurrentTimeNanos: () => 0n,\n    currentTimeMillis: Effect.sync(() => realDateNow()),\n    currentTimeNanos: Effect.sync(() => BigInt(realDateNow()) * 1_000_000n),\n  };\n};\n\nconst withStubbedDateNow = async <T>(\n  queryHandler: (clock: Clock.Clock) => Promise<T>,\n): Promise<T> => {\n  const realDateNow = Date.now;\n  const clock = unpatchedClock(realDateNow);\n  Date.now = () => 0;\n  try {\n    return await queryHandler(clock);\n  } finally {\n    Date.now = realDateNow;\n  }\n};\n\nconst queryFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<\n    Returns,\n    E,\n    | DatabaseReader.DatabaseReader<DatabaseSchema_>\n    | Auth.Auth\n    | StorageReader\n    | QueryRunner.QueryRunner\n    | QueryCtx.QueryCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >\n  >;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    withStubbedDateNow((clock) =>\n      Effect.gen(function* () {\n        const decodedArgs = yield* pipe(\n          actualArgs,\n          Schema.decode(args),\n          Effect.orDie,\n        );\n        const decodedReturns = yield* handler(decodedArgs).pipe(\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(databaseSchema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n                >(),\n                ctx,\n              ),\n              Layer.setConfigProvider(ConvexConfigProvider.make()),\n            ),\n          ),\n        );\n        return yield* pipe(\n          decodedReturns,\n          Schema.encode(returns),\n          Effect.orDie,\n        );\n      }).pipe(\n        Effect.withClock(clock),\n        RegisteredFunction.runHandlerPromise(error),\n      ),\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n    Layer.setConfigProvider(ConvexConfigProvider.make()),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decode(args),\n        Effect.orDie,\n      );\n      const decodedReturns = yield* handler(decodedArgs).pipe(\n        Effect.provide(mutationLayer(databaseSchema, ctx)),\n      );\n      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);\n    }).pipe(RegisteredFunction.runHandlerPromise(error)),\n});\n\nconst convexActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    error,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    error: Schema.Schema.AnyNoContext | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      RegisteredFunction.ActionServices<DatabaseSchema_>\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    error,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(schema, ctx),\n        Layer.setConfigProvider(ConvexConfigProvider.make()),\n      ),\n  });\n"],"mappings":"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"}
+{"version":3,"file":"RegisteredConvexFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","DatabaseReader.layer","Auth.layer","QueryRunner.layer","QueryCtx.QueryCtx","ConvexConfigProvider.make","RegisteredFunction.runHandlerPromise","DatabaseWriter.layer","Scheduler.layer","MutationRunner.layer","MutationCtx.MutationCtx","RegisteredFunction.actionFunctionBase","RegisteredFunction.actionLayer"],"sources":["../src/RegisteredConvexFunction.ts"],"sourcesContent":["import type * as FunctionSpec from \"@confect/core/FunctionSpec\";\nimport {\n  actionGeneric,\n  type DefaultFunctionArgs,\n  type GenericMutationCtx,\n  type GenericQueryCtx,\n  internalActionGeneric,\n  internalMutationGeneric,\n  internalQueryGeneric,\n  mutationGeneric,\n  queryGeneric,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Clock from \"effect/Clock\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Match from \"effect/Match\";\nimport * as Schema from \"effect/Schema\";\nimport * as Auth from \"./Auth\";\nimport * as ConvexConfigProvider from \"./ConvexConfigProvider\";\nimport * as DatabaseReader from \"./DatabaseReader\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport * as DatabaseWriter from \"./DatabaseWriter\";\nimport type * as DataModel from \"./DataModel\";\nimport type * as Handler from \"./Handler\";\nimport * as MutationCtx from \"./MutationCtx\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryCtx from \"./QueryCtx\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as RegisteredFunction from \"./RegisteredFunction\";\nimport type * as RegistryItem from \"./RegistryItem\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport { StorageReader } from \"./StorageReader\";\nimport { StorageWriter } from \"./StorageWriter\";\n\nexport const make = (\n  databaseSchema: DatabaseSchema.AnyWithProps,\n  { functionSpec, handler }: RegistryItem.AnyWithProps,\n): RegisteredFunction.Any =>\n  Match.value(functionSpec.functionProvenance).pipe(\n    Match.tag(\"Convex\", () => handler as RegisteredFunction.Any),\n    Match.tag(\"Confect\", () => {\n      const { functionVisibility, functionProvenance } =\n        functionSpec as FunctionSpec.AnyConfect;\n\n      return Match.value(functionSpec.runtimeAndFunctionType.functionType).pipe(\n        Match.when(\"query\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => queryGeneric),\n            Match.when(\"internal\", () => internalQueryGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            queryFunction({\n              databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"mutation\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => mutationGeneric),\n            Match.when(\"internal\", () => internalMutationGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            mutationFunction({\n              databaseSchema,\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.when(\"action\", () => {\n          const genericFunction = Match.value(functionVisibility).pipe(\n            Match.when(\"public\", () => actionGeneric),\n            Match.when(\"internal\", () => internalActionGeneric),\n            Match.exhaustive,\n          );\n\n          return genericFunction(\n            convexActionFunction(databaseSchema, {\n              args: functionProvenance.args,\n              returns: functionProvenance.returns,\n              error: functionProvenance.error,\n              handler: handler as Handler.AnyConfectProvenance,\n            }),\n          );\n        }),\n        Match.exhaustive,\n      );\n    }),\n    Match.exhaustive,\n  );\n\n/**\n * Convex's query cache is invalidated by any Date.now() call during handler\n * execution. Effect's unsafeFork calls Date.now() when constructing a\n * FiberId.Runtime, which trips the cache for every confect-wrapped query. We\n * stub Date.now to 0 for the span of the handler; queries are forbidden from\n * relying on real time for correctness anyway.\n *\n * Users who explicitly want the real timestamp can still reach it via Effect's\n * Clock service (Clock.currentTimeMillis/Clock.currentTimeNanos). We provide a\n * Clock whose user-facing Effects call realDateNow (Convex's tracker) directly,\n * making Clock an explicit opt-in to cache invalidation. The unsafe methods\n * used internally by Effect (logging, span events, scheduler) return constants\n * so they never touch the tracker—caching is not broken by default.\n */\nconst unpatchedClock = (realDateNow: () => number): Clock.Clock => {\n  const defaultClock = Clock.make();\n  return {\n    ...defaultClock,\n    unsafeCurrentTimeMillis: () => 0,\n    unsafeCurrentTimeNanos: () => 0n,\n    currentTimeMillis: Effect.sync(() => realDateNow()),\n    currentTimeNanos: Effect.sync(() => BigInt(realDateNow()) * 1_000_000n),\n  };\n};\n\nconst withStubbedDateNow = async <T>(\n  queryHandler: (clock: Clock.Clock) => Promise<T>,\n): Promise<T> => {\n  const realDateNow = Date.now;\n  const clock = unpatchedClock(realDateNow);\n  Date.now = () => 0;\n  try {\n    return await queryHandler(clock);\n  } finally {\n    Date.now = realDateNow;\n  }\n};\n\nconst queryFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<\n    Returns,\n    E,\n    | DatabaseReader.DatabaseReader<DatabaseSchema_>\n    | Auth.Auth\n    | StorageReader\n    | QueryRunner.QueryRunner\n    | QueryCtx.QueryCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >\n  >;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericQueryCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    withStubbedDateNow((clock) =>\n      Effect.gen(function* () {\n        const decodedArgs = yield* pipe(\n          actualArgs,\n          Schema.decode(args),\n          Effect.orDie,\n        );\n        const decodedReturns = yield* handler(decodedArgs).pipe(\n          Effect.provide(\n            Layer.mergeAll(\n              DatabaseReader.layer(databaseSchema, ctx.db),\n              Auth.layer(ctx.auth),\n              StorageReader.layer(ctx.storage),\n              QueryRunner.layer(ctx.runQuery),\n              Layer.succeed(\n                QueryCtx.QueryCtx<\n                  DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n                >(),\n                ctx,\n              ),\n              Layer.setConfigProvider(ConvexConfigProvider.make()),\n            ),\n          ),\n        );\n        return yield* pipe(\n          decodedReturns,\n          Schema.encode(returns),\n          Effect.orDie,\n        );\n      }).pipe(\n        Effect.withClock(clock),\n        RegisteredFunction.runHandlerPromise(error),\n      ),\n    ),\n});\n\nexport const mutationLayer = <Schema extends DatabaseSchema.AnyWithProps>(\n  schema: Schema,\n  ctx: GenericMutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n) =>\n  Layer.mergeAll(\n    DatabaseReader.layer(schema, ctx.db),\n    DatabaseWriter.layer(schema, ctx.db),\n    Auth.layer(ctx.auth),\n    Scheduler.layer(ctx.scheduler),\n    StorageReader.layer(ctx.storage),\n    StorageWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    Layer.succeed(\n      MutationCtx.MutationCtx<\n        DataModel.ToConvex<DataModel.FromSchema<Schema>>\n      >(),\n      ctx,\n    ),\n    Layer.setConfigProvider(ConvexConfigProvider.make()),\n  );\n\nexport type MutationServices<Schema extends DatabaseSchema.AnyWithProps> =\n  | DatabaseReader.DatabaseReader<Schema>\n  | DatabaseWriter.DatabaseWriter<Schema>\n  | Auth.Auth\n  | Scheduler.Scheduler\n  | StorageReader\n  | StorageWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | MutationCtx.MutationCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>;\n\nconst mutationFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>({\n  databaseSchema,\n  args,\n  returns,\n  error,\n  handler,\n}: {\n  databaseSchema: DatabaseSchema_;\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (\n    a: Args,\n  ) => Effect.Effect<Returns, E, MutationServices<DatabaseSchema_>>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericMutationCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decode(args),\n        Effect.orDie,\n      );\n      const decodedReturns = yield* handler(decodedArgs).pipe(\n        Effect.provide(mutationLayer(databaseSchema, ctx)),\n      );\n      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);\n    }).pipe(RegisteredFunction.runHandlerPromise(error)),\n});\n\nconst convexActionFunction = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n>(\n  schema: DatabaseSchema_,\n  {\n    args,\n    returns,\n    error,\n    handler,\n  }: {\n    args: Schema.Schema<Args, ConvexArgs>;\n    returns: Schema.Schema<Returns, ConvexReturns>;\n    error: Schema.Schema.AnyNoContext | undefined;\n    handler: (\n      a: Args,\n    ) => Effect.Effect<\n      Returns,\n      E,\n      RegisteredFunction.ActionServices<DatabaseSchema_>\n    >;\n  },\n) =>\n  RegisteredFunction.actionFunctionBase({\n    args,\n    returns,\n    error,\n    handler,\n    createLayer: (ctx) =>\n      Layer.mergeAll(\n        RegisteredFunction.actionLayer(schema, ctx),\n        Layer.setConfigProvider(ConvexConfigProvider.make()),\n      ),\n  });\n"],"mappings":"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"}

package/dist/RegisteredFunction.d.ts

@@ -1,43 +1,32 @@
-import { ActionCtx } from "./ActionCtx.js";
-import { ActionRunner } from "./ActionRunner.js";
-import { Auth as Auth$1 } from "./Auth.js";
-import { AnyWithProps } from "./DatabaseSchema.js";
-import { FromSchema, TableNames, ToConvex } from "./DataModel.js";
-import { MutationRunner } from "./MutationRunner.js";
-import { QueryRunner } from "./QueryRunner.js";
-import { Scheduler as Scheduler$1 } from "./Scheduler.js";
-import { StorageActionWriter as StorageActionWriter$1 } from "./StorageActionWriter.js";
-import { StorageReader as StorageReader$1 } from "./StorageReader.js";
-import { StorageWriter as StorageWriter$1 } from "./StorageWriter.js";
-import { VectorSearch } from "./VectorSearch.js";
-import * as _confect_core_Ref0 from "@confect/core/Ref";
-import * as convex_server0 from "convex/server";
-import { DefaultFunctionArgs, FunctionVisibility, GenericActionCtx, RegisteredAction, RegisteredMutation, RegisteredQuery } from "convex/server";
-import * as Layer from "effect/Layer";
+import type { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
+import type * as FunctionProvenance from "@confect/core/FunctionProvenance";
+import { type DefaultFunctionArgs, type FunctionVisibility, type GenericActionCtx, type RegisteredAction, type RegisteredMutation, type RegisteredQuery } from "convex/server";
+import type { Value } from "convex/values";
 import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import * as Schema from "effect/Schema";
-import { FunctionSpec, RuntimeAndFunctionType } from "@confect/core";
-import * as effect_Duration0 from "effect/Duration";
-import * as effect_ParseResult0 from "effect/ParseResult";
-import * as convex_values0 from "convex/values";
-import { Value } from "convex/values";
-import * as effect_DateTime0 from "effect/DateTime";
-import * as FunctionProvenance from "@confect/core/FunctionProvenance";
-
-//#region src/RegisteredFunction.d.ts
-declare namespace RegisteredFunction_d_exports {
-  export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, actionFunctionBase, actionLayer, runHandlerPromise };
-}
-type Any = RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
+import * as ActionCtx from "./ActionCtx";
+import * as ActionRunner from "./ActionRunner";
+import * as Auth from "./Auth";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as DataModel from "./DataModel";
+import * as MutationRunner from "./MutationRunner";
+import * as QueryRunner from "./QueryRunner";
+import * as Scheduler from "./Scheduler";
+import * as StorageActionWriter from "./StorageActionWriter";
+import * as StorageReader from "./StorageReader";
+import * as StorageWriter from "./StorageWriter";
+import * as VectorSearch from "./VectorSearch";
+export type Any = RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any> | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;
 type ConfectRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends DefaultFunctionArgs ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>> : never : never;
-type ConvexRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends {
-  functionProvenance: {
-    _tag: "Convex";
-    _args: infer Args_ extends DefaultFunctionArgs;
-    _returns: infer Returns_;
-  };
+export type ConvexRegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends {
+    functionProvenance: {
+        _tag: "Convex";
+        _args: infer Args_ extends DefaultFunctionArgs;
+        _returns: infer Returns_;
+    };
 } ? RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "query" ? RegisteredQuery<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "mutation" ? RegisteredMutation<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : RuntimeAndFunctionType.GetFunctionType<FunctionSpec_["runtimeAndFunctionType"]> extends "action" ? RegisteredAction<FunctionSpec.GetFunctionVisibility<FunctionSpec_>, Args_, Returns_> : never : never;
-type RegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConvex> ? ConvexRegisteredFunction<FunctionSpec_> : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConfect> ? ConfectRegisteredFunction<FunctionSpec_> : never;
+export type RegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConvex> ? ConvexRegisteredFunction<FunctionSpec_> : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<FunctionSpec_, FunctionProvenance.AnyConfect> ? ConfectRegisteredFunction<FunctionSpec_> : never;
 /**
  * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of
  * failures that may be surfaced to the client as a `ConvexError`:
@@ -53,36 +42,29 @@ type RegisteredFunction<FunctionSpec_ extends FunctionSpec.AnyWithProps> = Funct
  * error channel—reaches the client as a `ConvexError`. The fiber dies and
  * `runPromise` rejects with a generic failure.
  */
-declare const runHandlerPromise: (errorSchema: Schema.Schema.AnyNoContext | undefined) => <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
-declare const actionFunctionBase: <Schema extends AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E, R>({
-  args,
-  returns,
-  error,
-  handler,
-  createLayer
-}: {
-  args: Schema.Schema<Args, ConvexArgs>;
-  returns: Schema.Schema<Returns, ConvexReturns>;
-  error: Schema.Schema<Error, Value> | undefined;
-  handler: (a: Args) => Effect.Effect<Returns, E, R>;
-  createLayer: (ctx: GenericActionCtx<ToConvex<FromSchema<Schema>>>) => Layer.Layer<R>;
+export declare const runHandlerPromise: (errorSchema: Schema.Schema.AnyNoContext | undefined) => <A, E>(effect: Effect.Effect<A, E>) => Promise<A>;
+export declare const actionFunctionBase: <Schema extends DatabaseSchema.AnyWithProps, Args, ConvexArgs extends DefaultFunctionArgs, Returns, ConvexReturns, E, R>({ args, returns, error, handler, createLayer, }: {
+    args: Schema.Schema<Args, ConvexArgs>;
+    returns: Schema.Schema<Returns, ConvexReturns>;
+    error: Schema.Schema<Error, Value> | undefined;
+    handler: (a: Args) => Effect.Effect<Returns, E, R>;
+    createLayer: (ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>) => Layer.Layer<R>;
 }) => {
-  args: convex_values0.PropertyValidators;
-  returns: convex_values0.Validator<any, any, any>;
-  handler: (ctx: GenericActionCtx<ToConvex<FromSchema<Schema>>>, actualArgs: ConvexArgs) => Promise<ConvexReturns>;
+    args: import("convex/values").PropertyValidators;
+    returns: import("convex/values").Validator<any, any, any>;
+    handler: (ctx: GenericActionCtx<DataModel.ToConvex<DataModel.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<(<Action extends _confect_core_Ref0.AnyAction>(action: Action, ...args: _confect_core_Ref0.OptionalArgs<Action>) => Effect.Effect<_confect_core_Ref0.Returns<Action>, _confect_core_Ref0.Error<Action> | effect_ParseResult0.ParseError>) | Auth$1 | (<Query extends _confect_core_Ref0.AnyQuery>(query: Query, ...args: _confect_core_Ref0.OptionalArgs<Query>) => Effect.Effect<_confect_core_Ref0.Returns<Query>, _confect_core_Ref0.Error<Query> | effect_ParseResult0.ParseError>) | {
-  runAfter: <Ref_ extends _confect_core_Ref0.AnyMutation | _confect_core_Ref0.AnyAction>(delay: effect_Duration0.Duration, ref: Ref_, ...args: _confect_core_Ref0.OptionalArgs<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: _confect_core_Ref0.OptionalArgs<Ref_>) => Effect.Effect<convex_values0.GenericId<"_scheduled_functions">, never, never>;
-} | StorageReader$1 | StorageWriter$1 | (<Mutation extends _confect_core_Ref0.AnyMutation>(mutation: Mutation, ...args: _confect_core_Ref0.OptionalArgs<Mutation>) => Effect.Effect<_confect_core_Ref0.Returns<Mutation>, _confect_core_Ref0.Error<Mutation> | effect_ParseResult0.ParseError>) | GenericActionCtx<ToConvex<FromSchema<DatabaseSchema_>>> | StorageActionWriter$1 | (<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>;
+export type ActionServices<DatabaseSchema_ extends DatabaseSchema.AnyWithProps> = Scheduler.Scheduler | Auth.Auth | StorageReader.StorageReader | StorageWriter.StorageWriter | StorageActionWriter.StorageActionWriter | QueryRunner.QueryRunner | MutationRunner.MutationRunner | ActionRunner.ActionRunner | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>> | ActionCtx.ActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>;
+export declare const actionLayer: <DatabaseSchema_ extends DatabaseSchema.AnyWithProps>(databaseSchema: DatabaseSchema_, ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>>) => Layer.Layer<(<Action extends import("@confect/core/Ref").AnyAction>(action: Action, ...args: import("@confect/core/Ref").OptionalArgs<Action>) => Effect.Effect<import("@confect/core/Ref").Returns<Action>, import("@confect/core/Ref").Error<Action> | import("effect/ParseResult").ParseError>) | Auth.Auth | (<Mutation extends import("@confect/core/Ref").AnyMutation>(mutation: Mutation, ...args: import("@confect/core/Ref").OptionalArgs<Mutation>) => Effect.Effect<import("@confect/core/Ref").Returns<Mutation>, import("@confect/core/Ref").Error<Mutation> | import("effect/ParseResult").ParseError>) | (<Query extends import("@confect/core/Ref").AnyQuery>(query: Query, ...args: import("@confect/core/Ref").OptionalArgs<Query>) => Effect.Effect<import("@confect/core/Ref").Returns<Query>, import("@confect/core/Ref").Error<Query> | import("effect/ParseResult").ParseError>) | {
+    runAfter: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(delay: import("effect/Duration").Duration, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
+    runAt: <Ref_ extends import("@confect/core/Ref").AnyMutation | import("@confect/core/Ref").AnyAction>(dateTime: import("effect/DateTime").DateTime, ref: Ref_, ...args: import("@confect/core/Ref").OptionalArgs<Ref_>) => Effect.Effect<import("convex/values").GenericId<"_scheduled_functions">, never, never>;
+} | StorageActionWriter.StorageActionWriter | StorageReader.StorageReader | StorageWriter.StorageWriter | GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>> | (<TableName extends DataModel.TableNames<DataModel.FromSchema<DatabaseSchema_>>, IndexName extends keyof import("convex/server").VectorIndexes<import("convex/server").NamedTableInfo<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>, TableName>>>(tableName: TableName, indexName: IndexName, query: {
+    vector: number[];
+    limit?: number;
+    filter?: (q: import("convex/server").VectorFilterBuilder<import("convex/server").DocumentByInfo<import("convex/server").NamedTableInfo<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>, TableName>>, import("convex/server").NamedVectorIndex<import("convex/server").NamedTableInfo<DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>, TableName>, IndexName>>) => import("convex/server").FilterExpression<boolean>;
 }) => Effect.Effect<{
-  _id: convex_values0.GenericId<TableName>;
-  _score: number;
+    _id: import("convex/values").GenericId<TableName>;
+    _score: number;
 }[], never, never>), never, never>;
-//#endregion
-export { ActionServices, Any, ConvexRegisteredFunction, RegisteredFunction, RegisteredFunction_d_exports, actionFunctionBase, actionLayer, runHandlerPromise };
+export {};
 //# sourceMappingURL=RegisteredFunction.d.ts.map

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","sourceRoot":"","sources":["../src/RegisteredFunction.ts"],"names":[],"mappings":"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"}

package/dist/RegisteredFunction.js

@@ -6,9 +6,9 @@ import { compileArgsSchema, compileReturnsSchema } from "./SchemaToValidator.js"
 import { layer as layer$2 } from "./MutationRunner.js";
 import { layer as layer$3 } from "./QueryRunner.js";
 import { layer as layer$4 } from "./Scheduler.js";
-import { StorageActionWriter as StorageActionWriter$1 } from "./StorageActionWriter.js";
-import { StorageReader as StorageReader$1 } from "./StorageReader.js";
-import { StorageWriter as StorageWriter$1 } from "./StorageWriter.js";
+import { StorageActionWriter } from "./StorageActionWriter.js";
+import { StorageReader } from "./StorageReader.js";
+import { StorageWriter } from "./StorageWriter.js";
 import { layer as layer$5 } from "./VectorSearch.js";
 import "convex/server";
 import * as Layer from "effect/Layer";
@@ -56,7 +56,7 @@ const actionFunctionBase = ({ args, returns, error, handler, createLayer }) => (
 		return yield* pipe(yield* handler(yield* pipe(actualArgs, Schema.decode(args), Effect.orDie)).pipe(Effect.provide(createLayer(ctx))), Schema.encode(returns), Effect.orDie);
 	}).pipe(runHandlerPromise(error))
 });
-const actionLayer = (databaseSchema, ctx) => Layer.mergeAll(layer$4(ctx.scheduler), layer$1(ctx.auth), StorageReader$1.layer(ctx.storage), StorageWriter$1.layer(ctx.storage), StorageActionWriter$1.layer(ctx.storage), layer$3(ctx.runQuery), layer$2(ctx.runMutation), layer(ctx.runAction), layer$5(ctx.vectorSearch), Layer.succeed(ActionCtx(), ctx));
+const actionLayer = (databaseSchema, ctx) => Layer.mergeAll(layer$4(ctx.scheduler), layer$1(ctx.auth), StorageReader.layer(ctx.storage), StorageWriter.layer(ctx.storage), StorageActionWriter.layer(ctx.storage), layer$3(ctx.runQuery), layer$2(ctx.runMutation), layer(ctx.runAction), layer$5(ctx.vectorSearch), Layer.succeed(ActionCtx(), ctx));
 
 //#endregion
 export { RegisteredFunction_exports, actionFunctionBase, actionLayer, runHandlerPromise };

package/dist/RegisteredFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","Scheduler.layer","Auth.layer","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["import type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { ConvexError } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Either from \"effect/Either\";\nimport * as Layer from \"effect/Layer\";\nimport * as Schema from \"effect/Schema\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport * as Auth from \"./Auth\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport * as StorageActionWriter from \"./StorageActionWriter\";\nimport * as StorageReader from \"./StorageReader\";\nimport * as StorageWriter from \"./StorageWriter\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type Any =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\ntype ConfectRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends\n    DefaultFunctionArgs\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n            >\n          : never\n    : never;\n\nexport type ConvexRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> = FunctionSpec_ extends {\n  functionProvenance: {\n    _tag: \"Convex\";\n    _args: infer Args_ extends DefaultFunctionArgs;\n    _returns: infer Returns_;\n  };\n}\n  ? RuntimeAndFunctionType.GetFunctionType<\n      FunctionSpec_[\"runtimeAndFunctionType\"]\n    > extends \"query\"\n    ? RegisteredQuery<\n        FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n        Args_,\n        Returns_\n      >\n    : RuntimeAndFunctionType.GetFunctionType<\n          FunctionSpec_[\"runtimeAndFunctionType\"]\n        > extends \"mutation\"\n      ? RegisteredMutation<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Returns_\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"action\"\n        ? RegisteredAction<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Returns_\n          >\n        : never\n  : never;\n\nexport type RegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexRegisteredFunction<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectRegisteredFunction<FunctionSpec_>\n      : never;\n\n/**\n * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of\n * failures that may be surfaced to the client as a `ConvexError`:\n *\n * - With a schema: typed errors are schema-encoded and wrapped in a\n * `ConvexError`, then thrown so Convex surfaces the data to the client.\n * `Effect.either` escapes the failure channel before `runPromise` so the thrown\n * `ConvexError` retains its `Symbol.for(\"ConvexError\")` identity instead of\n * being wrapped in Effect's `FiberFailure`.\n *\n * - Without a schema: every failure is converted to a defect via\n * `Effect.orDie`, so nothing—not even a `ConvexError` the handler placed in its\n * error channel—reaches the client as a `ConvexError`. The fiber dies and\n * `runPromise` rejects with a generic failure.\n */\nexport const runHandlerPromise =\n  (errorSchema: Schema.Schema.AnyNoContext | undefined) =>\n  <A, E>(effect: Effect.Effect<A, E>): Promise<A> => {\n    if (errorSchema === undefined) {\n      return Effect.runPromise(Effect.orDie(effect));\n    }\n    const withConvexError = effect.pipe(\n      Effect.catchAll((typedError) =>\n        pipe(\n          Schema.encode(errorSchema)(typedError),\n          Effect.orDie,\n          Effect.andThen((encodedError) =>\n            Effect.fail(new ConvexError(encodedError)),\n          ),\n        ),\n      ),\n    );\n    return Effect.runPromise(Effect.either(withConvexError)).then(\n      Either.match({\n        onLeft: (error) => {\n          throw error;\n        },\n        onRight: (value) => value,\n      }),\n    );\n  };\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  args,\n  returns,\n  error,\n  handler,\n  createLayer,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decode(args),\n        Effect.orDie,\n      );\n      const decodedReturns = yield* handler(decodedArgs).pipe(\n        Effect.provide(createLayer(ctx)),\n      );\n      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);\n    }).pipe(runHandlerPromise(error)),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | Scheduler.Scheduler\n  | Auth.Auth\n  | StorageReader.StorageReader\n  | StorageWriter.StorageWriter\n  | StorageActionWriter.StorageActionWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | ActionRunner.ActionRunner\n  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>\n  | ActionCtx.ActionCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >;\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer(ctx.scheduler),\n    Auth.layer(ctx.auth),\n    StorageReader.StorageReader.layer(ctx.storage),\n    StorageWriter.StorageWriter.layer(ctx.storage),\n    StorageActionWriter.StorageActionWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    ActionRunner.layer(ctx.runAction),\n    VectorSearch.layer(ctx.vectorSearch),\n    Layer.succeed(\n      ActionCtx.ActionCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >(),\n      ctx,\n    ),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsIA,MAAa,qBACV,iBACM,WAA4C;AACjD,KAAI,gBAAgB,OAClB,QAAO,OAAO,WAAW,OAAO,MAAM,OAAO,CAAC;CAEhD,MAAM,kBAAkB,OAAO,KAC7B,OAAO,UAAU,eACf,KACE,OAAO,OAAO,YAAY,CAAC,WAAW,EACtC,OAAO,OACP,OAAO,SAAS,iBACd,OAAO,KAAK,IAAI,YAAY,aAAa,CAAC,CAC3C,CACF,CACF,CACF;AACD,QAAO,OAAO,WAAW,OAAO,OAAO,gBAAgB,CAAC,CAAC,KACvD,OAAO,MAAM;EACX,SAAS,UAAU;AACjB,SAAM;;EAER,UAAU,UAAU;EACrB,CAAC,CACH;;AAGL,MAAa,sBAQX,EACA,MACA,SACA,OACA,SACA,mBASK;CACL,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,OAAO,IAAI,aAAa;AAStB,SAAO,OAAO,KAHS,OAAO,QALV,OAAO,KACzB,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,MACR,CACiD,CAAC,KACjD,OAAO,QAAQ,YAAY,IAAI,CAAC,CACjC,EACkC,OAAO,OAAO,QAAQ,EAAE,OAAO,MAAM;GACxE,CAAC,KAAK,kBAAkB,MAAM,CAAC;CACpC;AAkBD,MAAa,eAGX,gBACA,QAIA,MAAM,SACJC,QAAgB,IAAI,UAAU,EAC9BC,QAAW,IAAI,KAAK,kBACQ,MAAM,IAAI,QAAQ,kBAClB,MAAM,IAAI,QAAQ,wBACN,MAAM,IAAI,QAAQ,EAC1DC,QAAkB,IAAI,SAAS,EAC/BC,QAAqB,IAAI,YAAY,EACrCC,MAAmB,IAAI,UAAU,EACjCC,QAAmB,IAAI,aAAa,EACpC,MAAM,QACJC,WAEG,EACH,IACD,CACF"}
+{"version":3,"file":"RegisteredFunction.js","names":["SchemaToValidator.compileArgsSchema","SchemaToValidator.compileReturnsSchema","Scheduler.layer","Auth.layer","QueryRunner.layer","MutationRunner.layer","ActionRunner.layer","VectorSearch.layer","ActionCtx.ActionCtx"],"sources":["../src/RegisteredFunction.ts"],"sourcesContent":["import type { FunctionSpec, RuntimeAndFunctionType } from \"@confect/core\";\nimport type * as FunctionProvenance from \"@confect/core/FunctionProvenance\";\nimport {\n  type DefaultFunctionArgs,\n  type FunctionVisibility,\n  type GenericActionCtx,\n  type RegisteredAction,\n  type RegisteredMutation,\n  type RegisteredQuery,\n} from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { ConvexError } from \"convex/values\";\nimport { pipe } from \"effect/Function\";\nimport * as Effect from \"effect/Effect\";\nimport * as Either from \"effect/Either\";\nimport * as Layer from \"effect/Layer\";\nimport * as Schema from \"effect/Schema\";\nimport * as ActionCtx from \"./ActionCtx\";\nimport * as ActionRunner from \"./ActionRunner\";\nimport * as Auth from \"./Auth\";\nimport type * as DatabaseSchema from \"./DatabaseSchema\";\nimport type * as DataModel from \"./DataModel\";\nimport * as MutationRunner from \"./MutationRunner\";\nimport * as QueryRunner from \"./QueryRunner\";\nimport * as Scheduler from \"./Scheduler\";\nimport * as SchemaToValidator from \"./SchemaToValidator\";\nimport * as StorageActionWriter from \"./StorageActionWriter\";\nimport * as StorageReader from \"./StorageReader\";\nimport * as StorageWriter from \"./StorageWriter\";\nimport * as VectorSearch from \"./VectorSearch\";\n\nexport type Any =\n  | RegisteredQuery<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredMutation<FunctionVisibility, DefaultFunctionArgs, any>\n  | RegisteredAction<FunctionVisibility, DefaultFunctionArgs, any>;\n\ntype ConfectRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec.EncodedArgs<FunctionSpec_> extends infer Args_ extends\n    DefaultFunctionArgs\n    ? RuntimeAndFunctionType.GetFunctionType<\n        FunctionSpec_[\"runtimeAndFunctionType\"]\n      > extends \"query\"\n      ? RegisteredQuery<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"mutation\"\n        ? RegisteredMutation<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n          >\n        : RuntimeAndFunctionType.GetFunctionType<\n              FunctionSpec_[\"runtimeAndFunctionType\"]\n            > extends \"action\"\n          ? RegisteredAction<\n              FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n              Args_,\n              Promise<FunctionSpec.EncodedReturns<FunctionSpec_>>\n            >\n          : never\n    : never;\n\nexport type ConvexRegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> = FunctionSpec_ extends {\n  functionProvenance: {\n    _tag: \"Convex\";\n    _args: infer Args_ extends DefaultFunctionArgs;\n    _returns: infer Returns_;\n  };\n}\n  ? RuntimeAndFunctionType.GetFunctionType<\n      FunctionSpec_[\"runtimeAndFunctionType\"]\n    > extends \"query\"\n    ? RegisteredQuery<\n        FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n        Args_,\n        Returns_\n      >\n    : RuntimeAndFunctionType.GetFunctionType<\n          FunctionSpec_[\"runtimeAndFunctionType\"]\n        > extends \"mutation\"\n      ? RegisteredMutation<\n          FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n          Args_,\n          Returns_\n        >\n      : RuntimeAndFunctionType.GetFunctionType<\n            FunctionSpec_[\"runtimeAndFunctionType\"]\n          > extends \"action\"\n        ? RegisteredAction<\n            FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n            Args_,\n            Returns_\n          >\n        : never\n  : never;\n\nexport type RegisteredFunction<\n  FunctionSpec_ extends FunctionSpec.AnyWithProps,\n> =\n  FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n    FunctionSpec_,\n    FunctionProvenance.AnyConvex\n  >\n    ? ConvexRegisteredFunction<FunctionSpec_>\n    : FunctionSpec_ extends FunctionSpec.WithFunctionProvenance<\n          FunctionSpec_,\n          FunctionProvenance.AnyConfect\n        >\n      ? ConfectRegisteredFunction<FunctionSpec_>\n      : never;\n\n/**\n * Run the `Effect` as a `Promise`. The error schema acts as an allowlist of\n * failures that may be surfaced to the client as a `ConvexError`:\n *\n * - With a schema: typed errors are schema-encoded and wrapped in a\n * `ConvexError`, then thrown so Convex surfaces the data to the client.\n * `Effect.either` escapes the failure channel before `runPromise` so the thrown\n * `ConvexError` retains its `Symbol.for(\"ConvexError\")` identity instead of\n * being wrapped in Effect's `FiberFailure`.\n *\n * - Without a schema: every failure is converted to a defect via\n * `Effect.orDie`, so nothing—not even a `ConvexError` the handler placed in its\n * error channel—reaches the client as a `ConvexError`. The fiber dies and\n * `runPromise` rejects with a generic failure.\n */\nexport const runHandlerPromise =\n  (errorSchema: Schema.Schema.AnyNoContext | undefined) =>\n  <A, E>(effect: Effect.Effect<A, E>): Promise<A> => {\n    if (errorSchema === undefined) {\n      return Effect.runPromise(Effect.orDie(effect));\n    }\n    const withConvexError = effect.pipe(\n      Effect.catchAll((typedError) =>\n        pipe(\n          Schema.encode(errorSchema)(typedError),\n          Effect.orDie,\n          Effect.andThen((encodedError) =>\n            Effect.fail(new ConvexError(encodedError)),\n          ),\n        ),\n      ),\n    );\n    return Effect.runPromise(Effect.either(withConvexError)).then(\n      Either.match({\n        onLeft: (error) => {\n          throw error;\n        },\n        onRight: (value) => value,\n      }),\n    );\n  };\n\nexport const actionFunctionBase = <\n  Schema extends DatabaseSchema.AnyWithProps,\n  Args,\n  ConvexArgs extends DefaultFunctionArgs,\n  Returns,\n  ConvexReturns,\n  E,\n  R,\n>({\n  args,\n  returns,\n  error,\n  handler,\n  createLayer,\n}: {\n  args: Schema.Schema<Args, ConvexArgs>;\n  returns: Schema.Schema<Returns, ConvexReturns>;\n  error: Schema.Schema<Error, Value> | undefined;\n  handler: (a: Args) => Effect.Effect<Returns, E, R>;\n  createLayer: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n  ) => Layer.Layer<R>;\n}) => ({\n  args: SchemaToValidator.compileArgsSchema(args),\n  returns: SchemaToValidator.compileReturnsSchema(returns),\n  handler: (\n    ctx: GenericActionCtx<DataModel.ToConvex<DataModel.FromSchema<Schema>>>,\n    actualArgs: ConvexArgs,\n  ): Promise<ConvexReturns> =>\n    Effect.gen(function* () {\n      const decodedArgs = yield* pipe(\n        actualArgs,\n        Schema.decode(args),\n        Effect.orDie,\n      );\n      const decodedReturns = yield* handler(decodedArgs).pipe(\n        Effect.provide(createLayer(ctx)),\n      );\n      return yield* pipe(decodedReturns, Schema.encode(returns), Effect.orDie);\n    }).pipe(runHandlerPromise(error)),\n});\n\nexport type ActionServices<\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n> =\n  | Scheduler.Scheduler\n  | Auth.Auth\n  | StorageReader.StorageReader\n  | StorageWriter.StorageWriter\n  | StorageActionWriter.StorageActionWriter\n  | QueryRunner.QueryRunner\n  | MutationRunner.MutationRunner\n  | ActionRunner.ActionRunner\n  | VectorSearch.VectorSearch<DataModel.FromSchema<DatabaseSchema_>>\n  | ActionCtx.ActionCtx<\n      DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n    >;\n\nexport const actionLayer = <\n  DatabaseSchema_ extends DatabaseSchema.AnyWithProps,\n>(\n  databaseSchema: DatabaseSchema_,\n  ctx: GenericActionCtx<\n    DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n  >,\n) =>\n  Layer.mergeAll(\n    Scheduler.layer(ctx.scheduler),\n    Auth.layer(ctx.auth),\n    StorageReader.StorageReader.layer(ctx.storage),\n    StorageWriter.StorageWriter.layer(ctx.storage),\n    StorageActionWriter.StorageActionWriter.layer(ctx.storage),\n    QueryRunner.layer(ctx.runQuery),\n    MutationRunner.layer(ctx.runMutation),\n    ActionRunner.layer(ctx.runAction),\n    VectorSearch.layer(ctx.vectorSearch),\n    Layer.succeed(\n      ActionCtx.ActionCtx<\n        DataModel.ToConvex<DataModel.FromSchema<DatabaseSchema_>>\n      >(),\n      ctx,\n    ),\n  );\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsIA,MAAa,qBACV,iBACM,WAA4C;AACjD,KAAI,gBAAgB,OAClB,QAAO,OAAO,WAAW,OAAO,MAAM,OAAO,CAAC;CAEhD,MAAM,kBAAkB,OAAO,KAC7B,OAAO,UAAU,eACf,KACE,OAAO,OAAO,YAAY,CAAC,WAAW,EACtC,OAAO,OACP,OAAO,SAAS,iBACd,OAAO,KAAK,IAAI,YAAY,aAAa,CAAC,CAC3C,CACF,CACF,CACF;AACD,QAAO,OAAO,WAAW,OAAO,OAAO,gBAAgB,CAAC,CAAC,KACvD,OAAO,MAAM;EACX,SAAS,UAAU;AACjB,SAAM;;EAER,UAAU,UAAU;EACrB,CAAC,CACH;;AAGL,MAAa,sBAQX,EACA,MACA,SACA,OACA,SACA,mBASK;CACL,MAAMA,kBAAoC,KAAK;CAC/C,SAASC,qBAAuC,QAAQ;CACxD,UACE,KACA,eAEA,OAAO,IAAI,aAAa;AAStB,SAAO,OAAO,KAHS,OAAO,QALV,OAAO,KACzB,YACA,OAAO,OAAO,KAAK,EACnB,OAAO,MACR,CACiD,CAAC,KACjD,OAAO,QAAQ,YAAY,IAAI,CAAC,CACjC,EACkC,OAAO,OAAO,QAAQ,EAAE,OAAO,MAAM;GACxE,CAAC,KAAK,kBAAkB,MAAM,CAAC;CACpC;AAkBD,MAAa,eAGX,gBACA,QAIA,MAAM,SACJC,QAAgB,IAAI,UAAU,EAC9BC,QAAW,IAAI,KAAK,gBACQ,MAAM,IAAI,QAAQ,gBAClB,MAAM,IAAI,QAAQ,sBACN,MAAM,IAAI,QAAQ,EAC1DC,QAAkB,IAAI,SAAS,EAC/BC,QAAqB,IAAI,YAAY,EACrCC,MAAmB,IAAI,UAAU,EACjCC,QAAmB,IAAI,aAAa,EACpC,MAAM,QACJC,WAEG,EACH,IACD,CACF"}

package/dist/RegisteredFunctions.d.ts

@@ -1,20 +1,19 @@
-import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
-import { Any, RegisteredFunction } from "./RegisteredFunction.js";
-import { GroupImpl } from "./GroupImpl.js";
-import { AnyWithProps as AnyWithProps$2 } from "./RegistryItem.js";
-import { Layer, Types } from "effect";
-import * as FunctionSpec from "@confect/core/FunctionSpec";
-import * as GroupSpec from "@confect/core/GroupSpec";
-import * as Spec from "@confect/core/Spec";
-
-//#region src/RegisteredFunctions.d.ts
-declare namespace RegisteredFunctions_d_exports {
-  export { AnyWithProps, RegisteredFunctions, RegisteredFunctionsForGroupSpec, buildForGroup };
-}
-type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> = Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
-type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = { [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? RegisteredFunctionsForGroupSpec<Group> : never };
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type * as GroupSpec from "@confect/core/GroupSpec";
+import type * as Spec from "@confect/core/Spec";
+import type { Layer, Types } from "effect";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as GroupImpl from "./GroupImpl";
+import type * as RegisteredFunction from "./RegisteredFunction";
+import * as RegistryItem from "./RegistryItem";
+export type RegisteredFunctions<Spec_ extends Spec.AnyWithProps> = Types.Simplify<RegisteredFunctionsHelper<Spec.Groups<Spec_>>>;
+type RegisteredFunctionsHelper<Groups extends GroupSpec.AnyWithProps> = {
+    [GroupName in GroupSpec.Name<Groups>]: GroupSpec.WithName<Groups, GroupName> extends infer Group extends GroupSpec.AnyWithProps ? RegisteredFunctionsForGroupSpec<Group> : never;
+};
 /** The `RegisteredFunction` record for a group's own declared functions. */
-type RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = { [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction<FunctionSpec_> : never };
+type RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = {
+    [FunctionName in FunctionSpec.Name<GroupSpec.Functions<Group>>]: FunctionSpec.WithName<GroupSpec.Functions<Group>, FunctionName> extends infer FunctionSpec_ extends FunctionSpec.AnyWithProps ? RegisteredFunction.RegisteredFunction<FunctionSpec_> : never;
+};
 /**
  * The registered-functions record for a single group, derived from the group's
  * own `GroupSpec`: its declared functions, plus any nested subgroups it carries
@@ -25,9 +24,9 @@ type RegisteredFunctionsOf<Group extends GroupSpec.AnyWithProps> = { [FunctionNa
  * (subdirectory children are assembled separately into `_generated/spec.ts`),
  * so this resolves to just the leaf's functions.
  */
-type RegisteredFunctionsForGroupSpec<Group extends GroupSpec.AnyWithProps> = GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>> : RegisteredFunctionsOf<Group>;
-interface AnyWithProps {
-  readonly [key: string]: Any | AnyWithProps;
+export type RegisteredFunctionsForGroupSpec<Group extends GroupSpec.AnyWithProps> = GroupSpec.Groups<Group> extends infer SubGroups extends GroupSpec.AnyWithProps ? Types.Simplify<RegisteredFunctionsHelper<SubGroups> & RegisteredFunctionsOf<Group>> : RegisteredFunctionsOf<Group>;
+export interface AnyWithProps {
+    readonly [key: string]: RegisteredFunction.Any | AnyWithProps;
 }
 /**
  * Build the registered Convex functions for a single group from its finalized
@@ -51,7 +50,6 @@ interface AnyWithProps {
  * the leaf spec type-only (`typeof import("…/<group>.spec")["default"]`), so a
  * function's bundle never imports a spec module at runtime.
  */
-declare const buildForGroup: <Group extends GroupSpec.AnyWithProps>(databaseSchema: AnyWithProps$1, groupLayer: Layer.Layer<GroupImpl<"Finalized">>, makeRegisteredFunction: (databaseSchema: AnyWithProps$1, registryItem: AnyWithProps$2) => Any) => RegisteredFunctionsForGroupSpec<Group>;
-//#endregion
-export { AnyWithProps, RegisteredFunctions, RegisteredFunctionsForGroupSpec, RegisteredFunctions_d_exports, buildForGroup };
+export declare const buildForGroup: <Group extends GroupSpec.AnyWithProps>(databaseSchema: DatabaseSchema.AnyWithProps, groupLayer: Layer.Layer<GroupImpl.GroupImpl<"Finalized">>, makeRegisteredFunction: (databaseSchema: DatabaseSchema.AnyWithProps, registryItem: RegistryItem.AnyWithProps) => RegisteredFunction.Any) => RegisteredFunctionsForGroupSpec<Group>;
+export {};
 //# sourceMappingURL=RegisteredFunctions.d.ts.map

package/dist/RegisteredFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredFunctions.d.ts","names":[],"sources":["../src/RegisteredFunctions.ts"],"mappings":";;;;;;;;;;;;;KAaY,mBAAA,eAAkC,IAAA,CAAK,YAAA,IACjD,KAAA,CAAM,QAAA,CAAS,yBAAA,CAA0B,IAAA,CAAK,MAAA,CAAO,KAAA;AAAA,KAElD,yBAAA,gBAAyC,SAAA,CAAU,YAAA,oBACxC,SAAA,CAAU,IAAA,CAAK,MAAA,IAAU,SAAA,CAAU,QAAA,CAC/C,MAAA,EACA,SAAA,8BAC4B,SAAA,CAAU,YAAA,GACpC,+BAAA,CAAgC,KAAA;;KAKjC,qBAAA,eAAoC,SAAA,CAAU,YAAA,uBAChC,YAAA,CAAa,IAAA,CAC5B,SAAA,CAAU,SAAA,CAAU,KAAA,KAClB,YAAA,CAAa,QAAA,CACf,SAAA,CAAU,SAAA,CAAU,KAAA,GACpB,YAAA,sCACoC,YAAA,CAAa,YAAA,GAC/C,kBAAA,CAAsC,aAAA;;AApB5C;;;;;;;;;KAkCY,+BAAA,eACI,SAAA,CAAU,YAAA,IAExB,SAAA,CAAU,MAAA,CAAO,KAAA,kCAAuC,SAAA,CAAU,YAAA,GAC9D,KAAA,CAAM,QAAA,CACJ,yBAAA,CAA0B,SAAA,IAAa,qBAAA,CAAsB,KAAA,KAE/D,qBAAA,CAAsB,KAAA;AAAA,UAEX,YAAA;EAAA,UACL,GAAA,WAAc,GAAA,GAAyB,YAAA;AAAA;;;;;;;;;AA3Ca;;;;;;;;;;;;;;cAoEnD,aAAA,iBAA+B,SAAA,CAAU,YAAA,EACpD,cAAA,EAAgB,cAAA,EAChB,UAAA,EAAY,KAAA,CAAM,KAAA,CAAM,SAAA,gBACxB,sBAAA,GACE,cAAA,EAAgB,cAAA,EAChB,YAAA,EAAc,cAAA,KACX,GAAA,KACJ,+BAAA,CAAgC,KAAA"}
+{"version":3,"file":"RegisteredFunctions.d.ts","sourceRoot":"","sources":["../src/RegisteredFunctions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,KAAK,SAAS,MAAM,yBAAyB,CAAC;AAE1D,OAAO,KAAK,KAAK,IAAI,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAG3C,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,SAAS,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,KAAK,kBAAkB,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAE/C,MAAM,MAAM,mBAAmB,CAAC,KAAK,SAAS,IAAI,CAAC,YAAY,IAC7D,KAAK,CAAC,QAAQ,CAAC,yBAAyB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAEhE,KAAK,yBAAyB,CAAC,MAAM,SAAS,SAAS,CAAC,YAAY,IAAI;KACrE,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,QAAQ,CACvD,MAAM,EACN,SAAS,CACV,SAAS,MAAM,KAAK,SAAS,SAAS,CAAC,YAAY,GAChD,+BAA+B,CAAC,KAAK,CAAC,GACtC,KAAK;CACV,CAAC;AAEF,4EAA4E;AAC5E,KAAK,qBAAqB,CAAC,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;KAChE,YAAY,IAAI,YAAY,CAAC,IAAI,CAChC,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAC3B,GAAG,YAAY,CAAC,QAAQ,CACvB,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,EAC1B,YAAY,CACb,SAAS,MAAM,aAAa,SAAS,YAAY,CAAC,YAAY,GAC3D,kBAAkB,CAAC,kBAAkB,CAAC,aAAa,CAAC,GACpD,KAAK;CACV,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,+BAA+B,CACzC,KAAK,SAAS,SAAS,CAAC,YAAY,IAEpC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,SAAS,MAAM,SAAS,SAAS,SAAS,CAAC,YAAY,GAC1E,KAAK,CAAC,QAAQ,CACZ,yBAAyB,CAAC,SAAS,CAAC,GAAG,qBAAqB,CAAC,KAAK,CAAC,CACpE,GACD,qBAAqB,CAAC,KAAK,CAAC,CAAC;AAEnC,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,kBAAkB,CAAC,GAAG,GAAG,YAAY,CAAC;CAC/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK,SAAS,SAAS,CAAC,YAAY,EAChE,gBAAgB,cAAc,CAAC,YAAY,EAC3C,YAAY,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,EACzD,wBAAwB,CACtB,cAAc,EAAE,cAAc,CAAC,YAAY,EAC3C,YAAY,EAAE,YAAY,CAAC,YAAY,KACpC,kBAAkB,CAAC,GAAG,KAC1B,+BAA+B,CAAC,KAAK,CAkBvC,CAAC"}

package/dist/RegisteredNodeFunction.d.ts

@@ -1,15 +1,5 @@
-import { AnyWithProps } from "./DatabaseSchema.js";
-import { Any } from "./RegisteredFunction.js";
-import { AnyWithProps as AnyWithProps$1 } from "./RegistryItem.js";
-
-//#region src/RegisteredNodeFunction.d.ts
-declare namespace RegisteredNodeFunction_d_exports {
-  export { make };
-}
-declare const make: (databaseSchema: AnyWithProps, {
-  functionSpec,
-  handler
-}: AnyWithProps$1) => Any;
-//#endregion
-export { RegisteredNodeFunction_d_exports, make };
+import type * as DatabaseSchema from "./DatabaseSchema";
+import * as RegisteredFunction from "./RegisteredFunction";
+import type * as RegistryItem from "./RegistryItem";
+export declare const make: (databaseSchema: DatabaseSchema.AnyWithProps, { functionSpec, handler }: RegistryItem.AnyWithProps) => RegisteredFunction.Any;
 //# sourceMappingURL=RegisteredNodeFunction.d.ts.map

package/dist/RegisteredNodeFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegisteredNodeFunction.d.ts","names":[],"sources":["../src/RegisteredNodeFunction.ts"],"mappings":";;;;;;;;cAgBa,IAAA,GACX,cAAA,EAAgB,YAAA;EAChB,YAAA;EAAA;AAAA,GAA2B,cAAA,KAC1B,GAAA"}
+{"version":3,"file":"RegisteredNodeFunction.d.ts","sourceRoot":"","sources":["../src/RegisteredNodeFunction.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,kBAAkB,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAEpD,eAAO,MAAM,IAAI,GACf,gBAAgB,cAAc,CAAC,YAAY,EAC3C,2BAA2B,YAAY,CAAC,YAAY,KACnD,kBAAkB,CAAC,GAuBnB,CAAC"}

package/dist/RegistryItem.d.ts

@@ -1,31 +1,21 @@
-import { AnyWithProps as AnyWithProps$1 } from "./DatabaseSchema.js";
-import { Any, Handler } from "./Handler.js";
-import * as FunctionSpec from "@confect/core/FunctionSpec";
-
-//#region src/RegistryItem.d.ts
-declare namespace RegistryItem_d_exports {
-  export { AnyWithProps, RegistryItem, TypeId, isRegistryItem, make };
+import type * as FunctionSpec from "@confect/core/FunctionSpec";
+import type * as DatabaseSchema from "./DatabaseSchema";
+import type * as Handler from "./Handler";
+export declare const TypeId = "@confect/server/RegistryItem";
+export type TypeId = typeof TypeId;
+export declare const isRegistryItem: (value: unknown) => value is AnyWithProps;
+export interface RegistryItem<DatabaseSchema_ extends DatabaseSchema.AnyWithProps, FunctionSpec_ extends FunctionSpec.AnyWithProps> {
+    readonly [TypeId]: TypeId;
+    readonly functionSpec: FunctionSpec_;
+    readonly handler: Handler.Handler<DatabaseSchema_, FunctionSpec_>;
 }
-declare const TypeId = "@confect/server/RegistryItem";
-type TypeId = typeof TypeId;
-declare const isRegistryItem: (value: unknown) => value is AnyWithProps;
-interface RegistryItem<DatabaseSchema_ extends AnyWithProps$1, FunctionSpec_ extends FunctionSpec.AnyWithProps> {
-  readonly [TypeId]: TypeId;
-  readonly functionSpec: FunctionSpec_;
-  readonly handler: Handler<DatabaseSchema_, FunctionSpec_>;
+export interface AnyWithProps {
+    readonly [TypeId]: TypeId;
+    readonly functionSpec: FunctionSpec.AnyWithProps;
+    readonly handler: Handler.Any;
 }
-interface AnyWithProps {
-  readonly [TypeId]: TypeId;
-  readonly functionSpec: FunctionSpec.AnyWithProps;
-  readonly handler: Any;
-}
-declare const make: ({
-  functionSpec,
-  handler
-}: {
-  functionSpec: FunctionSpec.AnyWithProps;
-  handler: AnyWithProps["handler"];
+export declare const make: ({ functionSpec, handler, }: {
+    functionSpec: FunctionSpec.AnyWithProps;
+    handler: AnyWithProps["handler"];
 }) => AnyWithProps;
-//#endregion
-export { AnyWithProps, RegistryItem, RegistryItem_d_exports, TypeId, isRegistryItem, make };
 //# sourceMappingURL=RegistryItem.d.ts.map

package/dist/RegistryItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RegistryItem.d.ts","names":[],"sources":["../src/RegistryItem.ts"],"mappings":";;;;;;;;cAKa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,cAAA,GAAkB,KAAA,cAAiB,KAAA,IAAS,YAAA;AAAA,UAOxC,YAAA,yBACS,cAAA,wBACF,YAAA,CAAa,YAAA;EAAA,UAEzB,MAAA,GAAS,MAAA;EAAA,SACV,YAAA,EAAc,aAAA;EAAA,SACd,OAAA,EAAS,OAAA,CAAgB,eAAA,EAAiB,aAAA;AAAA;AAAA,UAGpC,YAAA;EAAA,UACL,MAAA,GAAS,MAAA;EAAA,SACV,YAAA,EAAc,YAAA,CAAa,YAAA;EAAA,SAC3B,OAAA,EAAS,GAAA;AAAA;AAAA,cAGP,IAAA;EAAQ,YAAA;EAAA;AAAA;EAInB,YAAA,EAAc,YAAA,CAAa,YAAA;EAC3B,OAAA,EAAS,YAAA;AAAA,MACP,YAAA"}
+{"version":3,"file":"RegistryItem.d.ts","sourceRoot":"","sources":["../src/RegistryItem.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAEhE,OAAO,KAAK,KAAK,cAAc,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,CAAC;AAE1C,eAAO,MAAM,MAAM,iCAAiC,CAAC;AACrD,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,YACnB,CAAC;AAMvC,MAAM,WAAW,YAAY,CAC3B,eAAe,SAAS,cAAc,CAAC,YAAY,EACnD,aAAa,SAAS,YAAY,CAAC,YAAY;IAE/C,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;CACnE;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC;IACjD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC;CAC/B;AAED,eAAO,MAAM,IAAI,GAAI,4BAGlB;IACD,YAAY,EAAE,YAAY,CAAC,YAAY,CAAC;IACxC,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,CAAC;CAClC,KAAG,YAIA,CAAC"}