diff --git a/.changeset/crazy-beans-spend.md b/.changeset/crazy-beans-spend.md
new file mode 100644
index 00000000..7680e791
--- /dev/null
+++ b/.changeset/crazy-beans-spend.md
@@ -0,0 +1,45 @@
+---
+"@graphprotocol/hypergraph-react": patch
+"@graphprotocol/hypergraph": patch
+---
+
+Extend Entity.Schema to allow querying for relation entity values
+
+In the following example we define a Project entity and a Podcast entity with the relation `projects` to the Project entity. In the Type.Relation you now can define the properties of the relation entity as a second argument. In the mapping you also need to define the properties of the relation entity instead of just the property id of the relation.
+
+```ts
+export const Project = Entity.Schema(
+  {
+    name: Type.String,
+  },
+  {
+    types: [Id('69732974-c632-490d-81a3-12ea567b2a8e')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+    },
+  },
+);
+
+export const Podcast = Entity.Schema(
+  {
+    name: Type.String,
+    projects: Type.Relation(Project, {
+      properties: {
+        website: Type.optional(Type.String),
+      },
+    }),
+  },
+  {
+    types: [Id('69732974-c632-490d-81a3-12ea567b2a8e')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      projects: {
+        propertyId: Id('71931b5f-1d6a-462e-81d9-5b8e85fb5c4b'),
+        properties: {
+          website: Id('eed38e74-e679-46bf-8a42-ea3e4f8fb5fb'),
+        },
+      },
+    },
+  },
+);
+```
\ No newline at end of file
diff --git a/apps/events/src/routeTree.gen.ts b/apps/events/src/routeTree.gen.ts
index de3d360a..fe31d430 100644
--- a/apps/events/src/routeTree.gen.ts
+++ b/apps/events/src/routeTree.gen.ts
@@ -23,9 +23,15 @@ import { Route as SpaceSpaceIdPlaygroundRouteImport } from './routes/space/$spac
 import { Route as SpaceSpaceIdEventsRouteImport } from './routes/space/$spaceId/events'
 import { Route as SpaceSpaceIdChatRouteImport } from './routes/space/$spaceId/chat'
 
+const PodcastsLazyRouteImport = createFileRoute('/podcasts')()
 const PlaygroundLazyRouteImport = createFileRoute('/playground')()
 const LoginLazyRouteImport = createFileRoute('/login')()
 
+const PodcastsLazyRoute = PodcastsLazyRouteImport.update({
+  id: '/podcasts',
+  path: '/podcasts',
+  getParentRoute: () => rootRouteImport,
+} as any).lazy(() => import('./routes/podcasts.lazy').then((d) => d.Route))
 const PlaygroundLazyRoute = PlaygroundLazyRouteImport.update({
   id: '/playground',
   path: '/playground',
@@ -98,6 +104,7 @@ export interface FileRoutesByFullPath {
   '/authenticate-success': typeof AuthenticateSuccessRoute
   '/login': typeof LoginLazyRoute
   '/playground': typeof PlaygroundLazyRoute
+  '/podcasts': typeof PodcastsLazyRoute
   '/account-inbox/$inboxId': typeof AccountInboxInboxIdRoute
   '/friends/$accountAddress': typeof FriendsAccountAddressRoute
   '/space/$spaceId': typeof SpaceSpaceIdRouteWithChildren
@@ -113,6 +120,7 @@ export interface FileRoutesByTo {
   '/authenticate-success': typeof AuthenticateSuccessRoute
   '/login': typeof LoginLazyRoute
   '/playground': typeof PlaygroundLazyRoute
+  '/podcasts': typeof PodcastsLazyRoute
   '/account-inbox/$inboxId': typeof AccountInboxInboxIdRoute
   '/friends/$accountAddress': typeof FriendsAccountAddressRoute
   '/space/$spaceId/chat': typeof SpaceSpaceIdChatRoute
@@ -128,6 +136,7 @@ export interface FileRoutesById {
   '/authenticate-success': typeof AuthenticateSuccessRoute
   '/login': typeof LoginLazyRoute
   '/playground': typeof PlaygroundLazyRoute
+  '/podcasts': typeof PodcastsLazyRoute
   '/account-inbox/$inboxId': typeof AccountInboxInboxIdRoute
   '/friends/$accountAddress': typeof FriendsAccountAddressRoute
   '/space/$spaceId': typeof SpaceSpaceIdRouteWithChildren
@@ -145,6 +154,7 @@ export interface FileRouteTypes {
     | '/authenticate-success'
     | '/login'
     | '/playground'
+    | '/podcasts'
     | '/account-inbox/$inboxId'
     | '/friends/$accountAddress'
     | '/space/$spaceId'
@@ -160,6 +170,7 @@ export interface FileRouteTypes {
     | '/authenticate-success'
     | '/login'
     | '/playground'
+    | '/podcasts'
     | '/account-inbox/$inboxId'
     | '/friends/$accountAddress'
     | '/space/$spaceId/chat'
@@ -174,6 +185,7 @@ export interface FileRouteTypes {
     | '/authenticate-success'
     | '/login'
     | '/playground'
+    | '/podcasts'
     | '/account-inbox/$inboxId'
     | '/friends/$accountAddress'
     | '/space/$spaceId'
@@ -190,6 +202,7 @@ export interface RootRouteChildren {
   AuthenticateSuccessRoute: typeof AuthenticateSuccessRoute
   LoginLazyRoute: typeof LoginLazyRoute
   PlaygroundLazyRoute: typeof PlaygroundLazyRoute
+  PodcastsLazyRoute: typeof PodcastsLazyRoute
   AccountInboxInboxIdRoute: typeof AccountInboxInboxIdRoute
   FriendsAccountAddressRoute: typeof FriendsAccountAddressRoute
   SpaceSpaceIdRoute: typeof SpaceSpaceIdRouteWithChildren
@@ -197,6 +210,13 @@ export interface RootRouteChildren {
 
 declare module '@tanstack/react-router' {
   interface FileRoutesByPath {
+    '/podcasts': {
+      id: '/podcasts'
+      path: '/podcasts'
+      fullPath: '/podcasts'
+      preLoaderRoute: typeof PodcastsLazyRouteImport
+      parentRoute: typeof rootRouteImport
+    }
     '/playground': {
       id: '/playground'
       path: '/playground'
@@ -318,6 +338,7 @@ const rootRouteChildren: RootRouteChildren = {
   AuthenticateSuccessRoute: AuthenticateSuccessRoute,
   LoginLazyRoute: LoginLazyRoute,
   PlaygroundLazyRoute: PlaygroundLazyRoute,
+  PodcastsLazyRoute: PodcastsLazyRoute,
   AccountInboxInboxIdRoute: AccountInboxInboxIdRoute,
   FriendsAccountAddressRoute: FriendsAccountAddressRoute,
   SpaceSpaceIdRoute: SpaceSpaceIdRouteWithChildren,
diff --git a/apps/events/src/routes/__root.tsx b/apps/events/src/routes/__root.tsx
index 426949e4..ed2ee452 100644
--- a/apps/events/src/routes/__root.tsx
+++ b/apps/events/src/routes/__root.tsx
@@ -33,6 +33,9 @@ export const Route = createRootRoute({
           <nav className="ml-auto flex gap-4 sm:gap-6">
             {authenticated ? (
               <div className="flex items-center gap-4">
+                <Link className="text-xs" to="/podcasts">
+                  Podcasts
+                </Link>
                 <Link className="text-xs" to="/playground">
                   Playground
                 </Link>
diff --git a/apps/events/src/routes/podcasts.lazy.tsx b/apps/events/src/routes/podcasts.lazy.tsx
new file mode 100644
index 00000000..1507de14
--- /dev/null
+++ b/apps/events/src/routes/podcasts.lazy.tsx
@@ -0,0 +1,40 @@
+import { useEntities } from '@graphprotocol/hypergraph-react';
+import { createLazyFileRoute } from '@tanstack/react-router';
+import { Podcast } from '@/schema';
+
+export const Route = createLazyFileRoute('/podcasts')({
+  component: RouteComponent,
+});
+
+function RouteComponent() {
+  const space = '530a70d9-d5ee-410a-850a-cf70e4be2ee5';
+
+  const { data, isLoading, isError } = useEntities(Podcast, {
+    mode: 'public',
+    first: 100,
+    space: space,
+    include: {
+      projects: {},
+    },
+  });
+  console.log({ data, isLoading, isError });
+  return (
+    <>
+      <h1>Podcasts</h1>
+      {isLoading && <div>Loading...</div>}
+      {isError && <div>Error</div>}
+      {data?.map((podcast) => (
+        <div key={podcast.id}>
+          <h2>{podcast.name}</h2>
+          {podcast.projects.map((project) => (
+            <div key={project._relation.id}>
+              <h3>- {project.name}</h3>
+              <div>--{project._relation.website}</div>
+            </div>
+          ))}
+        </div>
+      ))}
+      <pre className="text-xs">{JSON.stringify(data, null, 2)}</pre>
+    </>
+  );
+}
diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index c8850a52..f46e8b0d 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -111,7 +111,6 @@ export const Project = Entity.Schema(
     name: Type.String,
     description: Type.optional(Type.String),
     x: Type.optional(Type.String),
-    avatar: Type.Relation(Image),
   },
   {
     types: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
@@ -119,7 +118,35 @@ export const Project = Entity.Schema(
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
       description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
       x: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
-      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
+    },
+  },
+);
+
+export const Podcast = Entity.Schema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    dateFounded: Type.Date,
+    rssFeedUrl: Type.optional(Type.String),
+    projects: Type.Relation(Project, {
+      properties: {
+        website: Type.optional(Type.String),
+      },
+    }),
+  },
+  {
+    types: [Id('69732974-c632-490d-81a3-12ea567b2a8e')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
+      dateFounded: Id('41aa3d98-47b6-4a97-b7ec-427e575b910e'),
+      rssFeedUrl: Id('4dd1a486-c1ad-48c6-b261-e4c8edf7ac65'),
+      projects: {
+        propertyId: Id('71931b5f-1d6a-462e-81d9-5b8e85fb5c4b'),
+        properties: {
+          website: Id('eed38e74-e679-46bf-8a42-ea3e4f8fb5fb'),
+        },
+      },
     },
   },
 );
diff --git a/packages/hypergraph-react/src/internal/convert-relations.ts b/packages/hypergraph-react/src/internal/convert-relations.ts
deleted file mode 100644
index 3de29442..00000000
--- a/packages/hypergraph-react/src/internal/convert-relations.ts
+++ /dev/null
@@ -1,100 +0,0 @@
-import { Constants, Utils } from '@graphprotocol/hypergraph';
-import * as Option from 'effect/Option';
-import type * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-
-// A recursive representation of the entity structure returned by the public GraphQL
-// endpoint. `values` and `relations` are optional because the nested `to` selections
-// get slimmer the deeper we traverse in the query. This type intentionally mirrors
-// only the fields we actually consume inside `convertRelations`.
-type RecursiveQueryEntity = {
-  id: string;
-  name: string;
-  valuesList?: {
-    propertyId: string;
-    string: string;
-    boolean: boolean;
-    number: number;
-    time: string;
-    point: string;
-  }[];
-  relationsList?: {
-    id: string;
-    toEntity: RecursiveQueryEntity;
-    typeId: string;
-  }[];
-};
-
-type RawEntityValue = string | boolean | number | unknown[] | Date | { id: string };
-type RawEntity = Record<string, RawEntityValue>;
-type NestedRawEntity = RawEntity & { _relation: { id: string } };
-
-export const convertRelations = <_S extends Schema.Schema.AnyNoContext>(
-  queryEntity: RecursiveQueryEntity,
-  ast: SchemaAST.TypeLiteral,
-) => {
-  const rawEntity: RawEntity = {};
-
-  for (const prop of ast.propertySignatures) {
-    const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
-
-    if (Utils.isRelation(prop.type) && Option.isSome(result)) {
-      rawEntity[String(prop.name)] = [];
-
-      if (!SchemaAST.isTupleType(prop.type)) {
-        continue;
-      }
-      const relationType = prop.type;
-      const relationTransformation = relationType.rest[0]?.type;
-      if (!relationTransformation || !SchemaAST.isTypeLiteral(relationTransformation)) {
-        continue;
-      }
-
-      const typeIds: string[] = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(relationTransformation).pipe(
-        Option.getOrElse(() => []),
-      );
-      if (typeIds.length === 0) {
-        continue;
-      }
-
-      const allRelationsWithTheCorrectPropertyTypeId = queryEntity.relationsList?.filter(
-        (a) => a.typeId === result.value,
-      );
-      if (allRelationsWithTheCorrectPropertyTypeId) {
-        for (const relationEntry of allRelationsWithTheCorrectPropertyTypeId) {
-          let nestedRawEntity: NestedRawEntity = {
-            id: relationEntry.toEntity.id,
-            _relation: {
-              id: relationEntry.id,
-            },
-          };
-
-          const relationsForRawNestedEntity = convertRelations(relationEntry.toEntity, relationTransformation);
-
-          nestedRawEntity = {
-            ...nestedRawEntity,
-            ...relationsForRawNestedEntity,
-          };
-
-          for (const nestedProp of relationTransformation.propertySignatures) {
-            const nestedResult = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(nestedProp.type);
-            if (Option.isSome(nestedResult)) {
-              const value = relationEntry.toEntity.valuesList?.find((a) => a.propertyId === nestedResult.value);
-              if (!value) {
-                continue;
-              }
-              const rawValue = Utils.convertPropertyValue(value, nestedProp.type);
-              if (rawValue) {
-                nestedRawEntity[String(nestedProp.name)] = rawValue;
-              }
-            }
-          }
-          // TODO: in the end every entry should be validated using the Schema?!?
-          rawEntity[String(prop.name)] = [...(rawEntity[String(prop.name)] as unknown[]), nestedRawEntity];
-        }
-      }
-    }
-  }
-
-  return rawEntity;
-};
diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index 6ee560bd..c790a536 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -47,6 +47,16 @@ query entity($id: UUID!, $spaceId: UUID!, $relationTypeIdsLevel1: [UUID!]!) {
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
       id
+      entity {
+        valuesList(filter: {spaceId: {is: $spaceId}}) {
+          propertyId
+          string
+          boolean
+          number
+          time
+          point
+        }
+      }
       toEntity {
         id
         name
@@ -84,6 +94,16 @@ query entity($id: UUID!, $spaceId: UUID!, $relationTypeIdsLevel1: [UUID!]!, $rel
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
       id
+      entity {
+        valuesList(filter: {spaceId: {is: $spaceId}}) {
+          propertyId
+          string
+          boolean
+          number
+          time
+          point
+        }
+      }
       toEntity {
         id
         name
@@ -99,6 +119,16 @@ query entity($id: UUID!, $spaceId: UUID!, $relationTypeIdsLevel1: [UUID!]!, $rel
           filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel2}},
         ) {
           id
+          entity {
+            valuesList(filter: {spaceId: {is: $spaceId}}) {
+              propertyId
+              string
+              boolean
+              number
+              time
+              point
+            }
+          }
           toEntity {
             id
             name
@@ -134,6 +164,16 @@ type EntityQueryResult = {
     }[];
     relationsList?: {
       id: string;
+      entity: {
+        valuesList: {
+          propertyId: string;
+          string: string;
+          boolean: boolean;
+          number: number;
+          time: string;
+          point: string;
+        }[];
+      };
       toEntity: {
         id: string;
         name: string;
@@ -147,6 +187,16 @@ type EntityQueryResult = {
         }[];
         relationsList?: {
           id: string;
+          entity: {
+            valuesList: {
+              propertyId: string;
+              string: string;
+              boolean: boolean;
+              number: number;
+              time: string;
+              point: string;
+            }[];
+          };
           toEntity: {
             id: string;
             name: string;
diff --git a/packages/hypergraph/src/constants.ts b/packages/hypergraph/src/constants.ts
index 10f48f46..73f39e20 100644
--- a/packages/hypergraph/src/constants.ts
+++ b/packages/hypergraph/src/constants.ts
@@ -7,3 +7,5 @@ export const RelationSymbol = Symbol.for('grc-20/relation');
 export const RelationSchemaSymbol = Symbol.for('grc-20/relation/schema');
 
 export const PropertyTypeSymbol = Symbol.for('grc-20/property/type');
+
+export const RelationPropertiesSymbol = Symbol.for('grc-20/relation/properties');
diff --git a/packages/hypergraph/src/entity/find-many-public.ts b/packages/hypergraph/src/entity/find-many-public.ts
index ed707ce4..6b1fcdd7 100644
--- a/packages/hypergraph/src/entity/find-many-public.ts
+++ b/packages/hypergraph/src/entity/find-many-public.ts
@@ -60,6 +60,16 @@ query entities($spaceId: UUID!, $typeIds: [UUID!]!, $relationTypeIdsLevel1: [UUI
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
       id
+      entity {
+        valuesList(filter: {spaceId: {is: $spaceId}}) {
+          propertyId
+          string
+          boolean
+          number
+          time
+          point
+        }
+      }
       toEntity {
         id
         name
@@ -101,6 +111,16 @@ query entities($spaceId: UUID!, $typeIds: [UUID!]!, $relationTypeIdsLevel1: [UUI
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
       id
+      entity {
+        valuesList(filter: {spaceId: {is: $spaceId}}) {
+          propertyId
+          string
+          boolean
+          number
+          time
+          point
+        }
+      }
       toEntity {
         id
         name
@@ -117,6 +137,16 @@ query entities($spaceId: UUID!, $typeIds: [UUID!]!, $relationTypeIdsLevel1: [UUI
           # filter: {spaceId: {is: $spaceId}, toEntity: {relations: {some: {typeId: {is: "8f151ba4-de20-4e3c-9cb4-99ddf96f48f1"}, toEntityId: {in: $relationTypeIdsLevel2}}}}}
         ) {
           id
+          entity {
+            valuesList(filter: {spaceId: {is: $spaceId}}) {
+              propertyId
+              string
+              boolean
+              number
+              time
+              point
+            }
+          }
           toEntity {
             id
             name
@@ -152,6 +182,16 @@ type EntityQueryResult = {
     }[];
     relationsList: {
       id: string;
+      entity: {
+        valuesList: {
+          propertyId: string;
+          string: string;
+          boolean: boolean;
+          number: number;
+          time: string;
+          point: string;
+        }[];
+      };
       toEntity: {
         id: string;
         name: string;
@@ -165,6 +205,16 @@ type EntityQueryResult = {
         }[];
         relationsList: {
           id: string;
+          entity: {
+            valuesList: {
+              propertyId: string;
+              string: string;
+              boolean: boolean;
+              number: number;
+              time: string;
+              point: string;
+            }[];
+          };
           toEntity: {
             id: string;
             name: string;
diff --git a/packages/hypergraph/src/entity/schema.ts b/packages/hypergraph/src/entity/schema.ts
index ded3d400..796ac0e8 100644
--- a/packages/hypergraph/src/entity/schema.ts
+++ b/packages/hypergraph/src/entity/schema.ts
@@ -20,12 +20,14 @@ import { PropertyIdSymbol, TypeIdsSymbol } from '../constants.js';
  * ```
  */
 export function Schema<
-  T extends Record<
+  const T extends Record<
     string,
     // biome-ignore lint/suspicious/noExplicitAny: any
-    (propertyId: string) => EffectSchema.Schema<any> | EffectSchema.PropertySignature<any, any, any, any, any, any, any>
+    (propertyId: any) => EffectSchema.Schema<any> | EffectSchema.PropertySignature<any, any, any, any, any, any, any>
   >,
-  P extends Record<keyof T, string>,
+  const P extends {
+    [K in keyof T]: Parameters<T[K]>[0];
+  },
 >(
   schemaTypes: T,
   mapping: {
@@ -42,8 +44,8 @@ export function Schema<
   > = {};
 
   for (const [key, schemaType] of Object.entries(schemaTypes)) {
-    const propertyId = mapping.properties[key as keyof P];
-    properties[key] = schemaType(propertyId);
+    const propertyMapping = mapping.properties[key as keyof P];
+    properties[key] = schemaType(propertyMapping);
   }
 
   // biome-ignore lint/suspicious/noExplicitAny: any
diff --git a/packages/hypergraph/src/entity/search-many-public.ts b/packages/hypergraph/src/entity/search-many-public.ts
index f2959d7d..8e1caa34 100644
--- a/packages/hypergraph/src/entity/search-many-public.ts
+++ b/packages/hypergraph/src/entity/search-many-public.ts
@@ -1,7 +1,7 @@
 import { Graph } from '@graphprotocol/grc-20';
 import { Constants, type Entity, Utils } from '@graphprotocol/hypergraph';
 import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
+import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { gql, request } from 'graphql-request';
 import { parseResult } from './find-many-public.js';
@@ -67,6 +67,16 @@ query search($query: String!, $spaceId: UUID!, $typeIds: [UUID!]!, $relationType
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
       id
+      entity {
+        valuesList(filter: {spaceId: {is: $spaceId}}) {
+          propertyId
+          string
+          boolean
+          number
+          time
+          point
+        }
+      }
       toEntity {
         id
         name
@@ -111,6 +121,16 @@ query search($query: String!, $spaceId: UUID!, $typeIds: [UUID!]!, $relationType
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
       id
+      entity {
+        valuesList(filter: {spaceId: {is: $spaceId}}) {
+          propertyId
+          string
+          boolean
+          number
+          time
+          point
+        }
+      }
       toEntity {
         id
         name
@@ -126,6 +146,16 @@ query search($query: String!, $spaceId: UUID!, $typeIds: [UUID!]!, $relationType
           filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel2}},
         ) {
           id
+          entity {
+            valuesList(filter: {spaceId: {is: $spaceId}}) {
+              propertyId
+              string
+              boolean
+              number
+              time
+              point
+            }
+          }
           toEntity {
             id
             name
@@ -161,6 +191,16 @@ type SearchQueryResult = {
     }[];
     relationsList: {
       id: string;
+      entity: {
+        valuesList: {
+          propertyId: string;
+          string: string;
+          boolean: boolean;
+          number: number;
+          time: string;
+          point: string;
+        }[];
+      };
       toEntity: {
         id: string;
         name: string;
@@ -174,6 +214,16 @@ type SearchQueryResult = {
         }[];
         relationsList: {
           id: string;
+          entity: {
+            valuesList: {
+              propertyId: string;
+              string: string;
+              boolean: boolean;
+              number: number;
+              time: string;
+              point: string;
+            }[];
+          };
           toEntity: {
             id: string;
             name: string;
diff --git a/packages/hypergraph/src/entity/types.ts b/packages/hypergraph/src/entity/types.ts
index c526d506..1ed5cec3 100644
--- a/packages/hypergraph/src/entity/types.ts
+++ b/packages/hypergraph/src/entity/types.ts
@@ -5,7 +5,11 @@ export type Entity<S extends Schema.Schema.AnyNoContext> = Schema.Schema.Type<S>
 };
 
 export type EntityWithRelation<S extends Schema.Schema.AnyNoContext> = Entity<S> & {
-  _relation: { id: string } | undefined;
+  _relation:
+    | ({
+        id: string;
+      } & Record<string, unknown>)
+    | undefined;
 };
 
 export type DocumentEntity = {
diff --git a/packages/hypergraph/src/type/type.ts b/packages/hypergraph/src/type/type.ts
index 03a59fe3..bf767c44 100644
--- a/packages/hypergraph/src/type/type.ts
+++ b/packages/hypergraph/src/type/type.ts
@@ -4,11 +4,57 @@ import * as SchemaAST from 'effect/SchemaAST';
 import {
   PropertyIdSymbol,
   PropertyTypeSymbol,
+  RelationPropertiesSymbol,
   RelationSchemaSymbol,
   RelationSymbol,
   TypeIdsSymbol,
 } from '../constants.js';
 
+type SchemaBuilderReturn =
+  | Schema.Schema.AnyNoContext
+  // biome-ignore lint/suspicious/noExplicitAny: effect schema property signature is intentionally untyped here
+  | Schema.PropertySignature<any, any, any, any, any, any, any>;
+
+// biome-ignore lint/suspicious/noExplicitAny: property builders accept property ids of varying shapes
+type SchemaBuilder = (propertyId: any) => SchemaBuilderReturn;
+
+type RelationPropertiesDefinition = Record<string, SchemaBuilder>;
+
+type RelationOptions<RP extends RelationPropertiesDefinition> = {
+  properties: RP;
+};
+
+type RelationMappingInput<RP extends RelationPropertiesDefinition | undefined> = RP extends RelationPropertiesDefinition
+  ? {
+      propertyId: string;
+      properties: {
+        [K in keyof RP]: Parameters<RP[K]>[0];
+      };
+    }
+  : string | { propertyId: string };
+
+type RelationPropertyValue<RP extends RelationPropertiesDefinition | undefined> =
+  RP extends RelationPropertiesDefinition
+    ? {
+        readonly [K in keyof RP]: Schema.Schema.Type<ReturnType<RP[K]>>;
+      }
+    : Record<string, never>;
+
+type RelationPropertyEncoded<RP extends RelationPropertiesDefinition | undefined> =
+  RP extends RelationPropertiesDefinition
+    ? {
+        readonly [K in keyof RP]: Schema.Schema.Encoded<ReturnType<RP[K]>>;
+      }
+    : Record<string, never>;
+
+type RelationMetadata<RP extends RelationPropertiesDefinition | undefined> = {
+  readonly id: string;
+} & RelationPropertyValue<RP>;
+
+type RelationMetadataEncoded<RP extends RelationPropertiesDefinition | undefined> = {
+  readonly id: string;
+} & RelationPropertyEncoded<RP>;
+
 /**
  * Creates a String schema with the specified GRC-20 property ID
  */
@@ -50,24 +96,76 @@ export const Point = (propertyId: string) =>
     encode: (points: readonly number[]) => points.join(','),
   }).pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId, [PropertyTypeSymbol]: 'point' }));
 
-export const Relation =
-  <S extends Schema.Schema.AnyNoContext>(schema: S) =>
-  (propertyId: string) => {
+export function Relation<S extends Schema.Schema.AnyNoContext>(
+  schema: S,
+): (mapping: RelationMappingInput<undefined>) => Schema.Schema<
+  readonly (Schema.Schema.Type<S> & { readonly id: string; readonly _relation: RelationMetadata<undefined> })[],
+  readonly (Schema.Schema.Encoded<S> & {
+    readonly id: string;
+    readonly _relation: RelationMetadataEncoded<undefined>;
+  })[],
+  never
+>;
+export function Relation<S extends Schema.Schema.AnyNoContext, RP extends RelationPropertiesDefinition>(
+  schema: S,
+  options: RelationOptions<RP>,
+): (
+  mapping: RelationMappingInput<RP>,
+) => Schema.Schema<
+  readonly (Schema.Schema.Type<S> & { readonly id: string; readonly _relation: RelationMetadata<RP> })[],
+  readonly (Schema.Schema.Encoded<S> & { readonly id: string; readonly _relation: RelationMetadataEncoded<RP> })[],
+  never
+>;
+export function Relation<
+  S extends Schema.Schema.AnyNoContext,
+  RP extends RelationPropertiesDefinition | undefined = undefined,
+  // biome-ignore lint/suspicious/noExplicitAny: implementation signature for overloads must use any
+>(schema: S, options?: RP extends RelationPropertiesDefinition ? RelationOptions<RP> : undefined): any {
+  return (mapping: RelationMappingInput<RP>) => {
+    const { propertyId, relationPropertyIds } =
+      typeof mapping === 'string'
+        ? { propertyId: mapping, relationPropertyIds: undefined as undefined }
+        : typeof mapping === 'object' && mapping !== null && 'properties' in mapping
+          ? { propertyId: mapping.propertyId, relationPropertyIds: mapping.properties }
+          : { propertyId: mapping.propertyId, relationPropertyIds: undefined as undefined };
+
     const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(schema.ast as SchemaAST.TypeLiteral).pipe(
       Option.getOrElse(() => []),
     );
 
+    const relationEntityPropertiesSchemas: Record<string, SchemaBuilderReturn> = {};
+
+    if (options?.properties) {
+      for (const [key, schemaType] of Object.entries(options.properties)) {
+        const propertyMapping = relationPropertyIds?.[key];
+        relationEntityPropertiesSchemas[key] = schemaType(propertyMapping);
+      }
+    }
+
+    const relationEntitySchemaStruct = Schema.Struct({
+      ...relationEntityPropertiesSchemas,
+    });
+
     const schemaWithId = Schema.asSchema(
       Schema.extend(schema)(
         Schema.Struct({
           id: Schema.String,
-          _relation: Schema.Struct({ id: Schema.String }),
+          _relation: Schema.extend(relationEntitySchemaStruct)(
+            Schema.Struct({
+              id: Schema.String,
+            }),
+          ),
         }),
       ),
       // manually adding the type ids to the schema since they get lost when extending the schema
-    ).pipe(Schema.annotations({ [TypeIdsSymbol]: typeIds })) as Schema.Schema<
-      Schema.Schema.Type<S> & { readonly id: string; readonly _relation: { readonly id: string } },
-      Schema.Schema.Encoded<S> & { readonly id: string; readonly _relation: { readonly id: string } },
+    ).pipe(
+      Schema.annotations({
+        [TypeIdsSymbol]: typeIds,
+        [RelationPropertiesSymbol]: relationEntitySchemaStruct,
+      }),
+    ) as Schema.Schema<
+      Schema.Schema.Type<S> & { readonly id: string; readonly _relation: RelationMetadata<RP> },
+      Schema.Schema.Encoded<S> & { readonly id: string; readonly _relation: RelationMetadataEncoded<RP> },
       never
     >;
 
@@ -78,8 +176,13 @@ export const Relation =
         [RelationSymbol]: true,
         [PropertyTypeSymbol]: 'relation',
       }),
-    );
+    ) as Schema.Schema<
+      readonly (Schema.Schema.Type<S> & { readonly id: string; readonly _relation: RelationMetadata<RP> })[],
+      readonly (Schema.Schema.Encoded<S> & { readonly id: string; readonly _relation: RelationMetadataEncoded<RP> })[],
+      never
+    >;
   };
+}
 
 export const optional =
   <S extends Schema.Schema.AnyNoContext>(schemaFn: (propertyId: string) => S) =>
diff --git a/packages/hypergraph/src/utils/convert-relations.ts b/packages/hypergraph/src/utils/convert-relations.ts
index 49b14f9a..66cf293e 100644
--- a/packages/hypergraph/src/utils/convert-relations.ts
+++ b/packages/hypergraph/src/utils/convert-relations.ts
@@ -4,6 +4,15 @@ import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { convertPropertyValue } from './convert-property-value.js';
 
+type ValueList = {
+  propertyId: string;
+  string: string;
+  boolean: boolean;
+  number: number;
+  time: string;
+  point: string;
+}[];
+
 // A recursive representation of the entity structure returned by the public GraphQL
 // endpoint. `values` and `relations` are optional because the nested `to` selections
 // get slimmer the deeper we traverse in the query. This type intentionally mirrors
@@ -11,24 +20,20 @@ import { convertPropertyValue } from './convert-property-value.js';
 type RecursiveQueryEntity = {
   id: string;
   name: string;
-  valuesList?: {
-    propertyId: string;
-    string: string;
-    boolean: boolean;
-    number: number;
-    time: string;
-    point: string;
-  }[];
+  valuesList?: ValueList;
   relationsList?: {
     id: string;
     toEntity: RecursiveQueryEntity;
+    entity: {
+      valuesList?: ValueList;
+    };
     typeId: string;
   }[];
 };
 
 type RawEntityValue = string | boolean | number | unknown[] | Date | { id: string };
 type RawEntity = Record<string, RawEntityValue>;
-type NestedRawEntity = RawEntity & { _relation: { id: string } };
+type NestedRawEntity = RawEntity & { _relation: { id: string } & Record<string, RawEntityValue> };
 
 export const convertRelations = <_S extends Schema.Schema.AnyNoContext>(
   queryEntity: RecursiveQueryEntity,
@@ -45,6 +50,7 @@ export const convertRelations = <_S extends Schema.Schema.AnyNoContext>(
       if (!SchemaAST.isTupleType(prop.type)) {
         continue;
       }
+
       const relationType = prop.type;
       const relationTransformation = relationType.rest[0]?.type;
       if (!relationTransformation || !SchemaAST.isTypeLiteral(relationTransformation)) {
@@ -90,6 +96,31 @@ export const convertRelations = <_S extends Schema.Schema.AnyNoContext>(
               }
             }
           }
+
+          const relationPropertiesSchema = SchemaAST.getAnnotation<Schema.Schema.AnyNoContext>(
+            Constants.RelationPropertiesSymbol,
+          )(relationTransformation);
+          if (Option.isSome(relationPropertiesSchema)) {
+            const relationPropertiesSchemaAst = relationPropertiesSchema.value.ast as SchemaAST.TypeLiteral;
+            for (const nestedProp of relationPropertiesSchemaAst.propertySignatures) {
+              const propType =
+                nestedProp.isOptional && SchemaAST.isUnion(nestedProp.type)
+                  ? (nestedProp.type.types.find((member) => !SchemaAST.isUndefinedKeyword(member)) ?? nestedProp.type)
+                  : nestedProp.type;
+
+              const nestedResult = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(propType);
+              if (Option.isSome(nestedResult)) {
+                const value = relationEntry.entity.valuesList?.find((a) => a.propertyId === nestedResult.value);
+                if (value) {
+                  const rawValue = convertPropertyValue(value, propType);
+                  if (rawValue !== undefined) {
+                    nestedRawEntity._relation[String(nestedProp.name)] = rawValue;
+                  }
+                }
+              }
+            }
+          }
+
           // TODO: in the end every entry should be validated using the Schema?!?
           rawEntity[String(prop.name)] = [...(rawEntity[String(prop.name)] as unknown[]), nestedRawEntity];
         }