From 79e51cfe0f11a5512dd4f73e08c9a03f3661b8aa Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 23 Sep 2025 18:22:42 +0200
Subject: [PATCH 01/22] migrate to new schema

---
 apps/events/src/components/todos.tsx          |  22 +-
 apps/events/src/components/users.tsx          |  14 +-
 apps/events/src/schema.ts                     |  43 +-
 .../src/hooks/use-create-entity.ts            |  14 +
 .../hypergraph-react/src/hooks/use-query.tsx  |  32 +-
 packages/hypergraph-react/src/index.ts        |  16 +-
 .../src/internal/use-query-private.tsx        |  50 ++
 packages/hypergraph/src/entity/create.ts      |  21 +-
 .../src/entity/decodedEntitiesCacheNew.ts     |  37 ++
 packages/hypergraph/src/entity/entity-new.ts  |  80 +++
 packages/hypergraph/src/entity/findMany.ts    |   2 +-
 packages/hypergraph/src/entity/findManyNew.ts | 530 ++++++++++++++++++
 packages/hypergraph/src/entity/findOne.ts     |  34 +-
 packages/hypergraph/src/entity/index.ts       |   1 +
 .../hypergraph/src/entity/internal-new.ts     |   3 +
 packages/hypergraph/src/entity/type-new.ts    |  34 ++
 packages/hypergraph/src/entity/types.ts       |   4 +
 packages/hypergraph/src/index.ts              |   6 +-
 18 files changed, 913 insertions(+), 30 deletions(-)
 create mode 100644 packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts
 create mode 100644 packages/hypergraph/src/entity/entity-new.ts
 create mode 100644 packages/hypergraph/src/entity/findManyNew.ts
 create mode 100644 packages/hypergraph/src/entity/internal-new.ts
 create mode 100644 packages/hypergraph/src/entity/type-new.ts

diff --git a/apps/events/src/components/todos.tsx b/apps/events/src/components/todos.tsx
index bda38ed6..7f0290e8 100644
--- a/apps/events/src/components/todos.tsx
+++ b/apps/events/src/components/todos.tsx
@@ -1,32 +1,34 @@
 import {
-  useCreateEntity,
+  useCreateEntityNew,
   useDeleteEntity,
-  useQuery,
+  useQueryNew,
   useRemoveRelation,
   useSpace,
   useUpdateEntity,
 } from '@graphprotocol/hypergraph-react';
 import { useEffect, useState } from 'react';
 import Select from 'react-select';
-import { Todo, User } from '../schema';
+import { Todo, TodoNew, UserNew } from '../schema';
 import { Button } from './ui/button';
 import { Input } from './ui/input';
 
 export const Todos = () => {
-  const { data: todos } = useQuery(Todo, {
+  const { data: todos } = useQueryNew(TodoNew, {
     mode: 'private',
-    include: { assignees: {} },
+    // include: { assignees: {} },
     // filter: { or: [{ name: { startsWith: 'aa' } }, { name: { is: 'sdasd' } }] },
   });
-  const { data: users } = useQuery(User, { mode: 'private' });
+  const { data: users } = useQueryNew(UserNew, { mode: 'private' });
   const { ready: spaceReady } = useSpace({ mode: 'private' });
-  const createEntity = useCreateEntity(Todo);
+  const createEntity = useCreateEntityNew(TodoNew);
   const updateEntity = useUpdateEntity(Todo);
   const deleteEntity = useDeleteEntity();
   const removeRelation = useRemoveRelation();
   const [newTodoName, setNewTodoName] = useState('');
   const [assignees, setAssignees] = useState<{ value: string; label: string }[]>([]);
 
+  console.log(todos);
+
   useEffect(() => {
     setAssignees((prevFilteredAssignees) => {
       // filter out assignees that are not in the users array whenever users change
@@ -54,7 +56,7 @@ export const Todos = () => {
             createEntity({
               name: newTodoName,
               completed: false,
-              assignees: assignees.map(({ value }) => value),
+              // assignees: assignees.map(({ value }) => value),
             });
             setNewTodoName('');
           }}
@@ -65,7 +67,7 @@ export const Todos = () => {
       {todos.map((todo) => (
         <div key={todo.id} className="flex flex-row items-center gap-2">
           <h2>{todo.name}</h2>
-          {todo.assignees.length > 0 && (
+          {/* {todo.assignees.length > 0 && (
             <span className="text-xs text-gray-500">
               Assigned to:{' '}
               {todo.assignees.map((assignee) => (
@@ -85,7 +87,7 @@ export const Todos = () => {
                 </span>
               ))}
             </span>
-          )}
+          )} */}
           <input
             type="checkbox"
             checked={todo.completed}
diff --git a/apps/events/src/components/users.tsx b/apps/events/src/components/users.tsx
index 056109f6..38bc93ba 100644
--- a/apps/events/src/components/users.tsx
+++ b/apps/events/src/components/users.tsx
@@ -1,16 +1,18 @@
-import { useCreateEntity, useQuery, useSpace } from '@graphprotocol/hypergraph-react';
+import { useCreateEntityNew, useQueryNew, useSpace } from '@graphprotocol/hypergraph-react';
 import { useState } from 'react';
-import { User } from '../schema.js';
+import { UserNew } from '../schema.js';
 import { Button } from './ui/button.js';
 import { Input } from './ui/input.js';
 import { UserEntry } from './user-entry.js';
 
 export const Users = () => {
-  const { data: users } = useQuery(User, { mode: 'private' });
+  const { data: users } = useQueryNew(UserNew, { mode: 'private' });
   const { ready: spaceReady } = useSpace({ mode: 'private' });
-  const createEntity = useCreateEntity(User);
+  const createEntityNew = useCreateEntityNew(UserNew);
   const [newUserName, setNewUserName] = useState('');
 
+  console.log(users);
+
   if (!spaceReady) {
     return <div>Loading space...</div>;
   }
@@ -22,7 +24,9 @@ export const Users = () => {
         <Input type="text" value={newUserName} onChange={(e) => setNewUserName(e.target.value)} />
         <Button
           onClick={() => {
-            createEntity({ name: newUserName });
+            // createEntity({ name: newUserName });
+            const user = createEntityNew({ name: newUserName });
+            console.log(user);
             setNewUserName('');
           }}
         >
diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index ff8bf043..dbff2859 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -1,4 +1,4 @@
-import { Entity, Type } from '@graphprotocol/hypergraph';
+import { Entity, EntityNew, Id, Type, TypeNew } from '@graphprotocol/hypergraph';
 
 export class User extends Entity.Class<User>('User')({
   name: Type.String,
@@ -41,3 +41,44 @@ export class Todo3 extends Entity.Class<Todo3>('Todo3')({
   completed: Type.Boolean,
   description: Type.String,
 }) {}
+
+export const UserNew = EntityNew(
+  {
+    name: TypeNew.String,
+  },
+  {
+    types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+    },
+  },
+);
+
+export const TodoNew = EntityNew(
+  {
+    name: TypeNew.String,
+    completed: TypeNew.Boolean,
+    // assignees: TypeNew.Relation(UserNew),
+  },
+  {
+    types: [Id('44fe82a9-e4c2-4330-a395-ce85ed78e421')],
+    properties: {
+      name: Id('c668aa67-bbca-4b2c-908c-9c5599035eab'),
+      completed: Id('71e7654f-2623-4794-88fb-841c8f3dd9b4'),
+    },
+  },
+);
+
+export const JobOfferNew = EntityNew(
+  {
+    name: TypeNew.String,
+    salary: TypeNew.Number,
+  },
+  {
+    types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      salary: Id('baa36ac9-78ac-4cf7-8394-6b2d3006bebe'),
+    },
+  },
+);
diff --git a/packages/hypergraph-react/src/hooks/use-create-entity.ts b/packages/hypergraph-react/src/hooks/use-create-entity.ts
index 8f9d6a47..60564771 100644
--- a/packages/hypergraph-react/src/hooks/use-create-entity.ts
+++ b/packages/hypergraph-react/src/hooks/use-create-entity.ts
@@ -1,6 +1,7 @@
 'use client';
 
 import { Entity } from '@graphprotocol/hypergraph';
+import type * as Schema from 'effect/Schema';
 import { useHypergraphSpaceInternal } from '../internal/use-hypergraph-space-internal.js';
 import { useSubscribeToSpaceAndGetHandle } from '../internal/use-subscribe-to-space.js';
 
@@ -16,3 +17,16 @@ export function useCreateEntity<const S extends Entity.AnyNoContext>(type: S, op
   }
   return Entity.create(handle, type);
 }
+
+export function useCreateEntityNew<const S extends Schema.Schema.AnyNoContext>(type: S, options?: { space?: string }) {
+  const { space: spaceIdFromParams } = options ?? {};
+  const { space: spaceFromContext } = useHypergraphSpaceInternal();
+  const spaceId = spaceIdFromParams ?? spaceFromContext;
+  const handle = useSubscribeToSpaceAndGetHandle({ spaceId, enabled: true });
+  if (!handle) {
+    return () => {
+      throw new Error('Space not found or not ready');
+    };
+  }
+  return Entity.createNew(handle, type);
+}
diff --git a/packages/hypergraph-react/src/hooks/use-query.tsx b/packages/hypergraph-react/src/hooks/use-query.tsx
index 0a866c94..611d6061 100644
--- a/packages/hypergraph-react/src/hooks/use-query.tsx
+++ b/packages/hypergraph-react/src/hooks/use-query.tsx
@@ -1,6 +1,6 @@
 import type { Entity } from '@graphprotocol/hypergraph';
 import type * as Schema from 'effect/Schema';
-import { useQueryPrivate } from '../internal/use-query-private.js';
+import { useQueryPrivate, useQueryPrivateNew } from '../internal/use-query-private.js';
 import { useQueryPublic } from '../internal/use-query-public.js';
 
 type QueryParams<S extends Entity.AnyNoContext> = {
@@ -34,3 +34,33 @@ export function useQuery<const S extends Entity.AnyNoContext>(type: S, params: Q
     preparePublish: preparePublishDummy,
   };
 }
+
+type QueryParamsNew<S extends Schema.Schema.AnyNoContext> = {
+  mode: 'public' | 'private';
+  filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
+  // TODO: for multi-level nesting it should only allow the allowed properties instead of Record<string, Record<string, never>>
+  include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
+  space?: string | undefined;
+  first?: number | undefined;
+};
+
+export function useQueryNew<const S extends Schema.Schema.AnyNoContext>(type: S, params: QueryParamsNew<S>) {
+  const { mode, filter, include, space, first } = params;
+  const publicResult = useQueryPublic(type, { enabled: mode === 'public', filter, include, first, space });
+  const localResult = useQueryPrivateNew(type, { enabled: mode === 'private', filter, include, space });
+
+  if (mode === 'public') {
+    return {
+      ...publicResult,
+      deleted: [],
+      preparePublish: preparePublishDummy,
+    };
+  }
+
+  return {
+    ...publicResult,
+    data: localResult.entities,
+    deleted: localResult.deletedEntities,
+    preparePublish: preparePublishDummy,
+  };
+}
diff --git a/packages/hypergraph-react/src/index.ts b/packages/hypergraph-react/src/index.ts
index 6458ffff..1b6c286a 100644
--- a/packages/hypergraph-react/src/index.ts
+++ b/packages/hypergraph-react/src/index.ts
@@ -1,18 +1,12 @@
 export { PublishDiff } from './components/publish-diff/publish-diff.js';
 export { createWalletClient } from './create-wallet-client.js';
-export {
-  HypergraphAppProvider,
-  useHypergraphApp,
-  useHypergraphAuth,
-} from './HypergraphAppContext.js';
-export { HypergraphSpaceProvider } from './HypergraphSpaceContext.js';
-export { useCreateEntity } from './hooks/use-create-entity.js';
+export { useCreateEntity, useCreateEntityNew } from './hooks/use-create-entity.js';
 export { useDeleteEntity } from './hooks/use-delete-entity.js';
 export { useEntity } from './hooks/use-entity.js';
 export { useHardDeleteEntity } from './hooks/use-hard-delete-entity.js';
 export { usePrivyAuthCreatePrivateSpace as _usePrivyAuthCreatePrivateSpace } from './hooks/use-privy-auth-create-private-space.js';
 export { usePrivyAuthCreatePublicSpace as _usePrivyAuthCreatePublicSpace } from './hooks/use-privy-auth-create-public-space.js';
-export { useQuery } from './hooks/use-query.js';
+export { useQuery, useQueryNew } from './hooks/use-query.js';
 export { useRemoveRelation } from './hooks/use-remove-relation.js';
 export { useSpace } from './hooks/use-space.js';
 export { useSpaces } from './hooks/use-spaces.js';
@@ -23,6 +17,12 @@ export { useOwnAccountInbox } from './hooks/useOwnAccountInbox.js';
 export { useOwnSpaceInbox } from './hooks/useOwnSpaceInbox.js';
 export { usePublicAccountInboxes } from './hooks/usePublicAccountInboxes.js';
 export { usePublishToPublicSpace } from './hooks/usePublishToSpace.js';
+export {
+  HypergraphAppProvider,
+  useHypergraphApp,
+  useHypergraphAuth,
+} from './HypergraphAppContext.js';
+export { HypergraphSpaceProvider } from './HypergraphSpaceContext.js';
 export { generateDeleteOps as _generateDeleteOps } from './internal/generate-delete-ops.js';
 export { useCreateEntityPublic as _useCreateEntityPublic } from './internal/use-create-entity-public.js';
 export { useDeleteEntityPublic as _useDeleteEntityPublic } from './internal/use-delete-entity-public.js';
diff --git a/packages/hypergraph-react/src/internal/use-query-private.tsx b/packages/hypergraph-react/src/internal/use-query-private.tsx
index 7424a50d..6b1941b6 100644
--- a/packages/hypergraph-react/src/internal/use-query-private.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-private.tsx
@@ -53,3 +53,53 @@ export function useQueryPrivate<const S extends Entity.AnyNoContext>(type: S, pa
 
   return { entities, deletedEntities };
 }
+
+type QueryParamsNew<S extends Schema.Schema.AnyNoContext> = {
+  space?: string | undefined;
+  enabled: boolean;
+  filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
+  include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
+};
+
+export function useQueryPrivateNew<const S extends Schema.Schema.AnyNoContext>(type: S, params?: QueryParamsNew<S>) {
+  const { enabled = true, filter, include, space: spaceFromParams } = params ?? {};
+  const entitiesRef = useRef<Entity.EntityNew<S>[]>([]);
+  const subscriptionRef = useRef<Entity.FindManySubscriptionNew<S>>({
+    subscribe: () => () => undefined,
+    getEntities: () => entitiesRef.current,
+  });
+  const { space: spaceFromContext } = useHypergraphSpaceInternal();
+  const handle = useSubscribeToSpaceAndGetHandle({ spaceId: spaceFromParams ?? spaceFromContext, enabled });
+  const handleIsReady = handle ? handle.isReady() : false;
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: allow to change filter and include
+  useLayoutEffect(() => {
+    if (enabled && handle && handleIsReady) {
+      const subscription = Entity.subscribeToFindManyNew(handle, type, filter, include);
+      subscriptionRef.current.subscribe = subscription.subscribe;
+      subscriptionRef.current.getEntities = subscription.getEntities;
+    }
+  }, [enabled, handleIsReady, handle, type]);
+
+  // TODO: allow to change the enabled state
+  const allEntities = useSyncExternalStore(
+    subscriptionRef.current.subscribe,
+    subscriptionRef.current.getEntities,
+    () => entitiesRef.current,
+  );
+
+  const { entities, deletedEntities } = useMemo(() => {
+    const entities: Entity.EntityNew<S>[] = [];
+    const deletedEntities: Entity.EntityNew<S>[] = [];
+    for (const entity of allEntities) {
+      if (entity.__deleted === true) {
+        deletedEntities.push(entity);
+      } else {
+        entities.push(entity);
+      }
+    }
+    return { entities, deletedEntities };
+  }, [allEntities]);
+
+  return { entities, deletedEntities };
+}
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index 08ec62f9..a3431733 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -2,7 +2,8 @@ import type { DocHandle } from '@automerge/automerge-repo';
 import * as Schema from 'effect/Schema';
 import { generateId } from '../utils/generateId.js';
 import { isRelationField } from '../utils/isRelationField.js';
-import { findOne } from './findOne.js';
+import { encodeToGrc20Json } from './entity-new.js';
+import { findOne, findOneNew } from './findOne.js';
 import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, Insert } from './types.js';
 
 /**
@@ -56,3 +57,21 @@ export const create = <const S extends AnyNoContext>(handle: DocHandle<DocumentC
     return findOne(handle, type)(entityId) as Entity<S>;
   };
 };
+
+export const createNew = <const S extends Schema.Schema.AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
+  // TODO: return type
+  return (data: Readonly<Schema.Schema.Type<S>>) => {
+    const entityId = generateId();
+    const encoded = encodeToGrc20Json(type, { ...data, id: entityId });
+
+    handle.change((doc) => {
+      doc.entities ??= {};
+      doc.entities[entityId] = {
+        ...encoded,
+        __deleted: false,
+      };
+    });
+
+    return findOneNew(handle, type)(entityId);
+  };
+};
diff --git a/packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts b/packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts
new file mode 100644
index 00000000..484f9f58
--- /dev/null
+++ b/packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts
@@ -0,0 +1,37 @@
+import type * as Schema from 'effect/Schema';
+import type { EntityNew } from './types.js';
+
+export type QueryEntry = {
+  data: Array<EntityNew<Schema.Schema.AnyNoContext>>; // holds the decoded entities of this query and must be a stable reference and use the same reference for the `entities` array
+  listeners: Array<() => void>; // listeners to this query
+  isInvalidated: boolean;
+  include: { [K in keyof Schema.Schema.Type<Schema.Schema.AnyNoContext>]?: Record<string, Record<string, never>> };
+};
+
+export type DecodedEntitiesCacheEntry = {
+  type: Schema.Schema.AnyNoContext; // TODO should be the type of the entity
+  entities: Map<string, EntityNew<Schema.Schema.AnyNoContext>>; // holds all entities of this type
+  queries: Map<
+    string, // instead of serializedQueryKey as string we could also have the actual params
+    QueryEntry
+  >;
+  isInvalidated: boolean;
+};
+
+/*
+/*
+ * Note: Currently we only use one global cache for all entities.
+ * In the future we probably want a build function that creates a cache and returns the
+ * functions (create, update, findMany, …) that use this specific cache.
+ *
+ * How does it work?
+ *
+ * We store all decoded entities in a cache and for each query we reference the entities relevant to this query.
+ * Whenever a query is registered we add it to the cache and add a listener to the query. Whenever a query is unregistered we remove the listener from the query.
+ */
+type DecodedEntitiesCache = Map<
+  string, // serialized type IDs
+  DecodedEntitiesCacheEntry
+>;
+
+export const decodedEntitiesCache: DecodedEntitiesCache = new Map();
diff --git a/packages/hypergraph/src/entity/entity-new.ts b/packages/hypergraph/src/entity/entity-new.ts
new file mode 100644
index 00000000..752e2976
--- /dev/null
+++ b/packages/hypergraph/src/entity/entity-new.ts
@@ -0,0 +1,80 @@
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { PropertyIdSymbol, TypeIdsSymbol } from './internal-new.js';
+
+/**
+ * Entity function for creating schemas with a nicer API.
+ * Takes a schema configuration object and a property ID mapping object.
+ *
+ * @example
+ * ```typescript
+ * const User = Entity({
+ *   name: Type.String,
+ *   age: Type.Number,
+ * }, {
+ *   name: "grc-20-name",
+ *   age: "grc-20-age"
+ * });
+ * ```
+ */
+export function Entity<
+  T extends Record<string, (propertyId: string) => Schema.Schema<any>>,
+  P extends Record<keyof T, string>,
+>(
+  schemaTypes: T,
+  mapping: {
+    types: Array<string>;
+    properties: P;
+  },
+): Schema.Struct<{
+  [K in keyof T]: ReturnType<T[K]> & { id: string };
+}> {
+  const properties: Record<string, Schema.Schema<any>> = {};
+
+  for (const [key, schemaType] of Object.entries(schemaTypes)) {
+    const propertyId = mapping.properties[key as keyof P];
+    properties[key] = schemaType(propertyId);
+  }
+
+  return Schema.Struct(properties).pipe(Schema.annotations({ [TypeIdsSymbol]: mapping.types })) as any;
+}
+
+export function encodeToGrc20Json<T extends object, E>(schema: Schema.Schema<T, E>, value: T): Record<string, unknown> {
+  const ast = schema.ast as SchemaAST.TypeLiteral;
+  const out: Record<string, unknown> = {};
+
+  for (const prop of ast.propertySignatures) {
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+    if (Option.isSome(result)) {
+      out[result.value] = (value as any)[prop.name];
+    }
+  }
+
+  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(ast).pipe(Option.getOrElse(() => []));
+  out['@@types@@'] = typeIds;
+
+  return out;
+}
+
+export function decodeFromGrc20Json<T extends object, E>(
+  schema: Schema.Schema<T, E>,
+  grc20Data: Record<string, unknown>,
+): T {
+  const ast = schema.ast as SchemaAST.TypeLiteral;
+  const out: Record<string, unknown> = {};
+
+  for (const prop of ast.propertySignatures) {
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+    if (Option.isSome(result)) {
+      const grc20Key = result.value;
+      if (grc20Key in grc20Data && typeof prop.name === 'string') {
+        out[prop.name] = (grc20Data as any)[grc20Key];
+      }
+    }
+  }
+
+  out.id = grc20Data.id as string;
+
+  return out as T;
+}
diff --git a/packages/hypergraph/src/entity/findMany.ts b/packages/hypergraph/src/entity/findMany.ts
index 297d0190..04250255 100644
--- a/packages/hypergraph/src/entity/findMany.ts
+++ b/packages/hypergraph/src/entity/findMany.ts
@@ -3,7 +3,7 @@ import * as Schema from 'effect/Schema';
 import { deepMerge } from '../utils/internal/deep-merge.js';
 import { isRelationField } from '../utils/isRelationField.js';
 import { canonicalize } from '../utils/jsc.js';
-import { type DecodedEntitiesCacheEntry, decodedEntitiesCache, type QueryEntry } from './decodedEntitiesCache.js';
+import { decodedEntitiesCache, type DecodedEntitiesCacheEntry, type QueryEntry } from './decodedEntitiesCache.js';
 import { entityRelationParentsMap } from './entityRelationParentsMap.js';
 import { getEntityRelations } from './getEntityRelations.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
diff --git a/packages/hypergraph/src/entity/findManyNew.ts b/packages/hypergraph/src/entity/findManyNew.ts
new file mode 100644
index 00000000..752b24dc
--- /dev/null
+++ b/packages/hypergraph/src/entity/findManyNew.ts
@@ -0,0 +1,530 @@
+import type { DocHandle, Patch } from '@automerge/automerge-repo';
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { deepMerge } from '../utils/internal/deep-merge.js';
+import { canonicalize } from '../utils/jsc.js';
+import { decodedEntitiesCache, type DecodedEntitiesCacheEntry, type QueryEntry } from './decodedEntitiesCacheNew.js';
+import { decodeFromGrc20Json } from './entity-new.js';
+import { entityRelationParentsMap } from './entityRelationParentsMap.js';
+import { hasValidTypesProperty } from './hasValidTypesProperty.js';
+import { TypeIdsSymbol } from './internal-new.js';
+import type {
+  CrossFieldFilter,
+  DocumentContent,
+  EntityFieldFilter,
+  EntityFilter,
+  EntityNew,
+  EntityNumberFilter,
+  EntityStringFilter,
+} from './types.js';
+
+const documentChangeListener: {
+  subscribedQueriesCount: number;
+  unsubscribe: undefined | (() => void);
+} = {
+  subscribedQueriesCount: 0,
+  unsubscribe: undefined,
+};
+
+const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
+  const onChange = ({ patches, doc }: { patches: Array<Patch>; doc: DocumentContent }) => {
+    const changedRelations = new Set<string>();
+    const deletedRelations = new Set<string>();
+    const changedEntities = new Set<string>();
+    const deletedEntities = new Set<string>();
+
+    for (const patch of patches) {
+      switch (patch.action) {
+        case 'put':
+        case 'insert':
+        case 'splice': {
+          if (patch.path.length > 2 && patch.path[0] === 'entities' && typeof patch.path[1] === 'string') {
+            changedEntities.add(patch.path[1]);
+          }
+          if (patch.path.length > 2 && patch.path[0] === 'relations' && typeof patch.path[1] === 'string') {
+            changedRelations.add(patch.path[1]);
+          }
+          break;
+        }
+        case 'del': {
+          if (patch.path.length === 2 && patch.path[0] === 'entities' && typeof patch.path[1] === 'string') {
+            deletedEntities.add(patch.path[1]);
+          }
+          if (patch.path.length === 2 && patch.path[0] === 'relations' && typeof patch.path[1] === 'string') {
+            deletedRelations.add(patch.path[1]);
+          }
+          break;
+        }
+      }
+    }
+
+    const entityTypes = new Set<string>();
+    // collect all query entries that changed and only at the end make one copy to change the
+    // reference to reduce the amount of O(n) operations per query to 1
+    const touchedQueries = new Set<Array<string>>();
+
+    // collect all entities that used this entity as a entry in on of their relation fields
+    const touchedRelationParents = new Set<DecodedEntitiesCacheEntry>();
+
+    // loop over all changed entities and update the cache
+    for (const entityId of changedEntities) {
+      const entity = doc.entities?.[entityId];
+      if (!hasValidTypesProperty(entity)) continue;
+      for (const typeName of entity['@@types@@']) {
+        if (typeof typeName !== 'string') continue;
+        const cacheEntry = decodedEntitiesCache.get(typeName);
+        if (!cacheEntry) continue;
+
+        let includeFromAllQueries = {};
+        for (const [, query] of cacheEntry.queries) {
+          includeFromAllQueries = deepMerge(includeFromAllQueries, query.include);
+        }
+
+        const oldDecodedEntry = cacheEntry.entities.get(entityId);
+        // const relations = getEntityRelations(entityId, cacheEntry.type, doc, includeFromAllQueries);
+        let decoded: unknown | undefined;
+        try {
+          // decoded = cacheEntry.decoder({
+          decoded = decodeFromGrc20Json(cacheEntry.type, {
+            ...entity,
+            // ...relations,
+            id: entityId,
+          });
+          cacheEntry.entities.set(entityId, decoded);
+        } catch (error) {
+          // TODO: store the corrupt entity ids somewhere, so they can be read via the API
+          console.error('error', error);
+        }
+
+        if (oldDecodedEntry) {
+          // collect all the Ids for relation entries in the `oldDecodedEntry`
+          // const deletedRelationIds = new Set<string>();
+          // for (const [, value] of Object.entries(oldDecodedEntry)) {
+          //   if (Array.isArray(value)) {
+          //     for (const relationEntity of value) {
+          //       deletedRelationIds.add(relationEntity.id);
+          //     }
+          //   }
+          // }
+          // it's fine to remove all of them since they are re-added below
+          // for (const deletedRelationId of deletedRelationIds) {
+          //   const deletedRelationEntry = entityRelationParentsMap.get(deletedRelationId);
+          //   if (deletedRelationEntry) {
+          //     deletedRelationEntry.set(cacheEntry, (deletedRelationEntry.get(cacheEntry) ?? 0) - 1);
+          //     if (deletedRelationEntry.get(cacheEntry) === 0) {
+          //       deletedRelationEntry.delete(cacheEntry);
+          //     }
+          //     if (deletedRelationEntry.size === 0) {
+          //       entityRelationParentsMap.delete(deletedRelationId);
+          //     }
+          //   }
+          // }
+        }
+
+        if (decoded) {
+          for (const [, value] of Object.entries(decoded)) {
+            // if (Array.isArray(value)) {
+            //   for (const relationEntity of value) {
+            //     let relationParentEntry = entityRelationParentsMap.get(relationEntity.id);
+            //     if (relationParentEntry) {
+            //       relationParentEntry.set(cacheEntry, (relationParentEntry.get(cacheEntry) ?? 0) + 1);
+            //     } else {
+            //       relationParentEntry = new Map();
+            //       entityRelationParentsMap.set(relationEntity.id, relationParentEntry);
+            //       relationParentEntry.set(cacheEntry, 1);
+            //     }
+            //   }
+            // }
+          }
+        }
+
+        for (const [queryKey, query] of cacheEntry.queries) {
+          touchedQueries.add([typeName, queryKey]);
+          query.isInvalidated = true;
+        }
+
+        entityTypes.add(typeName);
+
+        // gather all the decodedEntitiesCacheEntries that have a relation to this entity to
+        // invoke their query listeners below
+        if (entityRelationParentsMap.has(entityId)) {
+          const decodedEntitiesCacheEntries = entityRelationParentsMap.get(entityId);
+          if (!decodedEntitiesCacheEntries) return;
+
+          for (const [entry] of decodedEntitiesCacheEntries) {
+            touchedRelationParents.add(entry);
+          }
+        }
+      }
+    }
+
+    // loop over all deleted entities and remove them from the cache
+    for (const entityId of deletedEntities) {
+      for (const [affectedTypeName, cacheEntry] of decodedEntitiesCache) {
+        if (cacheEntry.entities.has(entityId)) {
+          entityTypes.add(affectedTypeName);
+          cacheEntry.entities.delete(entityId);
+
+          for (const [queryKey, query] of cacheEntry.queries) {
+            // find the entity in the query and remove it using splice
+            const index = query.data.findIndex((entity) => entity.id === entityId);
+            if (index !== -1) {
+              query.data.splice(index, 1);
+              touchedQueries.add([affectedTypeName, queryKey]);
+            }
+          }
+        }
+      }
+
+      // gather all the queries of impacted parent relation queries and then remove the cacheEntry
+      if (entityRelationParentsMap.has(entityId)) {
+        const decodedEntitiesCacheEntries = entityRelationParentsMap.get(entityId);
+        if (!decodedEntitiesCacheEntries) return;
+
+        for (const [entry] of decodedEntitiesCacheEntries) {
+          touchedRelationParents.add(entry);
+        }
+
+        entityRelationParentsMap.delete(entityId);
+      }
+    }
+
+    // update the queries affected queries
+    for (const [typeName, queryKey] of touchedQueries) {
+      const cacheEntry = decodedEntitiesCache.get(typeName);
+      if (!cacheEntry) continue;
+
+      const query = cacheEntry.queries.get(queryKey);
+      if (!query) continue;
+
+      query.data = [...query.data]; // must be a new reference for React.useSyncExternalStore
+    }
+
+    // invoke all the listeners per type
+    for (const typeName of entityTypes) {
+      const cacheEntry = decodedEntitiesCache.get(typeName);
+      if (!cacheEntry) continue;
+
+      for (const query of cacheEntry.queries.values()) {
+        for (const listener of query.listeners) {
+          listener();
+        }
+      }
+    }
+
+    // trigger all the listeners of the parent relation queries
+    for (const decodedEntitiesCacheEntry of touchedRelationParents) {
+      decodedEntitiesCacheEntry.isInvalidated = true;
+      for (const query of decodedEntitiesCacheEntry.queries.values()) {
+        query.isInvalidated = true;
+        for (const listener of query.listeners) {
+          listener();
+        }
+      }
+    }
+  };
+
+  handle.on('change', onChange);
+
+  return () => {
+    handle.off('change', onChange);
+    decodedEntitiesCache.clear(); // currently we only support exactly one space
+  };
+};
+
+/**
+ * Queries for a list of entities of the given type from the repo.
+ */
+export function findManyNew<const S extends Schema.Schema.AnyNoContext>(
+  handle: DocHandle<DocumentContent>,
+  type: S,
+  filter: EntityFilter<Schema.Schema.Type<S>> | undefined,
+  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
+): { entities: Readonly<Array<EntityNew<S>>>; corruptEntityIds: Readonly<Array<string>> } {
+  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+    Option.getOrElse(() => []),
+  );
+
+  const doc = handle.doc();
+  if (!doc) {
+    return { entities: [], corruptEntityIds: [] };
+  }
+  const entities = doc.entities ?? {};
+  const corruptEntityIds: string[] = [];
+  const filtered: Array<EntityNew<S>> = [];
+
+  const evaluateFilter = <T>(fieldFilter: EntityFieldFilter<T>, fieldValue: T): boolean => {
+    if ('not' in fieldFilter || 'or' in fieldFilter) {
+      throw new Error("Logical operators 'not', 'or' are only allowed at the root (cross-field) level.");
+    }
+
+    // handle basic filters
+    if ('is' in fieldFilter) {
+      if (typeof fieldValue === 'boolean') {
+        return fieldValue === fieldFilter.is;
+      }
+      if (typeof fieldValue === 'number') {
+        return fieldValue === fieldFilter.is;
+      }
+      if (typeof fieldValue === 'string') {
+        return fieldValue === fieldFilter.is;
+      }
+    }
+
+    if (typeof fieldValue === 'number') {
+      if ('greaterThan' in fieldFilter) {
+        const numberFilter = fieldFilter as EntityNumberFilter;
+        if (numberFilter.greaterThan !== undefined && fieldValue <= numberFilter.greaterThan) {
+          return false;
+        }
+      }
+      if ('lessThan' in fieldFilter) {
+        const numberFilter = fieldFilter as EntityNumberFilter;
+        if (numberFilter.lessThan !== undefined && fieldValue >= numberFilter.lessThan) {
+          return false;
+        }
+      }
+    }
+
+    if (typeof fieldValue === 'string') {
+      if ('startsWith' in fieldFilter) {
+        const textFilter = fieldFilter as EntityStringFilter;
+        if (textFilter.startsWith !== undefined && !fieldValue.startsWith(textFilter.startsWith)) {
+          return false;
+        }
+      }
+      if ('endsWith' in fieldFilter) {
+        const textFilter = fieldFilter as EntityStringFilter;
+        if (textFilter.endsWith !== undefined && !fieldValue.endsWith(textFilter.endsWith)) {
+          return false;
+        }
+      }
+      if ('contains' in fieldFilter) {
+        const textFilter = fieldFilter as EntityStringFilter;
+        if (textFilter.contains !== undefined && !fieldValue.includes(textFilter.contains)) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  };
+
+  const evaluateCrossFieldFilter = (
+    crossFieldFilter: CrossFieldFilter<Schema.Schema.Type<S>>,
+    entity: EntityNew<S>,
+  ): boolean => {
+    // evaluate regular field filters with AND semantics
+    for (const fieldName in crossFieldFilter) {
+      if (fieldName === 'or' || fieldName === 'not') continue;
+      const fieldFilter = crossFieldFilter[fieldName];
+      if (!fieldFilter) continue;
+      const fieldValue = entity[fieldName];
+      if (!evaluateFilter(fieldFilter, fieldValue)) {
+        return false;
+      }
+    }
+
+    // evaluate nested OR at cross-field level (if present)
+    if (Array.isArray(crossFieldFilter.or)) {
+      const orSatisfied = crossFieldFilter.or.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
+      if (!orSatisfied) return false;
+    }
+
+    // evaluate nested NOT at cross-field level (if present)
+    if (crossFieldFilter.not && evaluateCrossFieldFilter(crossFieldFilter.not, entity)) {
+      return false;
+    }
+
+    return true;
+  };
+
+  const evaluateEntityFilter = (entityFilter: EntityFilter<Schema.Schema.Type<S>>, entity: EntityNew<S>): boolean => {
+    // handle top-level NOT operator
+    if ('not' in entityFilter && entityFilter.not) {
+      return !evaluateCrossFieldFilter(entityFilter.not, entity);
+    }
+
+    // handle top-level OR operator
+    if ('or' in entityFilter && Array.isArray(entityFilter.or)) {
+      return entityFilter.or.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
+    }
+
+    // evaluate regular field filters
+    return evaluateCrossFieldFilter(entityFilter, entity);
+  };
+
+  for (const id in entities) {
+    const entity = entities[id];
+    if (
+      hasValidTypesProperty(entity) &&
+      typeIds.every((typeId) => {
+        return entity['@@types@@'].includes(typeId);
+      })
+    ) {
+      // const relations = getEntityRelations(id, type, doc, include);
+      try {
+        // const decoded = { ...decodeFromGrc20Json(type, { ...entity, ...relations, id }) };
+        const decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
+
+        if (filter) {
+          if (evaluateEntityFilter(filter, decoded)) {
+            // injecting the schema to the entity to be able to access it in the preparePublish function
+            decoded.__schema = type;
+            filtered.push(decoded);
+          }
+        } else {
+          // injecting the schema to the entity to be able to access it in the preparePublish function
+          decoded.__schema = type;
+          filtered.push(decoded);
+        }
+      } catch (error) {
+        // rethrow in case it's filter error
+        if (
+          error instanceof Error &&
+          error.message.includes("Logical operators 'not', 'or' are only allowed at the root (cross-field) level")
+        ) {
+          throw error;
+        }
+        corruptEntityIds.push(id);
+      }
+    }
+  }
+
+  return { entities: filtered, corruptEntityIds: [] };
+}
+
+const stableEmptyArray: Array<unknown> = [];
+
+export type FindManySubscriptionNew<S extends Schema.Schema.AnyNoContext> = {
+  subscribe: (callback: () => void) => () => void;
+  getEntities: () => Readonly<Array<EntityNew<S>>>;
+};
+
+export function subscribeToFindManyNew<const S extends Schema.Schema.AnyNoContext>(
+  handle: DocHandle<DocumentContent>,
+  type: S,
+  filter: { [K in keyof Schema.Schema.Type<S>]?: EntityFieldFilter<Schema.Schema.Type<S>[K]> } | undefined,
+  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
+): FindManySubscriptionNew<S> {
+  const queryKey = filter ? canonicalize(filter) : 'all';
+  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+    Option.getOrElse(() => []),
+  );
+
+  const getEntities = () => {
+    const cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
+    if (!cacheEntry) return stableEmptyArray;
+
+    const query = cacheEntry.queries.get(queryKey);
+    if (!query) return stableEmptyArray;
+
+    if (!cacheEntry.isInvalidated && !query.isInvalidated) {
+      return query.data;
+    }
+
+    const { entities } = findManyNew(handle, type, filter, include);
+    console.log('getEntities', entities);
+
+    for (const entity of entities) {
+      cacheEntry?.entities.set(entity.id, entity);
+    }
+
+    // must be a new reference to ensure it can be used in React.useMemo
+    query.data = [...entities];
+    cacheEntry.isInvalidated = false;
+    query.isInvalidated = false;
+
+    return query.data;
+  };
+
+  // const allTypes = new Set<S>();
+  // for (const [_key, field] of Object.entries(type.fields)) {
+  //   if (isRelationField(field)) {
+  //     allTypes.add(field as S);
+  //   }
+  // }
+
+  const subscribe = (callback: () => void) => {
+    let cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
+
+    if (!cacheEntry) {
+      const entitiesMap = new Map();
+      const queries = new Map<string, QueryEntry>();
+
+      queries.set(queryKey, {
+        data: [],
+        listeners: [],
+        isInvalidated: true,
+        include: include ?? {},
+      });
+
+      cacheEntry = {
+        type,
+        entities: entitiesMap,
+        queries,
+        isInvalidated: true,
+      };
+
+      decodedEntitiesCache.set(canonicalize(typeIds), cacheEntry);
+    }
+
+    let query = cacheEntry.queries.get(queryKey);
+    if (!query) {
+      query = {
+        data: [],
+        listeners: [],
+        isInvalidated: true,
+        include: include ?? {},
+      };
+      // we just set up the query and expect it to correctly set itself up in findMany
+      cacheEntry.queries.set(queryKey, query);
+    }
+
+    if (query?.listeners) {
+      query.listeners.push(callback);
+    }
+
+    return () => {
+      const cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
+      if (cacheEntry) {
+        // first cleanup the queries
+        const query = cacheEntry.queries.get(queryKey);
+        if (query) {
+          query.listeners = query?.listeners?.filter((cachedListener) => cachedListener !== callback);
+          if (query.listeners.length === 0) {
+            cacheEntry.queries.delete(queryKey);
+          }
+        }
+        // if the last query is removed, cleanup the entityRelationParentsMap and remove the decodedEntitiesCacheEntry
+        if (cacheEntry.queries.size === 0) {
+          entityRelationParentsMap.forEach((relationCacheEntries, key) => {
+            for (const [relationCacheEntry, counter] of relationCacheEntries) {
+              if (relationCacheEntry === cacheEntry && counter === 0) {
+                // relationCacheEntries.delete(cacheEntry);
+              }
+            }
+            if (relationCacheEntries.size === 0) {
+              entityRelationParentsMap.delete(key);
+            }
+          });
+          decodedEntitiesCache.delete(canonicalize(typeIds));
+        }
+      }
+
+      documentChangeListener.subscribedQueriesCount--;
+      if (documentChangeListener.subscribedQueriesCount === 0) {
+        documentChangeListener.unsubscribe?.();
+        documentChangeListener.unsubscribe = undefined;
+      }
+    };
+  };
+
+  if (documentChangeListener.subscribedQueriesCount === 0) {
+    documentChangeListener.unsubscribe = subscribeToDocumentChanges(handle);
+  }
+  documentChangeListener.subscribedQueriesCount++;
+
+  return { subscribe, getEntities };
+}
diff --git a/packages/hypergraph/src/entity/findOne.ts b/packages/hypergraph/src/entity/findOne.ts
index e501667f..b5ffd38d 100644
--- a/packages/hypergraph/src/entity/findOne.ts
+++ b/packages/hypergraph/src/entity/findOne.ts
@@ -1,8 +1,12 @@
 import type { DocHandle } from '@automerge/automerge-repo';
+import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { decodeFromGrc20Json } from './entity-new.js';
 import { getEntityRelations } from './getEntityRelations.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
-import type { AnyNoContext, DocumentContent, Entity } from './types.js';
+import { TypeIdsSymbol } from './internal-new.js';
+import type { AnyNoContext, DocumentContent, Entity, EntityNew } from './types.js';
 
 /**
  * Find the entity of the given type, with the given id, from the repo.
@@ -35,3 +39,31 @@ export const findOne = <const S extends AnyNoContext>(
     return undefined;
   };
 };
+
+export const findOneNew = <const S extends Schema.Schema.AnyNoContext>(
+  handle: DocHandle<DocumentContent>,
+  type: S,
+  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined = undefined,
+) => {
+  return (id: string): EntityNew<S> | undefined => {
+    // TODO: Instead of this insane filtering logic, we should be keeping track of the entities in
+    // an index and store the decoded values instead of re-decoding over and over again.
+    const doc = handle.doc();
+    const entity = doc?.entities?.[id];
+    console.log('raw entity', entity);
+    const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+      Option.getOrElse(() => []),
+    );
+
+    // TODO: implement relations
+
+    if (hasValidTypesProperty(entity) && typeIds.every((typeId) => entity['@@types@@'].includes(typeId))) {
+      const decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
+      // injecting the schema to the entity to be able to access it in the preparePublish function
+      decoded.__schema = type;
+      return decoded;
+    }
+
+    return undefined;
+  };
+};
diff --git a/packages/hypergraph/src/entity/index.ts b/packages/hypergraph/src/entity/index.ts
index e8c1d24e..3ce71cd7 100644
--- a/packages/hypergraph/src/entity/index.ts
+++ b/packages/hypergraph/src/entity/index.ts
@@ -2,6 +2,7 @@ export * from './create.js';
 export * from './delete.js';
 export * from './entity.js';
 export * from './findMany.js';
+export * from './findManyNew.js';
 export * from './findOne.js';
 export * from './removeRelation.js';
 export * from './types.js';
diff --git a/packages/hypergraph/src/entity/internal-new.ts b/packages/hypergraph/src/entity/internal-new.ts
new file mode 100644
index 00000000..cffffc4c
--- /dev/null
+++ b/packages/hypergraph/src/entity/internal-new.ts
@@ -0,0 +1,3 @@
+export const PropertyIdSymbol = Symbol.for('grc-20/property/id');
+
+export const TypeIdsSymbol = Symbol.for('grc-20/type/ids');
diff --git a/packages/hypergraph/src/entity/type-new.ts b/packages/hypergraph/src/entity/type-new.ts
new file mode 100644
index 00000000..eae2e856
--- /dev/null
+++ b/packages/hypergraph/src/entity/type-new.ts
@@ -0,0 +1,34 @@
+import * as Schema from 'effect/Schema';
+import { PropertyIdSymbol } from './internal-new.js';
+
+/**
+ * Creates a String schema with the specified GRC-20 property ID
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
+export const String = (propertyId: string) => {
+  return Schema.String.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
+
+/**
+ * Creates a Number schema with the specified GRC-20 property ID
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
+export const Number = (propertyId: string) => {
+  return Schema.Number.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
+
+/**
+ * Creates a Boolean schema with the specified GRC-20 property ID
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
+export const Boolean = (propertyId: string) => {
+  return Schema.Boolean.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
+
+/**
+ * Creates a Date schema with the specified GRC-20 property ID
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
+export const Date = (propertyId: string) => {
+  return Schema.Date.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
diff --git a/packages/hypergraph/src/entity/types.ts b/packages/hypergraph/src/entity/types.ts
index df9449a4..b0c1c9cb 100644
--- a/packages/hypergraph/src/entity/types.ts
+++ b/packages/hypergraph/src/entity/types.ts
@@ -24,6 +24,10 @@ export type Entity<S extends AnyNoContext> = Schema.Schema.Type<S> & {
   // __version: string;
 };
 
+export type EntityNew<S extends Schema.Schema.AnyNoContext> = Schema.Schema.Type<S> & {
+  id: string;
+};
+
 export type EntityWithRelation<S extends AnyNoContext> = Entity<S> & {
   _relation: { id: string } | undefined;
 };
diff --git a/packages/hypergraph/src/index.ts b/packages/hypergraph/src/index.ts
index f8cff785..455d168d 100644
--- a/packages/hypergraph/src/index.ts
+++ b/packages/hypergraph/src/index.ts
@@ -1,7 +1,9 @@
 export { Id } from '@graphprotocol/grc-20';
 export * as Typesync from './cli/services/Model.js';
 export * as Connect from './connect/index.js';
+export { Entity as EntityNew } from './entity/entity-new.js';
 export * as Entity from './entity/index.js';
+export * as TypeNew from './entity/type-new.js';
 export * as Identity from './identity/index.js';
 export * as Inboxes from './inboxes/index.js';
 export * as Key from './key/index.js';
@@ -10,9 +12,9 @@ export * as Messages from './messages/index.js';
 export * as PrivyAuth from './privy-auth/privy-auth.js';
 export * as SpaceEvents from './space-events/index.js';
 export * as SpaceInfo from './space-info/index.js';
-export * from './store.js';
 export * as StoreConnect from './store-connect.js';
-export * as Type from './type/type.js';
+export * from './store.js';
 export * as TypeUtils from './type-utils/type-utils.js';
+export * as Type from './type/type.js';
 export * from './types.js';
 export * as Utils from './utils/index.js';

From ab111b10b7a5795cd2a2a81bc89bdeccc745d63b Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 23 Sep 2025 18:56:00 +0200
Subject: [PATCH 02/22] wip

---
 apps/events/src/components/todos.tsx           |  2 +-
 apps/events/src/schema.ts                      |  3 ++-
 packages/hypergraph/src/entity/create.ts       | 18 +++++++++++++++++-
 packages/hypergraph/src/entity/findManyNew.ts  |  1 +
 packages/hypergraph/src/entity/internal-new.ts |  2 ++
 packages/hypergraph/src/entity/type-new.ts     | 10 +++++++++-
 6 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/apps/events/src/components/todos.tsx b/apps/events/src/components/todos.tsx
index 7f0290e8..271444ad 100644
--- a/apps/events/src/components/todos.tsx
+++ b/apps/events/src/components/todos.tsx
@@ -56,7 +56,7 @@ export const Todos = () => {
             createEntity({
               name: newTodoName,
               completed: false,
-              // assignees: assignees.map(({ value }) => value),
+              assignees: assignees.map(({ value }) => value),
             });
             setNewTodoName('');
           }}
diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index dbff2859..cb03aa11 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -58,13 +58,14 @@ export const TodoNew = EntityNew(
   {
     name: TypeNew.String,
     completed: TypeNew.Boolean,
-    // assignees: TypeNew.Relation(UserNew),
+    assignees: TypeNew.Relation(UserNew),
   },
   {
     types: [Id('44fe82a9-e4c2-4330-a395-ce85ed78e421')],
     properties: {
       name: Id('c668aa67-bbca-4b2c-908c-9c5599035eab'),
       completed: Id('71e7654f-2623-4794-88fb-841c8f3dd9b4'),
+      assignees: Id('5b80d3ee-2463-4246-b628-44ba808ab3e1'),
     },
   },
 );
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index a3431733..8c795c04 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -6,6 +6,22 @@ import { encodeToGrc20Json } from './entity-new.js';
 import { findOne, findOneNew } from './findOne.js';
 import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, Insert } from './types.js';
 
+/**
+ * Type utility to transform relation fields to accept string arrays instead of their typed values
+ * This specifically targets TypeNew.Relation fields which are arrays of objects
+ */
+type WithRelationsAsStringArrays<T> = {
+  [K in keyof T]: T[K] extends readonly (infer U)[]
+    ? U extends object
+      ? string[]
+      : T[K]
+    : T[K] extends (infer U)[]
+      ? U extends object
+        ? string[]
+        : T[K]
+      : T[K];
+};
+
 /**
  * Creates an entity model of given type and stores it in the repo.
  */
@@ -60,7 +76,7 @@ export const create = <const S extends AnyNoContext>(handle: DocHandle<DocumentC
 
 export const createNew = <const S extends Schema.Schema.AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
   // TODO: return type
-  return (data: Readonly<Schema.Schema.Type<S>>) => {
+  return (data: Readonly<WithRelationsAsStringArrays<Schema.Schema.Type<S>>>) => {
     const entityId = generateId();
     const encoded = encodeToGrc20Json(type, { ...data, id: entityId });
 
diff --git a/packages/hypergraph/src/entity/findManyNew.ts b/packages/hypergraph/src/entity/findManyNew.ts
index 752b24dc..c3f6c456 100644
--- a/packages/hypergraph/src/entity/findManyNew.ts
+++ b/packages/hypergraph/src/entity/findManyNew.ts
@@ -247,6 +247,7 @@ export function findManyNew<const S extends Schema.Schema.AnyNoContext>(
   );
 
   const doc = handle.doc();
+  console.log('doc', doc);
   if (!doc) {
     return { entities: [], corruptEntityIds: [] };
   }
diff --git a/packages/hypergraph/src/entity/internal-new.ts b/packages/hypergraph/src/entity/internal-new.ts
index cffffc4c..43627e44 100644
--- a/packages/hypergraph/src/entity/internal-new.ts
+++ b/packages/hypergraph/src/entity/internal-new.ts
@@ -1,3 +1,5 @@
 export const PropertyIdSymbol = Symbol.for('grc-20/property/id');
 
 export const TypeIdsSymbol = Symbol.for('grc-20/type/ids');
+
+export const RelationSchemaSymbol = Symbol.for('grc-20/relation/schema');
diff --git a/packages/hypergraph/src/entity/type-new.ts b/packages/hypergraph/src/entity/type-new.ts
index eae2e856..6b53372c 100644
--- a/packages/hypergraph/src/entity/type-new.ts
+++ b/packages/hypergraph/src/entity/type-new.ts
@@ -1,5 +1,5 @@
 import * as Schema from 'effect/Schema';
-import { PropertyIdSymbol } from './internal-new.js';
+import { PropertyIdSymbol, RelationSchemaSymbol } from './internal-new.js';
 
 /**
  * Creates a String schema with the specified GRC-20 property ID
@@ -32,3 +32,11 @@ export const Boolean = (propertyId: string) => {
 export const Date = (propertyId: string) => {
   return Schema.Date.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
 };
+
+export const Relation =
+  <S extends Schema.Schema.AnyNoContext>(schema: S) =>
+  (propertyId: string) => {
+    return Schema.Array(schema).pipe(
+      Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema }),
+    );
+  };

From f8b1d3fef0af2f2ab592a506657847535a7fcfc7 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Thu, 25 Sep 2025 10:52:21 +0200
Subject: [PATCH 03/22] re-enable relations

---
 apps/events/src/components/todos.tsx          |  6 +-
 apps/events/src/schema.ts                     |  4 +-
 .../hypergraph-react/src/internal/types.ts    |  9 ++
 packages/hypergraph/src/entity/create.ts      | 36 +++++++-
 packages/hypergraph/src/entity/findManyNew.ts | 84 ++++++++++---------
 packages/hypergraph/src/entity/findOne.ts     |  7 +-
 .../src/entity/getEntityRelationsNew.ts       | 50 +++++++++++
 .../hypergraph/src/entity/internal-new.ts     |  2 +
 packages/hypergraph/src/entity/type-new.ts    |  4 +-
 packages/hypergraph/src/entity/types.ts       |  3 +-
 packages/hypergraph/src/utils/isRelation.ts   |  7 ++
 11 files changed, 155 insertions(+), 57 deletions(-)
 create mode 100644 packages/hypergraph/src/entity/getEntityRelationsNew.ts
 create mode 100644 packages/hypergraph/src/utils/isRelation.ts

diff --git a/apps/events/src/components/todos.tsx b/apps/events/src/components/todos.tsx
index 271444ad..d3c35f7a 100644
--- a/apps/events/src/components/todos.tsx
+++ b/apps/events/src/components/todos.tsx
@@ -15,7 +15,7 @@ import { Input } from './ui/input';
 export const Todos = () => {
   const { data: todos } = useQueryNew(TodoNew, {
     mode: 'private',
-    // include: { assignees: {} },
+    include: { assignees: {} },
     // filter: { or: [{ name: { startsWith: 'aa' } }, { name: { is: 'sdasd' } }] },
   });
   const { data: users } = useQueryNew(UserNew, { mode: 'private' });
@@ -67,7 +67,7 @@ export const Todos = () => {
       {todos.map((todo) => (
         <div key={todo.id} className="flex flex-row items-center gap-2">
           <h2>{todo.name}</h2>
-          {/* {todo.assignees.length > 0 && (
+          {todo.assignees.length > 0 && (
             <span className="text-xs text-gray-500">
               Assigned to:{' '}
               {todo.assignees.map((assignee) => (
@@ -87,7 +87,7 @@ export const Todos = () => {
                 </span>
               ))}
             </span>
-          )} */}
+          )}
           <input
             type="checkbox"
             checked={todo.completed}
diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index cb03aa11..eab10bdd 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -43,9 +43,7 @@ export class Todo3 extends Entity.Class<Todo3>('Todo3')({
 }) {}
 
 export const UserNew = EntityNew(
-  {
-    name: TypeNew.String,
-  },
+  { name: TypeNew.String },
   {
     types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
     properties: {
diff --git a/packages/hypergraph-react/src/internal/types.ts b/packages/hypergraph-react/src/internal/types.ts
index 2090adc0..5ca34d5f 100644
--- a/packages/hypergraph-react/src/internal/types.ts
+++ b/packages/hypergraph-react/src/internal/types.ts
@@ -9,3 +9,12 @@ export type QueryPublicParams<S extends Entity.AnyNoContext> = {
   include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
   first?: number | undefined;
 };
+
+export type QueryPublicParamsNew<S extends Schema.Schema.AnyNoContext> = {
+  enabled: boolean;
+  filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
+  // TODO: for multi-level nesting it should only allow the allowed properties instead of Record<string, Record<string, never>>
+  include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
+  space?: string | undefined;
+  first?: number | undefined;
+};
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index 8c795c04..1dd5d65c 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -1,10 +1,14 @@
 import type { DocHandle } from '@automerge/automerge-repo';
+import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import { generateId } from '../utils/generateId.js';
+import { isRelation } from '../utils/isRelation.js';
 import { isRelationField } from '../utils/isRelationField.js';
 import { encodeToGrc20Json } from './entity-new.js';
 import { findOne, findOneNew } from './findOne.js';
-import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, Insert } from './types.js';
+import { PropertyIdSymbol } from './internal-new.js';
+import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, EntityNew, Insert } from './types.js';
 
 /**
  * Type utility to transform relation fields to accept string arrays instead of their typed values
@@ -75,19 +79,43 @@ export const create = <const S extends AnyNoContext>(handle: DocHandle<DocumentC
 };
 
 export const createNew = <const S extends Schema.Schema.AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
-  // TODO: return type
-  return (data: Readonly<WithRelationsAsStringArrays<Schema.Schema.Type<S>>>) => {
+  return (data: Readonly<WithRelationsAsStringArrays<Schema.Schema.Type<S>>>): EntityNew<S> => {
     const entityId = generateId();
     const encoded = encodeToGrc20Json(type, { ...data, id: entityId });
 
+    const relations: Record<string, DocumentRelation> = {};
+
+    const ast = type.ast as SchemaAST.TypeLiteral;
+
+    for (const prop of ast.propertySignatures) {
+      const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+      if (Option.isSome(result) && isRelation(prop.type)) {
+        const relationId = generateId();
+        for (const toEntityId of encoded[result.value] as string[]) {
+          relations[relationId] = {
+            from: entityId,
+            to: toEntityId as string,
+            fromPropertyId: result.value,
+            __deleted: false,
+          };
+        }
+        delete encoded[result.value];
+      }
+    }
+
     handle.change((doc) => {
       doc.entities ??= {};
       doc.entities[entityId] = {
         ...encoded,
         __deleted: false,
       };
+      doc.relations ??= {};
+      // merge relations with existing relations
+      for (const [relationId, relation] of Object.entries(relations)) {
+        doc.relations[relationId] = relation;
+      }
     });
 
-    return findOneNew(handle, type)(entityId);
+    return findOneNew(handle, type)(entityId) as EntityNew<S>;
   };
 };
diff --git a/packages/hypergraph/src/entity/findManyNew.ts b/packages/hypergraph/src/entity/findManyNew.ts
index c3f6c456..4db77faf 100644
--- a/packages/hypergraph/src/entity/findManyNew.ts
+++ b/packages/hypergraph/src/entity/findManyNew.ts
@@ -7,6 +7,7 @@ import { canonicalize } from '../utils/jsc.js';
 import { decodedEntitiesCache, type DecodedEntitiesCacheEntry, type QueryEntry } from './decodedEntitiesCacheNew.js';
 import { decodeFromGrc20Json } from './entity-new.js';
 import { entityRelationParentsMap } from './entityRelationParentsMap.js';
+import { getEntityRelationsNew } from './getEntityRelationsNew.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
 import { TypeIdsSymbol } from './internal-new.js';
 import type {
@@ -82,15 +83,17 @@ const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
         }
 
         const oldDecodedEntry = cacheEntry.entities.get(entityId);
-        // const relations = getEntityRelations(entityId, cacheEntry.type, doc, includeFromAllQueries);
+        const relations = getEntityRelationsNew(entityId, cacheEntry.type, doc, includeFromAllQueries);
         let decoded: unknown | undefined;
         try {
-          // decoded = cacheEntry.decoder({
           decoded = decodeFromGrc20Json(cacheEntry.type, {
             ...entity,
-            // ...relations,
             id: entityId,
           });
+          decoded = {
+            ...decoded,
+            ...relations,
+          };
           cacheEntry.entities.set(entityId, decoded);
         } catch (error) {
           // TODO: store the corrupt entity ids somewhere, so they can be read via the API
@@ -99,43 +102,43 @@ const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
 
         if (oldDecodedEntry) {
           // collect all the Ids for relation entries in the `oldDecodedEntry`
-          // const deletedRelationIds = new Set<string>();
-          // for (const [, value] of Object.entries(oldDecodedEntry)) {
-          //   if (Array.isArray(value)) {
-          //     for (const relationEntity of value) {
-          //       deletedRelationIds.add(relationEntity.id);
-          //     }
-          //   }
-          // }
+          const deletedRelationIds = new Set<string>();
+          for (const [, value] of Object.entries(oldDecodedEntry)) {
+            if (Array.isArray(value)) {
+              for (const relationEntity of value) {
+                deletedRelationIds.add(relationEntity.id);
+              }
+            }
+          }
           // it's fine to remove all of them since they are re-added below
-          // for (const deletedRelationId of deletedRelationIds) {
-          //   const deletedRelationEntry = entityRelationParentsMap.get(deletedRelationId);
-          //   if (deletedRelationEntry) {
-          //     deletedRelationEntry.set(cacheEntry, (deletedRelationEntry.get(cacheEntry) ?? 0) - 1);
-          //     if (deletedRelationEntry.get(cacheEntry) === 0) {
-          //       deletedRelationEntry.delete(cacheEntry);
-          //     }
-          //     if (deletedRelationEntry.size === 0) {
-          //       entityRelationParentsMap.delete(deletedRelationId);
-          //     }
-          //   }
-          // }
+          for (const deletedRelationId of deletedRelationIds) {
+            const deletedRelationEntry = entityRelationParentsMap.get(deletedRelationId);
+            if (deletedRelationEntry) {
+              deletedRelationEntry.set(cacheEntry, (deletedRelationEntry.get(cacheEntry) ?? 0) - 1);
+              if (deletedRelationEntry.get(cacheEntry) === 0) {
+                deletedRelationEntry.delete(cacheEntry);
+              }
+              if (deletedRelationEntry.size === 0) {
+                entityRelationParentsMap.delete(deletedRelationId);
+              }
+            }
+          }
         }
 
         if (decoded) {
           for (const [, value] of Object.entries(decoded)) {
-            // if (Array.isArray(value)) {
-            //   for (const relationEntity of value) {
-            //     let relationParentEntry = entityRelationParentsMap.get(relationEntity.id);
-            //     if (relationParentEntry) {
-            //       relationParentEntry.set(cacheEntry, (relationParentEntry.get(cacheEntry) ?? 0) + 1);
-            //     } else {
-            //       relationParentEntry = new Map();
-            //       entityRelationParentsMap.set(relationEntity.id, relationParentEntry);
-            //       relationParentEntry.set(cacheEntry, 1);
-            //     }
-            //   }
-            // }
+            if (Array.isArray(value)) {
+              for (const relationEntity of value) {
+                let relationParentEntry = entityRelationParentsMap.get(relationEntity.id);
+                if (relationParentEntry) {
+                  relationParentEntry.set(cacheEntry, (relationParentEntry.get(cacheEntry) ?? 0) + 1);
+                } else {
+                  relationParentEntry = new Map();
+                  entityRelationParentsMap.set(relationEntity.id, relationParentEntry);
+                  relationParentEntry.set(cacheEntry, 1);
+                }
+              }
+            }
           }
         }
 
@@ -247,7 +250,6 @@ export function findManyNew<const S extends Schema.Schema.AnyNoContext>(
   );
 
   const doc = handle.doc();
-  console.log('doc', doc);
   if (!doc) {
     return { entities: [], corruptEntityIds: [] };
   }
@@ -364,10 +366,13 @@ export function findManyNew<const S extends Schema.Schema.AnyNoContext>(
         return entity['@@types@@'].includes(typeId);
       })
     ) {
-      // const relations = getEntityRelations(id, type, doc, include);
+      const relations = getEntityRelationsNew(id, type, doc, include);
       try {
-        // const decoded = { ...decodeFromGrc20Json(type, { ...entity, ...relations, id }) };
-        const decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
+        let decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
+        decoded = {
+          ...decoded,
+          ...relations,
+        };
 
         if (filter) {
           if (evaluateEntityFilter(filter, decoded)) {
@@ -426,7 +431,6 @@ export function subscribeToFindManyNew<const S extends Schema.Schema.AnyNoContex
     }
 
     const { entities } = findManyNew(handle, type, filter, include);
-    console.log('getEntities', entities);
 
     for (const entity of entities) {
       cacheEntry?.entities.set(entity.id, entity);
diff --git a/packages/hypergraph/src/entity/findOne.ts b/packages/hypergraph/src/entity/findOne.ts
index b5ffd38d..c4623397 100644
--- a/packages/hypergraph/src/entity/findOne.ts
+++ b/packages/hypergraph/src/entity/findOne.ts
@@ -4,6 +4,7 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { decodeFromGrc20Json } from './entity-new.js';
 import { getEntityRelations } from './getEntityRelations.js';
+import { getEntityRelationsNew } from './getEntityRelationsNew.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
 import { TypeIdsSymbol } from './internal-new.js';
 import type { AnyNoContext, DocumentContent, Entity, EntityNew } from './types.js';
@@ -50,18 +51,18 @@ export const findOneNew = <const S extends Schema.Schema.AnyNoContext>(
     // an index and store the decoded values instead of re-decoding over and over again.
     const doc = handle.doc();
     const entity = doc?.entities?.[id];
-    console.log('raw entity', entity);
+
     const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
       Option.getOrElse(() => []),
     );
 
-    // TODO: implement relations
+    const relations = doc ? getEntityRelationsNew(id, type, doc, include) : {};
 
     if (hasValidTypesProperty(entity) && typeIds.every((typeId) => entity['@@types@@'].includes(typeId))) {
       const decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
       // injecting the schema to the entity to be able to access it in the preparePublish function
       decoded.__schema = type;
-      return decoded;
+      return { ...decoded, ...relations };
     }
 
     return undefined;
diff --git a/packages/hypergraph/src/entity/getEntityRelationsNew.ts b/packages/hypergraph/src/entity/getEntityRelationsNew.ts
new file mode 100644
index 00000000..86c5e97b
--- /dev/null
+++ b/packages/hypergraph/src/entity/getEntityRelationsNew.ts
@@ -0,0 +1,50 @@
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { isRelation } from '../utils/isRelation.js';
+import { decodeFromGrc20Json } from './entity-new.js';
+import { PropertyIdSymbol, RelationSchemaSymbol } from './internal-new.js';
+import type { DocumentContent, EntityNew } from './types.js';
+export const getEntityRelationsNew = <const S extends Schema.Schema.AnyNoContext>(
+  entityId: string,
+  type: S,
+  doc: DocumentContent,
+  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
+) => {
+  const relations: Record<string, EntityNew<Schema.Schema.AnyNoContext>> = {};
+  const ast = type.ast as SchemaAST.TypeLiteral;
+
+  for (const prop of ast.propertySignatures) {
+    if (!isRelation(prop.type)) continue;
+
+    // TODO: should we add an empty array for relations that are not included?
+    // Currently we still add an empty array for relations that are not included.
+    // This is to ensure that the relation is not undefined in the decoded entity.
+    // In the future we might want to derive a schema based on the include object.
+    // if (!include?.[fieldName]) {
+    //   relations[fieldName] = [];
+    //   continue;
+    // }
+
+    const relationEntities: Array<EntityNew<Schema.Schema.AnyNoContext>> = [];
+
+    for (const [relationId, relation] of Object.entries(doc.relations ?? {})) {
+      const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+      const schema = SchemaAST.getAnnotation<Schema.Schema.AnyNoContext>(RelationSchemaSymbol)(prop.type);
+      if (Option.isSome(result) && Option.isSome(schema)) {
+        if (relation.fromPropertyId !== result.value || relation.from !== entityId) continue;
+        if (relation.__deleted) continue;
+
+        const relationEntity = doc.entities?.[relation.to];
+        const decodedRelationEntity = { ...decodeFromGrc20Json(schema.value, { ...relationEntity, id: relation.to }) };
+        // TODO: should we check if the relation entity is valid?
+        // if (!hasValidTypesProperty(relationEntity)) continue;
+
+        relationEntities.push({ ...decodedRelationEntity, id: relation.to, _relation: { id: relationId } });
+      }
+    }
+    relations[prop.name] = relationEntities;
+  }
+
+  return relations;
+};
diff --git a/packages/hypergraph/src/entity/internal-new.ts b/packages/hypergraph/src/entity/internal-new.ts
index 43627e44..f9a86df8 100644
--- a/packages/hypergraph/src/entity/internal-new.ts
+++ b/packages/hypergraph/src/entity/internal-new.ts
@@ -2,4 +2,6 @@ export const PropertyIdSymbol = Symbol.for('grc-20/property/id');
 
 export const TypeIdsSymbol = Symbol.for('grc-20/type/ids');
 
+export const RelationSymbol = Symbol.for('grc-20/relation');
+
 export const RelationSchemaSymbol = Symbol.for('grc-20/relation/schema');
diff --git a/packages/hypergraph/src/entity/type-new.ts b/packages/hypergraph/src/entity/type-new.ts
index 6b53372c..2e02a97e 100644
--- a/packages/hypergraph/src/entity/type-new.ts
+++ b/packages/hypergraph/src/entity/type-new.ts
@@ -1,5 +1,5 @@
 import * as Schema from 'effect/Schema';
-import { PropertyIdSymbol, RelationSchemaSymbol } from './internal-new.js';
+import { PropertyIdSymbol, RelationSchemaSymbol, RelationSymbol } from './internal-new.js';
 
 /**
  * Creates a String schema with the specified GRC-20 property ID
@@ -37,6 +37,6 @@ export const Relation =
   <S extends Schema.Schema.AnyNoContext>(schema: S) =>
   (propertyId: string) => {
     return Schema.Array(schema).pipe(
-      Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema }),
+      Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema, [RelationSymbol]: true }),
     );
   };
diff --git a/packages/hypergraph/src/entity/types.ts b/packages/hypergraph/src/entity/types.ts
index b0c1c9cb..d4369e08 100644
--- a/packages/hypergraph/src/entity/types.ts
+++ b/packages/hypergraph/src/entity/types.ts
@@ -40,8 +40,7 @@ export type DocumentEntity = {
 export type DocumentRelation = {
   from: string;
   to: string;
-  fromTypeName: string;
-  fromPropertyName: string;
+  fromPropertyId: string;
   __deleted: boolean;
   [key: string]: unknown;
 };
diff --git a/packages/hypergraph/src/utils/isRelation.ts b/packages/hypergraph/src/utils/isRelation.ts
new file mode 100644
index 00000000..48eccb25
--- /dev/null
+++ b/packages/hypergraph/src/utils/isRelation.ts
@@ -0,0 +1,7 @@
+import * as Option from 'effect/Option';
+import * as SchemaAST from 'effect/SchemaAST';
+import { RelationSymbol } from '../entity/internal-new.js';
+
+export const isRelation = (ast: SchemaAST.AST) => {
+  return SchemaAST.getAnnotation<boolean>(RelationSymbol)(ast).pipe(Option.getOrElse(() => false));
+};

From 05c9074a18fe10541da9740ae77d1fbea61fe5b4 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Thu, 25 Sep 2025 11:33:47 +0200
Subject: [PATCH 04/22] move symbols

---
 .../hypergraph/src/{entity/internal-new.ts => constants.ts}     | 0
 packages/hypergraph/src/entity/create.ts                        | 2 +-
 packages/hypergraph/src/entity/entity-new.ts                    | 2 +-
 packages/hypergraph/src/entity/findManyNew.ts                   | 2 +-
 packages/hypergraph/src/entity/findOne.ts                       | 2 +-
 packages/hypergraph/src/entity/getEntityRelationsNew.ts         | 2 +-
 packages/hypergraph/src/entity/type-new.ts                      | 2 +-
 packages/hypergraph/src/utils/isRelation.ts                     | 2 +-
 8 files changed, 7 insertions(+), 7 deletions(-)
 rename packages/hypergraph/src/{entity/internal-new.ts => constants.ts} (100%)

diff --git a/packages/hypergraph/src/entity/internal-new.ts b/packages/hypergraph/src/constants.ts
similarity index 100%
rename from packages/hypergraph/src/entity/internal-new.ts
rename to packages/hypergraph/src/constants.ts
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index 1dd5d65c..a539ea3b 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -2,12 +2,12 @@ import type { DocHandle } from '@automerge/automerge-repo';
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
+import { PropertyIdSymbol } from '../constants.js';
 import { generateId } from '../utils/generateId.js';
 import { isRelation } from '../utils/isRelation.js';
 import { isRelationField } from '../utils/isRelationField.js';
 import { encodeToGrc20Json } from './entity-new.js';
 import { findOne, findOneNew } from './findOne.js';
-import { PropertyIdSymbol } from './internal-new.js';
 import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, EntityNew, Insert } from './types.js';
 
 /**
diff --git a/packages/hypergraph/src/entity/entity-new.ts b/packages/hypergraph/src/entity/entity-new.ts
index 752e2976..812677b3 100644
--- a/packages/hypergraph/src/entity/entity-new.ts
+++ b/packages/hypergraph/src/entity/entity-new.ts
@@ -1,7 +1,7 @@
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
-import { PropertyIdSymbol, TypeIdsSymbol } from './internal-new.js';
+import { PropertyIdSymbol, TypeIdsSymbol } from '../constants.js';
 
 /**
  * Entity function for creating schemas with a nicer API.
diff --git a/packages/hypergraph/src/entity/findManyNew.ts b/packages/hypergraph/src/entity/findManyNew.ts
index 4db77faf..372c5666 100644
--- a/packages/hypergraph/src/entity/findManyNew.ts
+++ b/packages/hypergraph/src/entity/findManyNew.ts
@@ -2,6 +2,7 @@ import type { DocHandle, Patch } from '@automerge/automerge-repo';
 import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
+import { TypeIdsSymbol } from '../constants.js';
 import { deepMerge } from '../utils/internal/deep-merge.js';
 import { canonicalize } from '../utils/jsc.js';
 import { decodedEntitiesCache, type DecodedEntitiesCacheEntry, type QueryEntry } from './decodedEntitiesCacheNew.js';
@@ -9,7 +10,6 @@ import { decodeFromGrc20Json } from './entity-new.js';
 import { entityRelationParentsMap } from './entityRelationParentsMap.js';
 import { getEntityRelationsNew } from './getEntityRelationsNew.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
-import { TypeIdsSymbol } from './internal-new.js';
 import type {
   CrossFieldFilter,
   DocumentContent,
diff --git a/packages/hypergraph/src/entity/findOne.ts b/packages/hypergraph/src/entity/findOne.ts
index c4623397..20f9bcdd 100644
--- a/packages/hypergraph/src/entity/findOne.ts
+++ b/packages/hypergraph/src/entity/findOne.ts
@@ -2,11 +2,11 @@ import type { DocHandle } from '@automerge/automerge-repo';
 import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
+import { TypeIdsSymbol } from '../constants.js';
 import { decodeFromGrc20Json } from './entity-new.js';
 import { getEntityRelations } from './getEntityRelations.js';
 import { getEntityRelationsNew } from './getEntityRelationsNew.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
-import { TypeIdsSymbol } from './internal-new.js';
 import type { AnyNoContext, DocumentContent, Entity, EntityNew } from './types.js';
 
 /**
diff --git a/packages/hypergraph/src/entity/getEntityRelationsNew.ts b/packages/hypergraph/src/entity/getEntityRelationsNew.ts
index 86c5e97b..98f0c66a 100644
--- a/packages/hypergraph/src/entity/getEntityRelationsNew.ts
+++ b/packages/hypergraph/src/entity/getEntityRelationsNew.ts
@@ -1,9 +1,9 @@
 import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
+import { PropertyIdSymbol, RelationSchemaSymbol } from '../constants.js';
 import { isRelation } from '../utils/isRelation.js';
 import { decodeFromGrc20Json } from './entity-new.js';
-import { PropertyIdSymbol, RelationSchemaSymbol } from './internal-new.js';
 import type { DocumentContent, EntityNew } from './types.js';
 export const getEntityRelationsNew = <const S extends Schema.Schema.AnyNoContext>(
   entityId: string,
diff --git a/packages/hypergraph/src/entity/type-new.ts b/packages/hypergraph/src/entity/type-new.ts
index 2e02a97e..cf3786e1 100644
--- a/packages/hypergraph/src/entity/type-new.ts
+++ b/packages/hypergraph/src/entity/type-new.ts
@@ -1,5 +1,5 @@
 import * as Schema from 'effect/Schema';
-import { PropertyIdSymbol, RelationSchemaSymbol, RelationSymbol } from './internal-new.js';
+import { PropertyIdSymbol, RelationSchemaSymbol, RelationSymbol } from '../constants.js';
 
 /**
  * Creates a String schema with the specified GRC-20 property ID
diff --git a/packages/hypergraph/src/utils/isRelation.ts b/packages/hypergraph/src/utils/isRelation.ts
index 48eccb25..90889ba1 100644
--- a/packages/hypergraph/src/utils/isRelation.ts
+++ b/packages/hypergraph/src/utils/isRelation.ts
@@ -1,6 +1,6 @@
 import * as Option from 'effect/Option';
 import * as SchemaAST from 'effect/SchemaAST';
-import { RelationSymbol } from '../entity/internal-new.js';
+import { RelationSymbol } from '../constants.js';
 
 export const isRelation = (ast: SchemaAST.AST) => {
   return SchemaAST.getAnnotation<boolean>(RelationSymbol)(ast).pipe(Option.getOrElse(() => false));

From 0c10528cbeb53dfa3b1396b716046b6bcacfb853 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Thu, 25 Sep 2025 12:14:27 +0200
Subject: [PATCH 05/22] implement Type.optional

---
 apps/events/src/components/todos.tsx         | 2 --
 packages/hypergraph/src/entity/entity-new.ts | 8 ++++++--
 packages/hypergraph/src/entity/type-new.ts   | 7 +++++++
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/apps/events/src/components/todos.tsx b/apps/events/src/components/todos.tsx
index d3c35f7a..0d500903 100644
--- a/apps/events/src/components/todos.tsx
+++ b/apps/events/src/components/todos.tsx
@@ -27,8 +27,6 @@ export const Todos = () => {
   const [newTodoName, setNewTodoName] = useState('');
   const [assignees, setAssignees] = useState<{ value: string; label: string }[]>([]);
 
-  console.log(todos);
-
   useEffect(() => {
     setAssignees((prevFilteredAssignees) => {
       // filter out assignees that are not in the users array whenever users change
diff --git a/packages/hypergraph/src/entity/entity-new.ts b/packages/hypergraph/src/entity/entity-new.ts
index 812677b3..c4a2e03e 100644
--- a/packages/hypergraph/src/entity/entity-new.ts
+++ b/packages/hypergraph/src/entity/entity-new.ts
@@ -19,7 +19,10 @@ import { PropertyIdSymbol, TypeIdsSymbol } from '../constants.js';
  * ```
  */
 export function Entity<
-  T extends Record<string, (propertyId: string) => Schema.Schema<any>>,
+  T extends Record<
+    string,
+    (propertyId: string) => Schema.Schema<any> | Schema.PropertySignature<any, any, any, any, any, any, any>
+  >,
   P extends Record<keyof T, string>,
 >(
   schemaTypes: T,
@@ -30,7 +33,8 @@ export function Entity<
 ): Schema.Struct<{
   [K in keyof T]: ReturnType<T[K]> & { id: string };
 }> {
-  const properties: Record<string, Schema.Schema<any>> = {};
+  const properties: Record<string, Schema.Schema<any> | Schema.PropertySignature<any, any, any, any, any, any, any>> =
+    {};
 
   for (const [key, schemaType] of Object.entries(schemaTypes)) {
     const propertyId = mapping.properties[key as keyof P];
diff --git a/packages/hypergraph/src/entity/type-new.ts b/packages/hypergraph/src/entity/type-new.ts
index cf3786e1..13bf529f 100644
--- a/packages/hypergraph/src/entity/type-new.ts
+++ b/packages/hypergraph/src/entity/type-new.ts
@@ -40,3 +40,10 @@ export const Relation =
       Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema, [RelationSymbol]: true }),
     );
   };
+
+export const optional =
+  <S extends Schema.Schema.AnyNoContext>(schemaFn: (propertyId: string) => S) =>
+  (propertyId: string) => {
+    const innerSchema = schemaFn(propertyId);
+    return Schema.optional(innerSchema);
+  };

From bdacabcc3c14e3547d58d0cef91a0703a56d5af6 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Thu, 25 Sep 2025 15:15:49 +0200
Subject: [PATCH 06/22] move from new function/files to core

---
 apps/events/src/components/todos.tsx          |  12 +-
 apps/events/src/components/users.tsx          |   8 +-
 apps/events/src/schema.ts                     | 116 ++--
 apps/privy-login-example/src/mapping.ts       |   8 -
 apps/privy-login-example/src/schema.ts        | 126 +++--
 .../src/hooks/use-create-entity.ts            |  15 +-
 .../hypergraph-react/src/hooks/use-entity.tsx |   4 +-
 .../hypergraph-react/src/hooks/use-query.tsx  |  40 +-
 .../src/hooks/use-update-entity.ts            |   3 +-
 .../src/hooks/usePublishToSpace.ts            |   7 +-
 packages/hypergraph-react/src/index.ts        |   4 +-
 .../src/internal/convert-property-value.ts    |   5 +-
 .../src/internal/convert-relations.ts         |  24 +-
 .../internal/translate-filter-to-graphql.ts   |   2 +-
 .../hypergraph-react/src/internal/types.ts    |  11 +-
 .../src/internal/use-create-entity-public.ts  |   6 +-
 .../src/internal/use-delete-entity-public.tsx |   8 +-
 .../src/internal/use-entity-private.tsx       |   2 +-
 .../src/internal/use-entity-public.tsx        |   6 +-
 .../src/internal/use-query-private.tsx        |  54 +-
 .../src/internal/use-query-public.tsx         |   4 +-
 .../hypergraph-react/src/prepare-publish.ts   |   5 +-
 packages/hypergraph-react/src/types.ts        |   2 +-
 packages/hypergraph/src/entity/create.ts      |  12 +-
 .../src/entity/decodedEntitiesCache.ts        |  13 +-
 .../src/entity/decodedEntitiesCacheNew.ts     |  37 --
 packages/hypergraph/src/entity/entity-new.ts  |  84 ---
 packages/hypergraph/src/entity/entity.ts      | 105 +++-
 packages/hypergraph/src/entity/findMany.ts    |  75 +--
 packages/hypergraph/src/entity/findManyNew.ts | 535 ------------------
 packages/hypergraph/src/entity/findOne.ts     |  43 +-
 .../src/entity/getEntityRelations.ts          |  60 +-
 .../src/entity/getEntityRelationsNew.ts       |  50 --
 packages/hypergraph/src/entity/index.ts       |   2 -
 packages/hypergraph/src/entity/type-new.ts    |  49 --
 packages/hypergraph/src/entity/types.ts       |  28 +-
 packages/hypergraph/src/entity/update.ts      |  16 +-
 packages/hypergraph/src/index.ts              |   3 +-
 packages/hypergraph/src/type/type.ts          |  72 ++-
 39 files changed, 456 insertions(+), 1200 deletions(-)
 delete mode 100644 packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts
 delete mode 100644 packages/hypergraph/src/entity/entity-new.ts
 delete mode 100644 packages/hypergraph/src/entity/findManyNew.ts
 delete mode 100644 packages/hypergraph/src/entity/getEntityRelationsNew.ts
 delete mode 100644 packages/hypergraph/src/entity/type-new.ts

diff --git a/apps/events/src/components/todos.tsx b/apps/events/src/components/todos.tsx
index 0d500903..bda38ed6 100644
--- a/apps/events/src/components/todos.tsx
+++ b/apps/events/src/components/todos.tsx
@@ -1,26 +1,26 @@
 import {
-  useCreateEntityNew,
+  useCreateEntity,
   useDeleteEntity,
-  useQueryNew,
+  useQuery,
   useRemoveRelation,
   useSpace,
   useUpdateEntity,
 } from '@graphprotocol/hypergraph-react';
 import { useEffect, useState } from 'react';
 import Select from 'react-select';
-import { Todo, TodoNew, UserNew } from '../schema';
+import { Todo, User } from '../schema';
 import { Button } from './ui/button';
 import { Input } from './ui/input';
 
 export const Todos = () => {
-  const { data: todos } = useQueryNew(TodoNew, {
+  const { data: todos } = useQuery(Todo, {
     mode: 'private',
     include: { assignees: {} },
     // filter: { or: [{ name: { startsWith: 'aa' } }, { name: { is: 'sdasd' } }] },
   });
-  const { data: users } = useQueryNew(UserNew, { mode: 'private' });
+  const { data: users } = useQuery(User, { mode: 'private' });
   const { ready: spaceReady } = useSpace({ mode: 'private' });
-  const createEntity = useCreateEntityNew(TodoNew);
+  const createEntity = useCreateEntity(Todo);
   const updateEntity = useUpdateEntity(Todo);
   const deleteEntity = useDeleteEntity();
   const removeRelation = useRemoveRelation();
diff --git a/apps/events/src/components/users.tsx b/apps/events/src/components/users.tsx
index 38bc93ba..1d092652 100644
--- a/apps/events/src/components/users.tsx
+++ b/apps/events/src/components/users.tsx
@@ -1,14 +1,14 @@
-import { useCreateEntityNew, useQueryNew, useSpace } from '@graphprotocol/hypergraph-react';
+import { useCreateEntity, useQuery, useSpace } from '@graphprotocol/hypergraph-react';
 import { useState } from 'react';
-import { UserNew } from '../schema.js';
+import { User } from '../schema.js';
 import { Button } from './ui/button.js';
 import { Input } from './ui/input.js';
 import { UserEntry } from './user-entry.js';
 
 export const Users = () => {
-  const { data: users } = useQueryNew(UserNew, { mode: 'private' });
+  const { data: users } = useQuery(User, { mode: 'private' });
   const { ready: spaceReady } = useSpace({ mode: 'private' });
-  const createEntityNew = useCreateEntityNew(UserNew);
+  const createEntityNew = useCreateEntity(User);
   const [newUserName, setNewUserName] = useState('');
 
   console.log(users);
diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index eab10bdd..6ef13e89 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -1,49 +1,7 @@
-import { Entity, EntityNew, Id, Type, TypeNew } from '@graphprotocol/hypergraph';
+import { EntitySchema, Id, Type } from '@graphprotocol/hypergraph';
 
-export class User extends Entity.Class<User>('User')({
-  name: Type.String,
-}) {}
-
-export class Todo extends Entity.Class<Todo>('Todo')({
-  name: Type.String,
-  completed: Type.Boolean,
-  assignees: Type.Relation(User),
-}) {}
-
-export class Todo2 extends Entity.Class<Todo2>('Todo2')({
-  name: Type.String,
-  checked: Type.Boolean,
-  assignees: Type.Relation(User),
-  due: Type.Date,
-  amount: Type.Number,
-  point: Type.Point,
-  website: Type.String,
-}) {}
-
-export class JobOffer extends Entity.Class<JobOffer>('JobOffer')({
-  name: Type.String,
-  salary: Type.Number,
-}) {}
-
-export class Company extends Entity.Class<Company>('Company')({
-  name: Type.String,
-  jobOffers: Type.Relation(JobOffer),
-}) {}
-
-export class Event extends Entity.Class<Event>('Event')({
-  name: Type.String,
-  description: Type.optional(Type.String),
-  sponsors: Type.Relation(Company),
-}) {}
-
-export class Todo3 extends Entity.Class<Todo3>('Todo3')({
-  name: Type.String,
-  completed: Type.Boolean,
-  description: Type.String,
-}) {}
-
-export const UserNew = EntityNew(
-  { name: TypeNew.String },
+export const User = EntitySchema(
+  { name: Type.String },
   {
     types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
     properties: {
@@ -52,11 +10,11 @@ export const UserNew = EntityNew(
   },
 );
 
-export const TodoNew = EntityNew(
+export const Todo = EntitySchema(
   {
-    name: TypeNew.String,
-    completed: TypeNew.Boolean,
-    assignees: TypeNew.Relation(UserNew),
+    name: Type.String,
+    completed: Type.Boolean,
+    assignees: Type.Relation(User),
   },
   {
     types: [Id('44fe82a9-e4c2-4330-a395-ce85ed78e421')],
@@ -68,10 +26,34 @@ export const TodoNew = EntityNew(
   },
 );
 
-export const JobOfferNew = EntityNew(
+export const Todo2 = EntitySchema(
   {
-    name: TypeNew.String,
-    salary: TypeNew.Number,
+    name: Type.String,
+    checked: Type.Boolean,
+    assignees: Type.Relation(User),
+    due: Type.Date,
+    amount: Type.Number,
+    point: Type.Point,
+    website: Type.String,
+  },
+  {
+    types: [Id('210f4e94-234c-49d7-af0f-f3b74fb07650')],
+    properties: {
+      name: Id('e291f4da-632d-4b70-aca8-5c6c01dbf1ca'),
+      checked: Id('d1cc82ef-8bde-45f4-b31c-56b6d59279ec'),
+      assignees: Id('1115e9f8-db2e-41df-8969-c5d34c367c10'),
+      due: Id('6a28f275-b31c-47bc-83cd-ad416aaa7073'),
+      amount: Id('0c8219be-e284-4738-bd95-91a1c113c78e'),
+      point: Id('7f032477-c60e-4c85-a161-019b70db05ca'),
+      website: Id('75b6a647-5c2b-41e7-92c0-b0a0c9b28b02'),
+    },
+  },
+);
+
+export const JobOffer = EntitySchema(
+  {
+    name: Type.String,
+    salary: Type.Number,
   },
   {
     types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
@@ -81,3 +63,33 @@ export const JobOfferNew = EntityNew(
     },
   },
 );
+
+export const Company = EntitySchema(
+  {
+    name: Type.String,
+    jobOffers: Type.Relation(JobOffer),
+  },
+  {
+    types: [Id('6c504df5-1a8f-43d1-bf2d-1ef9fa5b08b5')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      jobOffers: Id('1203064e-9741-4235-89d4-97f4b22eddfb'),
+    },
+  },
+);
+
+export const Event = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    sponsors: Type.Relation(Company),
+  },
+  {
+    types: [Id('7f9562d4-034d-4385-bf5c-f02cdebba47a')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
+      sponsors: Id('6860bfac-f703-4289-b789-972d0aaf3abe'),
+    },
+  },
+);
diff --git a/apps/privy-login-example/src/mapping.ts b/apps/privy-login-example/src/mapping.ts
index 849a04a8..f811b62c 100644
--- a/apps/privy-login-example/src/mapping.ts
+++ b/apps/privy-login-example/src/mapping.ts
@@ -58,12 +58,4 @@ export const mapping: Mapping.Mapping = {
       sponsors: Id('6860bfac-f703-4289-b789-972d0aaf3abe'),
     },
   },
-  Todo3: {
-    typeIds: [Id('4f7bba76-7855-4d63-b59d-1d9f2be866df')],
-    properties: {
-      name: Id('47006386-d351-411c-8287-1dae1c1aa8c1'),
-      completed: Id('9f9f00eb-4f32-4f71-92ba-b266566d0013'),
-      description: Id('89cac80a-1dbd-4bca-97b2-45e1556d9122'),
-    },
-  },
 };
diff --git a/apps/privy-login-example/src/schema.ts b/apps/privy-login-example/src/schema.ts
index ff8bf043..6ef13e89 100644
--- a/apps/privy-login-example/src/schema.ts
+++ b/apps/privy-login-example/src/schema.ts
@@ -1,43 +1,95 @@
-import { Entity, Type } from '@graphprotocol/hypergraph';
+import { EntitySchema, Id, Type } from '@graphprotocol/hypergraph';
 
-export class User extends Entity.Class<User>('User')({
-  name: Type.String,
-}) {}
+export const User = EntitySchema(
+  { name: Type.String },
+  {
+    types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+    },
+  },
+);
 
-export class Todo extends Entity.Class<Todo>('Todo')({
-  name: Type.String,
-  completed: Type.Boolean,
-  assignees: Type.Relation(User),
-}) {}
+export const Todo = EntitySchema(
+  {
+    name: Type.String,
+    completed: Type.Boolean,
+    assignees: Type.Relation(User),
+  },
+  {
+    types: [Id('44fe82a9-e4c2-4330-a395-ce85ed78e421')],
+    properties: {
+      name: Id('c668aa67-bbca-4b2c-908c-9c5599035eab'),
+      completed: Id('71e7654f-2623-4794-88fb-841c8f3dd9b4'),
+      assignees: Id('5b80d3ee-2463-4246-b628-44ba808ab3e1'),
+    },
+  },
+);
 
-export class Todo2 extends Entity.Class<Todo2>('Todo2')({
-  name: Type.String,
-  checked: Type.Boolean,
-  assignees: Type.Relation(User),
-  due: Type.Date,
-  amount: Type.Number,
-  point: Type.Point,
-  website: Type.String,
-}) {}
+export const Todo2 = EntitySchema(
+  {
+    name: Type.String,
+    checked: Type.Boolean,
+    assignees: Type.Relation(User),
+    due: Type.Date,
+    amount: Type.Number,
+    point: Type.Point,
+    website: Type.String,
+  },
+  {
+    types: [Id('210f4e94-234c-49d7-af0f-f3b74fb07650')],
+    properties: {
+      name: Id('e291f4da-632d-4b70-aca8-5c6c01dbf1ca'),
+      checked: Id('d1cc82ef-8bde-45f4-b31c-56b6d59279ec'),
+      assignees: Id('1115e9f8-db2e-41df-8969-c5d34c367c10'),
+      due: Id('6a28f275-b31c-47bc-83cd-ad416aaa7073'),
+      amount: Id('0c8219be-e284-4738-bd95-91a1c113c78e'),
+      point: Id('7f032477-c60e-4c85-a161-019b70db05ca'),
+      website: Id('75b6a647-5c2b-41e7-92c0-b0a0c9b28b02'),
+    },
+  },
+);
 
-export class JobOffer extends Entity.Class<JobOffer>('JobOffer')({
-  name: Type.String,
-  salary: Type.Number,
-}) {}
+export const JobOffer = EntitySchema(
+  {
+    name: Type.String,
+    salary: Type.Number,
+  },
+  {
+    types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      salary: Id('baa36ac9-78ac-4cf7-8394-6b2d3006bebe'),
+    },
+  },
+);
 
-export class Company extends Entity.Class<Company>('Company')({
-  name: Type.String,
-  jobOffers: Type.Relation(JobOffer),
-}) {}
+export const Company = EntitySchema(
+  {
+    name: Type.String,
+    jobOffers: Type.Relation(JobOffer),
+  },
+  {
+    types: [Id('6c504df5-1a8f-43d1-bf2d-1ef9fa5b08b5')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      jobOffers: Id('1203064e-9741-4235-89d4-97f4b22eddfb'),
+    },
+  },
+);
 
-export class Event extends Entity.Class<Event>('Event')({
-  name: Type.String,
-  description: Type.optional(Type.String),
-  sponsors: Type.Relation(Company),
-}) {}
-
-export class Todo3 extends Entity.Class<Todo3>('Todo3')({
-  name: Type.String,
-  completed: Type.Boolean,
-  description: Type.String,
-}) {}
+export const Event = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    sponsors: Type.Relation(Company),
+  },
+  {
+    types: [Id('7f9562d4-034d-4385-bf5c-f02cdebba47a')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
+      sponsors: Id('6860bfac-f703-4289-b789-972d0aaf3abe'),
+    },
+  },
+);
diff --git a/packages/hypergraph-react/src/hooks/use-create-entity.ts b/packages/hypergraph-react/src/hooks/use-create-entity.ts
index 60564771..f995eec3 100644
--- a/packages/hypergraph-react/src/hooks/use-create-entity.ts
+++ b/packages/hypergraph-react/src/hooks/use-create-entity.ts
@@ -5,20 +5,7 @@ import type * as Schema from 'effect/Schema';
 import { useHypergraphSpaceInternal } from '../internal/use-hypergraph-space-internal.js';
 import { useSubscribeToSpaceAndGetHandle } from '../internal/use-subscribe-to-space.js';
 
-export function useCreateEntity<const S extends Entity.AnyNoContext>(type: S, options?: { space?: string }) {
-  const { space: spaceIdFromParams } = options ?? {};
-  const { space: spaceFromContext } = useHypergraphSpaceInternal();
-  const spaceId = spaceIdFromParams ?? spaceFromContext;
-  const handle = useSubscribeToSpaceAndGetHandle({ spaceId, enabled: true });
-  if (!handle) {
-    return () => {
-      throw new Error('Space not found or not ready');
-    };
-  }
-  return Entity.create(handle, type);
-}
-
-export function useCreateEntityNew<const S extends Schema.Schema.AnyNoContext>(type: S, options?: { space?: string }) {
+export function useCreateEntity<const S extends Schema.Schema.AnyNoContext>(type: S, options?: { space?: string }) {
   const { space: spaceIdFromParams } = options ?? {};
   const { space: spaceFromContext } = useHypergraphSpaceInternal();
   const spaceId = spaceIdFromParams ?? spaceFromContext;
diff --git a/packages/hypergraph-react/src/hooks/use-entity.tsx b/packages/hypergraph-react/src/hooks/use-entity.tsx
index 25d5d5eb..ef00a285 100644
--- a/packages/hypergraph-react/src/hooks/use-entity.tsx
+++ b/packages/hypergraph-react/src/hooks/use-entity.tsx
@@ -1,9 +1,9 @@
-import type { Entity, Id } from '@graphprotocol/hypergraph';
+import type { Id } from '@graphprotocol/hypergraph';
 import type * as Schema from 'effect/Schema';
 import { useEntityPrivate } from '../internal/use-entity-private.js';
 import { useEntityPublic } from '../internal/use-entity-public.js';
 
-export function useEntity<const S extends Entity.AnyNoContext>(
+export function useEntity<const S extends Schema.Schema.AnyNoContext>(
   type: S,
   params: {
     id: string | Id;
diff --git a/packages/hypergraph-react/src/hooks/use-query.tsx b/packages/hypergraph-react/src/hooks/use-query.tsx
index 611d6061..89cd68ad 100644
--- a/packages/hypergraph-react/src/hooks/use-query.tsx
+++ b/packages/hypergraph-react/src/hooks/use-query.tsx
@@ -1,9 +1,9 @@
 import type { Entity } from '@graphprotocol/hypergraph';
 import type * as Schema from 'effect/Schema';
-import { useQueryPrivate, useQueryPrivateNew } from '../internal/use-query-private.js';
+import { useQueryPrivate } from '../internal/use-query-private.js';
 import { useQueryPublic } from '../internal/use-query-public.js';
 
-type QueryParams<S extends Entity.AnyNoContext> = {
+type QueryParams<S extends Schema.Schema.AnyNoContext> = {
   mode: 'public' | 'private';
   filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
   // TODO: for multi-level nesting it should only allow the allowed properties instead of Record<string, Record<string, never>>
@@ -12,9 +12,7 @@ type QueryParams<S extends Entity.AnyNoContext> = {
   first?: number | undefined;
 };
 
-const preparePublishDummy = () => undefined;
-
-export function useQuery<const S extends Entity.AnyNoContext>(type: S, params: QueryParams<S>) {
+export function useQuery<const S extends Schema.Schema.AnyNoContext>(type: S, params: QueryParams<S>) {
   const { mode, filter, include, space, first } = params;
   const publicResult = useQueryPublic(type, { enabled: mode === 'public', filter, include, first, space });
   const localResult = useQueryPrivate(type, { enabled: mode === 'private', filter, include, space });
@@ -23,37 +21,6 @@ export function useQuery<const S extends Entity.AnyNoContext>(type: S, params: Q
     return {
       ...publicResult,
       deleted: [],
-      preparePublish: preparePublishDummy,
-    };
-  }
-
-  return {
-    ...publicResult,
-    data: localResult.entities,
-    deleted: localResult.deletedEntities,
-    preparePublish: preparePublishDummy,
-  };
-}
-
-type QueryParamsNew<S extends Schema.Schema.AnyNoContext> = {
-  mode: 'public' | 'private';
-  filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
-  // TODO: for multi-level nesting it should only allow the allowed properties instead of Record<string, Record<string, never>>
-  include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
-  space?: string | undefined;
-  first?: number | undefined;
-};
-
-export function useQueryNew<const S extends Schema.Schema.AnyNoContext>(type: S, params: QueryParamsNew<S>) {
-  const { mode, filter, include, space, first } = params;
-  const publicResult = useQueryPublic(type, { enabled: mode === 'public', filter, include, first, space });
-  const localResult = useQueryPrivateNew(type, { enabled: mode === 'private', filter, include, space });
-
-  if (mode === 'public') {
-    return {
-      ...publicResult,
-      deleted: [],
-      preparePublish: preparePublishDummy,
     };
   }
 
@@ -61,6 +28,5 @@ export function useQueryNew<const S extends Schema.Schema.AnyNoContext>(type: S,
     ...publicResult,
     data: localResult.entities,
     deleted: localResult.deletedEntities,
-    preparePublish: preparePublishDummy,
   };
 }
diff --git a/packages/hypergraph-react/src/hooks/use-update-entity.ts b/packages/hypergraph-react/src/hooks/use-update-entity.ts
index 414f3d2f..afe16177 100644
--- a/packages/hypergraph-react/src/hooks/use-update-entity.ts
+++ b/packages/hypergraph-react/src/hooks/use-update-entity.ts
@@ -1,10 +1,11 @@
 'use client';
 
 import { Entity } from '@graphprotocol/hypergraph';
+import type * as Schema from 'effect/Schema';
 import { useHypergraphSpaceInternal } from '../internal/use-hypergraph-space-internal.js';
 import { useSubscribeToSpaceAndGetHandle } from '../internal/use-subscribe-to-space.js';
 
-export function useUpdateEntity<const S extends Entity.AnyNoContext>(type: S, options?: { space?: string }) {
+export function useUpdateEntity<const S extends Schema.Schema.AnyNoContext>(type: S, options?: { space?: string }) {
   const { space: spaceFromContext } = useHypergraphSpaceInternal();
   const { space } = options ?? {};
   const handle = useSubscribeToSpaceAndGetHandle({ spaceId: space ?? spaceFromContext, enabled: true });
diff --git a/packages/hypergraph-react/src/hooks/usePublishToSpace.ts b/packages/hypergraph-react/src/hooks/usePublishToSpace.ts
index 1bea5923..fb29ee12 100644
--- a/packages/hypergraph-react/src/hooks/usePublishToSpace.ts
+++ b/packages/hypergraph-react/src/hooks/usePublishToSpace.ts
@@ -1,21 +1,22 @@
 import type { Entity } from '@graphprotocol/hypergraph';
 import { type UseMutationOptions, useMutation } from '@tanstack/react-query';
+import type * as Schema from 'effect/Schema';
 import { useHypergraphApp } from '../HypergraphAppContext.js';
 import { preparePublish } from '../prepare-publish.js';
 import { publishOps } from '../publish-ops.js';
 import type { OmitStrict } from '../types.js';
 
-type Variables<S extends Entity.AnyNoContext> = {
+type Variables<S extends Schema.Schema.AnyNoContext> = {
   entity: Entity.Entity<S>;
   spaceId: string;
 };
 
-type UsePublishToSpaceOptions<S extends Entity.AnyNoContext> = OmitStrict<
+type UsePublishToSpaceOptions<S extends Schema.Schema.AnyNoContext> = OmitStrict<
   UseMutationOptions<Awaited<ReturnType<typeof publishOps>>, Error, Variables<S>, unknown>,
   'mutationFn' | 'mutationKey'
 >;
 
-export function usePublishToPublicSpace<const S extends Entity.AnyNoContext>(
+export function usePublishToPublicSpace<const S extends Schema.Schema.AnyNoContext>(
   options: UsePublishToSpaceOptions<S> = {},
 ) {
   const { getSmartSessionClient } = useHypergraphApp();
diff --git a/packages/hypergraph-react/src/index.ts b/packages/hypergraph-react/src/index.ts
index 1b6c286a..b572db35 100644
--- a/packages/hypergraph-react/src/index.ts
+++ b/packages/hypergraph-react/src/index.ts
@@ -1,12 +1,12 @@
 export { PublishDiff } from './components/publish-diff/publish-diff.js';
 export { createWalletClient } from './create-wallet-client.js';
-export { useCreateEntity, useCreateEntityNew } from './hooks/use-create-entity.js';
+export { useCreateEntity } from './hooks/use-create-entity.js';
 export { useDeleteEntity } from './hooks/use-delete-entity.js';
 export { useEntity } from './hooks/use-entity.js';
 export { useHardDeleteEntity } from './hooks/use-hard-delete-entity.js';
 export { usePrivyAuthCreatePrivateSpace as _usePrivyAuthCreatePrivateSpace } from './hooks/use-privy-auth-create-private-space.js';
 export { usePrivyAuthCreatePublicSpace as _usePrivyAuthCreatePublicSpace } from './hooks/use-privy-auth-create-public-space.js';
-export { useQuery, useQueryNew } from './hooks/use-query.js';
+export { useQuery } from './hooks/use-query.js';
 export { useRemoveRelation } from './hooks/use-remove-relation.js';
 export { useSpace } from './hooks/use-space.js';
 export { useSpaces } from './hooks/use-spaces.js';
diff --git a/packages/hypergraph-react/src/internal/convert-property-value.ts b/packages/hypergraph-react/src/internal/convert-property-value.ts
index 9601a352..b74470cc 100644
--- a/packages/hypergraph-react/src/internal/convert-property-value.ts
+++ b/packages/hypergraph-react/src/internal/convert-property-value.ts
@@ -1,9 +1,10 @@
-import { type Entity, TypeUtils } from '@graphprotocol/hypergraph';
+import { TypeUtils } from '@graphprotocol/hypergraph';
+import type * as Schema from 'effect/Schema';
 
 export const convertPropertyValue = (
   property: { propertyId: string; string: string; boolean: boolean; number: number; time: string; point: string },
   key: string,
-  type: Entity.AnyNoContext,
+  type: Schema.Schema.AnyNoContext,
 ) => {
   if (TypeUtils.isBooleanOrOptionalBooleanType(type.fields[key]) && property.boolean !== undefined) {
     return Boolean(property.boolean);
diff --git a/packages/hypergraph-react/src/internal/convert-relations.ts b/packages/hypergraph-react/src/internal/convert-relations.ts
index 9a74a81d..15456d48 100644
--- a/packages/hypergraph-react/src/internal/convert-relations.ts
+++ b/packages/hypergraph-react/src/internal/convert-relations.ts
@@ -1,4 +1,5 @@
-import type { Entity, Mapping } from '@graphprotocol/hypergraph';
+import type { Mapping } from '@graphprotocol/hypergraph';
+import type * as Schema from 'effect/Schema';
 import { convertPropertyValue } from './convert-property-value.js';
 
 // A recursive representation of the entity structure returned by the public GraphQL
@@ -22,7 +23,7 @@ type RecursiveQueryEntity = {
   }[];
 };
 
-export const convertRelations = <S extends Entity.AnyNoContext>(
+export const convertRelations = <S extends Schema.Schema.AnyNoContext>(
   queryEntity: RecursiveQueryEntity,
   type: S,
   mappingEntry: Mapping.MappingEntry,
@@ -43,14 +44,19 @@ export const convertRelations = <S extends Entity.AnyNoContext>(
       console.error(`Field ${key} not found in ${type.name}`);
       continue;
     }
-    // @ts-expect-error TODO: properly access the type.name
-    const annotations = field.ast.rest[0].type.to.annotations;
+    const relationTransformation = field.ast.rest?.[0];
+    if (!relationTransformation) {
+      console.error(`Relation transformation for ${key} not found`);
+      continue;
+    }
+
+    const identifierAnnotation = SchemaAST.getIdentifierAnnotation(relationTransformation.type.to);
+    if (Option.isNone(identifierAnnotation)) {
+      console.error(`Relation identifier for ${key} not found`);
+      continue;
+    }
 
-    // TODO: fix this access using proper effect types
-    const relationTypeName =
-      annotations[
-        Object.getOwnPropertySymbols(annotations).find((sym) => sym.description === 'effect/annotation/Identifier')
-      ];
+    const relationTypeName = identifierAnnotation.value;
 
     const relationMappingEntry = mapping[relationTypeName];
     if (!relationMappingEntry) {
diff --git a/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts b/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
index 14ea0ffa..8ba1dfb9 100644
--- a/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
+++ b/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
@@ -35,7 +35,7 @@ type GraphqlFilterEntry =
  * Translates internal filter format to GraphQL filter format
  * Maps the internal EntityFieldFilter structure to the expected GraphQL filter structure
  */
-export function translateFilterToGraphql<S extends Entity.AnyNoContext>(
+export function translateFilterToGraphql<S extends Schema.Schema.AnyNoContext>(
   filter: { [K in keyof Schema.Schema.Type<S>]?: Entity.EntityFieldFilter<Schema.Schema.Type<S>[K]> } | undefined,
   type: S,
   mapping: Mapping.Mapping,
diff --git a/packages/hypergraph-react/src/internal/types.ts b/packages/hypergraph-react/src/internal/types.ts
index 5ca34d5f..77f50412 100644
--- a/packages/hypergraph-react/src/internal/types.ts
+++ b/packages/hypergraph-react/src/internal/types.ts
@@ -1,16 +1,7 @@
 import type { Entity } from '@graphprotocol/hypergraph';
 import type * as Schema from 'effect/Schema';
 
-export type QueryPublicParams<S extends Entity.AnyNoContext> = {
-  enabled: boolean;
-  space?: string | undefined;
-  filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
-  // TODO: for multi-level nesting it should only allow the allowed properties instead of Record<string, Record<string, never>>
-  include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
-  first?: number | undefined;
-};
-
-export type QueryPublicParamsNew<S extends Schema.Schema.AnyNoContext> = {
+export type QueryPublicParams<S extends Schema.Schema.AnyNoContext> = {
   enabled: boolean;
   filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
   // TODO: for multi-level nesting it should only allow the allowed properties instead of Record<string, Record<string, never>>
diff --git a/packages/hypergraph-react/src/internal/use-create-entity-public.ts b/packages/hypergraph-react/src/internal/use-create-entity-public.ts
index 8fde1901..f5626458 100644
--- a/packages/hypergraph-react/src/internal/use-create-entity-public.ts
+++ b/packages/hypergraph-react/src/internal/use-create-entity-public.ts
@@ -1,5 +1,5 @@
 import { Graph, Id, type PropertiesParam, type RelationsParam } from '@graphprotocol/grc-20';
-import type { Connect, Entity } from '@graphprotocol/hypergraph';
+import type { Connect } from '@graphprotocol/hypergraph';
 import { store, TypeUtils } from '@graphprotocol/hypergraph';
 import { useQueryClient } from '@tanstack/react-query';
 import { useSelector } from '@xstate/store/react';
@@ -10,7 +10,7 @@ type CreateEntityPublicParams = {
   space: string;
 };
 
-export function useCreateEntityPublic<const S extends Entity.AnyNoContext>(
+export function useCreateEntityPublic<const S extends Schema.Schema.AnyNoContext>(
   type: S,
   { space }: CreateEntityPublicParams,
 ) {
@@ -18,7 +18,7 @@ export function useCreateEntityPublic<const S extends Entity.AnyNoContext>(
   const queryClient = useQueryClient();
 
   return async (
-    data: Readonly<Schema.Schema.Type<Entity.Insert<S>>>,
+    data: Readonly<Schema.Schema.Type<S>>,
     { walletClient }: { walletClient: Connect.SmartSessionClient },
     // TODO: return the entity with this type: Promise<Entity.Entity<S>>
   ) => {
diff --git a/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx b/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx
index ab5d6b08..ad339377 100644
--- a/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-delete-entity-public.tsx
@@ -1,6 +1,7 @@
 import { Graph, type Op } from '@graphprotocol/grc-20';
-import type { Connect, Entity } from '@graphprotocol/hypergraph';
+import type { Connect } from '@graphprotocol/hypergraph';
 import { useQueryClient } from '@tanstack/react-query';
+import type * as Schema from 'effect/Schema';
 import request, { gql } from 'graphql-request';
 import { publishOps } from '../publish-ops.js';
 
@@ -32,7 +33,10 @@ type EntityToDeleteQueryResult = {
   };
 } | null;
 
-export const useDeleteEntityPublic = <S extends Entity.AnyNoContext>(type: S, { space }: DeleteEntityPublicParams) => {
+export const useDeleteEntityPublic = <S extends Schema.Schema.AnyNoContext>(
+  type: S,
+  { space }: DeleteEntityPublicParams,
+) => {
   const queryClient = useQueryClient();
 
   return async ({ id, walletClient }: { id: string; walletClient: Connect.SmartSessionClient }) => {
diff --git a/packages/hypergraph-react/src/internal/use-entity-private.tsx b/packages/hypergraph-react/src/internal/use-entity-private.tsx
index 9dacf179..ee61e475 100644
--- a/packages/hypergraph-react/src/internal/use-entity-private.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-private.tsx
@@ -4,7 +4,7 @@ import { useRef, useSyncExternalStore } from 'react';
 import { useHypergraphSpaceInternal } from './use-hypergraph-space-internal.js';
 import { useSubscribeToSpaceAndGetHandle } from './use-subscribe-to-space.js';
 
-export function useEntityPrivate<const S extends Entity.AnyNoContext>(
+export function useEntityPrivate<const S extends Schema.Schema.AnyNoContext>(
   type: S,
   params: {
     id: string | Id;
diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index 3799edd1..0f6a82c2 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -163,7 +163,7 @@ type EntityQueryResult = {
   } | null;
 };
 
-export const parseResult = <S extends Entity.AnyNoContext>(
+export const parseResult = <S extends Schema.Schema.AnyNoContext>(
   queryData: EntityQueryResult,
   type: S,
   mappingEntry: Mapping.MappingEntry,
@@ -208,7 +208,7 @@ export const parseResult = <S extends Entity.AnyNoContext>(
   return { data: null, invalidEntity: rawEntity };
 };
 
-type UseEntityPublicParams<S extends Entity.AnyNoContext> = {
+type UseEntityPublicParams<S extends Schema.Schema.AnyNoContext> = {
   id: string;
   enabled?: boolean;
   space?: string;
@@ -216,7 +216,7 @@ type UseEntityPublicParams<S extends Entity.AnyNoContext> = {
   include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
 };
 
-export const useEntityPublic = <S extends Entity.AnyNoContext>(type: S, params: UseEntityPublicParams<S>) => {
+export const useEntityPublic = <S extends Schema.Schema.AnyNoContext>(type: S, params: UseEntityPublicParams<S>) => {
   const { id, enabled = true, space: spaceFromParams, include } = params;
   const { space: spaceFromContext } = useHypergraphSpaceInternal();
   const space = spaceFromParams ?? spaceFromContext;
diff --git a/packages/hypergraph-react/src/internal/use-query-private.tsx b/packages/hypergraph-react/src/internal/use-query-private.tsx
index 6b1941b6..e3e238d2 100644
--- a/packages/hypergraph-react/src/internal/use-query-private.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-private.tsx
@@ -4,14 +4,14 @@ import { useLayoutEffect, useMemo, useRef, useSyncExternalStore } from 'react';
 import { useHypergraphSpaceInternal } from './use-hypergraph-space-internal.js';
 import { useSubscribeToSpaceAndGetHandle } from './use-subscribe-to-space.js';
 
-type QueryParams<S extends Entity.AnyNoContext> = {
+type QueryParams<S extends Schema.Schema.AnyNoContext> = {
   space?: string | undefined;
   enabled: boolean;
   filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
   include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
 };
 
-export function useQueryPrivate<const S extends Entity.AnyNoContext>(type: S, params?: QueryParams<S>) {
+export function useQueryPrivate<const S extends Schema.Schema.AnyNoContext>(type: S, params?: QueryParams<S>) {
   const { enabled = true, filter, include, space: spaceFromParams } = params ?? {};
   const entitiesRef = useRef<Entity.Entity<S>[]>([]);
   const subscriptionRef = useRef<Entity.FindManySubscription<S>>({
@@ -53,53 +53,3 @@ export function useQueryPrivate<const S extends Entity.AnyNoContext>(type: S, pa
 
   return { entities, deletedEntities };
 }
-
-type QueryParamsNew<S extends Schema.Schema.AnyNoContext> = {
-  space?: string | undefined;
-  enabled: boolean;
-  filter?: Entity.EntityFilter<Schema.Schema.Type<S>> | undefined;
-  include?: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined;
-};
-
-export function useQueryPrivateNew<const S extends Schema.Schema.AnyNoContext>(type: S, params?: QueryParamsNew<S>) {
-  const { enabled = true, filter, include, space: spaceFromParams } = params ?? {};
-  const entitiesRef = useRef<Entity.EntityNew<S>[]>([]);
-  const subscriptionRef = useRef<Entity.FindManySubscriptionNew<S>>({
-    subscribe: () => () => undefined,
-    getEntities: () => entitiesRef.current,
-  });
-  const { space: spaceFromContext } = useHypergraphSpaceInternal();
-  const handle = useSubscribeToSpaceAndGetHandle({ spaceId: spaceFromParams ?? spaceFromContext, enabled });
-  const handleIsReady = handle ? handle.isReady() : false;
-
-  // biome-ignore lint/correctness/useExhaustiveDependencies: allow to change filter and include
-  useLayoutEffect(() => {
-    if (enabled && handle && handleIsReady) {
-      const subscription = Entity.subscribeToFindManyNew(handle, type, filter, include);
-      subscriptionRef.current.subscribe = subscription.subscribe;
-      subscriptionRef.current.getEntities = subscription.getEntities;
-    }
-  }, [enabled, handleIsReady, handle, type]);
-
-  // TODO: allow to change the enabled state
-  const allEntities = useSyncExternalStore(
-    subscriptionRef.current.subscribe,
-    subscriptionRef.current.getEntities,
-    () => entitiesRef.current,
-  );
-
-  const { entities, deletedEntities } = useMemo(() => {
-    const entities: Entity.EntityNew<S>[] = [];
-    const deletedEntities: Entity.EntityNew<S>[] = [];
-    for (const entity of allEntities) {
-      if (entity.__deleted === true) {
-        deletedEntities.push(entity);
-      } else {
-        entities.push(entity);
-      }
-    }
-    return { entities, deletedEntities };
-  }, [allEntities]);
-
-  return { entities, deletedEntities };
-}
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index 14242d42..a631829e 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -178,7 +178,7 @@ type EntityQueryResult = {
   }[];
 };
 
-export const parseResult = <S extends Entity.AnyNoContext>(
+export const parseResult = <S extends Schema.Schema.AnyNoContext>(
   queryData: EntityQueryResult,
   type: S,
   mappingEntry: Mapping.MappingEntry,
@@ -222,7 +222,7 @@ export const parseResult = <S extends Entity.AnyNoContext>(
   return { data, invalidEntities };
 };
 
-export const useQueryPublic = <S extends Entity.AnyNoContext>(type: S, params?: QueryPublicParams<S>) => {
+export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, params?: QueryPublicParams<S>) => {
   const { enabled = true, filter, include, space: spaceFromParams, first = 100 } = params ?? {};
   const { space: spaceFromContext } = useHypergraphSpaceInternal();
   const space = spaceFromParams ?? spaceFromContext;
diff --git a/packages/hypergraph-react/src/prepare-publish.ts b/packages/hypergraph-react/src/prepare-publish.ts
index c0cb8afd..b485607e 100644
--- a/packages/hypergraph-react/src/prepare-publish.ts
+++ b/packages/hypergraph-react/src/prepare-publish.ts
@@ -8,9 +8,10 @@ import {
 } from '@graphprotocol/grc-20';
 import type { Entity } from '@graphprotocol/hypergraph';
 import { store, TypeUtils } from '@graphprotocol/hypergraph';
+import type * as Schema from 'effect/Schema';
 import request, { gql } from 'graphql-request';
 
-export type PreparePublishParams<S extends Entity.AnyNoContext> = {
+export type PreparePublishParams<S extends Schema.Schema.AnyNoContext> = {
   entity: Entity.Entity<S>;
   publicSpace: string | Id;
 };
@@ -49,7 +50,7 @@ type EntityToPublishQueryResult = {
   };
 } | null;
 
-export const preparePublish = async <S extends Entity.AnyNoContext>({
+export const preparePublish = async <S extends Schema.Schema.AnyNoContext>({
   entity,
   publicSpace,
 }: PreparePublishParams<S>) => {
diff --git a/packages/hypergraph-react/src/types.ts b/packages/hypergraph-react/src/types.ts
index df31f3be..060590a4 100644
--- a/packages/hypergraph-react/src/types.ts
+++ b/packages/hypergraph-react/src/types.ts
@@ -9,7 +9,7 @@ export type EntityLike = {
   [key: string]: unknown;
 };
 
-export type PartialEntity<S extends Entity.AnyNoContext> = Partial<Schema.Schema.Type<Entity.Update<S>>> & {
+export type PartialEntity<S extends Schema.Schema.AnyNoContext> = Partial<Schema.Schema.Type<Entity.Update<S>>> & {
   id: string;
 };
 
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index a539ea3b..64aa22bb 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -6,13 +6,13 @@ import { PropertyIdSymbol } from '../constants.js';
 import { generateId } from '../utils/generateId.js';
 import { isRelation } from '../utils/isRelation.js';
 import { isRelationField } from '../utils/isRelationField.js';
-import { encodeToGrc20Json } from './entity-new.js';
-import { findOne, findOneNew } from './findOne.js';
-import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, EntityNew, Insert } from './types.js';
+import { encodeToGrc20Json } from './entity.js';
+import { findOne } from './findOne.js';
+import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, Insert } from './types.js';
 
 /**
  * Type utility to transform relation fields to accept string arrays instead of their typed values
- * This specifically targets TypeNew.Relation fields which are arrays of objects
+ * This specifically targets Type.Relation fields which are arrays of objects
  */
 type WithRelationsAsStringArrays<T> = {
   [K in keyof T]: T[K] extends readonly (infer U)[]
@@ -79,7 +79,7 @@ export const create = <const S extends AnyNoContext>(handle: DocHandle<DocumentC
 };
 
 export const createNew = <const S extends Schema.Schema.AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
-  return (data: Readonly<WithRelationsAsStringArrays<Schema.Schema.Type<S>>>): EntityNew<S> => {
+  return (data: Readonly<WithRelationsAsStringArrays<Schema.Schema.Type<S>>>): Entity<S> => {
     const entityId = generateId();
     const encoded = encodeToGrc20Json(type, { ...data, id: entityId });
 
@@ -116,6 +116,6 @@ export const createNew = <const S extends Schema.Schema.AnyNoContext>(handle: Do
       }
     });
 
-    return findOneNew(handle, type)(entityId) as EntityNew<S>;
+    return findOne(handle, type)(entityId) as Entity<S>;
   };
 };
diff --git a/packages/hypergraph/src/entity/decodedEntitiesCache.ts b/packages/hypergraph/src/entity/decodedEntitiesCache.ts
index e93981d9..ba62d7fd 100644
--- a/packages/hypergraph/src/entity/decodedEntitiesCache.ts
+++ b/packages/hypergraph/src/entity/decodedEntitiesCache.ts
@@ -1,17 +1,16 @@
 import type * as Schema from 'effect/Schema';
-import type { AnyNoContext, Entity } from './types.js';
+import type { Entity } from './types.js';
 
 export type QueryEntry = {
-  data: Array<Entity<AnyNoContext>>; // holds the decoded entities of this query and must be a stable reference and use the same reference for the `entities` array
+  data: Array<Entity<Schema.Schema.AnyNoContext>>; // holds the decoded entities of this query and must be a stable reference and use the same reference for the `entities` array
   listeners: Array<() => void>; // listeners to this query
   isInvalidated: boolean;
-  include: { [K in keyof Schema.Schema.Type<AnyNoContext>]?: Record<string, Record<string, never>> };
+  include: { [K in keyof Schema.Schema.Type<Schema.Schema.AnyNoContext>]?: Record<string, Record<string, never>> };
 };
 
 export type DecodedEntitiesCacheEntry = {
-  decoder: (data: unknown) => unknown;
-  type: AnyNoContext; // TODO should be the type of the entity
-  entities: Map<string, Entity<AnyNoContext>>; // holds all entities of this type
+  type: Schema.Schema.AnyNoContext; // TODO should be the type of the entity
+  entities: Map<string, Entity<Schema.Schema.AnyNoContext>>; // holds all entities of this type
   queries: Map<
     string, // instead of serializedQueryKey as string we could also have the actual params
     QueryEntry
@@ -31,7 +30,7 @@ export type DecodedEntitiesCacheEntry = {
  * Whenever a query is registered we add it to the cache and add a listener to the query. Whenever a query is unregistered we remove the listener from the query.
  */
 type DecodedEntitiesCache = Map<
-  string, // type name
+  string, // serialized type IDs
   DecodedEntitiesCacheEntry
 >;
 
diff --git a/packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts b/packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts
deleted file mode 100644
index 484f9f58..00000000
--- a/packages/hypergraph/src/entity/decodedEntitiesCacheNew.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import type * as Schema from 'effect/Schema';
-import type { EntityNew } from './types.js';
-
-export type QueryEntry = {
-  data: Array<EntityNew<Schema.Schema.AnyNoContext>>; // holds the decoded entities of this query and must be a stable reference and use the same reference for the `entities` array
-  listeners: Array<() => void>; // listeners to this query
-  isInvalidated: boolean;
-  include: { [K in keyof Schema.Schema.Type<Schema.Schema.AnyNoContext>]?: Record<string, Record<string, never>> };
-};
-
-export type DecodedEntitiesCacheEntry = {
-  type: Schema.Schema.AnyNoContext; // TODO should be the type of the entity
-  entities: Map<string, EntityNew<Schema.Schema.AnyNoContext>>; // holds all entities of this type
-  queries: Map<
-    string, // instead of serializedQueryKey as string we could also have the actual params
-    QueryEntry
-  >;
-  isInvalidated: boolean;
-};
-
-/*
-/*
- * Note: Currently we only use one global cache for all entities.
- * In the future we probably want a build function that creates a cache and returns the
- * functions (create, update, findMany, …) that use this specific cache.
- *
- * How does it work?
- *
- * We store all decoded entities in a cache and for each query we reference the entities relevant to this query.
- * Whenever a query is registered we add it to the cache and add a listener to the query. Whenever a query is unregistered we remove the listener from the query.
- */
-type DecodedEntitiesCache = Map<
-  string, // serialized type IDs
-  DecodedEntitiesCacheEntry
->;
-
-export const decodedEntitiesCache: DecodedEntitiesCache = new Map();
diff --git a/packages/hypergraph/src/entity/entity-new.ts b/packages/hypergraph/src/entity/entity-new.ts
deleted file mode 100644
index c4a2e03e..00000000
--- a/packages/hypergraph/src/entity/entity-new.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-import { PropertyIdSymbol, TypeIdsSymbol } from '../constants.js';
-
-/**
- * Entity function for creating schemas with a nicer API.
- * Takes a schema configuration object and a property ID mapping object.
- *
- * @example
- * ```typescript
- * const User = Entity({
- *   name: Type.String,
- *   age: Type.Number,
- * }, {
- *   name: "grc-20-name",
- *   age: "grc-20-age"
- * });
- * ```
- */
-export function Entity<
-  T extends Record<
-    string,
-    (propertyId: string) => Schema.Schema<any> | Schema.PropertySignature<any, any, any, any, any, any, any>
-  >,
-  P extends Record<keyof T, string>,
->(
-  schemaTypes: T,
-  mapping: {
-    types: Array<string>;
-    properties: P;
-  },
-): Schema.Struct<{
-  [K in keyof T]: ReturnType<T[K]> & { id: string };
-}> {
-  const properties: Record<string, Schema.Schema<any> | Schema.PropertySignature<any, any, any, any, any, any, any>> =
-    {};
-
-  for (const [key, schemaType] of Object.entries(schemaTypes)) {
-    const propertyId = mapping.properties[key as keyof P];
-    properties[key] = schemaType(propertyId);
-  }
-
-  return Schema.Struct(properties).pipe(Schema.annotations({ [TypeIdsSymbol]: mapping.types })) as any;
-}
-
-export function encodeToGrc20Json<T extends object, E>(schema: Schema.Schema<T, E>, value: T): Record<string, unknown> {
-  const ast = schema.ast as SchemaAST.TypeLiteral;
-  const out: Record<string, unknown> = {};
-
-  for (const prop of ast.propertySignatures) {
-    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
-    if (Option.isSome(result)) {
-      out[result.value] = (value as any)[prop.name];
-    }
-  }
-
-  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(ast).pipe(Option.getOrElse(() => []));
-  out['@@types@@'] = typeIds;
-
-  return out;
-}
-
-export function decodeFromGrc20Json<T extends object, E>(
-  schema: Schema.Schema<T, E>,
-  grc20Data: Record<string, unknown>,
-): T {
-  const ast = schema.ast as SchemaAST.TypeLiteral;
-  const out: Record<string, unknown> = {};
-
-  for (const prop of ast.propertySignatures) {
-    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
-    if (Option.isSome(result)) {
-      const grc20Key = result.value;
-      if (grc20Key in grc20Data && typeof prop.name === 'string') {
-        out[prop.name] = (grc20Data as any)[grc20Key];
-      }
-    }
-  }
-
-  out.id = grc20Data.id as string;
-
-  return out as T;
-}
diff --git a/packages/hypergraph/src/entity/entity.ts b/packages/hypergraph/src/entity/entity.ts
index c772ed52..f688f305 100644
--- a/packages/hypergraph/src/entity/entity.ts
+++ b/packages/hypergraph/src/entity/entity.ts
@@ -1,26 +1,91 @@
 import * as Data from 'effect/Data';
-import type { AnyNoContext } from './types.js';
-import * as VariantSchema from './variant-schema.js';
-
-const {
-  Class,
-  Field,
-  // FieldExcept,
-  // FieldOnly,
-  // Struct,
-  // Union,
-  // extract,
-  // fieldEvolve,
-  // fieldFromKey
-} = VariantSchema.make({
-  variants: ['select', 'insert', 'update'],
-  defaultVariant: 'select',
-});
-
-export { Class, Field };
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { PropertyIdSymbol, TypeIdsSymbol } from '../constants.js';
+
+/**
+ * Entity function for creating schemas with a nicer API.
+ * Takes a schema configuration object and a property ID mapping object.
+ *
+ * @example
+ * ```typescript
+ * const User = EntityDefinition({
+ *   name: Type.String,
+ *   age: Type.Number,
+ * }, {
+ *   name: "grc-20-name",
+ *   age: "grc-20-age"
+ * });
+ * ```
+ */
+export function EntitySchema<
+  T extends Record<
+    string,
+    (propertyId: string) => Schema.Schema<any> | Schema.PropertySignature<any, any, any, any, any, any, any>
+  >,
+  P extends Record<keyof T, string>,
+>(
+  schemaTypes: T,
+  mapping: {
+    types: Array<string>;
+    properties: P;
+  },
+): Schema.Struct<{
+  [K in keyof T]: ReturnType<T[K]> & { id: string };
+}> {
+  const properties: Record<string, Schema.Schema<any> | Schema.PropertySignature<any, any, any, any, any, any, any>> =
+    {};
+
+  for (const [key, schemaType] of Object.entries(schemaTypes)) {
+    const propertyId = mapping.properties[key as keyof P];
+    properties[key] = schemaType(propertyId);
+  }
+
+  return Schema.Struct(properties).pipe(Schema.annotations({ [TypeIdsSymbol]: mapping.types })) as any;
+}
+
+export function encodeToGrc20Json<T extends object, E>(schema: Schema.Schema<T, E>, value: T): Record<string, unknown> {
+  const ast = schema.ast as SchemaAST.TypeLiteral;
+  const out: Record<string, unknown> = {};
+
+  for (const prop of ast.propertySignatures) {
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+    if (Option.isSome(result)) {
+      out[result.value] = (value as any)[prop.name];
+    }
+  }
+
+  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(ast).pipe(Option.getOrElse(() => []));
+  out['@@types@@'] = typeIds;
+
+  return out;
+}
+
+export function decodeFromGrc20Json<T extends object, E>(
+  schema: Schema.Schema<T, E>,
+  grc20Data: Record<string, unknown>,
+): T {
+  const ast = schema.ast as SchemaAST.TypeLiteral;
+  const out: Record<string, unknown> = {};
+
+  for (const prop of ast.propertySignatures) {
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+    if (Option.isSome(result)) {
+      const grc20Key = result.value;
+      if (grc20Key in grc20Data && typeof prop.name === 'string') {
+        out[prop.name] = (grc20Data as any)[grc20Key];
+      }
+    }
+  }
+
+  out.id = grc20Data.id as string;
+
+  return out as T;
+}
 
 export class EntityNotFoundError extends Data.TaggedError('EntityNotFoundError')<{
   id: string;
-  type: AnyNoContext;
+  type: Schema.Schema.AnyNoContext;
   cause?: unknown;
 }> {}
diff --git a/packages/hypergraph/src/entity/findMany.ts b/packages/hypergraph/src/entity/findMany.ts
index 04250255..5640b848 100644
--- a/packages/hypergraph/src/entity/findMany.ts
+++ b/packages/hypergraph/src/entity/findMany.ts
@@ -1,14 +1,16 @@
 import type { DocHandle, Patch } from '@automerge/automerge-repo';
-import * as Schema from 'effect/Schema';
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { TypeIdsSymbol } from '../constants.js';
 import { deepMerge } from '../utils/internal/deep-merge.js';
-import { isRelationField } from '../utils/isRelationField.js';
 import { canonicalize } from '../utils/jsc.js';
 import { decodedEntitiesCache, type DecodedEntitiesCacheEntry, type QueryEntry } from './decodedEntitiesCache.js';
+import { decodeFromGrc20Json } from './entity.js';
 import { entityRelationParentsMap } from './entityRelationParentsMap.js';
 import { getEntityRelations } from './getEntityRelations.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
 import type {
-  AnyNoContext,
   CrossFieldFilter,
   DocumentContent,
   Entity,
@@ -84,11 +86,14 @@ const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
         const relations = getEntityRelations(entityId, cacheEntry.type, doc, includeFromAllQueries);
         let decoded: unknown | undefined;
         try {
-          decoded = cacheEntry.decoder({
+          decoded = decodeFromGrc20Json(cacheEntry.type, {
             ...entity,
-            ...relations,
             id: entityId,
           });
+          decoded = {
+            ...decoded,
+            ...relations,
+          };
           cacheEntry.entities.set(entityId, decoded);
         } catch (error) {
           // TODO: store the corrupt entity ids somewhere, so they can be read via the API
@@ -105,7 +110,6 @@ const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
               }
             }
           }
-
           // it's fine to remove all of them since they are re-added below
           for (const deletedRelationId of deletedRelationIds) {
             const deletedRelationEntry = entityRelationParentsMap.get(deletedRelationId);
@@ -235,16 +239,15 @@ const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
 /**
  * Queries for a list of entities of the given type from the repo.
  */
-export function findMany<const S extends AnyNoContext>(
+export function findMany<const S extends Schema.Schema.AnyNoContext>(
   handle: DocHandle<DocumentContent>,
   type: S,
   filter: EntityFilter<Schema.Schema.Type<S>> | undefined,
   include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
 ): { entities: Readonly<Array<Entity<S>>>; corruptEntityIds: Readonly<Array<string>> } {
-  const decode = Schema.decodeUnknownSync(type);
-  // TODO: what's the right way to get the name of the type?
-  // @ts-expect-error name is defined
-  const typeName = type.name;
+  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+    Option.getOrElse(() => []),
+  );
 
   const doc = handle.doc();
   if (!doc) {
@@ -357,10 +360,20 @@ export function findMany<const S extends AnyNoContext>(
 
   for (const id in entities) {
     const entity = entities[id];
-    if (hasValidTypesProperty(entity) && entity['@@types@@'].includes(typeName)) {
+    if (
+      hasValidTypesProperty(entity) &&
+      typeIds.every((typeId) => {
+        return entity['@@types@@'].includes(typeId);
+      })
+    ) {
       const relations = getEntityRelations(id, type, doc, include);
       try {
-        const decoded = { ...decode({ ...entity, ...relations, id }), type: typeName };
+        let decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
+        decoded = {
+          ...decoded,
+          ...relations,
+        };
+
         if (filter) {
           if (evaluateEntityFilter(filter, decoded)) {
             // injecting the schema to the entity to be able to access it in the preparePublish function
@@ -390,25 +403,24 @@ export function findMany<const S extends AnyNoContext>(
 
 const stableEmptyArray: Array<unknown> = [];
 
-export type FindManySubscription<S extends AnyNoContext> = {
+export type FindManySubscription<S extends Schema.Schema.AnyNoContext> = {
   subscribe: (callback: () => void) => () => void;
   getEntities: () => Readonly<Array<Entity<S>>>;
 };
 
-export function subscribeToFindMany<const S extends AnyNoContext>(
+export function subscribeToFindMany<const S extends Schema.Schema.AnyNoContext>(
   handle: DocHandle<DocumentContent>,
   type: S,
   filter: { [K in keyof Schema.Schema.Type<S>]?: EntityFieldFilter<Schema.Schema.Type<S>[K]> } | undefined,
   include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
 ): FindManySubscription<S> {
   const queryKey = filter ? canonicalize(filter) : 'all';
-  const decode = Schema.decodeUnknownSync(type);
-  // TODO: what's the right way to get the name of the type?
-  // @ts-expect-error name is defined
-  const typeName = type.name;
+  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+    Option.getOrElse(() => []),
+  );
 
   const getEntities = () => {
-    const cacheEntry = decodedEntitiesCache.get(typeName);
+    const cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
     if (!cacheEntry) return stableEmptyArray;
 
     const query = cacheEntry.queries.get(queryKey);
@@ -432,15 +444,15 @@ export function subscribeToFindMany<const S extends AnyNoContext>(
     return query.data;
   };
 
-  const allTypes = new Set<S>();
-  for (const [_key, field] of Object.entries(type.fields)) {
-    if (isRelationField(field)) {
-      allTypes.add(field as S);
-    }
-  }
+  // const allTypes = new Set<S>();
+  // for (const [_key, field] of Object.entries(type.fields)) {
+  //   if (isRelationField(field)) {
+  //     allTypes.add(field as S);
+  //   }
+  // }
 
   const subscribe = (callback: () => void) => {
-    let cacheEntry = decodedEntitiesCache.get(typeName);
+    let cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
 
     if (!cacheEntry) {
       const entitiesMap = new Map();
@@ -454,14 +466,13 @@ export function subscribeToFindMany<const S extends AnyNoContext>(
       });
 
       cacheEntry = {
-        decoder: decode,
         type,
         entities: entitiesMap,
         queries,
         isInvalidated: true,
       };
 
-      decodedEntitiesCache.set(typeName, cacheEntry);
+      decodedEntitiesCache.set(canonicalize(typeIds), cacheEntry);
     }
 
     let query = cacheEntry.queries.get(queryKey);
@@ -481,7 +492,7 @@ export function subscribeToFindMany<const S extends AnyNoContext>(
     }
 
     return () => {
-      const cacheEntry = decodedEntitiesCache.get(typeName);
+      const cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
       if (cacheEntry) {
         // first cleanup the queries
         const query = cacheEntry.queries.get(queryKey);
@@ -496,14 +507,14 @@ export function subscribeToFindMany<const S extends AnyNoContext>(
           entityRelationParentsMap.forEach((relationCacheEntries, key) => {
             for (const [relationCacheEntry, counter] of relationCacheEntries) {
               if (relationCacheEntry === cacheEntry && counter === 0) {
-                relationCacheEntries.delete(cacheEntry);
+                // relationCacheEntries.delete(cacheEntry);
               }
             }
             if (relationCacheEntries.size === 0) {
               entityRelationParentsMap.delete(key);
             }
           });
-          decodedEntitiesCache.delete(typeName);
+          decodedEntitiesCache.delete(canonicalize(typeIds));
         }
       }
 
diff --git a/packages/hypergraph/src/entity/findManyNew.ts b/packages/hypergraph/src/entity/findManyNew.ts
deleted file mode 100644
index 372c5666..00000000
--- a/packages/hypergraph/src/entity/findManyNew.ts
+++ /dev/null
@@ -1,535 +0,0 @@
-import type { DocHandle, Patch } from '@automerge/automerge-repo';
-import * as Option from 'effect/Option';
-import type * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-import { TypeIdsSymbol } from '../constants.js';
-import { deepMerge } from '../utils/internal/deep-merge.js';
-import { canonicalize } from '../utils/jsc.js';
-import { decodedEntitiesCache, type DecodedEntitiesCacheEntry, type QueryEntry } from './decodedEntitiesCacheNew.js';
-import { decodeFromGrc20Json } from './entity-new.js';
-import { entityRelationParentsMap } from './entityRelationParentsMap.js';
-import { getEntityRelationsNew } from './getEntityRelationsNew.js';
-import { hasValidTypesProperty } from './hasValidTypesProperty.js';
-import type {
-  CrossFieldFilter,
-  DocumentContent,
-  EntityFieldFilter,
-  EntityFilter,
-  EntityNew,
-  EntityNumberFilter,
-  EntityStringFilter,
-} from './types.js';
-
-const documentChangeListener: {
-  subscribedQueriesCount: number;
-  unsubscribe: undefined | (() => void);
-} = {
-  subscribedQueriesCount: 0,
-  unsubscribe: undefined,
-};
-
-const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
-  const onChange = ({ patches, doc }: { patches: Array<Patch>; doc: DocumentContent }) => {
-    const changedRelations = new Set<string>();
-    const deletedRelations = new Set<string>();
-    const changedEntities = new Set<string>();
-    const deletedEntities = new Set<string>();
-
-    for (const patch of patches) {
-      switch (patch.action) {
-        case 'put':
-        case 'insert':
-        case 'splice': {
-          if (patch.path.length > 2 && patch.path[0] === 'entities' && typeof patch.path[1] === 'string') {
-            changedEntities.add(patch.path[1]);
-          }
-          if (patch.path.length > 2 && patch.path[0] === 'relations' && typeof patch.path[1] === 'string') {
-            changedRelations.add(patch.path[1]);
-          }
-          break;
-        }
-        case 'del': {
-          if (patch.path.length === 2 && patch.path[0] === 'entities' && typeof patch.path[1] === 'string') {
-            deletedEntities.add(patch.path[1]);
-          }
-          if (patch.path.length === 2 && patch.path[0] === 'relations' && typeof patch.path[1] === 'string') {
-            deletedRelations.add(patch.path[1]);
-          }
-          break;
-        }
-      }
-    }
-
-    const entityTypes = new Set<string>();
-    // collect all query entries that changed and only at the end make one copy to change the
-    // reference to reduce the amount of O(n) operations per query to 1
-    const touchedQueries = new Set<Array<string>>();
-
-    // collect all entities that used this entity as a entry in on of their relation fields
-    const touchedRelationParents = new Set<DecodedEntitiesCacheEntry>();
-
-    // loop over all changed entities and update the cache
-    for (const entityId of changedEntities) {
-      const entity = doc.entities?.[entityId];
-      if (!hasValidTypesProperty(entity)) continue;
-      for (const typeName of entity['@@types@@']) {
-        if (typeof typeName !== 'string') continue;
-        const cacheEntry = decodedEntitiesCache.get(typeName);
-        if (!cacheEntry) continue;
-
-        let includeFromAllQueries = {};
-        for (const [, query] of cacheEntry.queries) {
-          includeFromAllQueries = deepMerge(includeFromAllQueries, query.include);
-        }
-
-        const oldDecodedEntry = cacheEntry.entities.get(entityId);
-        const relations = getEntityRelationsNew(entityId, cacheEntry.type, doc, includeFromAllQueries);
-        let decoded: unknown | undefined;
-        try {
-          decoded = decodeFromGrc20Json(cacheEntry.type, {
-            ...entity,
-            id: entityId,
-          });
-          decoded = {
-            ...decoded,
-            ...relations,
-          };
-          cacheEntry.entities.set(entityId, decoded);
-        } catch (error) {
-          // TODO: store the corrupt entity ids somewhere, so they can be read via the API
-          console.error('error', error);
-        }
-
-        if (oldDecodedEntry) {
-          // collect all the Ids for relation entries in the `oldDecodedEntry`
-          const deletedRelationIds = new Set<string>();
-          for (const [, value] of Object.entries(oldDecodedEntry)) {
-            if (Array.isArray(value)) {
-              for (const relationEntity of value) {
-                deletedRelationIds.add(relationEntity.id);
-              }
-            }
-          }
-          // it's fine to remove all of them since they are re-added below
-          for (const deletedRelationId of deletedRelationIds) {
-            const deletedRelationEntry = entityRelationParentsMap.get(deletedRelationId);
-            if (deletedRelationEntry) {
-              deletedRelationEntry.set(cacheEntry, (deletedRelationEntry.get(cacheEntry) ?? 0) - 1);
-              if (deletedRelationEntry.get(cacheEntry) === 0) {
-                deletedRelationEntry.delete(cacheEntry);
-              }
-              if (deletedRelationEntry.size === 0) {
-                entityRelationParentsMap.delete(deletedRelationId);
-              }
-            }
-          }
-        }
-
-        if (decoded) {
-          for (const [, value] of Object.entries(decoded)) {
-            if (Array.isArray(value)) {
-              for (const relationEntity of value) {
-                let relationParentEntry = entityRelationParentsMap.get(relationEntity.id);
-                if (relationParentEntry) {
-                  relationParentEntry.set(cacheEntry, (relationParentEntry.get(cacheEntry) ?? 0) + 1);
-                } else {
-                  relationParentEntry = new Map();
-                  entityRelationParentsMap.set(relationEntity.id, relationParentEntry);
-                  relationParentEntry.set(cacheEntry, 1);
-                }
-              }
-            }
-          }
-        }
-
-        for (const [queryKey, query] of cacheEntry.queries) {
-          touchedQueries.add([typeName, queryKey]);
-          query.isInvalidated = true;
-        }
-
-        entityTypes.add(typeName);
-
-        // gather all the decodedEntitiesCacheEntries that have a relation to this entity to
-        // invoke their query listeners below
-        if (entityRelationParentsMap.has(entityId)) {
-          const decodedEntitiesCacheEntries = entityRelationParentsMap.get(entityId);
-          if (!decodedEntitiesCacheEntries) return;
-
-          for (const [entry] of decodedEntitiesCacheEntries) {
-            touchedRelationParents.add(entry);
-          }
-        }
-      }
-    }
-
-    // loop over all deleted entities and remove them from the cache
-    for (const entityId of deletedEntities) {
-      for (const [affectedTypeName, cacheEntry] of decodedEntitiesCache) {
-        if (cacheEntry.entities.has(entityId)) {
-          entityTypes.add(affectedTypeName);
-          cacheEntry.entities.delete(entityId);
-
-          for (const [queryKey, query] of cacheEntry.queries) {
-            // find the entity in the query and remove it using splice
-            const index = query.data.findIndex((entity) => entity.id === entityId);
-            if (index !== -1) {
-              query.data.splice(index, 1);
-              touchedQueries.add([affectedTypeName, queryKey]);
-            }
-          }
-        }
-      }
-
-      // gather all the queries of impacted parent relation queries and then remove the cacheEntry
-      if (entityRelationParentsMap.has(entityId)) {
-        const decodedEntitiesCacheEntries = entityRelationParentsMap.get(entityId);
-        if (!decodedEntitiesCacheEntries) return;
-
-        for (const [entry] of decodedEntitiesCacheEntries) {
-          touchedRelationParents.add(entry);
-        }
-
-        entityRelationParentsMap.delete(entityId);
-      }
-    }
-
-    // update the queries affected queries
-    for (const [typeName, queryKey] of touchedQueries) {
-      const cacheEntry = decodedEntitiesCache.get(typeName);
-      if (!cacheEntry) continue;
-
-      const query = cacheEntry.queries.get(queryKey);
-      if (!query) continue;
-
-      query.data = [...query.data]; // must be a new reference for React.useSyncExternalStore
-    }
-
-    // invoke all the listeners per type
-    for (const typeName of entityTypes) {
-      const cacheEntry = decodedEntitiesCache.get(typeName);
-      if (!cacheEntry) continue;
-
-      for (const query of cacheEntry.queries.values()) {
-        for (const listener of query.listeners) {
-          listener();
-        }
-      }
-    }
-
-    // trigger all the listeners of the parent relation queries
-    for (const decodedEntitiesCacheEntry of touchedRelationParents) {
-      decodedEntitiesCacheEntry.isInvalidated = true;
-      for (const query of decodedEntitiesCacheEntry.queries.values()) {
-        query.isInvalidated = true;
-        for (const listener of query.listeners) {
-          listener();
-        }
-      }
-    }
-  };
-
-  handle.on('change', onChange);
-
-  return () => {
-    handle.off('change', onChange);
-    decodedEntitiesCache.clear(); // currently we only support exactly one space
-  };
-};
-
-/**
- * Queries for a list of entities of the given type from the repo.
- */
-export function findManyNew<const S extends Schema.Schema.AnyNoContext>(
-  handle: DocHandle<DocumentContent>,
-  type: S,
-  filter: EntityFilter<Schema.Schema.Type<S>> | undefined,
-  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
-): { entities: Readonly<Array<EntityNew<S>>>; corruptEntityIds: Readonly<Array<string>> } {
-  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
-    Option.getOrElse(() => []),
-  );
-
-  const doc = handle.doc();
-  if (!doc) {
-    return { entities: [], corruptEntityIds: [] };
-  }
-  const entities = doc.entities ?? {};
-  const corruptEntityIds: string[] = [];
-  const filtered: Array<EntityNew<S>> = [];
-
-  const evaluateFilter = <T>(fieldFilter: EntityFieldFilter<T>, fieldValue: T): boolean => {
-    if ('not' in fieldFilter || 'or' in fieldFilter) {
-      throw new Error("Logical operators 'not', 'or' are only allowed at the root (cross-field) level.");
-    }
-
-    // handle basic filters
-    if ('is' in fieldFilter) {
-      if (typeof fieldValue === 'boolean') {
-        return fieldValue === fieldFilter.is;
-      }
-      if (typeof fieldValue === 'number') {
-        return fieldValue === fieldFilter.is;
-      }
-      if (typeof fieldValue === 'string') {
-        return fieldValue === fieldFilter.is;
-      }
-    }
-
-    if (typeof fieldValue === 'number') {
-      if ('greaterThan' in fieldFilter) {
-        const numberFilter = fieldFilter as EntityNumberFilter;
-        if (numberFilter.greaterThan !== undefined && fieldValue <= numberFilter.greaterThan) {
-          return false;
-        }
-      }
-      if ('lessThan' in fieldFilter) {
-        const numberFilter = fieldFilter as EntityNumberFilter;
-        if (numberFilter.lessThan !== undefined && fieldValue >= numberFilter.lessThan) {
-          return false;
-        }
-      }
-    }
-
-    if (typeof fieldValue === 'string') {
-      if ('startsWith' in fieldFilter) {
-        const textFilter = fieldFilter as EntityStringFilter;
-        if (textFilter.startsWith !== undefined && !fieldValue.startsWith(textFilter.startsWith)) {
-          return false;
-        }
-      }
-      if ('endsWith' in fieldFilter) {
-        const textFilter = fieldFilter as EntityStringFilter;
-        if (textFilter.endsWith !== undefined && !fieldValue.endsWith(textFilter.endsWith)) {
-          return false;
-        }
-      }
-      if ('contains' in fieldFilter) {
-        const textFilter = fieldFilter as EntityStringFilter;
-        if (textFilter.contains !== undefined && !fieldValue.includes(textFilter.contains)) {
-          return false;
-        }
-      }
-    }
-
-    return true;
-  };
-
-  const evaluateCrossFieldFilter = (
-    crossFieldFilter: CrossFieldFilter<Schema.Schema.Type<S>>,
-    entity: EntityNew<S>,
-  ): boolean => {
-    // evaluate regular field filters with AND semantics
-    for (const fieldName in crossFieldFilter) {
-      if (fieldName === 'or' || fieldName === 'not') continue;
-      const fieldFilter = crossFieldFilter[fieldName];
-      if (!fieldFilter) continue;
-      const fieldValue = entity[fieldName];
-      if (!evaluateFilter(fieldFilter, fieldValue)) {
-        return false;
-      }
-    }
-
-    // evaluate nested OR at cross-field level (if present)
-    if (Array.isArray(crossFieldFilter.or)) {
-      const orSatisfied = crossFieldFilter.or.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
-      if (!orSatisfied) return false;
-    }
-
-    // evaluate nested NOT at cross-field level (if present)
-    if (crossFieldFilter.not && evaluateCrossFieldFilter(crossFieldFilter.not, entity)) {
-      return false;
-    }
-
-    return true;
-  };
-
-  const evaluateEntityFilter = (entityFilter: EntityFilter<Schema.Schema.Type<S>>, entity: EntityNew<S>): boolean => {
-    // handle top-level NOT operator
-    if ('not' in entityFilter && entityFilter.not) {
-      return !evaluateCrossFieldFilter(entityFilter.not, entity);
-    }
-
-    // handle top-level OR operator
-    if ('or' in entityFilter && Array.isArray(entityFilter.or)) {
-      return entityFilter.or.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
-    }
-
-    // evaluate regular field filters
-    return evaluateCrossFieldFilter(entityFilter, entity);
-  };
-
-  for (const id in entities) {
-    const entity = entities[id];
-    if (
-      hasValidTypesProperty(entity) &&
-      typeIds.every((typeId) => {
-        return entity['@@types@@'].includes(typeId);
-      })
-    ) {
-      const relations = getEntityRelationsNew(id, type, doc, include);
-      try {
-        let decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
-        decoded = {
-          ...decoded,
-          ...relations,
-        };
-
-        if (filter) {
-          if (evaluateEntityFilter(filter, decoded)) {
-            // injecting the schema to the entity to be able to access it in the preparePublish function
-            decoded.__schema = type;
-            filtered.push(decoded);
-          }
-        } else {
-          // injecting the schema to the entity to be able to access it in the preparePublish function
-          decoded.__schema = type;
-          filtered.push(decoded);
-        }
-      } catch (error) {
-        // rethrow in case it's filter error
-        if (
-          error instanceof Error &&
-          error.message.includes("Logical operators 'not', 'or' are only allowed at the root (cross-field) level")
-        ) {
-          throw error;
-        }
-        corruptEntityIds.push(id);
-      }
-    }
-  }
-
-  return { entities: filtered, corruptEntityIds: [] };
-}
-
-const stableEmptyArray: Array<unknown> = [];
-
-export type FindManySubscriptionNew<S extends Schema.Schema.AnyNoContext> = {
-  subscribe: (callback: () => void) => () => void;
-  getEntities: () => Readonly<Array<EntityNew<S>>>;
-};
-
-export function subscribeToFindManyNew<const S extends Schema.Schema.AnyNoContext>(
-  handle: DocHandle<DocumentContent>,
-  type: S,
-  filter: { [K in keyof Schema.Schema.Type<S>]?: EntityFieldFilter<Schema.Schema.Type<S>[K]> } | undefined,
-  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
-): FindManySubscriptionNew<S> {
-  const queryKey = filter ? canonicalize(filter) : 'all';
-  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
-    Option.getOrElse(() => []),
-  );
-
-  const getEntities = () => {
-    const cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
-    if (!cacheEntry) return stableEmptyArray;
-
-    const query = cacheEntry.queries.get(queryKey);
-    if (!query) return stableEmptyArray;
-
-    if (!cacheEntry.isInvalidated && !query.isInvalidated) {
-      return query.data;
-    }
-
-    const { entities } = findManyNew(handle, type, filter, include);
-
-    for (const entity of entities) {
-      cacheEntry?.entities.set(entity.id, entity);
-    }
-
-    // must be a new reference to ensure it can be used in React.useMemo
-    query.data = [...entities];
-    cacheEntry.isInvalidated = false;
-    query.isInvalidated = false;
-
-    return query.data;
-  };
-
-  // const allTypes = new Set<S>();
-  // for (const [_key, field] of Object.entries(type.fields)) {
-  //   if (isRelationField(field)) {
-  //     allTypes.add(field as S);
-  //   }
-  // }
-
-  const subscribe = (callback: () => void) => {
-    let cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
-
-    if (!cacheEntry) {
-      const entitiesMap = new Map();
-      const queries = new Map<string, QueryEntry>();
-
-      queries.set(queryKey, {
-        data: [],
-        listeners: [],
-        isInvalidated: true,
-        include: include ?? {},
-      });
-
-      cacheEntry = {
-        type,
-        entities: entitiesMap,
-        queries,
-        isInvalidated: true,
-      };
-
-      decodedEntitiesCache.set(canonicalize(typeIds), cacheEntry);
-    }
-
-    let query = cacheEntry.queries.get(queryKey);
-    if (!query) {
-      query = {
-        data: [],
-        listeners: [],
-        isInvalidated: true,
-        include: include ?? {},
-      };
-      // we just set up the query and expect it to correctly set itself up in findMany
-      cacheEntry.queries.set(queryKey, query);
-    }
-
-    if (query?.listeners) {
-      query.listeners.push(callback);
-    }
-
-    return () => {
-      const cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
-      if (cacheEntry) {
-        // first cleanup the queries
-        const query = cacheEntry.queries.get(queryKey);
-        if (query) {
-          query.listeners = query?.listeners?.filter((cachedListener) => cachedListener !== callback);
-          if (query.listeners.length === 0) {
-            cacheEntry.queries.delete(queryKey);
-          }
-        }
-        // if the last query is removed, cleanup the entityRelationParentsMap and remove the decodedEntitiesCacheEntry
-        if (cacheEntry.queries.size === 0) {
-          entityRelationParentsMap.forEach((relationCacheEntries, key) => {
-            for (const [relationCacheEntry, counter] of relationCacheEntries) {
-              if (relationCacheEntry === cacheEntry && counter === 0) {
-                // relationCacheEntries.delete(cacheEntry);
-              }
-            }
-            if (relationCacheEntries.size === 0) {
-              entityRelationParentsMap.delete(key);
-            }
-          });
-          decodedEntitiesCache.delete(canonicalize(typeIds));
-        }
-      }
-
-      documentChangeListener.subscribedQueriesCount--;
-      if (documentChangeListener.subscribedQueriesCount === 0) {
-        documentChangeListener.unsubscribe?.();
-        documentChangeListener.unsubscribe = undefined;
-      }
-    };
-  };
-
-  if (documentChangeListener.subscribedQueriesCount === 0) {
-    documentChangeListener.unsubscribe = subscribeToDocumentChanges(handle);
-  }
-  documentChangeListener.subscribedQueriesCount++;
-
-  return { subscribe, getEntities };
-}
diff --git a/packages/hypergraph/src/entity/findOne.ts b/packages/hypergraph/src/entity/findOne.ts
index 20f9bcdd..45f5288c 100644
--- a/packages/hypergraph/src/entity/findOne.ts
+++ b/packages/hypergraph/src/entity/findOne.ts
@@ -1,62 +1,29 @@
 import type { DocHandle } from '@automerge/automerge-repo';
 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 { TypeIdsSymbol } from '../constants.js';
-import { decodeFromGrc20Json } from './entity-new.js';
+import { decodeFromGrc20Json } from './entity.js';
 import { getEntityRelations } from './getEntityRelations.js';
-import { getEntityRelationsNew } from './getEntityRelationsNew.js';
 import { hasValidTypesProperty } from './hasValidTypesProperty.js';
-import type { AnyNoContext, DocumentContent, Entity, EntityNew } from './types.js';
+import type { DocumentContent, Entity } from './types.js';
 
-/**
- * Find the entity of the given type, with the given id, from the repo.
- */
-export const findOne = <const S extends AnyNoContext>(
+export const findOne = <const S extends Schema.Schema.AnyNoContext>(
   handle: DocHandle<DocumentContent>,
   type: S,
   include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined = undefined,
 ) => {
-  const decode = Schema.decodeUnknownSync(type);
-
-  // TODO: what's the right way to get the name of the type?
-  // @ts-expect-error name is defined
-  const typeName = type.name;
-
   return (id: string): Entity<S> | undefined => {
     // TODO: Instead of this insane filtering logic, we should be keeping track of the entities in
     // an index and store the decoded values instead of re-decoding over and over again.
     const doc = handle.doc();
     const entity = doc?.entities?.[id];
-    const relations = doc ? getEntityRelations(id, type, doc, include) : {};
-
-    if (hasValidTypesProperty(entity) && entity['@@types@@'].includes(typeName)) {
-      const decoded = { ...decode({ ...entity, id, ...relations }), type: typeName };
-      // injecting the schema to the entity to be able to access it in the preparePublish function
-      decoded.__schema = type;
-      return decoded;
-    }
-
-    return undefined;
-  };
-};
-
-export const findOneNew = <const S extends Schema.Schema.AnyNoContext>(
-  handle: DocHandle<DocumentContent>,
-  type: S,
-  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined = undefined,
-) => {
-  return (id: string): EntityNew<S> | undefined => {
-    // TODO: Instead of this insane filtering logic, we should be keeping track of the entities in
-    // an index and store the decoded values instead of re-decoding over and over again.
-    const doc = handle.doc();
-    const entity = doc?.entities?.[id];
 
     const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
       Option.getOrElse(() => []),
     );
 
-    const relations = doc ? getEntityRelationsNew(id, type, doc, include) : {};
+    const relations = doc ? getEntityRelations(id, type, doc, include) : {};
 
     if (hasValidTypesProperty(entity) && typeIds.every((typeId) => entity['@@types@@'].includes(typeId))) {
       const decoded = { ...decodeFromGrc20Json(type, { ...entity, id }) };
diff --git a/packages/hypergraph/src/entity/getEntityRelations.ts b/packages/hypergraph/src/entity/getEntityRelations.ts
index 2fc53f95..8da6a638 100644
--- a/packages/hypergraph/src/entity/getEntityRelations.ts
+++ b/packages/hypergraph/src/entity/getEntityRelations.ts
@@ -1,44 +1,50 @@
+import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
-import { isRelationField } from '../utils/isRelationField.js';
-import { hasValidTypesProperty } from './hasValidTypesProperty.js';
-import type { AnyNoContext, DocumentContent, Entity } from './types.js';
-export const getEntityRelations = <const S extends AnyNoContext>(
+import * as SchemaAST from 'effect/SchemaAST';
+import { PropertyIdSymbol, RelationSchemaSymbol } from '../constants.js';
+import { isRelation } from '../utils/isRelation.js';
+import { decodeFromGrc20Json } from './entity.js';
+import type { DocumentContent, Entity } from './types.js';
+
+export const getEntityRelations = <const S extends Schema.Schema.AnyNoContext>(
   entityId: string,
   type: S,
   doc: DocumentContent,
   include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
 ) => {
-  const relations: Record<string, Entity<AnyNoContext>> = {};
-  for (const [fieldName, field] of Object.entries(type.fields)) {
-    // skip non-relation fields or relations that are not defined in the include object
-    if (!isRelationField(field)) continue;
+  const relations: Record<string, Entity<Schema.Schema.AnyNoContext>> = {};
+  const ast = type.ast as SchemaAST.TypeLiteral;
+
+  for (const prop of ast.propertySignatures) {
+    if (!isRelation(prop.type)) continue;
 
+    // TODO: should we add an empty array for relations that are not included?
     // Currently we still add an empty array for relations that are not included.
     // This is to ensure that the relation is not undefined in the decoded entity.
     // In the future we might want to derive a schema based on the include object.
-    if (!include?.[fieldName]) {
-      relations[fieldName] = [];
-      continue;
-    }
+    // if (!include?.[fieldName]) {
+    //   relations[fieldName] = [];
+    //   continue;
+    // }
 
-    const relationEntities: Array<Entity<AnyNoContext>> = [];
+    const relationEntities: Array<Entity<Schema.Schema.AnyNoContext>> = [];
 
     for (const [relationId, relation] of Object.entries(doc.relations ?? {})) {
-      // @ts-expect-error name is defined
-      const typeName = type.name;
-
-      if (relation.fromTypeName !== typeName || relation.fromPropertyName !== fieldName || relation.from !== entityId)
-        continue;
-
-      if (relation.__deleted) continue;
-
-      const relationEntity = doc.entities?.[relation.to];
-      if (!hasValidTypesProperty(relationEntity)) continue;
-
-      relationEntities.push({ ...relationEntity, id: relation.to, _relation: { id: relationId } });
+      const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+      const schema = SchemaAST.getAnnotation<Schema.Schema.AnyNoContext>(RelationSchemaSymbol)(prop.type);
+      if (Option.isSome(result) && Option.isSome(schema)) {
+        if (relation.fromPropertyId !== result.value || relation.from !== entityId) continue;
+        if (relation.__deleted) continue;
+
+        const relationEntity = doc.entities?.[relation.to];
+        const decodedRelationEntity = { ...decodeFromGrc20Json(schema.value, { ...relationEntity, id: relation.to }) };
+        // TODO: should we check if the relation entity is valid?
+        // if (!hasValidTypesProperty(relationEntity)) continue;
+
+        relationEntities.push({ ...decodedRelationEntity, id: relation.to, _relation: { id: relationId } });
+      }
     }
-
-    relations[fieldName] = relationEntities;
+    relations[prop.name] = relationEntities;
   }
 
   return relations;
diff --git a/packages/hypergraph/src/entity/getEntityRelationsNew.ts b/packages/hypergraph/src/entity/getEntityRelationsNew.ts
deleted file mode 100644
index 98f0c66a..00000000
--- a/packages/hypergraph/src/entity/getEntityRelationsNew.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import * as Option from 'effect/Option';
-import type * as Schema from 'effect/Schema';
-import * as SchemaAST from 'effect/SchemaAST';
-import { PropertyIdSymbol, RelationSchemaSymbol } from '../constants.js';
-import { isRelation } from '../utils/isRelation.js';
-import { decodeFromGrc20Json } from './entity-new.js';
-import type { DocumentContent, EntityNew } from './types.js';
-export const getEntityRelationsNew = <const S extends Schema.Schema.AnyNoContext>(
-  entityId: string,
-  type: S,
-  doc: DocumentContent,
-  include: { [K in keyof Schema.Schema.Type<S>]?: Record<string, Record<string, never>> } | undefined,
-) => {
-  const relations: Record<string, EntityNew<Schema.Schema.AnyNoContext>> = {};
-  const ast = type.ast as SchemaAST.TypeLiteral;
-
-  for (const prop of ast.propertySignatures) {
-    if (!isRelation(prop.type)) continue;
-
-    // TODO: should we add an empty array for relations that are not included?
-    // Currently we still add an empty array for relations that are not included.
-    // This is to ensure that the relation is not undefined in the decoded entity.
-    // In the future we might want to derive a schema based on the include object.
-    // if (!include?.[fieldName]) {
-    //   relations[fieldName] = [];
-    //   continue;
-    // }
-
-    const relationEntities: Array<EntityNew<Schema.Schema.AnyNoContext>> = [];
-
-    for (const [relationId, relation] of Object.entries(doc.relations ?? {})) {
-      const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
-      const schema = SchemaAST.getAnnotation<Schema.Schema.AnyNoContext>(RelationSchemaSymbol)(prop.type);
-      if (Option.isSome(result) && Option.isSome(schema)) {
-        if (relation.fromPropertyId !== result.value || relation.from !== entityId) continue;
-        if (relation.__deleted) continue;
-
-        const relationEntity = doc.entities?.[relation.to];
-        const decodedRelationEntity = { ...decodeFromGrc20Json(schema.value, { ...relationEntity, id: relation.to }) };
-        // TODO: should we check if the relation entity is valid?
-        // if (!hasValidTypesProperty(relationEntity)) continue;
-
-        relationEntities.push({ ...decodedRelationEntity, id: relation.to, _relation: { id: relationId } });
-      }
-    }
-    relations[prop.name] = relationEntities;
-  }
-
-  return relations;
-};
diff --git a/packages/hypergraph/src/entity/index.ts b/packages/hypergraph/src/entity/index.ts
index 3ce71cd7..7db90700 100644
--- a/packages/hypergraph/src/entity/index.ts
+++ b/packages/hypergraph/src/entity/index.ts
@@ -1,8 +1,6 @@
 export * from './create.js';
 export * from './delete.js';
-export * from './entity.js';
 export * from './findMany.js';
-export * from './findManyNew.js';
 export * from './findOne.js';
 export * from './removeRelation.js';
 export * from './types.js';
diff --git a/packages/hypergraph/src/entity/type-new.ts b/packages/hypergraph/src/entity/type-new.ts
deleted file mode 100644
index 13bf529f..00000000
--- a/packages/hypergraph/src/entity/type-new.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { PropertyIdSymbol, RelationSchemaSymbol, RelationSymbol } from '../constants.js';
-
-/**
- * Creates a String schema with the specified GRC-20 property ID
- */
-// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const String = (propertyId: string) => {
-  return Schema.String.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
-};
-
-/**
- * Creates a Number schema with the specified GRC-20 property ID
- */
-// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const Number = (propertyId: string) => {
-  return Schema.Number.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
-};
-
-/**
- * Creates a Boolean schema with the specified GRC-20 property ID
- */
-// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const Boolean = (propertyId: string) => {
-  return Schema.Boolean.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
-};
-
-/**
- * Creates a Date schema with the specified GRC-20 property ID
- */
-// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const Date = (propertyId: string) => {
-  return Schema.Date.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
-};
-
-export const Relation =
-  <S extends Schema.Schema.AnyNoContext>(schema: S) =>
-  (propertyId: string) => {
-    return Schema.Array(schema).pipe(
-      Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema, [RelationSymbol]: true }),
-    );
-  };
-
-export const optional =
-  <S extends Schema.Schema.AnyNoContext>(schemaFn: (propertyId: string) => S) =>
-  (propertyId: string) => {
-    const innerSchema = schemaFn(propertyId);
-    return Schema.optional(innerSchema);
-  };
diff --git a/packages/hypergraph/src/entity/types.ts b/packages/hypergraph/src/entity/types.ts
index d4369e08..c526d506 100644
--- a/packages/hypergraph/src/entity/types.ts
+++ b/packages/hypergraph/src/entity/types.ts
@@ -1,34 +1,10 @@
 import type * as Schema from 'effect/Schema';
 
-export type Any = Schema.Schema.Any & {
-  readonly fields: Schema.Struct.Fields;
-  readonly insert: Schema.Schema.Any;
-  readonly update: Schema.Schema.Any;
-};
-
-export type AnyNoContext = Schema.Schema.AnyNoContext & {
-  readonly fields: Schema.Struct.Fields;
-  readonly insert: Schema.Schema.AnyNoContext;
-  readonly update: Schema.Schema.AnyNoContext;
-};
-
-export type Update<S extends Any> = S['update'];
-export type Insert<S extends Any> = S['insert'];
-
-export type Entity<S extends AnyNoContext> = Schema.Schema.Type<S> & {
-  type: string;
-  // TODO: can we solve this directly on the variante schema?
-  id: string;
-  // TODO: should we expose these internal fields?
-  // __deleted: boolean;
-  // __version: string;
-};
-
-export type EntityNew<S extends Schema.Schema.AnyNoContext> = Schema.Schema.Type<S> & {
+export type Entity<S extends Schema.Schema.AnyNoContext> = Schema.Schema.Type<S> & {
   id: string;
 };
 
-export type EntityWithRelation<S extends AnyNoContext> = Entity<S> & {
+export type EntityWithRelation<S extends Schema.Schema.AnyNoContext> = Entity<S> & {
   _relation: { id: string } | undefined;
 };
 
diff --git a/packages/hypergraph/src/entity/update.ts b/packages/hypergraph/src/entity/update.ts
index f88762e1..2295ad24 100644
--- a/packages/hypergraph/src/entity/update.ts
+++ b/packages/hypergraph/src/entity/update.ts
@@ -1,21 +1,19 @@
 import type { DocHandle } from '@automerge/automerge-repo';
 import * as Schema from 'effect/Schema';
-import { EntityNotFoundError } from './entity.js';
-import type { AnyNoContext, DocumentContent, Entity, Update } from './types.js';
+import { decodeFromGrc20Json, encodeToGrc20Json, EntityNotFoundError } from './entity.js';
+import type { DocumentContent, Entity } from './types.js';
 
 /**
  * Update an existing entity model of given type in the repo.
  */
-export const update = <const S extends AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
-  const validate = Schema.validateSync(Schema.partial(type.update));
-  const encode = Schema.encodeSync(type.update);
-  const decode = Schema.decodeUnknownSync(type.update);
+export const update = <const S extends Schema.Schema.AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
+  const validate = Schema.validateSync(Schema.partial(type));
 
   // TODO: what's the right way to get the name of the type?
   // @ts-expect-error name is defined
   const typeName = type.name;
 
-  return (id: string, data: Schema.Simplify<Partial<Schema.Schema.Type<Update<S>>>>): Entity<S> => {
+  return (id: string, data: Schema.Simplify<Partial<Schema.Schema.Type<S>>>): Entity<S> => {
     validate(data);
 
     // apply changes to the repo -> updates the existing entity to the repo entities document
@@ -32,10 +30,10 @@ export const update = <const S extends AnyNoContext>(handle: DocHandle<DocumentC
       }
 
       // TODO: Try to get a diff of the entity properties and only override the changed ones.
-      updated = { ...decode(entity), ...data };
+      updated = { ...decodeFromGrc20Json(type, entity), ...data };
 
       const encoded = {
-        ...encode(updated),
+        ...encodeToGrc20Json(type, updated),
         '@@types@@': [typeName],
         __deleted: entity.__deleted ?? false,
         __version: entity.__version ?? '',
diff --git a/packages/hypergraph/src/index.ts b/packages/hypergraph/src/index.ts
index 455d168d..1a105e7b 100644
--- a/packages/hypergraph/src/index.ts
+++ b/packages/hypergraph/src/index.ts
@@ -1,9 +1,8 @@
 export { Id } from '@graphprotocol/grc-20';
 export * as Typesync from './cli/services/Model.js';
 export * as Connect from './connect/index.js';
-export { Entity as EntityNew } from './entity/entity-new.js';
+export { EntitySchema } from './entity/entity.js';
 export * as Entity from './entity/index.js';
-export * as TypeNew from './entity/type-new.js';
 export * as Identity from './identity/index.js';
 export * as Inboxes from './inboxes/index.js';
 export * as Key from './key/index.js';
diff --git a/packages/hypergraph/src/type/type.ts b/packages/hypergraph/src/type/type.ts
index 0e9dcd1e..01b4c4f5 100644
--- a/packages/hypergraph/src/type/type.ts
+++ b/packages/hypergraph/src/type/type.ts
@@ -1,30 +1,58 @@
 import * as Schema from 'effect/Schema';
-import { Field } from '../entity/entity.js';
-import type { AnyNoContext, EntityWithRelation } from '../entity/types.js';
+import { PropertyIdSymbol, RelationSchemaSymbol, RelationSymbol } from '../constants.js';
 
+/**
+ * Creates a String schema with the specified GRC-20 property ID
+ */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const String = Schema.String;
+export const String = (propertyId: string) => {
+  return Schema.String.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
+
+/**
+ * Creates a Number schema with the specified GRC-20 property ID
+ */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const Number = Schema.Number;
+export const Number = (propertyId: string) => {
+  return Schema.Number.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
+
+/**
+ * Creates a Boolean schema with the specified GRC-20 property ID
+ */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const Boolean = Schema.Boolean;
+export const Boolean = (propertyId: string) => {
+  return Schema.Boolean.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
+
+/**
+ * Creates a Date schema with the specified GRC-20 property ID
+ */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
-export const Date = Schema.Date;
-export const Point = Schema.transform(Schema.String, Schema.Array(Number), {
-  strict: true,
-  decode: (str: string) => {
-    return str.split(',').map((n: string) => globalThis.Number(n));
-  },
-  encode: (points: readonly number[]) => points.join(','),
-});
+export const Date = (propertyId: string) => {
+  return Schema.Date.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+};
 
-export const optional = Schema.optional;
+export const Point = (propertyId: string) =>
+  Schema.transform(Schema.String, Schema.Array(Schema.Number), {
+    strict: true,
+    decode: (str: string) => {
+      return str.split(',').map((n: string) => globalThis.Number(n));
+    },
+    encode: (points: readonly number[]) => points.join(','),
+  }).pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
 
-export const Relation = <S extends AnyNoContext>(schema: S) => {
-  const relationSchema = Field({
-    select: Schema.Array(schema) as unknown as Schema.Schema<ReadonlyArray<EntityWithRelation<S>>>,
-    insert: Schema.optional(Schema.Array(Schema.String)),
-    update: Schema.Undefined,
-  });
-  return relationSchema;
-};
+export const Relation =
+  <S extends Schema.Schema.AnyNoContext>(schema: S) =>
+  (propertyId: string) => {
+    return Schema.Array(schema).pipe(
+      Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema, [RelationSymbol]: true }),
+    );
+  };
+
+export const optional =
+  <S extends Schema.Schema.AnyNoContext>(schemaFn: (propertyId: string) => S) =>
+  (propertyId: string) => {
+    const innerSchema = schemaFn(propertyId);
+    return Schema.optional(innerSchema);
+  };

From 3cece10e1ad7646571cec27379f6ae550373b755 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Mon, 29 Sep 2025 09:20:53 +0200
Subject: [PATCH 07/22] fix relation type

---
 packages/hypergraph/src/type/type.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/packages/hypergraph/src/type/type.ts b/packages/hypergraph/src/type/type.ts
index 01b4c4f5..f7125307 100644
--- a/packages/hypergraph/src/type/type.ts
+++ b/packages/hypergraph/src/type/type.ts
@@ -45,7 +45,10 @@ export const Point = (propertyId: string) =>
 export const Relation =
   <S extends Schema.Schema.AnyNoContext>(schema: S) =>
   (propertyId: string) => {
-    return Schema.Array(schema).pipe(
+    const schemaWithId = Schema.extend(
+      Schema.Struct({ id: Schema.String, _relation: Schema.Struct({ id: Schema.String }) }),
+    )(schema);
+    return Schema.Array(schemaWithId).pipe(
       Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema, [RelationSymbol]: true }),
     );
   };

From bcc83ac0b12bdcc1385e7ec81ff81f61c5f2cb76 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 30 Sep 2025 18:18:22 +0200
Subject: [PATCH 08/22] integrate public queryies without relations

---
 apps/events/src/components/playground.tsx     |  33 +----
 apps/events/src/components/projects.tsx       |  33 +++++
 apps/events/src/routes/playground.lazy.tsx    |   9 +-
 apps/events/src/schema.ts                     |  30 +++++
 .../src/components/playground.tsx             |  33 +----
 .../src/HypergraphAppContext.tsx              |   6 +-
 packages/hypergraph-react/src/index.ts        |   1 -
 .../src/internal/convert-property-value.ts    |  37 +++---
 .../src/internal/convert-relations.ts         |   8 +-
 .../internal/translate-filter-to-graphql.ts   | 111 ++++++++--------
 .../src/internal/use-create-entity-public.ts  | 105 ----------------
 .../src/internal/use-entity-public.tsx        |   2 +-
 .../src/internal/use-query-public.tsx         | 119 +++++++++++-------
 packages/hypergraph/src/constants.ts          |   2 +
 .../hypergraph/src/type-utils/type-utils.ts   |  20 +++
 packages/hypergraph/src/type/type.ts          |  19 +--
 16 files changed, 260 insertions(+), 308 deletions(-)
 create mode 100644 apps/events/src/components/projects.tsx
 delete mode 100644 packages/hypergraph-react/src/internal/use-create-entity-public.ts

diff --git a/apps/events/src/components/playground.tsx b/apps/events/src/components/playground.tsx
index 1ecaf4d9..a4f0ffed 100644
--- a/apps/events/src/components/playground.tsx
+++ b/apps/events/src/components/playground.tsx
@@ -1,10 +1,4 @@
-import {
-  _useCreateEntityPublic,
-  _useDeleteEntityPublic,
-  useHypergraphApp,
-  useQuery,
-  useSpace,
-} from '@graphprotocol/hypergraph-react';
+import { _useDeleteEntityPublic, useHypergraphApp, useQuery, useSpace } from '@graphprotocol/hypergraph-react';
 import { useState } from 'react';
 import { Event } from '../schema';
 import { Button } from './ui/button';
@@ -24,13 +18,11 @@ export const Playground = ({ spaceId }: { spaceId: string }) => {
     space: spaceId,
   });
   const [isDeleting, setIsDeleting] = useState(false);
-  const [isCreating, setIsCreating] = useState(false);
   const { getSmartSessionClient } = useHypergraphApp();
 
   const { name } = useSpace({ mode: 'public', space: spaceId });
 
   const deleteEntity = _useDeleteEntityPublic(Event, { space: spaceId });
-  const createEntity = _useCreateEntityPublic(Event, { space: spaceId });
 
   console.log({ isLoading, isError, data });
 
@@ -39,29 +31,6 @@ export const Playground = ({ spaceId }: { spaceId: string }) => {
       <h2 className="text-lg font-bold">Space: {name}</h2>
       {isLoading && <div>Loading...</div>}
       {isError && <div>Error</div>}
-      <Button
-        disabled={isCreating}
-        onClick={async () => {
-          setIsCreating(true);
-          const walletClient = await getSmartSessionClient();
-          if (!walletClient) {
-            alert('Wallet client not found');
-            setIsCreating(false);
-            return;
-          }
-          const { success, cid, txResult } = await createEntity(
-            {
-              name: 'Test Event 42 by Nik',
-              sponsors: [],
-            },
-            { walletClient },
-          );
-          console.log('created', { success, cid, txResult });
-          setIsCreating(false);
-        }}
-      >
-        Create
-      </Button>
       {data?.map((event) => (
         <div key={event.id}>
           <h2>{event.name}</h2>
diff --git a/apps/events/src/components/projects.tsx b/apps/events/src/components/projects.tsx
new file mode 100644
index 00000000..908343e4
--- /dev/null
+++ b/apps/events/src/components/projects.tsx
@@ -0,0 +1,33 @@
+import { useQuery } from '@graphprotocol/hypergraph-react';
+import { Project } from '../schema';
+
+export const Projects = ({ spaceId }: { spaceId: string }) => {
+  const { data, isLoading, isError } = useQuery(Project, {
+    mode: 'public',
+    // include: {
+    //   sponsors: {
+    //     jobOffers: {},
+    //   },
+    // },
+    // filter: {
+    //   or: [{ name: { startsWith: 'test' } }, { name: { startsWith: 'ETH' } }],
+    // },
+    first: 100,
+    space: spaceId,
+  });
+  console.log({ isLoading, isError, data });
+
+  return (
+    <div>
+      <h2 className="text-lg font-bold">Projects</h2>
+      {isLoading && <div>Loading...</div>}
+      {isError && <div>Error</div>}
+      {data?.map((project) => (
+        <div key={project.id}>
+          <h2>{project.name}</h2>
+          <pre className="text-xs">{JSON.stringify(project, null, 2)}</pre>
+        </div>
+      ))}
+    </div>
+  );
+};
diff --git a/apps/events/src/routes/playground.lazy.tsx b/apps/events/src/routes/playground.lazy.tsx
index a628da74..9ade330d 100644
--- a/apps/events/src/routes/playground.lazy.tsx
+++ b/apps/events/src/routes/playground.lazy.tsx
@@ -1,9 +1,9 @@
-import { HypergraphSpaceProvider } from '@graphprotocol/hypergraph-react';
-import { createLazyFileRoute } from '@tanstack/react-router';
 import { CreateEvents } from '@/components/create-events';
 import { CreatePropertiesAndTypesEvent } from '@/components/create-properties-and-types-event';
-import { Event } from '@/components/event';
 import { Playground } from '@/components/playground';
+import { Projects } from '@/components/projects';
+import { HypergraphSpaceProvider } from '@graphprotocol/hypergraph-react';
+import { createLazyFileRoute } from '@tanstack/react-router';
 
 export const Route = createLazyFileRoute('/playground')({
   component: RouteComponent,
@@ -13,8 +13,9 @@ function RouteComponent() {
   const space = 'a393e509-ae56-4d99-987c-bed71d9db631';
   return (
     <>
-      <Event spaceId={space} entityId="cf7c620b-d724-498f-b134-8280dc8249ae" />
+      {/* <Event spaceId={space} entityId="cf7c620b-d724-498f-b134-8280dc8249ae" /> */}
       <Playground spaceId={space} />
+      <Projects spaceId="3f32353d-3b27-4a13-b71a-746f06e1f7db" />
       <HypergraphSpaceProvider space={space}>
         <div className="flex flex-col gap-4 max-w-(--breakpoint-sm) mx-auto py-8">
           <h1 className="text-2xl font-bold">Playground</h1>
diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index 6ef13e89..f8aa091c 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -93,3 +93,33 @@ export const Event = EntitySchema(
     },
   },
 );
+
+export const Image = EntitySchema(
+  {
+    url: Type.String,
+  },
+  {
+    types: [Id('ba4e4146-0010-499d-a0a3-caaa7f579d0e')],
+    properties: {
+      url: Id('8a743832-c094-4a62-b665-0c3cc2f9c7bc'),
+    },
+  },
+);
+
+export const Project = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    x: Type.optional(Type.String),
+    // avatar: Type.Relation(Image),
+  },
+  {
+    types: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
+    properties: {
+      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'),
+    },
+  },
+);
diff --git a/apps/privy-login-example/src/components/playground.tsx b/apps/privy-login-example/src/components/playground.tsx
index 1ecaf4d9..a4f0ffed 100644
--- a/apps/privy-login-example/src/components/playground.tsx
+++ b/apps/privy-login-example/src/components/playground.tsx
@@ -1,10 +1,4 @@
-import {
-  _useCreateEntityPublic,
-  _useDeleteEntityPublic,
-  useHypergraphApp,
-  useQuery,
-  useSpace,
-} from '@graphprotocol/hypergraph-react';
+import { _useDeleteEntityPublic, useHypergraphApp, useQuery, useSpace } from '@graphprotocol/hypergraph-react';
 import { useState } from 'react';
 import { Event } from '../schema';
 import { Button } from './ui/button';
@@ -24,13 +18,11 @@ export const Playground = ({ spaceId }: { spaceId: string }) => {
     space: spaceId,
   });
   const [isDeleting, setIsDeleting] = useState(false);
-  const [isCreating, setIsCreating] = useState(false);
   const { getSmartSessionClient } = useHypergraphApp();
 
   const { name } = useSpace({ mode: 'public', space: spaceId });
 
   const deleteEntity = _useDeleteEntityPublic(Event, { space: spaceId });
-  const createEntity = _useCreateEntityPublic(Event, { space: spaceId });
 
   console.log({ isLoading, isError, data });
 
@@ -39,29 +31,6 @@ export const Playground = ({ spaceId }: { spaceId: string }) => {
       <h2 className="text-lg font-bold">Space: {name}</h2>
       {isLoading && <div>Loading...</div>}
       {isError && <div>Error</div>}
-      <Button
-        disabled={isCreating}
-        onClick={async () => {
-          setIsCreating(true);
-          const walletClient = await getSmartSessionClient();
-          if (!walletClient) {
-            alert('Wallet client not found');
-            setIsCreating(false);
-            return;
-          }
-          const { success, cid, txResult } = await createEntity(
-            {
-              name: 'Test Event 42 by Nik',
-              sponsors: [],
-            },
-            { walletClient },
-          );
-          console.log('created', { success, cid, txResult });
-          setIsCreating(false);
-        }}
-      >
-        Create
-      </Button>
       {data?.map((event) => (
         <div key={event.id}>
           <h2>{event.name}</h2>
diff --git a/packages/hypergraph-react/src/HypergraphAppContext.tsx b/packages/hypergraph-react/src/HypergraphAppContext.tsx
index e50eb65e..12829e27 100644
--- a/packages/hypergraph-react/src/HypergraphAppContext.tsx
+++ b/packages/hypergraph-react/src/HypergraphAppContext.tsx
@@ -1,10 +1,10 @@
 'use client';
 
-import { automergeWasmBase64 } from '@automerge/automerge/automerge.wasm.base64';
-import * as automerge from '@automerge/automerge/slim';
 import type { DocHandle } from '@automerge/automerge-repo';
-import { Repo } from '@automerge/automerge-repo/slim';
 import { RepoContext } from '@automerge/automerge-repo-react-hooks';
+import { Repo } from '@automerge/automerge-repo/slim';
+import { automergeWasmBase64 } from '@automerge/automerge/automerge.wasm.base64';
+import * as automerge from '@automerge/automerge/slim';
 import { Graph } from '@graphprotocol/grc-20';
 import {
   Connect,
diff --git a/packages/hypergraph-react/src/index.ts b/packages/hypergraph-react/src/index.ts
index b572db35..9e21031b 100644
--- a/packages/hypergraph-react/src/index.ts
+++ b/packages/hypergraph-react/src/index.ts
@@ -24,7 +24,6 @@ export {
 } from './HypergraphAppContext.js';
 export { HypergraphSpaceProvider } from './HypergraphSpaceContext.js';
 export { generateDeleteOps as _generateDeleteOps } from './internal/generate-delete-ops.js';
-export { useCreateEntityPublic as _useCreateEntityPublic } from './internal/use-create-entity-public.js';
 export { useDeleteEntityPublic as _useDeleteEntityPublic } from './internal/use-delete-entity-public.js';
 export { useEntityPublic as _useEntityPublic } from './internal/use-entity-public.js';
 export { useQueryPrivate as _useQueryPrivate } from './internal/use-query-private.js';
diff --git a/packages/hypergraph-react/src/internal/convert-property-value.ts b/packages/hypergraph-react/src/internal/convert-property-value.ts
index b74470cc..b93f9216 100644
--- a/packages/hypergraph-react/src/internal/convert-property-value.ts
+++ b/packages/hypergraph-react/src/internal/convert-property-value.ts
@@ -1,22 +1,27 @@
-import { TypeUtils } from '@graphprotocol/hypergraph';
-import type * as Schema from 'effect/Schema';
+import { PropertyTypeSymbol } from '@graphprotocol/hypergraph/constants';
+import * as Option from 'effect/Option';
+import * as SchemaAST from 'effect/SchemaAST';
 
 export const convertPropertyValue = (
   property: { propertyId: string; string: string; boolean: boolean; number: number; time: string; point: string },
-  key: string,
-  type: Schema.Schema.AnyNoContext,
+  type: SchemaAST.AST,
 ) => {
-  if (TypeUtils.isBooleanOrOptionalBooleanType(type.fields[key]) && property.boolean !== undefined) {
-    return Boolean(property.boolean);
+  const propertyType = SchemaAST.getAnnotation<string>(PropertyTypeSymbol)(type);
+  if (Option.isSome(propertyType)) {
+    if (propertyType.value === 'string') {
+      return property.string;
+    }
+    if (propertyType.value === 'boolean') {
+      return Boolean(property.boolean);
+    }
+    if (propertyType.value === 'point') {
+      return property.point;
+    }
+    if (propertyType.value === 'number') {
+      return Number(property.number);
+    }
+    if (propertyType.value === 'date') {
+      return property.time;
+    }
   }
-  if (TypeUtils.isPointOrOptionalPointType(type.fields[key]) && property.point !== undefined) {
-    return property.point;
-  }
-  if (TypeUtils.isDateOrOptionalDateType(type.fields[key]) && property.time !== undefined) {
-    return property.time;
-  }
-  if (TypeUtils.isNumberOrOptionalNumberType(type.fields[key]) && property.number !== undefined) {
-    return Number(property.number);
-  }
-  return property.string;
 };
diff --git a/packages/hypergraph-react/src/internal/convert-relations.ts b/packages/hypergraph-react/src/internal/convert-relations.ts
index 15456d48..794af743 100644
--- a/packages/hypergraph-react/src/internal/convert-relations.ts
+++ b/packages/hypergraph-react/src/internal/convert-relations.ts
@@ -1,4 +1,3 @@
-import type { Mapping } from '@graphprotocol/hypergraph';
 import type * as Schema from 'effect/Schema';
 import { convertPropertyValue } from './convert-property-value.js';
 
@@ -23,12 +22,7 @@ type RecursiveQueryEntity = {
   }[];
 };
 
-export const convertRelations = <S extends Schema.Schema.AnyNoContext>(
-  queryEntity: RecursiveQueryEntity,
-  type: S,
-  mappingEntry: Mapping.MappingEntry,
-  mapping: Mapping.Mapping,
-) => {
+export const convertRelations = <S extends Schema.Schema.AnyNoContext>(queryEntity: RecursiveQueryEntity, type: S) => {
   const rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {};
 
   for (const [key, relationId] of Object.entries(mappingEntry?.relations ?? {})) {
diff --git a/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts b/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
index 8ba1dfb9..d1da6e4d 100644
--- a/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
+++ b/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
@@ -1,6 +1,8 @@
 import { Graph } from '@graphprotocol/grc-20';
-import { type Entity, type Mapping, TypeUtils } from '@graphprotocol/hypergraph';
+import { type Entity, TypeUtils } from '@graphprotocol/hypergraph';
+import { PropertyIdSymbol } from '@graphprotocol/hypergraph/constants';
 import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 
 type GraphqlFilterEntry =
   | {
@@ -38,20 +40,11 @@ type GraphqlFilterEntry =
 export function translateFilterToGraphql<S extends Schema.Schema.AnyNoContext>(
   filter: { [K in keyof Schema.Schema.Type<S>]?: Entity.EntityFieldFilter<Schema.Schema.Type<S>[K]> } | undefined,
   type: S,
-  mapping: Mapping.Mapping,
 ): GraphqlFilterEntry {
   if (!filter) {
     return {};
   }
 
-  // @ts-expect-error TODO should use the actual type instead of the name in the mapping
-  const typeName = type.name;
-
-  const mappingEntry = mapping[typeName];
-  if (!mappingEntry) {
-    throw new Error(`Mapping entry for ${typeName} not found`);
-  }
-
   const graphqlFilter: GraphqlFilterEntry[] = [];
 
   for (const [fieldName, fieldFilter] of Object.entries(filter)) {
@@ -59,7 +52,7 @@ export function translateFilterToGraphql<S extends Schema.Schema.AnyNoContext>(
       graphqlFilter.push({
         or: fieldFilter.map(
           (filter: { [K in keyof Schema.Schema.Type<S>]?: Entity.EntityFieldFilter<Schema.Schema.Type<S>[K]> }) =>
-            translateFilterToGraphql(filter, type, mapping),
+            translateFilterToGraphql(filter, type),
         ),
       });
       continue;
@@ -67,64 +60,68 @@ export function translateFilterToGraphql<S extends Schema.Schema.AnyNoContext>(
 
     if (fieldName === 'not') {
       graphqlFilter.push({
-        not: translateFilterToGraphql(fieldFilter, type, mapping),
+        not: translateFilterToGraphql(fieldFilter, type),
       });
       continue;
     }
 
     if (!fieldFilter) continue;
 
-    const propertyId = mappingEntry?.properties?.[fieldName];
+    const ast = type.ast as SchemaAST.TypeLiteral;
+    const propertySignature = ast.propertySignatures.find((a) => a.name === fieldName);
+    if (!propertySignature) continue;
 
-    if (propertyId) {
-      if (
-        TypeUtils.isStringOrOptionalStringType(type.fields[fieldName]) &&
-        (fieldFilter.is || fieldFilter.startsWith || fieldFilter.endsWith || fieldFilter.contains)
-      ) {
-        graphqlFilter.push({
-          values: {
-            some: {
-              propertyId: { is: propertyId },
-              string: fieldFilter.is
-                ? { is: fieldFilter.is }
-                : fieldFilter.startsWith
-                  ? { startsWith: fieldFilter.startsWith }
-                  : fieldFilter.endsWith
-                    ? { endsWith: fieldFilter.endsWith }
-                    : { includes: fieldFilter.contains },
-            },
+    // find the property id for the field
+    const propertyId = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(propertySignature.type);
+    if (!propertyId) continue;
+
+    if (
+      TypeUtils.isStringOrOptionalStringType(type.fields[fieldName]) &&
+      (fieldFilter.is || fieldFilter.startsWith || fieldFilter.endsWith || fieldFilter.contains)
+    ) {
+      graphqlFilter.push({
+        values: {
+          some: {
+            propertyId: { is: propertyId },
+            string: fieldFilter.is
+              ? { is: fieldFilter.is }
+              : fieldFilter.startsWith
+                ? { startsWith: fieldFilter.startsWith }
+                : fieldFilter.endsWith
+                  ? { endsWith: fieldFilter.endsWith }
+                  : { includes: fieldFilter.contains },
           },
-        });
-      }
+        },
+      });
+    }
 
-      if (TypeUtils.isBooleanOrOptionalBooleanType(type.fields[fieldName]) && fieldFilter.is) {
-        graphqlFilter.push({
-          values: {
-            some: {
-              propertyId: { is: propertyId },
-              boolean: { is: fieldFilter.is },
-            },
+    if (TypeUtils.isBooleanOrOptionalBooleanType(type.fields[fieldName]) && fieldFilter.is) {
+      graphqlFilter.push({
+        values: {
+          some: {
+            propertyId: { is: propertyId },
+            boolean: { is: fieldFilter.is },
           },
-        });
-      }
+        },
+      });
+    }
 
-      if (
-        TypeUtils.isNumberOrOptionalNumberType(type.fields[fieldName]) &&
-        (fieldFilter.is || fieldFilter.greaterThan || fieldFilter.lessThan)
-      ) {
-        graphqlFilter.push({
-          values: {
-            some: {
-              propertyId: { is: propertyId },
-              number: fieldFilter.is
-                ? { is: Graph.serializeNumber(fieldFilter.is) }
-                : fieldFilter.greaterThan
-                  ? { greaterThan: Graph.serializeNumber(fieldFilter.greaterThan) }
-                  : { lessThan: Graph.serializeNumber(fieldFilter.lessThan) },
-            },
+    if (
+      TypeUtils.isNumberOrOptionalNumberType(type.fields[fieldName]) &&
+      (fieldFilter.is || fieldFilter.greaterThan || fieldFilter.lessThan)
+    ) {
+      graphqlFilter.push({
+        values: {
+          some: {
+            propertyId: { is: propertyId },
+            number: fieldFilter.is
+              ? { is: Graph.serializeNumber(fieldFilter.is) }
+              : fieldFilter.greaterThan
+                ? { greaterThan: Graph.serializeNumber(fieldFilter.greaterThan) }
+                : { lessThan: Graph.serializeNumber(fieldFilter.lessThan) },
           },
-        });
-      }
+        },
+      });
     }
   }
 
diff --git a/packages/hypergraph-react/src/internal/use-create-entity-public.ts b/packages/hypergraph-react/src/internal/use-create-entity-public.ts
deleted file mode 100644
index f5626458..00000000
--- a/packages/hypergraph-react/src/internal/use-create-entity-public.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { Graph, Id, type PropertiesParam, type RelationsParam } from '@graphprotocol/grc-20';
-import type { Connect } from '@graphprotocol/hypergraph';
-import { store, TypeUtils } from '@graphprotocol/hypergraph';
-import { useQueryClient } from '@tanstack/react-query';
-import { useSelector } from '@xstate/store/react';
-import type * as Schema from 'effect/Schema';
-import { publishOps } from '../publish-ops.js';
-
-type CreateEntityPublicParams = {
-  space: string;
-};
-
-export function useCreateEntityPublic<const S extends Schema.Schema.AnyNoContext>(
-  type: S,
-  { space }: CreateEntityPublicParams,
-) {
-  const mapping = useSelector(store, (state) => state.context.mapping);
-  const queryClient = useQueryClient();
-
-  return async (
-    data: Readonly<Schema.Schema.Type<S>>,
-    { walletClient }: { walletClient: Connect.SmartSessionClient },
-    // TODO: return the entity with this type: Promise<Entity.Entity<S>>
-  ) => {
-    try {
-      // @ts-expect-error TODO should use the actual type instead of the name in the mapping
-      const typeName = type.name;
-      const mappingEntry = mapping?.[typeName];
-      if (!mappingEntry) {
-        throw new Error(`Mapping entry for ${typeName} not found`);
-      }
-
-      const fields = type.fields;
-      const values: PropertiesParam = [];
-      for (const [key, value] of Object.entries(mappingEntry.properties || {})) {
-        if (data[key] === undefined) {
-          if (TypeUtils.isOptional(fields[key])) {
-            continue;
-          }
-          throw new Error(`Value for ${key} is undefined`);
-        }
-        let serializedValue: string = data[key];
-        if (TypeUtils.isBooleanOrOptionalBooleanType(fields[key])) {
-          serializedValue = Graph.serializeBoolean(data[key]);
-        } else if (TypeUtils.isDateOrOptionalDateType(fields[key])) {
-          serializedValue = Graph.serializeDate(data[key]);
-        } else if (TypeUtils.isPointOrOptionalPointType(fields[key])) {
-          serializedValue = Graph.serializePoint(data[key]);
-        } else if (TypeUtils.isNumberOrOptionalNumberType(fields[key])) {
-          serializedValue = Graph.serializeNumber(data[key]);
-        }
-
-        values.push({
-          property: Id(value),
-          value: serializedValue,
-        });
-      }
-
-      const relations: RelationsParam = {};
-      for (const [key, relationId] of Object.entries(mappingEntry.relations || {})) {
-        const toIds: { toEntity: Id }[] = [];
-
-        if (data[key]) {
-          // @ts-expect-error - TODO: fix the types error
-          for (const entity of data[key]) {
-            if (typeof entity === 'string') {
-              toIds.push({ toEntity: Id(entity) });
-            } else {
-              toIds.push({ toEntity: Id(entity.id) });
-            }
-          }
-          relations[Id(relationId)] = toIds;
-        }
-      }
-
-      const { ops } = Graph.createEntity({
-        types: mappingEntry.typeIds,
-        id: data.id,
-        values,
-        relations,
-      });
-
-      const { cid, txResult } = await publishOps({
-        ops,
-        space,
-        name: `Create entity ${data.id}`,
-        walletClient,
-      });
-      // TODO: temporary fix until we get the information from the API when a transaction is confirmed
-      await new Promise((resolve) => setTimeout(resolve, 2000));
-      queryClient.invalidateQueries({
-        queryKey: [
-          'hypergraph-public-entities',
-          // @ts-expect-error - TODO: find a better way to access the type.name
-          type.name,
-          space,
-        ],
-      });
-      return { success: true, cid, txResult };
-    } catch (error) {
-      console.error(error);
-      return { success: false, error: 'Failed to create entity' };
-    }
-  };
-}
diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index 0f6a82c2..b5f27ecf 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -183,7 +183,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(
   for (const [key, value] of Object.entries(mappingEntry?.properties ?? {})) {
     const property = queryEntity.valuesList.find((a) => a.propertyId === value);
     if (property) {
-      rawEntity[key] = convertPropertyValue(property, key, type);
+      rawEntity[key] = convertPropertyValue(property, type);
     }
   }
 
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index a631829e..d9afafcb 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -1,13 +1,15 @@
 import { Graph } from '@graphprotocol/grc-20';
-import { type Entity, type Mapping, store } from '@graphprotocol/hypergraph';
+import type { Entity } from '@graphprotocol/hypergraph';
+import { PropertyIdSymbol, TypeIdsSymbol } from '@graphprotocol/hypergraph/constants';
+import { isRelation } from '@graphprotocol/hypergraph/utils/isRelation';
 import { useQuery as useQueryTanstack } from '@tanstack/react-query';
-import { useSelector } from '@xstate/store/react';
 import * as Either from 'effect/Either';
+import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import { gql, request } from 'graphql-request';
 import { useMemo } from 'react';
 import { convertPropertyValue } from './convert-property-value.js';
-import { convertRelations } from './convert-relations.js';
 import { translateFilterToGraphql } from './translate-filter-to-graphql.js';
 import type { QueryPublicParams } from './types.js';
 import { useHypergraphSpaceInternal } from './use-hypergraph-space-internal.js';
@@ -178,13 +180,9 @@ type EntityQueryResult = {
   }[];
 };
 
-export const parseResult = <S extends Schema.Schema.AnyNoContext>(
-  queryData: EntityQueryResult,
-  type: S,
-  mappingEntry: Mapping.MappingEntry,
-  mapping: Mapping.Mapping,
-) => {
-  const decode = Schema.decodeUnknownEither(type);
+export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: EntityQueryResult, type: S) => {
+  const schemaWithId = Schema.extend(Schema.Struct({ id: Schema.String }))(type);
+  const decode = Schema.decodeUnknownEither(schemaWithId);
   const data: Entity.Entity<S>[] = [];
   const invalidEntities: Record<string, unknown>[] = [];
 
@@ -193,17 +191,26 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(
       id: queryEntity.id,
     };
 
-    // take the mappingEntry and assign the attributes to the rawEntity
-    for (const [key, value] of Object.entries(mappingEntry?.properties ?? {})) {
-      const property = queryEntity.valuesList.find((a) => a.propertyId === value);
-      if (property) {
-        rawEntity[key] = convertPropertyValue(property, key, type);
+    const ast = type.ast as SchemaAST.TypeLiteral;
+
+    for (const prop of ast.propertySignatures) {
+      const propType = prop.isOptional ? prop.type.types[0] : prop.type;
+      const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(propType);
+
+      if (Option.isSome(result)) {
+        const value = queryEntity.valuesList.find((a) => a.propertyId === result.value);
+        if (value) {
+          const rawValue = convertPropertyValue(value, propType);
+          if (rawValue) {
+            rawEntity[String(prop.name)] = rawValue;
+          }
+        }
       }
     }
 
     rawEntity = {
       ...rawEntity,
-      ...convertRelations(queryEntity, type, mappingEntry, mapping),
+      // ...convertRelations(queryEntity, type),
     };
 
     const decodeResult = decode({
@@ -214,6 +221,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(
     });
 
     if (Either.isRight(decodeResult)) {
+      // TODO: do we need __schema here?
       data.push({ ...decodeResult.right, __schema: type });
     } else {
       invalidEntities.push(rawEntity);
@@ -226,39 +234,46 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
   const { enabled = true, filter, include, space: spaceFromParams, first = 100 } = params ?? {};
   const { space: spaceFromContext } = useHypergraphSpaceInternal();
   const space = spaceFromParams ?? spaceFromContext;
-  const mapping = useSelector(store, (state) => state.context.mapping);
-
-  // @ts-expect-error TODO should use the actual type instead of the name in the mapping
-  const typeName = type.name;
-  const mappingEntry = mapping?.[typeName];
-  if (enabled && !mappingEntry) {
-    throw new Error(`Mapping entry for ${typeName} not found`);
-  }
 
   // constructing the relation type ids for the query
   const relationTypeIdsLevel1: string[] = [];
   const relationTypeIdsLevel2: string[] = [];
-  for (const key in mappingEntry?.relations ?? {}) {
-    if (include?.[key] && mappingEntry?.relations?.[key]) {
-      relationTypeIdsLevel1.push(mappingEntry?.relations?.[key]);
-      const field = type.fields[key];
-      // @ts-expect-error TODO find a better way to access the relation type name
-      const typeName2 = field.value.name;
-      const mappingEntry2 = mapping[typeName2];
-      for (const key2 in mappingEntry2?.relations ?? {}) {
-        if (include?.[key][key2] && mappingEntry2?.relations?.[key2]) {
-          relationTypeIdsLevel2.push(mappingEntry2?.relations?.[key2]);
-        }
-      }
+
+  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+    Option.getOrElse(() => []),
+  );
+
+  const ast = type.ast as SchemaAST.TypeLiteral;
+
+  for (const prop of ast.propertySignatures) {
+    if (!isRelation(prop.type)) continue;
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+    if (Option.isSome(result)) {
+      relationTypeIdsLevel1.push(result.value);
     }
   }
 
+  // for (const key in mappingEntry?.relations ?? {}) {
+  //   if (include?.[key] && mappingEntry?.relations?.[key]) {
+  //     relationTypeIdsLevel1.push(mappingEntry?.relations?.[key]);
+  //     const field = type.fields[key];
+  //     // @ts-expect-error TODO find a better way to access the relation type name
+  //     const typeName2 = field.value.name;
+  //     const mappingEntry2 = mapping[typeName2];
+  //     for (const key2 in mappingEntry2?.relations ?? {}) {
+  //       if (include?.[key][key2] && mappingEntry2?.relations?.[key2]) {
+  //         relationTypeIdsLevel2.push(mappingEntry2?.relations?.[key2]);
+  //       }
+  //     }
+  //   }
+  // }
+
   const result = useQueryTanstack({
     queryKey: [
       'hypergraph-public-entities',
-      typeName,
+      'TODO: type name',
       space,
-      mappingEntry?.typeIds,
+      typeIds,
       relationTypeIdsLevel1,
       relationTypeIdsLevel2,
       filter,
@@ -275,11 +290,11 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
 
       const result = await request<EntityQueryResult>(`${Graph.TESTNET_API_ORIGIN}/graphql`, queryDocument, {
         spaceId: space,
-        typeIds: mappingEntry?.typeIds || [],
+        typeIds,
         relationTypeIdsLevel1,
         relationTypeIdsLevel2,
         first,
-        filter: filter ? translateFilterToGraphql(filter, type, mapping) : {},
+        filter: filter ? translateFilterToGraphql(filter, type) : {},
       });
       return result;
     },
@@ -287,11 +302,29 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
   });
 
   const { data, invalidEntities } = useMemo(() => {
-    if (result.data && mappingEntry) {
-      return parseResult(result.data, type, mappingEntry, mapping);
+    if (result.data) {
+      return parseResult(result.data, type);
     }
     return { data: [], invalidEntities: [] };
-  }, [result.data, type, mappingEntry, mapping]);
+  }, [result.data, type]);
 
   return { ...result, data, invalidEntities };
 };
+
+// const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+//   Option.getOrElse(() => []),
+// );
+
+// const out: Record<string, unknown> = {};
+
+// for (const prop of ast.propertySignatures) {
+//   const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+//   if (Option.isSome(result)) {
+//     const grc20Key = result.value;
+//     if (grc20Key in grc20Data && typeof prop.name === 'string') {
+//       out[prop.name] = (grc20Data as any)[grc20Key];
+//     }
+//   }
+// }
+
+// out.id = grc20Data.id as string;
diff --git a/packages/hypergraph/src/constants.ts b/packages/hypergraph/src/constants.ts
index f9a86df8..10f48f46 100644
--- a/packages/hypergraph/src/constants.ts
+++ b/packages/hypergraph/src/constants.ts
@@ -5,3 +5,5 @@ export const TypeIdsSymbol = Symbol.for('grc-20/type/ids');
 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');
diff --git a/packages/hypergraph/src/type-utils/type-utils.ts b/packages/hypergraph/src/type-utils/type-utils.ts
index 6b590b99..ebcf4ad1 100644
--- a/packages/hypergraph/src/type-utils/type-utils.ts
+++ b/packages/hypergraph/src/type-utils/type-utils.ts
@@ -44,3 +44,23 @@ export const isPointOrOptionalPointType = (type: any) => {
 export const isOptional = (type: any) => {
   return type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional;
 };
+
+export const isStringType = (type: any) => {
+  return type === Type.String;
+};
+
+export const isNumberType = (type: any) => {
+  return type === Type.Number;
+};
+
+export const isDateType = (type: any) => {
+  return type === Type.Date;
+};
+
+export const isBooleanType = (type: any) => {
+  return type === Type.Boolean;
+};
+
+export const isPointType = (type: any) => {
+  return type === Type.Point;
+};
diff --git a/packages/hypergraph/src/type/type.ts b/packages/hypergraph/src/type/type.ts
index f7125307..6a8428ea 100644
--- a/packages/hypergraph/src/type/type.ts
+++ b/packages/hypergraph/src/type/type.ts
@@ -1,12 +1,12 @@
 import * as Schema from 'effect/Schema';
-import { PropertyIdSymbol, RelationSchemaSymbol, RelationSymbol } from '../constants.js';
+import { PropertyIdSymbol, PropertyTypeSymbol, RelationSchemaSymbol, RelationSymbol } from '../constants.js';
 
 /**
  * Creates a String schema with the specified GRC-20 property ID
  */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
 export const String = (propertyId: string) => {
-  return Schema.String.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+  return Schema.String.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId, [PropertyTypeSymbol]: 'string' }));
 };
 
 /**
@@ -14,7 +14,7 @@ export const String = (propertyId: string) => {
  */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
 export const Number = (propertyId: string) => {
-  return Schema.Number.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+  return Schema.Number.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId, [PropertyTypeSymbol]: 'number' }));
 };
 
 /**
@@ -22,7 +22,7 @@ export const Number = (propertyId: string) => {
  */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
 export const Boolean = (propertyId: string) => {
-  return Schema.Boolean.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+  return Schema.Boolean.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId, [PropertyTypeSymbol]: 'boolean' }));
 };
 
 /**
@@ -30,7 +30,7 @@ export const Boolean = (propertyId: string) => {
  */
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
 export const Date = (propertyId: string) => {
-  return Schema.Date.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+  return Schema.Date.pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId, [PropertyTypeSymbol]: 'date' }));
 };
 
 export const Point = (propertyId: string) =>
@@ -40,7 +40,7 @@ export const Point = (propertyId: string) =>
       return str.split(',').map((n: string) => globalThis.Number(n));
     },
     encode: (points: readonly number[]) => points.join(','),
-  }).pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId }));
+  }).pipe(Schema.annotations({ [PropertyIdSymbol]: propertyId, [PropertyTypeSymbol]: 'point' }));
 
 export const Relation =
   <S extends Schema.Schema.AnyNoContext>(schema: S) =>
@@ -49,7 +49,12 @@ export const Relation =
       Schema.Struct({ id: Schema.String, _relation: Schema.Struct({ id: Schema.String }) }),
     )(schema);
     return Schema.Array(schemaWithId).pipe(
-      Schema.annotations({ [PropertyIdSymbol]: propertyId, [RelationSchemaSymbol]: schema, [RelationSymbol]: true }),
+      Schema.annotations({
+        [PropertyIdSymbol]: propertyId,
+        [RelationSchemaSymbol]: schema,
+        [RelationSymbol]: true,
+        [PropertyTypeSymbol]: 'relation',
+      }),
     );
   };
 

From 4afe2ccda78d31bc280c43192d93d1854f1c4f5e Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 30 Sep 2025 23:17:42 +0200
Subject: [PATCH 09/22] handle relations in public query

---
 apps/events/src/schema.ts                     |   4 +-
 .../src/internal/convert-relations.ts         | 178 ++++++++++++------
 .../src/internal/use-query-public.tsx         |   3 +-
 packages/hypergraph/src/entity/entity.ts      |   1 +
 .../hypergraph/src/type-utils/type-utils.ts   |  45 -----
 packages/hypergraph/src/type/type.ts          |  20 +-
 6 files changed, 142 insertions(+), 109 deletions(-)

diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index f8aa091c..a9d0f630 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -111,7 +111,7 @@ export const Project = EntitySchema(
     name: Type.String,
     description: Type.optional(Type.String),
     x: Type.optional(Type.String),
-    // avatar: Type.Relation(Image),
+    avatar: Type.Relation(Image),
   },
   {
     types: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
@@ -119,7 +119,7 @@ export const Project = EntitySchema(
       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'),
+      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
     },
   },
 );
diff --git a/packages/hypergraph-react/src/internal/convert-relations.ts b/packages/hypergraph-react/src/internal/convert-relations.ts
index 794af743..4e20f9a2 100644
--- a/packages/hypergraph-react/src/internal/convert-relations.ts
+++ b/packages/hypergraph-react/src/internal/convert-relations.ts
@@ -1,4 +1,8 @@
+import { PropertyIdSymbol, TypeIdsSymbol } from '@graphprotocol/hypergraph/constants';
+import { isRelation } from '@graphprotocol/hypergraph/utils/isRelation';
+import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import { convertPropertyValue } from './convert-property-value.js';
 
 // A recursive representation of the entity structure returned by the public GraphQL
@@ -25,74 +29,132 @@ type RecursiveQueryEntity = {
 export const convertRelations = <S extends Schema.Schema.AnyNoContext>(queryEntity: RecursiveQueryEntity, type: S) => {
   const rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {};
 
-  for (const [key, relationId] of Object.entries(mappingEntry?.relations ?? {})) {
-    const properties = (queryEntity.relationsList ?? []).filter((a) => a.typeId === relationId);
-    if (properties.length === 0) {
-      rawEntity[key] = [] as unknown[];
-      continue;
-    }
-
-    const field = type.fields[key];
-    if (!field) {
-      // @ts-expect-error TODO: properly access the type.name
-      console.error(`Field ${key} not found in ${type.name}`);
-      continue;
-    }
-    const relationTransformation = field.ast.rest?.[0];
-    if (!relationTransformation) {
-      console.error(`Relation transformation for ${key} not found`);
-      continue;
-    }
+  const ast = type.ast as SchemaAST.TypeLiteral;
 
-    const identifierAnnotation = SchemaAST.getIdentifierAnnotation(relationTransformation.type.to);
-    if (Option.isNone(identifierAnnotation)) {
-      console.error(`Relation identifier for ${key} not found`);
-      continue;
-    }
+  // console.log('queryEntity', queryEntity);
 
-    const relationTypeName = identifierAnnotation.value;
+  for (const prop of ast.propertySignatures) {
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
 
-    const relationMappingEntry = mapping[relationTypeName];
-    if (!relationMappingEntry) {
-      console.error(`Relation mapping entry for ${relationTypeName} not found`);
-      continue;
-    }
+    if (isRelation(prop.type)) {
+      rawEntity[String(prop.name)] = [];
 
-    const newRelationEntities = properties.map((propertyEntry) => {
-      // @ts-expect-error TODO: properly access the type.name
-      const type = field.value;
-
-      let rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {
-        id: propertyEntry.toEntity.id,
-        name: propertyEntry.toEntity.name,
-        // TODO: should be determined by the actual value
-        __deleted: false,
-        // TODO: should be determined by the actual value
-        __version: '',
-      };
-
-      // take the mappingEntry and assign the attributes to the rawEntity
-      for (const [key, value] of Object.entries(relationMappingEntry?.properties ?? {})) {
-        const property = propertyEntry.toEntity.valuesList?.find((a) => a.propertyId === value);
-        if (property) {
-          rawEntity[key] = convertPropertyValue(property, key, type);
-        }
+      if (!queryEntity.valuesList) {
+        continue;
       }
 
-      rawEntity = {
-        ...rawEntity,
-        ...convertRelations(propertyEntry.toEntity, type, relationMappingEntry, mapping),
-      };
+      if (Option.isSome(result)) {
+        const relationTransformation = prop.type.rest?.[0]?.type;
+        const typeIds: string[] = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(relationTransformation).pipe(
+          Option.getOrElse(() => []),
+        );
+        if (typeIds.length === 0) {
+          continue;
+        }
 
-      return rawEntity;
-    });
+        const allRelationsWithTheCorrectPropertyTypeId = queryEntity.relationsList?.filter(
+          (a) => a.typeId === result.value,
+        );
+        if (allRelationsWithTheCorrectPropertyTypeId) {
+          for (const relationEntry of allRelationsWithTheCorrectPropertyTypeId) {
+            const nestedRawEntity:
+              | Record<string, string | boolean | number | unknown[] | Date>
+              | { _relation: { id: string } } = {
+              id: relationEntry.toEntity.id,
+              _relation: {
+                id: 'TODO: relation id',
+              },
+            };
 
-    if (rawEntity[key]) {
-      rawEntity[key] = [...(rawEntity[key] as unknown[]), ...newRelationEntities];
-    } else {
-      rawEntity[key] = newRelationEntities;
+            for (const nestedProp of relationTransformation.propertySignatures) {
+              const nestedResult = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(nestedProp.type);
+              if (Option.isSome(nestedResult)) {
+                const value = relationEntry.toEntity.valuesList?.find((a) => a.propertyId === nestedResult.value);
+                if (!value) {
+                  continue;
+                }
+                const rawValue = 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];
+            }
+          }
+        }
+      }
     }
   }
 
+  // for (const [key, relationId] of Object.entries(mappingEntry?.relations ?? {})) {
+  //   const properties = (queryEntity.relationsList ?? []).filter((a) => a.typeId === relationId);
+  //   if (properties.length === 0) {
+  //     rawEntity[key] = [] as unknown[];
+  //     continue;
+  //   }
+
+  //   const field = type.fields[key];
+  //   if (!field) {
+  //     // @ts-expect-error TODO: properly access the type.name
+  //     console.error(`Field ${key} not found in ${type.name}`);
+  //     continue;
+  //   }
+  //   const relationTransformation = field.ast.rest?.[0];
+  //   if (!relationTransformation) {
+  //     console.error(`Relation transformation for ${key} not found`);
+  //     continue;
+  //   }
+
+  //   const identifierAnnotation = SchemaAST.getIdentifierAnnotation(relationTransformation.type.to);
+  //   if (Option.isNone(identifierAnnotation)) {
+  //     console.error(`Relation identifier for ${key} not found`);
+  //     continue;
+  //   }
+
+  //   const relationTypeName = identifierAnnotation.value;
+
+  //   const relationMappingEntry = mapping[relationTypeName];
+  //   if (!relationMappingEntry) {
+  //     console.error(`Relation mapping entry for ${relationTypeName} not found`);
+  //     continue;
+  //   }
+
+  //   const newRelationEntities = properties.map((propertyEntry) => {
+  //     // @ts-expect-error TODO: properly access the type.name
+  //     const type = field.value;
+
+  //     let rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {
+  //       id: propertyEntry.toEntity.id,
+  //       name: propertyEntry.toEntity.name,
+  //       // TODO: should be determined by the actual value
+  //       __deleted: false,
+  //       // TODO: should be determined by the actual value
+  //       __version: '',
+  //     };
+
+  //     // take the mappingEntry and assign the attributes to the rawEntity
+  //     for (const [key, value] of Object.entries(relationMappingEntry?.properties ?? {})) {
+  //       const property = propertyEntry.toEntity.valuesList?.find((a) => a.propertyId === value);
+  //       if (property) {
+  //         rawEntity[key] = convertPropertyValue(property, type);
+  //       }
+  //     }
+
+  //     rawEntity = {
+  //       ...rawEntity,
+  //       ...convertRelations(propertyEntry.toEntity, type, relationMappingEntry, mapping),
+  //     };
+
+  //     return rawEntity;
+  //   });
+
+  //   if (rawEntity[key]) {
+  //     rawEntity[key] = [...(rawEntity[key] as unknown[]), ...newRelationEntities];
+  //   } else {
+  //     rawEntity[key] = newRelationEntities;
+  //   }
+  // }
+
   return rawEntity;
 };
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index d9afafcb..901870b9 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -10,6 +10,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { gql, request } from 'graphql-request';
 import { useMemo } from 'react';
 import { convertPropertyValue } from './convert-property-value.js';
+import { convertRelations } from './convert-relations.js';
 import { translateFilterToGraphql } from './translate-filter-to-graphql.js';
 import type { QueryPublicParams } from './types.js';
 import { useHypergraphSpaceInternal } from './use-hypergraph-space-internal.js';
@@ -210,7 +211,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
 
     rawEntity = {
       ...rawEntity,
-      // ...convertRelations(queryEntity, type),
+      ...convertRelations(queryEntity, type),
     };
 
     const decodeResult = decode({
diff --git a/packages/hypergraph/src/entity/entity.ts b/packages/hypergraph/src/entity/entity.ts
index f688f305..ee6ea624 100644
--- a/packages/hypergraph/src/entity/entity.ts
+++ b/packages/hypergraph/src/entity/entity.ts
@@ -50,6 +50,7 @@ export function encodeToGrc20Json<T extends object, E>(schema: Schema.Schema<T,
   const out: Record<string, unknown> = {};
 
   for (const prop of ast.propertySignatures) {
+    // TODO: what about optional properties here? usually we use prop.type.types[0] but we don't here?
     const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
     if (Option.isSome(result)) {
       out[result.value] = (value as any)[prop.name];
diff --git a/packages/hypergraph/src/type-utils/type-utils.ts b/packages/hypergraph/src/type-utils/type-utils.ts
index ebcf4ad1..bbac8f6c 100644
--- a/packages/hypergraph/src/type-utils/type-utils.ts
+++ b/packages/hypergraph/src/type-utils/type-utils.ts
@@ -1,50 +1,5 @@
 import * as Type from '../type/type.js';
 
-// biome-ignore lint/suspicious/noExplicitAny: TODO
-export const isStringOrOptionalStringType = (type: any) => {
-  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
-    return type.from === Type.String;
-  }
-  return type === Type.String;
-};
-
-// biome-ignore lint/suspicious/noExplicitAny: TODO
-export const isNumberOrOptionalNumberType = (type: any) => {
-  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
-    return type.from === Type.Number;
-  }
-  return type === Type.Number;
-};
-
-// biome-ignore lint/suspicious/noExplicitAny: TODO
-export const isDateOrOptionalDateType = (type: any) => {
-  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
-    return type.from === Type.Date;
-  }
-  return type === Type.Date;
-};
-
-// biome-ignore lint/suspicious/noExplicitAny: TODO
-export const isBooleanOrOptionalBooleanType = (type: any) => {
-  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
-    return type.from === Type.Boolean;
-  }
-  return type === Type.Boolean;
-};
-
-// biome-ignore lint/suspicious/noExplicitAny: TODO
-export const isPointOrOptionalPointType = (type: any) => {
-  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
-    return type.from === Type.Point;
-  }
-  return type === Type.Point;
-};
-
-// biome-ignore lint/suspicious/noExplicitAny: TODO
-export const isOptional = (type: any) => {
-  return type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional;
-};
-
 export const isStringType = (type: any) => {
   return type === Type.String;
 };
diff --git a/packages/hypergraph/src/type/type.ts b/packages/hypergraph/src/type/type.ts
index 6a8428ea..4c227c8d 100644
--- a/packages/hypergraph/src/type/type.ts
+++ b/packages/hypergraph/src/type/type.ts
@@ -1,5 +1,13 @@
+import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
-import { PropertyIdSymbol, PropertyTypeSymbol, RelationSchemaSymbol, RelationSymbol } from '../constants.js';
+import * as SchemaAST from 'effect/SchemaAST';
+import {
+  PropertyIdSymbol,
+  PropertyTypeSymbol,
+  RelationSchemaSymbol,
+  RelationSymbol,
+  TypeIdsSymbol,
+} from '../constants.js';
 
 /**
  * Creates a String schema with the specified GRC-20 property ID
@@ -45,9 +53,15 @@ export const Point = (propertyId: string) =>
 export const Relation =
   <S extends Schema.Schema.AnyNoContext>(schema: S) =>
   (propertyId: string) => {
-    const schemaWithId = Schema.extend(
+    const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(schema.ast as SchemaAST.TypeLiteral).pipe(
+      Option.getOrElse(() => []),
+    );
+
+    const schemaWithId = Schema.extend(schema)(
       Schema.Struct({ id: Schema.String, _relation: Schema.Struct({ id: Schema.String }) }),
-    )(schema);
+      // manually adding the type ids to the schema since they get lost when extending the schema
+    ).pipe(Schema.annotations({ [TypeIdsSymbol]: typeIds }));
+
     return Schema.Array(schemaWithId).pipe(
       Schema.annotations({
         [PropertyIdSymbol]: propertyId,

From 36ce1dccc51896e0550ef4fc563fad05cb77d9d9 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Mon, 6 Oct 2025 14:42:40 +0200
Subject: [PATCH 10/22] handle nested relations

---
 apps/events/src/components/playground.tsx     |   4 +-
 apps/events/src/mapping.ts                    |  12 +-
 apps/events/src/routes/playground.lazy.tsx    |   5 +-
 apps/events/src/schema.ts                     |  12 +-
 .../src/routes/playground.lazy.tsx            |   6 +-
 apps/privy-login-example/src/schema.ts        |  42 ++++-
 .../src/internal/convert-relations.ts         | 156 +++++-------------
 .../src/internal/use-query-public.tsx         |  59 +++----
 8 files changed, 122 insertions(+), 174 deletions(-)

diff --git a/apps/events/src/components/playground.tsx b/apps/events/src/components/playground.tsx
index a4f0ffed..9833b723 100644
--- a/apps/events/src/components/playground.tsx
+++ b/apps/events/src/components/playground.tsx
@@ -4,7 +4,7 @@ import { Event } from '../schema';
 import { Button } from './ui/button';
 
 export const Playground = ({ spaceId }: { spaceId: string }) => {
-  const { data, isLoading, isError } = useQuery(Event, {
+  const { data, isLoading, isError, invalidEntities } = useQuery(Event, {
     mode: 'public',
     include: {
       sponsors: {
@@ -24,7 +24,7 @@ export const Playground = ({ spaceId }: { spaceId: string }) => {
 
   const deleteEntity = _useDeleteEntityPublic(Event, { space: spaceId });
 
-  console.log({ isLoading, isError, data });
+  console.log({ isLoading, isError, data, invalidEntities });
 
   return (
     <div>
diff --git a/apps/events/src/mapping.ts b/apps/events/src/mapping.ts
index 849a04a8..3263a0f7 100644
--- a/apps/events/src/mapping.ts
+++ b/apps/events/src/mapping.ts
@@ -33,29 +33,29 @@ export const mapping: Mapping.Mapping = {
     },
   },
   JobOffer: {
-    typeIds: [Id('f60585af-71b6-4674-9a26-b74ca6c1cceb')],
+    typeIds: [Id('a4c1b288-756e-477b-aab2-007decf01c61')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      salary: Id('baa36ac9-78ac-4cf7-8394-6b2d3006bebe'),
+      salary: Id('86ff5361-b820-4ba8-b689-b48e815e07d2'),
     },
   },
   Company: {
-    typeIds: [Id('6c504df5-1a8f-43d1-bf2d-1ef9fa5b08b5')],
+    typeIds: [Id('bcf56f59-c532-47d5-a005-2d802f512c85')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
     },
     relations: {
-      jobOffers: Id('1203064e-9741-4235-89d4-97f4b22eddfb'),
+      jobOffers: Id('54190b30-1c68-499c-9ed8-5c6190810e31'),
     },
   },
   Event: {
-    typeIds: [Id('7f9562d4-034d-4385-bf5c-f02cdebba47a')],
+    typeIds: [Id('239bc639-938e-427c-bebb-d562d82ae272')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
       description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
     },
     relations: {
-      sponsors: Id('6860bfac-f703-4289-b789-972d0aaf3abe'),
+      sponsors: Id('926b00ee-68b5-4462-a27f-3806af705118'),
     },
   },
   Todo3: {
diff --git a/apps/events/src/routes/playground.lazy.tsx b/apps/events/src/routes/playground.lazy.tsx
index 9ade330d..e923231e 100644
--- a/apps/events/src/routes/playground.lazy.tsx
+++ b/apps/events/src/routes/playground.lazy.tsx
@@ -1,7 +1,6 @@
 import { CreateEvents } from '@/components/create-events';
 import { CreatePropertiesAndTypesEvent } from '@/components/create-properties-and-types-event';
 import { Playground } from '@/components/playground';
-import { Projects } from '@/components/projects';
 import { HypergraphSpaceProvider } from '@graphprotocol/hypergraph-react';
 import { createLazyFileRoute } from '@tanstack/react-router';
 
@@ -10,12 +9,12 @@ export const Route = createLazyFileRoute('/playground')({
 });
 
 function RouteComponent() {
-  const space = 'a393e509-ae56-4d99-987c-bed71d9db631';
+  const space = '282aee96-48b0-4c6e-b020-736430a82a87';
   return (
     <>
       {/* <Event spaceId={space} entityId="cf7c620b-d724-498f-b134-8280dc8249ae" /> */}
       <Playground spaceId={space} />
-      <Projects spaceId="3f32353d-3b27-4a13-b71a-746f06e1f7db" />
+      {/* <Projects spaceId="3f32353d-3b27-4a13-b71a-746f06e1f7db" /> */}
       <HypergraphSpaceProvider space={space}>
         <div className="flex flex-col gap-4 max-w-(--breakpoint-sm) mx-auto py-8">
           <h1 className="text-2xl font-bold">Playground</h1>
diff --git a/apps/events/src/schema.ts b/apps/events/src/schema.ts
index a9d0f630..fcefe3d8 100644
--- a/apps/events/src/schema.ts
+++ b/apps/events/src/schema.ts
@@ -56,10 +56,10 @@ export const JobOffer = EntitySchema(
     salary: Type.Number,
   },
   {
-    types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
+    types: [Id('a4c1b288-756e-477b-aab2-007decf01c61')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      salary: Id('baa36ac9-78ac-4cf7-8394-6b2d3006bebe'),
+      salary: Id('86ff5361-b820-4ba8-b689-b48e815e07d2'),
     },
   },
 );
@@ -70,10 +70,10 @@ export const Company = EntitySchema(
     jobOffers: Type.Relation(JobOffer),
   },
   {
-    types: [Id('6c504df5-1a8f-43d1-bf2d-1ef9fa5b08b5')],
+    types: [Id('bcf56f59-c532-47d5-a005-2d802f512c85')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      jobOffers: Id('1203064e-9741-4235-89d4-97f4b22eddfb'),
+      jobOffers: Id('54190b30-1c68-499c-9ed8-5c6190810e31'),
     },
   },
 );
@@ -85,11 +85,11 @@ export const Event = EntitySchema(
     sponsors: Type.Relation(Company),
   },
   {
-    types: [Id('7f9562d4-034d-4385-bf5c-f02cdebba47a')],
+    types: [Id('239bc639-938e-427c-bebb-d562d82ae272')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
       description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-      sponsors: Id('6860bfac-f703-4289-b789-972d0aaf3abe'),
+      sponsors: Id('926b00ee-68b5-4462-a27f-3806af705118'),
     },
   },
 );
diff --git a/apps/privy-login-example/src/routes/playground.lazy.tsx b/apps/privy-login-example/src/routes/playground.lazy.tsx
index a628da74..982d2d07 100644
--- a/apps/privy-login-example/src/routes/playground.lazy.tsx
+++ b/apps/privy-login-example/src/routes/playground.lazy.tsx
@@ -1,16 +1,16 @@
-import { HypergraphSpaceProvider } from '@graphprotocol/hypergraph-react';
-import { createLazyFileRoute } from '@tanstack/react-router';
 import { CreateEvents } from '@/components/create-events';
 import { CreatePropertiesAndTypesEvent } from '@/components/create-properties-and-types-event';
 import { Event } from '@/components/event';
 import { Playground } from '@/components/playground';
+import { HypergraphSpaceProvider } from '@graphprotocol/hypergraph-react';
+import { createLazyFileRoute } from '@tanstack/react-router';
 
 export const Route = createLazyFileRoute('/playground')({
   component: RouteComponent,
 });
 
 function RouteComponent() {
-  const space = 'a393e509-ae56-4d99-987c-bed71d9db631';
+  const space = '282aee96-48b0-4c6e-b020-736430a82a87';
   return (
     <>
       <Event spaceId={space} entityId="cf7c620b-d724-498f-b134-8280dc8249ae" />
diff --git a/apps/privy-login-example/src/schema.ts b/apps/privy-login-example/src/schema.ts
index 6ef13e89..fcefe3d8 100644
--- a/apps/privy-login-example/src/schema.ts
+++ b/apps/privy-login-example/src/schema.ts
@@ -56,10 +56,10 @@ export const JobOffer = EntitySchema(
     salary: Type.Number,
   },
   {
-    types: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
+    types: [Id('a4c1b288-756e-477b-aab2-007decf01c61')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      salary: Id('baa36ac9-78ac-4cf7-8394-6b2d3006bebe'),
+      salary: Id('86ff5361-b820-4ba8-b689-b48e815e07d2'),
     },
   },
 );
@@ -70,10 +70,10 @@ export const Company = EntitySchema(
     jobOffers: Type.Relation(JobOffer),
   },
   {
-    types: [Id('6c504df5-1a8f-43d1-bf2d-1ef9fa5b08b5')],
+    types: [Id('bcf56f59-c532-47d5-a005-2d802f512c85')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      jobOffers: Id('1203064e-9741-4235-89d4-97f4b22eddfb'),
+      jobOffers: Id('54190b30-1c68-499c-9ed8-5c6190810e31'),
     },
   },
 );
@@ -85,11 +85,41 @@ export const Event = EntitySchema(
     sponsors: Type.Relation(Company),
   },
   {
-    types: [Id('7f9562d4-034d-4385-bf5c-f02cdebba47a')],
+    types: [Id('239bc639-938e-427c-bebb-d562d82ae272')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
+      sponsors: Id('926b00ee-68b5-4462-a27f-3806af705118'),
+    },
+  },
+);
+
+export const Image = EntitySchema(
+  {
+    url: Type.String,
+  },
+  {
+    types: [Id('ba4e4146-0010-499d-a0a3-caaa7f579d0e')],
+    properties: {
+      url: Id('8a743832-c094-4a62-b665-0c3cc2f9c7bc'),
+    },
+  },
+);
+
+export const Project = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    x: Type.optional(Type.String),
+    avatar: Type.Relation(Image),
+  },
+  {
+    types: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
       description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-      sponsors: Id('6860bfac-f703-4289-b789-972d0aaf3abe'),
+      x: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
+      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
     },
   },
 );
diff --git a/packages/hypergraph-react/src/internal/convert-relations.ts b/packages/hypergraph-react/src/internal/convert-relations.ts
index 4e20f9a2..50a07606 100644
--- a/packages/hypergraph-react/src/internal/convert-relations.ts
+++ b/packages/hypergraph-react/src/internal/convert-relations.ts
@@ -21,140 +21,72 @@ type RecursiveQueryEntity = {
     point: string;
   }[];
   relationsList?: {
+    id: string;
     toEntity: RecursiveQueryEntity;
     typeId: string;
   }[];
 };
 
-export const convertRelations = <S extends Schema.Schema.AnyNoContext>(queryEntity: RecursiveQueryEntity, type: S) => {
+export const convertRelations = <S extends Schema.Schema.AnyNoContext>(
+  queryEntity: RecursiveQueryEntity,
+  ast: SchemaAST.TypeLiteral,
+) => {
   const rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {};
 
-  const ast = type.ast as SchemaAST.TypeLiteral;
-
-  // console.log('queryEntity', queryEntity);
-
   for (const prop of ast.propertySignatures) {
     const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
 
-    if (isRelation(prop.type)) {
+    if (isRelation(prop.type) && Option.isSome(result)) {
       rawEntity[String(prop.name)] = [];
 
-      if (!queryEntity.valuesList) {
+      const relationTransformation = prop.type.rest?.[0]?.type;
+      const typeIds: string[] = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(relationTransformation).pipe(
+        Option.getOrElse(() => []),
+      );
+      if (typeIds.length === 0) {
         continue;
       }
 
-      if (Option.isSome(result)) {
-        const relationTransformation = prop.type.rest?.[0]?.type;
-        const typeIds: string[] = SchemaAST.getAnnotation<string[]>(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) {
-            const nestedRawEntity:
-              | Record<string, string | boolean | number | unknown[] | Date>
-              | { _relation: { id: string } } = {
-              id: relationEntry.toEntity.id,
-              _relation: {
-                id: 'TODO: relation id',
-              },
-            };
-
-            for (const nestedProp of relationTransformation.propertySignatures) {
-              const nestedResult = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(nestedProp.type);
-              if (Option.isSome(nestedResult)) {
-                const value = relationEntry.toEntity.valuesList?.find((a) => a.propertyId === nestedResult.value);
-                if (!value) {
-                  continue;
-                }
-                const rawValue = convertPropertyValue(value, nestedProp.type);
-                if (rawValue) {
-                  nestedRawEntity[String(nestedProp.name)] = rawValue;
-                }
+      const allRelationsWithTheCorrectPropertyTypeId = queryEntity.relationsList?.filter(
+        (a) => a.typeId === result.value,
+      );
+      if (allRelationsWithTheCorrectPropertyTypeId) {
+        for (const relationEntry of allRelationsWithTheCorrectPropertyTypeId) {
+          let nestedRawEntity:
+            | Record<string, string | boolean | number | unknown[] | Date>
+            | { _relation: { id: string } } = {
+            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>(PropertyIdSymbol)(nestedProp.type);
+            if (Option.isSome(nestedResult)) {
+              const value = relationEntry.toEntity.valuesList?.find((a) => a.propertyId === nestedResult.value);
+              if (!value) {
+                continue;
+              }
+              const rawValue = 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];
             }
           }
+          // TODO: in the end every entry should be validated using the Schema?!?
+          rawEntity[String(prop.name)] = [...(rawEntity[String(prop.name)] as unknown[]), nestedRawEntity];
         }
       }
     }
   }
 
-  // for (const [key, relationId] of Object.entries(mappingEntry?.relations ?? {})) {
-  //   const properties = (queryEntity.relationsList ?? []).filter((a) => a.typeId === relationId);
-  //   if (properties.length === 0) {
-  //     rawEntity[key] = [] as unknown[];
-  //     continue;
-  //   }
-
-  //   const field = type.fields[key];
-  //   if (!field) {
-  //     // @ts-expect-error TODO: properly access the type.name
-  //     console.error(`Field ${key} not found in ${type.name}`);
-  //     continue;
-  //   }
-  //   const relationTransformation = field.ast.rest?.[0];
-  //   if (!relationTransformation) {
-  //     console.error(`Relation transformation for ${key} not found`);
-  //     continue;
-  //   }
-
-  //   const identifierAnnotation = SchemaAST.getIdentifierAnnotation(relationTransformation.type.to);
-  //   if (Option.isNone(identifierAnnotation)) {
-  //     console.error(`Relation identifier for ${key} not found`);
-  //     continue;
-  //   }
-
-  //   const relationTypeName = identifierAnnotation.value;
-
-  //   const relationMappingEntry = mapping[relationTypeName];
-  //   if (!relationMappingEntry) {
-  //     console.error(`Relation mapping entry for ${relationTypeName} not found`);
-  //     continue;
-  //   }
-
-  //   const newRelationEntities = properties.map((propertyEntry) => {
-  //     // @ts-expect-error TODO: properly access the type.name
-  //     const type = field.value;
-
-  //     let rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {
-  //       id: propertyEntry.toEntity.id,
-  //       name: propertyEntry.toEntity.name,
-  //       // TODO: should be determined by the actual value
-  //       __deleted: false,
-  //       // TODO: should be determined by the actual value
-  //       __version: '',
-  //     };
-
-  //     // take the mappingEntry and assign the attributes to the rawEntity
-  //     for (const [key, value] of Object.entries(relationMappingEntry?.properties ?? {})) {
-  //       const property = propertyEntry.toEntity.valuesList?.find((a) => a.propertyId === value);
-  //       if (property) {
-  //         rawEntity[key] = convertPropertyValue(property, type);
-  //       }
-  //     }
-
-  //     rawEntity = {
-  //       ...rawEntity,
-  //       ...convertRelations(propertyEntry.toEntity, type, relationMappingEntry, mapping),
-  //     };
-
-  //     return rawEntity;
-  //   });
-
-  //   if (rawEntity[key]) {
-  //     rawEntity[key] = [...(rawEntity[key] as unknown[]), ...newRelationEntities];
-  //   } else {
-  //     rawEntity[key] = newRelationEntities;
-  //   }
-  // }
-
   return rawEntity;
 };
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index 901870b9..60d64a98 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -60,6 +60,7 @@ query entities($spaceId: UUID!, $typeIds: [UUID!]!, $relationTypeIdsLevel1: [UUI
     relationsList(
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
+      id
       toEntity {
         id
         name
@@ -100,6 +101,7 @@ query entities($spaceId: UUID!, $typeIds: [UUID!]!, $relationTypeIdsLevel1: [UUI
     relationsList(
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
+      id
       toEntity {
         id
         name
@@ -115,6 +117,7 @@ query entities($spaceId: UUID!, $typeIds: [UUID!]!, $relationTypeIdsLevel1: [UUI
           filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel2}},
           # filter: {spaceId: {is: $spaceId}, toEntity: {relations: {some: {typeId: {is: "8f151ba4-de20-4e3c-9cb4-99ddf96f48f1"}, toEntityId: {in: $relationTypeIdsLevel2}}}}}
         ) {
+          id
           toEntity {
             id
             name
@@ -149,6 +152,7 @@ type EntityQueryResult = {
       point: string;
     }[];
     relationsList: {
+      id: string;
       toEntity: {
         id: string;
         name: string;
@@ -161,6 +165,7 @@ type EntityQueryResult = {
           point: string;
         }[];
         relationsList: {
+          id: string;
           toEntity: {
             id: string;
             name: string;
@@ -211,7 +216,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
 
     rawEntity = {
       ...rawEntity,
-      ...convertRelations(queryEntity, type),
+      ...convertRelations(queryEntity, ast),
     };
 
     const decodeResult = decode({
@@ -248,31 +253,31 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
 
   for (const prop of ast.propertySignatures) {
     if (!isRelation(prop.type)) continue;
+
     const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
-    if (Option.isSome(result)) {
+    if (Option.isSome(result) && include?.[prop.name]) {
       relationTypeIdsLevel1.push(result.value);
+      const relationTransformation = prop.type.rest?.[0]?.type;
+      const typeIds: string[] = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(relationTransformation).pipe(
+        Option.getOrElse(() => []),
+      );
+      if (typeIds.length === 0) {
+        continue;
+      }
+      for (const nestedProp of relationTransformation.propertySignatures) {
+        if (!isRelation(nestedProp.type)) continue;
+
+        const nestedResult = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(nestedProp.type);
+        if (Option.isSome(nestedResult) && include?.[prop.name][nestedProp.name]) {
+          relationTypeIdsLevel2.push(nestedResult.value);
+        }
+      }
     }
   }
 
-  // for (const key in mappingEntry?.relations ?? {}) {
-  //   if (include?.[key] && mappingEntry?.relations?.[key]) {
-  //     relationTypeIdsLevel1.push(mappingEntry?.relations?.[key]);
-  //     const field = type.fields[key];
-  //     // @ts-expect-error TODO find a better way to access the relation type name
-  //     const typeName2 = field.value.name;
-  //     const mappingEntry2 = mapping[typeName2];
-  //     for (const key2 in mappingEntry2?.relations ?? {}) {
-  //       if (include?.[key][key2] && mappingEntry2?.relations?.[key2]) {
-  //         relationTypeIdsLevel2.push(mappingEntry2?.relations?.[key2]);
-  //       }
-  //     }
-  //   }
-  // }
-
   const result = useQueryTanstack({
     queryKey: [
       'hypergraph-public-entities',
-      'TODO: type name',
       space,
       typeIds,
       relationTypeIdsLevel1,
@@ -311,21 +316,3 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
 
   return { ...result, data, invalidEntities };
 };
-
-// const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
-//   Option.getOrElse(() => []),
-// );
-
-// const out: Record<string, unknown> = {};
-
-// for (const prop of ast.propertySignatures) {
-//   const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
-//   if (Option.isSome(result)) {
-//     const grc20Key = result.value;
-//     if (grc20Key in grc20Data && typeof prop.name === 'string') {
-//       out[prop.name] = (grc20Data as any)[grc20Key];
-//     }
-//   }
-// }
-
-// out.id = grc20Data.id as string;

From b2037456aa6fecf66614fa5d03de1534aff4cb06 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Mon, 6 Oct 2025 15:46:36 +0200
Subject: [PATCH 11/22] implement useEntity public

---
 apps/events/src/routes/playground.lazy.tsx    |  3 +-
 .../src/internal/get-relation-type-ids.ts     | 45 +++++++++
 .../src/internal/use-entity-public.tsx        | 92 +++++++++----------
 .../src/internal/use-query-public.tsx         | 49 +++-------
 packages/hypergraph/src/index.ts              |  1 +
 packages/hypergraph/src/utils/index.ts        |  1 +
 6 files changed, 105 insertions(+), 86 deletions(-)
 create mode 100644 packages/hypergraph-react/src/internal/get-relation-type-ids.ts

diff --git a/apps/events/src/routes/playground.lazy.tsx b/apps/events/src/routes/playground.lazy.tsx
index e923231e..26ee5701 100644
--- a/apps/events/src/routes/playground.lazy.tsx
+++ b/apps/events/src/routes/playground.lazy.tsx
@@ -1,5 +1,6 @@
 import { CreateEvents } from '@/components/create-events';
 import { CreatePropertiesAndTypesEvent } from '@/components/create-properties-and-types-event';
+import { Event } from '@/components/event';
 import { Playground } from '@/components/playground';
 import { HypergraphSpaceProvider } from '@graphprotocol/hypergraph-react';
 import { createLazyFileRoute } from '@tanstack/react-router';
@@ -12,7 +13,7 @@ function RouteComponent() {
   const space = '282aee96-48b0-4c6e-b020-736430a82a87';
   return (
     <>
-      {/* <Event spaceId={space} entityId="cf7c620b-d724-498f-b134-8280dc8249ae" /> */}
+      <Event spaceId={space} entityId="22aa0386-3365-4425-a60e-eaaec919c034" />
       <Playground spaceId={space} />
       {/* <Projects spaceId="3f32353d-3b27-4a13-b71a-746f06e1f7db" /> */}
       <HypergraphSpaceProvider space={space}>
diff --git a/packages/hypergraph-react/src/internal/get-relation-type-ids.ts b/packages/hypergraph-react/src/internal/get-relation-type-ids.ts
new file mode 100644
index 00000000..71eef6cc
--- /dev/null
+++ b/packages/hypergraph-react/src/internal/get-relation-type-ids.ts
@@ -0,0 +1,45 @@
+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';
+
+export const getRelationTypeIds = (
+  type: Schema.Schema.AnyNoContext,
+  include:
+    | { [K in keyof Schema.Schema.Type<Schema.Schema.AnyNoContext>]?: Record<string, Record<string, never>> }
+    | undefined,
+) => {
+  const relationTypeIdsLevel1: string[] = [];
+  const relationTypeIdsLevel2: string[] = [];
+
+  const ast = type.ast as SchemaAST.TypeLiteral;
+
+  for (const prop of ast.propertySignatures) {
+    if (!Utils.isRelation(prop.type)) continue;
+
+    const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
+    if (Option.isSome(result) && include?.[prop.name]) {
+      relationTypeIdsLevel1.push(result.value);
+      const relationTransformation = prop.type.rest?.[0]?.type;
+      const typeIds2: string[] = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(
+        relationTransformation,
+      ).pipe(Option.getOrElse(() => []));
+      if (typeIds2.length === 0) {
+        continue;
+      }
+      for (const nestedProp of relationTransformation.propertySignatures) {
+        if (!Utils.isRelation(nestedProp.type)) continue;
+
+        const nestedResult = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(nestedProp.type);
+        if (Option.isSome(nestedResult) && include?.[prop.name][nestedProp.name]) {
+          relationTypeIdsLevel2.push(nestedResult.value);
+        }
+      }
+    }
+  }
+
+  return {
+    level1: relationTypeIdsLevel1,
+    level2: relationTypeIdsLevel2,
+  };
+};
diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index b5f27ecf..da8f3b43 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -1,13 +1,15 @@
 import { Graph } from '@graphprotocol/grc-20';
-import { type Entity, type Mapping, store } from '@graphprotocol/hypergraph';
+import { Constants, type Entity } from '@graphprotocol/hypergraph';
 import { useQuery as useQueryTanstack } from '@tanstack/react-query';
-import { useSelector } from '@xstate/store/react';
 import * as Either from 'effect/Either';
+import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import { gql, request } from 'graphql-request';
 import { useMemo } from 'react';
 import { convertPropertyValue } from './convert-property-value.js';
 import { convertRelations } from './convert-relations.js';
+import { getRelationTypeIds } from './get-relation-type-ids.js';
 import { useHypergraphSpaceInternal } from './use-hypergraph-space-internal.js';
 
 const entityQueryDocumentLevel0 = gql`
@@ -47,6 +49,7 @@ query entity($id: UUID!, $spaceId: UUID!, $relationTypeIdsLevel1: [UUID!]!) {
     relationsList(
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
+      id
       toEntity {
         id
         name
@@ -83,6 +86,7 @@ query entity($id: UUID!, $spaceId: UUID!, $relationTypeIdsLevel1: [UUID!]!, $rel
     relationsList(
       filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel1}},
     ) {
+      id
       toEntity {
         id
         name
@@ -97,6 +101,7 @@ query entity($id: UUID!, $spaceId: UUID!, $relationTypeIdsLevel1: [UUID!]!, $rel
         relationsList(
           filter: {spaceId: {is: $spaceId}, typeId:{ in: $relationTypeIdsLevel2}},
         ) {
+          id
           toEntity {
             id
             name
@@ -131,6 +136,7 @@ type EntityQueryResult = {
       point: string;
     }[];
     relationsList?: {
+      id: string;
       toEntity: {
         id: string;
         name: string;
@@ -143,6 +149,7 @@ type EntityQueryResult = {
           point: string;
         }[];
         relationsList?: {
+          id: string;
           toEntity: {
             id: string;
             name: string;
@@ -163,41 +170,51 @@ type EntityQueryResult = {
   } | null;
 };
 
-export const parseResult = <S extends Schema.Schema.AnyNoContext>(
-  queryData: EntityQueryResult,
-  type: S,
-  mappingEntry: Mapping.MappingEntry,
-  mapping: Mapping.Mapping,
-) => {
+export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: EntityQueryResult, type: S) => {
   if (!queryData.entity) {
     return { data: null, invalidEntity: null };
   }
 
-  const decode = Schema.decodeUnknownEither(type);
+  const schemaWithId = Schema.extend(Schema.Struct({ id: Schema.String }))(type);
+  const decode = Schema.decodeUnknownEither(schemaWithId);
   const queryEntity = queryData.entity;
   let rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {
     id: queryEntity.id,
   };
 
-  // take the mappingEntry and assign the attributes to the rawEntity
-  for (const [key, value] of Object.entries(mappingEntry?.properties ?? {})) {
-    const property = queryEntity.valuesList.find((a) => a.propertyId === value);
-    if (property) {
-      rawEntity[key] = convertPropertyValue(property, type);
+  const ast = type.ast as SchemaAST.TypeLiteral;
+
+  for (const prop of ast.propertySignatures) {
+    const propType = prop.isOptional ? prop.type.types[0] : prop.type;
+    const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(propType);
+
+    if (Option.isSome(result)) {
+      const value = queryEntity.valuesList.find((a) => a.propertyId === result.value);
+      if (value) {
+        const rawValue = convertPropertyValue(value, propType);
+        if (rawValue) {
+          rawEntity[String(prop.name)] = rawValue;
+        }
+      }
     }
   }
 
   rawEntity = {
     ...rawEntity,
-    ...convertRelations(queryEntity, type, mappingEntry, mapping),
+    ...convertRelations(queryEntity, ast),
   };
 
+  console.log('rawEntity', rawEntity);
+
   const decodeResult = decode({
     ...rawEntity,
     __deleted: false,
+    // __version: queryEntity.currentVersion.versionId,
     __version: '',
   });
 
+  console.log('decodeResult', decodeResult);
+
   if (Either.isRight(decodeResult)) {
     return {
       data: { ...decodeResult.right, __schema: type } as Entity.Entity<S>,
@@ -220,49 +237,30 @@ export const useEntityPublic = <S extends Schema.Schema.AnyNoContext>(type: S, p
   const { id, enabled = true, space: spaceFromParams, include } = params;
   const { space: spaceFromContext } = useHypergraphSpaceInternal();
   const space = spaceFromParams ?? spaceFromContext;
-  const mapping = useSelector(store, (state) => state.context.mapping);
-
-  // @ts-expect-error TODO should use the actual type instead of the name in the mapping
-  const typeName = type.name;
-  const mappingEntry = mapping?.[typeName];
-  if (enabled && !mappingEntry) {
-    throw new Error(`Mapping entry for ${typeName} not found`);
-  }
 
   // constructing the relation type ids for the query
-  const relationTypeIdsLevel1: string[] = [];
-  const relationTypeIdsLevel2: string[] = [];
-  for (const key in mappingEntry?.relations ?? {}) {
-    if (include?.[key] && mappingEntry?.relations?.[key]) {
-      relationTypeIdsLevel1.push(mappingEntry?.relations?.[key]);
-      const field = type.fields[key];
-      // @ts-expect-error TODO find a better way to access the relation type name
-      const typeName2 = field.value.name;
-      const mappingEntry2 = mapping[typeName2];
-      for (const key2 in mappingEntry2?.relations ?? {}) {
-        if (include?.[key][key2] && mappingEntry2?.relations?.[key2]) {
-          relationTypeIdsLevel2.push(mappingEntry2?.relations?.[key2]);
-        }
-      }
-    }
-  }
+  const relationTypeIds = getRelationTypeIds(type, include);
+
+  const typeIds = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+    Option.getOrElse(() => []),
+  );
 
   const result = useQueryTanstack({
-    queryKey: ['hypergraph-public-entity', typeName, id, space, relationTypeIdsLevel1, relationTypeIdsLevel2, include],
+    queryKey: ['hypergraph-public-entity', id, typeIds, space, relationTypeIds.level1, relationTypeIds.level2, include],
     queryFn: async () => {
       let queryDocument = entityQueryDocumentLevel0;
-      if (relationTypeIdsLevel1.length > 0) {
+      if (relationTypeIds.level1.length > 0) {
         queryDocument = entityQueryDocumentLevel1;
       }
-      if (relationTypeIdsLevel2.length > 0) {
+      if (relationTypeIds.level2.length > 0) {
         queryDocument = entityQueryDocumentLevel2;
       }
 
       const result = await request<EntityQueryResult>(`${Graph.TESTNET_API_ORIGIN}/graphql`, queryDocument, {
         id,
         spaceId: space,
-        relationTypeIdsLevel1,
-        relationTypeIdsLevel2,
+        relationTypeIdsLevel1: relationTypeIds.level1,
+        relationTypeIdsLevel2: relationTypeIds.level2,
       });
       return result;
     },
@@ -270,11 +268,11 @@ export const useEntityPublic = <S extends Schema.Schema.AnyNoContext>(type: S, p
   });
 
   const { data, invalidEntity } = useMemo(() => {
-    if (result.data && mappingEntry) {
-      return parseResult(result.data, type, mappingEntry, mapping);
+    if (result.data) {
+      return parseResult(result.data, type);
     }
     return { data: null, invalidEntity: null };
-  }, [result.data, type, mappingEntry, mapping]);
+  }, [result.data, type]);
 
   return { ...result, data, invalidEntity };
 };
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index 60d64a98..de16e99b 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -1,7 +1,6 @@
 import { Graph } from '@graphprotocol/grc-20';
 import type { Entity } from '@graphprotocol/hypergraph';
-import { PropertyIdSymbol, TypeIdsSymbol } from '@graphprotocol/hypergraph/constants';
-import { isRelation } from '@graphprotocol/hypergraph/utils/isRelation';
+import { Constants } from '@graphprotocol/hypergraph';
 import { useQuery as useQueryTanstack } from '@tanstack/react-query';
 import * as Either from 'effect/Either';
 import * as Option from 'effect/Option';
@@ -11,6 +10,7 @@ import { gql, request } from 'graphql-request';
 import { useMemo } from 'react';
 import { convertPropertyValue } from './convert-property-value.js';
 import { convertRelations } from './convert-relations.js';
+import { getRelationTypeIds } from './get-relation-type-ids.js';
 import { translateFilterToGraphql } from './translate-filter-to-graphql.js';
 import type { QueryPublicParams } from './types.js';
 import { useHypergraphSpaceInternal } from './use-hypergraph-space-internal.js';
@@ -201,7 +201,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
 
     for (const prop of ast.propertySignatures) {
       const propType = prop.isOptional ? prop.type.types[0] : prop.type;
-      const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(propType);
+      const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(propType);
 
       if (Option.isSome(result)) {
         const value = queryEntity.valuesList.find((a) => a.propertyId === result.value);
@@ -242,63 +242,36 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
   const space = spaceFromParams ?? spaceFromContext;
 
   // constructing the relation type ids for the query
-  const relationTypeIdsLevel1: string[] = [];
-  const relationTypeIdsLevel2: string[] = [];
+  const relationTypeIds = getRelationTypeIds(type, include);
 
-  const typeIds = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
+  const typeIds = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(type.ast as SchemaAST.TypeLiteral).pipe(
     Option.getOrElse(() => []),
   );
 
-  const ast = type.ast as SchemaAST.TypeLiteral;
-
-  for (const prop of ast.propertySignatures) {
-    if (!isRelation(prop.type)) continue;
-
-    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
-    if (Option.isSome(result) && include?.[prop.name]) {
-      relationTypeIdsLevel1.push(result.value);
-      const relationTransformation = prop.type.rest?.[0]?.type;
-      const typeIds: string[] = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(relationTransformation).pipe(
-        Option.getOrElse(() => []),
-      );
-      if (typeIds.length === 0) {
-        continue;
-      }
-      for (const nestedProp of relationTransformation.propertySignatures) {
-        if (!isRelation(nestedProp.type)) continue;
-
-        const nestedResult = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(nestedProp.type);
-        if (Option.isSome(nestedResult) && include?.[prop.name][nestedProp.name]) {
-          relationTypeIdsLevel2.push(nestedResult.value);
-        }
-      }
-    }
-  }
-
   const result = useQueryTanstack({
     queryKey: [
       'hypergraph-public-entities',
       space,
       typeIds,
-      relationTypeIdsLevel1,
-      relationTypeIdsLevel2,
+      relationTypeIds.level1,
+      relationTypeIds.level2,
       filter,
       first,
     ],
     queryFn: async () => {
       let queryDocument = entitiesQueryDocumentLevel0;
-      if (relationTypeIdsLevel1.length > 0) {
+      if (relationTypeIds.level1.length > 0) {
         queryDocument = entitiesQueryDocumentLevel1;
       }
-      if (relationTypeIdsLevel2.length > 0) {
+      if (relationTypeIds.level2.length > 0) {
         queryDocument = entitiesQueryDocumentLevel2;
       }
 
       const result = await request<EntityQueryResult>(`${Graph.TESTNET_API_ORIGIN}/graphql`, queryDocument, {
         spaceId: space,
         typeIds,
-        relationTypeIdsLevel1,
-        relationTypeIdsLevel2,
+        relationTypeIdsLevel1: relationTypeIds.level1,
+        relationTypeIdsLevel2: relationTypeIds.level2,
         first,
         filter: filter ? translateFilterToGraphql(filter, type) : {},
       });
diff --git a/packages/hypergraph/src/index.ts b/packages/hypergraph/src/index.ts
index 1a105e7b..dc64ef2e 100644
--- a/packages/hypergraph/src/index.ts
+++ b/packages/hypergraph/src/index.ts
@@ -1,6 +1,7 @@
 export { Id } from '@graphprotocol/grc-20';
 export * as Typesync from './cli/services/Model.js';
 export * as Connect from './connect/index.js';
+export * as Constants from './constants.js';
 export { EntitySchema } from './entity/entity.js';
 export * as Entity from './entity/index.js';
 export * as Identity from './identity/index.js';
diff --git a/packages/hypergraph/src/utils/index.ts b/packages/hypergraph/src/utils/index.ts
index b35bb747..6544ac10 100644
--- a/packages/hypergraph/src/utils/index.ts
+++ b/packages/hypergraph/src/utils/index.ts
@@ -3,6 +3,7 @@ export * from './automergeId.js';
 export * from './base58.js';
 export * from './generateId.js';
 export * from './hexBytesAddressUtils.js';
+export * from './isRelation.js';
 export * from './isRelationField.js';
 export * from './jsc.js';
 export * from './stringToUint8Array.js';

From e5eee3df348862922c2e7c8bba6cbb6eeb1a3e61 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Mon, 6 Oct 2025 21:51:10 +0200
Subject: [PATCH 12/22] re-implement filters

---
 apps/events/src/components/event.tsx          |  2 +-
 apps/events/src/components/playground.tsx     |  7 +++---
 .../internal/translate-filter-to-graphql.ts   | 25 +++++++++----------
 .../src/internal/use-entity-public.tsx        |  5 +---
 .../src/internal/use-query-public.tsx         |  7 ++++--
 .../hypergraph-react/src/prepare-publish.ts   |  2 +-
 packages/hypergraph/src/index.ts              |  1 -
 .../hypergraph/src/type-utils/type-utils.ts   | 21 ----------------
 8 files changed, 24 insertions(+), 46 deletions(-)
 delete mode 100644 packages/hypergraph/src/type-utils/type-utils.ts

diff --git a/apps/events/src/components/event.tsx b/apps/events/src/components/event.tsx
index 5ba8bda4..ffc06c4f 100644
--- a/apps/events/src/components/event.tsx
+++ b/apps/events/src/components/event.tsx
@@ -13,7 +13,7 @@ export const Event = ({ spaceId, entityId }: { spaceId: string; entityId: string
     space: spaceId,
   });
 
-  console.log({ component: 'Event', isPending, isError, data });
+  // console.log({ component: 'Event', isPending, isError, data });
 
   return (
     <div>
diff --git a/apps/events/src/components/playground.tsx b/apps/events/src/components/playground.tsx
index 9833b723..9cffe29a 100644
--- a/apps/events/src/components/playground.tsx
+++ b/apps/events/src/components/playground.tsx
@@ -11,9 +11,10 @@ export const Playground = ({ spaceId }: { spaceId: string }) => {
         jobOffers: {},
       },
     },
-    // filter: {
-    //   or: [{ name: { startsWith: 'test' } }, { name: { startsWith: 'ETH' } }],
-    // },
+    filter: {
+      or: [{ name: { startsWith: 'My' } }, { name: { startsWith: 'ETH' } }],
+    },
+    // filter: { name: { startsWith: 'My Test Event' } },
     first: 100,
     space: spaceId,
   });
diff --git a/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts b/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
index d1da6e4d..2814afc6 100644
--- a/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
+++ b/packages/hypergraph-react/src/internal/translate-filter-to-graphql.ts
@@ -1,6 +1,6 @@
 import { Graph } from '@graphprotocol/grc-20';
-import { type Entity, TypeUtils } from '@graphprotocol/hypergraph';
-import { PropertyIdSymbol } from '@graphprotocol/hypergraph/constants';
+import { Constants, type Entity } from '@graphprotocol/hypergraph';
+import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
@@ -72,17 +72,19 @@ export function translateFilterToGraphql<S extends Schema.Schema.AnyNoContext>(
     if (!propertySignature) continue;
 
     // find the property id for the field
-    const propertyId = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(propertySignature.type);
-    if (!propertyId) continue;
+    const propertyId = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(propertySignature.type);
+    const propertyType = SchemaAST.getAnnotation<string>(Constants.PropertyTypeSymbol)(propertySignature.type);
+
+    if (!Option.isSome(propertyId) || !Option.isSome(propertyType)) continue;
 
     if (
-      TypeUtils.isStringOrOptionalStringType(type.fields[fieldName]) &&
+      propertyType.value === 'string' &&
       (fieldFilter.is || fieldFilter.startsWith || fieldFilter.endsWith || fieldFilter.contains)
     ) {
       graphqlFilter.push({
         values: {
           some: {
-            propertyId: { is: propertyId },
+            propertyId: { is: propertyId.value },
             string: fieldFilter.is
               ? { is: fieldFilter.is }
               : fieldFilter.startsWith
@@ -95,25 +97,22 @@ export function translateFilterToGraphql<S extends Schema.Schema.AnyNoContext>(
       });
     }
 
-    if (TypeUtils.isBooleanOrOptionalBooleanType(type.fields[fieldName]) && fieldFilter.is) {
+    if (propertyType.value === 'boolean' && fieldFilter.is) {
       graphqlFilter.push({
         values: {
           some: {
-            propertyId: { is: propertyId },
+            propertyId: { is: propertyId.value },
             boolean: { is: fieldFilter.is },
           },
         },
       });
     }
 
-    if (
-      TypeUtils.isNumberOrOptionalNumberType(type.fields[fieldName]) &&
-      (fieldFilter.is || fieldFilter.greaterThan || fieldFilter.lessThan)
-    ) {
+    if (propertyType.value === 'number' && (fieldFilter.is || fieldFilter.greaterThan || fieldFilter.lessThan)) {
       graphqlFilter.push({
         values: {
           some: {
-            propertyId: { is: propertyId },
+            propertyId: { is: propertyId.value },
             number: fieldFilter.is
               ? { is: Graph.serializeNumber(fieldFilter.is) }
               : fieldFilter.greaterThan
diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index da8f3b43..616d6fbc 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -204,8 +204,6 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
     ...convertRelations(queryEntity, ast),
   };
 
-  console.log('rawEntity', rawEntity);
-
   const decodeResult = decode({
     ...rawEntity,
     __deleted: false,
@@ -213,10 +211,9 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
     __version: '',
   });
 
-  console.log('decodeResult', decodeResult);
-
   if (Either.isRight(decodeResult)) {
     return {
+      // injecting the schema to the entity to be able to access it in the preparePublish function
       data: { ...decodeResult.right, __schema: type } as Entity.Entity<S>,
       invalidEntity: null,
     };
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index de16e99b..9833968b 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -227,7 +227,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
     });
 
     if (Either.isRight(decodeResult)) {
-      // TODO: do we need __schema here?
+      // injecting the schema to the entity to be able to access it in the preparePublish function
       data.push({ ...decodeResult.right, __schema: type });
     } else {
       invalidEntities.push(rawEntity);
@@ -267,13 +267,16 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
         queryDocument = entitiesQueryDocumentLevel2;
       }
 
+      const filterResult = filter ? translateFilterToGraphql(filter, type) : {};
+      console.log('filterResult', filterResult);
+
       const result = await request<EntityQueryResult>(`${Graph.TESTNET_API_ORIGIN}/graphql`, queryDocument, {
         spaceId: space,
         typeIds,
         relationTypeIdsLevel1: relationTypeIds.level1,
         relationTypeIdsLevel2: relationTypeIds.level2,
         first,
-        filter: filter ? translateFilterToGraphql(filter, type) : {},
+        filter: filterResult,
       });
       return result;
     },
diff --git a/packages/hypergraph-react/src/prepare-publish.ts b/packages/hypergraph-react/src/prepare-publish.ts
index b485607e..bf7a04b1 100644
--- a/packages/hypergraph-react/src/prepare-publish.ts
+++ b/packages/hypergraph-react/src/prepare-publish.ts
@@ -7,7 +7,7 @@ import {
   type RelationsParam,
 } from '@graphprotocol/grc-20';
 import type { Entity } from '@graphprotocol/hypergraph';
-import { store, TypeUtils } from '@graphprotocol/hypergraph';
+import { store } from '@graphprotocol/hypergraph';
 import type * as Schema from 'effect/Schema';
 import request, { gql } from 'graphql-request';
 
diff --git a/packages/hypergraph/src/index.ts b/packages/hypergraph/src/index.ts
index dc64ef2e..a12650e3 100644
--- a/packages/hypergraph/src/index.ts
+++ b/packages/hypergraph/src/index.ts
@@ -14,7 +14,6 @@ export * as SpaceEvents from './space-events/index.js';
 export * as SpaceInfo from './space-info/index.js';
 export * as StoreConnect from './store-connect.js';
 export * from './store.js';
-export * as TypeUtils from './type-utils/type-utils.js';
 export * as Type from './type/type.js';
 export * from './types.js';
 export * as Utils from './utils/index.js';
diff --git a/packages/hypergraph/src/type-utils/type-utils.ts b/packages/hypergraph/src/type-utils/type-utils.ts
deleted file mode 100644
index bbac8f6c..00000000
--- a/packages/hypergraph/src/type-utils/type-utils.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import * as Type from '../type/type.js';
-
-export const isStringType = (type: any) => {
-  return type === Type.String;
-};
-
-export const isNumberType = (type: any) => {
-  return type === Type.Number;
-};
-
-export const isDateType = (type: any) => {
-  return type === Type.Date;
-};
-
-export const isBooleanType = (type: any) => {
-  return type === Type.Boolean;
-};
-
-export const isPointType = (type: any) => {
-  return type === Type.Point;
-};

From 5324cc8b4069b7ac33e4f7648616ba8f1a675ac9 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Mon, 6 Oct 2025 22:01:46 +0200
Subject: [PATCH 13/22] cleanup

---
 .../src/hooks/use-create-entity.ts            |  2 +-
 packages/hypergraph/src/entity/create.ts      | 59 +------------------
 packages/hypergraph/src/entity/findMany.ts    |  7 ---
 .../src/entity/getEntityRelations.ts          |  4 +-
 packages/hypergraph/src/utils/index.ts        |  1 -
 .../hypergraph/src/utils/isRelationField.ts   |  9 ---
 6 files changed, 6 insertions(+), 76 deletions(-)
 delete mode 100644 packages/hypergraph/src/utils/isRelationField.ts

diff --git a/packages/hypergraph-react/src/hooks/use-create-entity.ts b/packages/hypergraph-react/src/hooks/use-create-entity.ts
index f995eec3..842bf69b 100644
--- a/packages/hypergraph-react/src/hooks/use-create-entity.ts
+++ b/packages/hypergraph-react/src/hooks/use-create-entity.ts
@@ -15,5 +15,5 @@ export function useCreateEntity<const S extends Schema.Schema.AnyNoContext>(type
       throw new Error('Space not found or not ready');
     };
   }
-  return Entity.createNew(handle, type);
+  return Entity.create(handle, type);
 }
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index 64aa22bb..e14c0f41 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -1,14 +1,13 @@
 import type { DocHandle } from '@automerge/automerge-repo';
 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 { PropertyIdSymbol } from '../constants.js';
 import { generateId } from '../utils/generateId.js';
 import { isRelation } from '../utils/isRelation.js';
-import { isRelationField } from '../utils/isRelationField.js';
 import { encodeToGrc20Json } from './entity.js';
 import { findOne } from './findOne.js';
-import type { AnyNoContext, DocumentContent, DocumentRelation, Entity, Insert } from './types.js';
+import type { DocumentContent, DocumentRelation, Entity } from './types.js';
 
 /**
  * Type utility to transform relation fields to accept string arrays instead of their typed values
@@ -26,59 +25,7 @@ type WithRelationsAsStringArrays<T> = {
       : T[K];
 };
 
-/**
- * Creates an entity model of given type and stores it in the repo.
- */
-export const create = <const S extends AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
-  // TODO: what's the right way to get the name of the type?
-  // @ts-expect-error name is defined
-  const typeName = type.name;
-  const encode = Schema.encodeSync(type.insert);
-
-  return (data: Readonly<Schema.Schema.Type<Insert<S>>>): Entity<S> => {
-    const entityId = generateId();
-    const encoded = encode(data);
-
-    const relations: Record<string, DocumentRelation> = {};
-
-    for (const [propertyName, field] of Object.entries(type.fields)) {
-      if (isRelationField(field) && encoded[propertyName]) {
-        for (const toEntityId of encoded[propertyName]) {
-          const relationId = generateId();
-          relations[relationId] = {
-            from: entityId,
-            to: toEntityId,
-            fromTypeName: typeName,
-            fromPropertyName: propertyName,
-            __deleted: false,
-          };
-        }
-        // we create the relation object in the repo, so we don't need it in the entity
-        delete encoded[propertyName];
-      }
-    }
-
-    // apply changes to the repo -> adds the entity to the repo entities document
-    handle.change((doc) => {
-      doc.entities ??= {};
-      doc.entities[entityId] = {
-        ...encoded,
-        '@@types@@': [typeName],
-        __deleted: false,
-        __version: '',
-      };
-      doc.relations ??= {};
-      // merge relations with existing relations
-      for (const [relationId, relation] of Object.entries(relations)) {
-        doc.relations[relationId] = relation;
-      }
-    });
-
-    return findOne(handle, type)(entityId) as Entity<S>;
-  };
-};
-
-export const createNew = <const S extends Schema.Schema.AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
+export const create = <const S extends Schema.Schema.AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
   return (data: Readonly<WithRelationsAsStringArrays<Schema.Schema.Type<S>>>): Entity<S> => {
     const entityId = generateId();
     const encoded = encodeToGrc20Json(type, { ...data, id: entityId });
diff --git a/packages/hypergraph/src/entity/findMany.ts b/packages/hypergraph/src/entity/findMany.ts
index 5640b848..9fcc0b72 100644
--- a/packages/hypergraph/src/entity/findMany.ts
+++ b/packages/hypergraph/src/entity/findMany.ts
@@ -444,13 +444,6 @@ export function subscribeToFindMany<const S extends Schema.Schema.AnyNoContext>(
     return query.data;
   };
 
-  // const allTypes = new Set<S>();
-  // for (const [_key, field] of Object.entries(type.fields)) {
-  //   if (isRelationField(field)) {
-  //     allTypes.add(field as S);
-  //   }
-  // }
-
   const subscribe = (callback: () => void) => {
     let cacheEntry = decodedEntitiesCache.get(canonicalize(typeIds));
 
diff --git a/packages/hypergraph/src/entity/getEntityRelations.ts b/packages/hypergraph/src/entity/getEntityRelations.ts
index 8da6a638..9e68c550 100644
--- a/packages/hypergraph/src/entity/getEntityRelations.ts
+++ b/packages/hypergraph/src/entity/getEntityRelations.ts
@@ -4,6 +4,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { PropertyIdSymbol, RelationSchemaSymbol } from '../constants.js';
 import { isRelation } from '../utils/isRelation.js';
 import { decodeFromGrc20Json } from './entity.js';
+import { hasValidTypesProperty } from './hasValidTypesProperty.js';
 import type { DocumentContent, Entity } from './types.js';
 
 export const getEntityRelations = <const S extends Schema.Schema.AnyNoContext>(
@@ -38,8 +39,7 @@ export const getEntityRelations = <const S extends Schema.Schema.AnyNoContext>(
 
         const relationEntity = doc.entities?.[relation.to];
         const decodedRelationEntity = { ...decodeFromGrc20Json(schema.value, { ...relationEntity, id: relation.to }) };
-        // TODO: should we check if the relation entity is valid?
-        // if (!hasValidTypesProperty(relationEntity)) continue;
+        if (!hasValidTypesProperty(relationEntity)) continue;
 
         relationEntities.push({ ...decodedRelationEntity, id: relation.to, _relation: { id: relationId } });
       }
diff --git a/packages/hypergraph/src/utils/index.ts b/packages/hypergraph/src/utils/index.ts
index 6544ac10..ee566629 100644
--- a/packages/hypergraph/src/utils/index.ts
+++ b/packages/hypergraph/src/utils/index.ts
@@ -4,6 +4,5 @@ export * from './base58.js';
 export * from './generateId.js';
 export * from './hexBytesAddressUtils.js';
 export * from './isRelation.js';
-export * from './isRelationField.js';
 export * from './jsc.js';
 export * from './stringToUint8Array.js';
diff --git a/packages/hypergraph/src/utils/isRelationField.ts b/packages/hypergraph/src/utils/isRelationField.ts
deleted file mode 100644
index 00aa0e51..00000000
--- a/packages/hypergraph/src/utils/isRelationField.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import type * as Schema from 'effect/Schema';
-
-export const isRelationField = (field: Schema.Schema.All | Schema.PropertySignature.All<PropertyKey>) => {
-  // TODO: improve this check
-  if (field.ast._tag === 'TupleType') {
-    return true;
-  }
-  return false;
-};

From 64ba7f426e9453820bc6625f952bb982b2633cc9 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Mon, 6 Oct 2025 22:08:14 +0200
Subject: [PATCH 14/22] cleanup imports

---
 .../src/internal/convert-property-value.ts            |  4 ++--
 .../src/internal/convert-relations.ts                 | 11 +++++------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/packages/hypergraph-react/src/internal/convert-property-value.ts b/packages/hypergraph-react/src/internal/convert-property-value.ts
index b93f9216..92874bea 100644
--- a/packages/hypergraph-react/src/internal/convert-property-value.ts
+++ b/packages/hypergraph-react/src/internal/convert-property-value.ts
@@ -1,4 +1,4 @@
-import { PropertyTypeSymbol } from '@graphprotocol/hypergraph/constants';
+import { Constants } from '@graphprotocol/hypergraph';
 import * as Option from 'effect/Option';
 import * as SchemaAST from 'effect/SchemaAST';
 
@@ -6,7 +6,7 @@ export const convertPropertyValue = (
   property: { propertyId: string; string: string; boolean: boolean; number: number; time: string; point: string },
   type: SchemaAST.AST,
 ) => {
-  const propertyType = SchemaAST.getAnnotation<string>(PropertyTypeSymbol)(type);
+  const propertyType = SchemaAST.getAnnotation<string>(Constants.PropertyTypeSymbol)(type);
   if (Option.isSome(propertyType)) {
     if (propertyType.value === 'string') {
       return property.string;
diff --git a/packages/hypergraph-react/src/internal/convert-relations.ts b/packages/hypergraph-react/src/internal/convert-relations.ts
index 50a07606..2b19b2bf 100644
--- a/packages/hypergraph-react/src/internal/convert-relations.ts
+++ b/packages/hypergraph-react/src/internal/convert-relations.ts
@@ -1,5 +1,4 @@
-import { PropertyIdSymbol, TypeIdsSymbol } from '@graphprotocol/hypergraph/constants';
-import { isRelation } from '@graphprotocol/hypergraph/utils/isRelation';
+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';
@@ -34,13 +33,13 @@ export const convertRelations = <S extends Schema.Schema.AnyNoContext>(
   const rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {};
 
   for (const prop of ast.propertySignatures) {
-    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+    const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
 
-    if (isRelation(prop.type) && Option.isSome(result)) {
+    if (Utils.isRelation(prop.type) && Option.isSome(result)) {
       rawEntity[String(prop.name)] = [];
 
       const relationTransformation = prop.type.rest?.[0]?.type;
-      const typeIds: string[] = SchemaAST.getAnnotation<string[]>(TypeIdsSymbol)(relationTransformation).pipe(
+      const typeIds: string[] = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(relationTransformation).pipe(
         Option.getOrElse(() => []),
       );
       if (typeIds.length === 0) {
@@ -69,7 +68,7 @@ export const convertRelations = <S extends Schema.Schema.AnyNoContext>(
           };
 
           for (const nestedProp of relationTransformation.propertySignatures) {
-            const nestedResult = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(nestedProp.type);
+            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) {

From 21463da91c1134791be17c5edc7745a3f3f02523 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 12:06:01 +0200
Subject: [PATCH 15/22] improve types

---
 .../hypergraph-react/src/internal/use-entity-public.tsx     | 6 +++++-
 packages/hypergraph-react/src/internal/use-query-public.tsx | 6 +++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index 616d6fbc..c7414f26 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -185,7 +185,11 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
   const ast = type.ast as SchemaAST.TypeLiteral;
 
   for (const prop of ast.propertySignatures) {
-    const propType = prop.isOptional ? prop.type.types[0] : prop.type;
+    const propType =
+      prop.isOptional && SchemaAST.isUnion(prop.type)
+        ? (prop.type.types.find((member) => !SchemaAST.isUndefinedKeyword(member)) ?? prop.type)
+        : prop.type;
+
     const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(propType);
 
     if (Option.isSome(result)) {
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index 9833968b..a6d602cc 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -200,7 +200,11 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
     const ast = type.ast as SchemaAST.TypeLiteral;
 
     for (const prop of ast.propertySignatures) {
-      const propType = prop.isOptional ? prop.type.types[0] : prop.type;
+      const propType =
+        prop.isOptional && SchemaAST.isUnion(prop.type)
+          ? (prop.type.types.find((member) => !SchemaAST.isUndefinedKeyword(member)) ?? prop.type)
+          : prop.type;
+
       const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(propType);
 
       if (Option.isSome(result)) {

From 61ceb2259db13fda27ce1caec353c4ce8d0436ee Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 14:44:07 +0200
Subject: [PATCH 16/22] fix type issues

---
 .../src/internal/use-entity-public.tsx            |  4 ++--
 .../src/internal/use-query-public.tsx             | 10 ++++------
 packages/hypergraph/src/type/type.ts              | 15 ++++++++++++---
 packages/hypergraph/src/utils/addIdSchemaField.ts |  8 ++++++++
 packages/hypergraph/src/utils/index.ts            |  1 +
 5 files changed, 27 insertions(+), 11 deletions(-)
 create mode 100644 packages/hypergraph/src/utils/addIdSchemaField.ts

diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index c7414f26..9990f4ba 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -1,5 +1,5 @@
 import { Graph } from '@graphprotocol/grc-20';
-import { Constants, type Entity } from '@graphprotocol/hypergraph';
+import { Constants, type Entity, Utils } from '@graphprotocol/hypergraph';
 import { useQuery as useQueryTanstack } from '@tanstack/react-query';
 import * as Either from 'effect/Either';
 import * as Option from 'effect/Option';
@@ -175,7 +175,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
     return { data: null, invalidEntity: null };
   }
 
-  const schemaWithId = Schema.extend(Schema.Struct({ id: Schema.String }))(type);
+  const schemaWithId = Utils.addIdSchemaField(type);
   const decode = Schema.decodeUnknownEither(schemaWithId);
   const queryEntity = queryData.entity;
   let rawEntity: Record<string, string | boolean | number | unknown[] | Date> = {
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index a6d602cc..28793a28 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -1,6 +1,5 @@
 import { Graph } from '@graphprotocol/grc-20';
-import type { Entity } from '@graphprotocol/hypergraph';
-import { Constants } from '@graphprotocol/hypergraph';
+import { Constants, type Entity, Utils } from '@graphprotocol/hypergraph';
 import { useQuery as useQueryTanstack } from '@tanstack/react-query';
 import * as Either from 'effect/Either';
 import * as Option from 'effect/Option';
@@ -187,7 +186,7 @@ type EntityQueryResult = {
 };
 
 export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: EntityQueryResult, type: S) => {
-  const schemaWithId = Schema.extend(Schema.Struct({ id: Schema.String }))(type);
+  const schemaWithId = Utils.addIdSchemaField(type);
   const decode = Schema.decodeUnknownEither(schemaWithId);
   const data: Entity.Entity<S>[] = [];
   const invalidEntities: Record<string, unknown>[] = [];
@@ -271,8 +270,7 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
         queryDocument = entitiesQueryDocumentLevel2;
       }
 
-      const filterResult = filter ? translateFilterToGraphql(filter, type) : {};
-      console.log('filterResult', filterResult);
+      const filterParams = filter ? translateFilterToGraphql(filter, type) : {};
 
       const result = await request<EntityQueryResult>(`${Graph.TESTNET_API_ORIGIN}/graphql`, queryDocument, {
         spaceId: space,
@@ -280,7 +278,7 @@ export const useQueryPublic = <S extends Schema.Schema.AnyNoContext>(type: S, pa
         relationTypeIdsLevel1: relationTypeIds.level1,
         relationTypeIdsLevel2: relationTypeIds.level2,
         first,
-        filter: filterResult,
+        filter: filterParams,
       });
       return result;
     },
diff --git a/packages/hypergraph/src/type/type.ts b/packages/hypergraph/src/type/type.ts
index 4c227c8d..03a59fe3 100644
--- a/packages/hypergraph/src/type/type.ts
+++ b/packages/hypergraph/src/type/type.ts
@@ -57,10 +57,19 @@ export const Relation =
       Option.getOrElse(() => []),
     );
 
-    const schemaWithId = Schema.extend(schema)(
-      Schema.Struct({ id: Schema.String, _relation: Schema.Struct({ id: Schema.String }) }),
+    const schemaWithId = Schema.asSchema(
+      Schema.extend(schema)(
+        Schema.Struct({
+          id: Schema.String,
+          _relation: 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 }));
+    ).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 } },
+      never
+    >;
 
     return Schema.Array(schemaWithId).pipe(
       Schema.annotations({
diff --git a/packages/hypergraph/src/utils/addIdSchemaField.ts b/packages/hypergraph/src/utils/addIdSchemaField.ts
new file mode 100644
index 00000000..626ac18e
--- /dev/null
+++ b/packages/hypergraph/src/utils/addIdSchemaField.ts
@@ -0,0 +1,8 @@
+import * as Schema from 'effect/Schema';
+
+export const addIdSchemaField = <S extends Schema.Schema.AnyNoContext>(schema: S) =>
+  Schema.asSchema(Schema.extend(Schema.Struct({ id: Schema.String }))(schema)) as Schema.Schema<
+    Schema.Schema.Type<S> & { readonly id: string },
+    Schema.Schema.Encoded<S> & { readonly id: string },
+    never
+  >;
diff --git a/packages/hypergraph/src/utils/index.ts b/packages/hypergraph/src/utils/index.ts
index ee566629..4ea5aa16 100644
--- a/packages/hypergraph/src/utils/index.ts
+++ b/packages/hypergraph/src/utils/index.ts
@@ -1,3 +1,4 @@
+export * from './addIdSchemaField.js';
 export * from './assertExhaustive.js';
 export * from './automergeId.js';
 export * from './base58.js';

From 6267464b89641ab684d130b7f7141ea5c1f3c827 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 15:55:44 +0200
Subject: [PATCH 17/22] fix types

---
 .../src/internal/convert-relations.ts         | 20 ++++++++++++++-----
 .../src/internal/get-relation-type-ids.ts     | 12 ++++++++---
 2 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/packages/hypergraph-react/src/internal/convert-relations.ts b/packages/hypergraph-react/src/internal/convert-relations.ts
index 2b19b2bf..841e61dc 100644
--- a/packages/hypergraph-react/src/internal/convert-relations.ts
+++ b/packages/hypergraph-react/src/internal/convert-relations.ts
@@ -26,11 +26,15 @@ type RecursiveQueryEntity = {
   }[];
 };
 
+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: Record<string, string | boolean | number | unknown[] | Date> = {};
+  const rawEntity: RawEntity = {};
 
   for (const prop of ast.propertySignatures) {
     const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
@@ -38,7 +42,15 @@ export const convertRelations = <S extends Schema.Schema.AnyNoContext>(
     if (Utils.isRelation(prop.type) && Option.isSome(result)) {
       rawEntity[String(prop.name)] = [];
 
-      const relationTransformation = prop.type.rest?.[0]?.type;
+      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(() => []),
       );
@@ -51,9 +63,7 @@ export const convertRelations = <S extends Schema.Schema.AnyNoContext>(
       );
       if (allRelationsWithTheCorrectPropertyTypeId) {
         for (const relationEntry of allRelationsWithTheCorrectPropertyTypeId) {
-          let nestedRawEntity:
-            | Record<string, string | boolean | number | unknown[] | Date>
-            | { _relation: { id: string } } = {
+          let nestedRawEntity: NestedRawEntity = {
             id: relationEntry.toEntity.id,
             _relation: {
               id: relationEntry.id,
diff --git a/packages/hypergraph-react/src/internal/get-relation-type-ids.ts b/packages/hypergraph-react/src/internal/get-relation-type-ids.ts
index 71eef6cc..75ca0c2a 100644
--- a/packages/hypergraph-react/src/internal/get-relation-type-ids.ts
+++ b/packages/hypergraph-react/src/internal/get-relation-type-ids.ts
@@ -18,9 +18,15 @@ export const getRelationTypeIds = (
     if (!Utils.isRelation(prop.type)) continue;
 
     const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
-    if (Option.isSome(result) && include?.[prop.name]) {
+    if (Option.isSome(result) && include?.[String(prop.name)]) {
       relationTypeIdsLevel1.push(result.value);
-      const relationTransformation = prop.type.rest?.[0]?.type;
+      if (!SchemaAST.isTupleType(prop.type)) {
+        continue;
+      }
+      const relationTransformation = prop.type.rest[0]?.type;
+      if (!relationTransformation || !SchemaAST.isTypeLiteral(relationTransformation)) {
+        continue;
+      }
       const typeIds2: string[] = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(
         relationTransformation,
       ).pipe(Option.getOrElse(() => []));
@@ -31,7 +37,7 @@ export const getRelationTypeIds = (
         if (!Utils.isRelation(nestedProp.type)) continue;
 
         const nestedResult = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(nestedProp.type);
-        if (Option.isSome(nestedResult) && include?.[prop.name][nestedProp.name]) {
+        if (Option.isSome(nestedResult) && include?.[String(prop.name)]?.[String(nestedProp.name)]) {
           relationTypeIdsLevel2.push(nestedResult.value);
         }
       }

From e965c6d334431a7a968b4bb7a938b06bdc25a32d Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 16:08:10 +0200
Subject: [PATCH 18/22] implement prepare publish

---
 .../hypergraph-react/src/prepare-publish.ts   | 139 +++++++-----------
 1 file changed, 51 insertions(+), 88 deletions(-)

diff --git a/packages/hypergraph-react/src/prepare-publish.ts b/packages/hypergraph-react/src/prepare-publish.ts
index bf7a04b1..589272f3 100644
--- a/packages/hypergraph-react/src/prepare-publish.ts
+++ b/packages/hypergraph-react/src/prepare-publish.ts
@@ -1,14 +1,8 @@
-import {
-  type EntityRelationParams,
-  Graph,
-  type Id,
-  type Op,
-  type PropertiesParam,
-  type RelationsParam,
-} from '@graphprotocol/grc-20';
-import type { Entity } from '@graphprotocol/hypergraph';
-import { store } from '@graphprotocol/hypergraph';
+import { Graph, type Id, type Op, type PropertiesParam, type RelationsParam } from '@graphprotocol/grc-20';
+import { Constants, type Entity, Utils } from '@graphprotocol/hypergraph';
+import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import request, { gql } from 'graphql-request';
 
 export type PreparePublishParams<S extends Schema.Schema.AnyNoContext> = {
@@ -63,54 +57,57 @@ export const preparePublish = async <S extends Schema.Schema.AnyNoContext>({
     },
   );
 
-  const mapping = store.getSnapshot().context.mapping;
-  const typeName = entity.type;
-  const mappingEntry = mapping[typeName];
-  if (!mappingEntry) {
-    throw new Error(`Mapping entry for ${typeName} not found`);
-  }
-
   const ops: Op[] = [];
   const values: PropertiesParam = [];
   const relations: RelationsParam = {};
-  const fields = entity.__schema.fields;
+  const type = entity.__schema;
 
   if (data?.entity === null) {
-    for (const [key, propertyId] of Object.entries(mappingEntry.properties || {})) {
-      if (entity[key] === undefined) {
-        if (TypeUtils.isOptional(fields[key])) {
-          continue;
-        }
-        throw new Error(`Value for ${key} is undefined`);
-      }
-      let serializedValue: string = entity[key];
-      if (TypeUtils.isBooleanOrOptionalBooleanType(fields[key])) {
-        serializedValue = Graph.serializeBoolean(entity[key]);
-      } else if (TypeUtils.isDateOrOptionalDateType(fields[key])) {
-        serializedValue = Graph.serializeDate(entity[key]);
-      } else if (TypeUtils.isPointOrOptionalPointType(fields[key])) {
-        serializedValue = Graph.serializePoint(entity[key]);
-      } else if (TypeUtils.isNumberOrOptionalNumberType(fields[key])) {
-        serializedValue = Graph.serializeNumber(entity[key]);
-      }
-      values.push({ property: propertyId, value: serializedValue });
-    }
-    for (const [key, relationId] of Object.entries(mappingEntry.relations || {})) {
-      // @ts-expect-error - TODO: fix the types error
-      relations[relationId] = entity[key].map((relationEntity) => {
-        const newRelation: EntityRelationParams = { toEntity: relationEntity.id };
-        if (relationEntity._relation.id) {
-          newRelation.id = relationEntity._relation.id;
+    const ast = type.ast as SchemaAST.TypeLiteral;
+
+    const typeIds = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(ast).pipe(Option.getOrElse(() => []));
+
+    for (const prop of ast.propertySignatures) {
+      const propertyId = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
+      const propertyType = SchemaAST.getAnnotation<string>(Constants.PropertyTypeSymbol)(prop.type);
+      if (!Option.isSome(propertyId) || !Option.isSome(propertyType)) continue;
+
+      if (Utils.isRelation(prop.type)) {
+        // @ts-expect-error any is ok here
+        relations[propertyId.value] = entity[prop.name].map((relationEntity) => {
+          const newRelation: Record<string, string> = { toEntity: relationEntity.id };
+          if (relationEntity._relation.id) {
+            newRelation.id = relationEntity._relation.id;
+          }
+          if (relationEntity._relation.position) {
+            newRelation.position = relationEntity._relation.position;
+          }
+          return newRelation;
+        });
+      } else {
+        if (entity[prop.name] === undefined) {
+          if (prop.isOptional) {
+            continue;
+          }
+          throw new Error(`Value for ${String(prop.name)} is undefined`);
         }
-        if (relationEntity._relation.position) {
-          newRelation.position = relationEntity._relation.position;
+        let serializedValue: string = entity[prop.name];
+        if (propertyType.value === 'boolean') {
+          serializedValue = Graph.serializeBoolean(entity[prop.name]);
+        } else if (propertyType.value === 'date') {
+          serializedValue = Graph.serializeDate(entity[prop.name]);
+        } else if (propertyType.value === 'point') {
+          serializedValue = Graph.serializePoint(entity[prop.name]);
+        } else if (propertyType.value === 'number') {
+          serializedValue = Graph.serializeNumber(entity[prop.name]);
         }
-        return newRelation;
-      });
+        values.push({ property: propertyId.value, value: serializedValue });
+      }
     }
+
     const { ops: createOps } = Graph.createEntity({
       id: entity.id,
-      types: mappingEntry.typeIds,
+      types: typeIds,
       values,
       relations,
     });
@@ -118,46 +115,12 @@ export const preparePublish = async <S extends Schema.Schema.AnyNoContext>({
     return { ops };
   }
 
-  if (data?.entity) {
-    for (const [key, propertyId] of Object.entries(mappingEntry.properties || {})) {
-      if (entity[key] === undefined) {
-        if (TypeUtils.isOptional(fields[key])) {
-          continue;
-        }
-        throw new Error(`Value for ${key} is undefined`);
-      }
-
-      const existingValueEntry = data.entity.valuesList.find((value) => value.propertyId === propertyId);
-      let existingValue = existingValueEntry?.string;
-      let serializedValue: string = entity[key];
-      if (TypeUtils.isBooleanOrOptionalBooleanType(fields[key])) {
-        existingValue =
-          existingValueEntry?.boolean !== undefined ? Graph.serializeBoolean(existingValueEntry.boolean) : undefined;
-        serializedValue = Graph.serializeBoolean(entity[key]);
-      } else if (TypeUtils.isDateOrOptionalDateType(fields[key])) {
-        existingValue = existingValueEntry?.time;
-        serializedValue = Graph.serializeDate(entity[key]);
-      } else if (TypeUtils.isPointOrOptionalPointType(fields[key])) {
-        existingValue = existingValueEntry?.point;
-        serializedValue = Graph.serializePoint(entity[key]);
-      } else if (TypeUtils.isNumberOrOptionalNumberType(fields[key])) {
-        existingValue =
-          existingValueEntry?.number !== undefined ? Graph.serializeNumber(existingValueEntry.number) : undefined;
-        serializedValue = Graph.serializeNumber(entity[key]);
-      }
-
-      if (serializedValue !== existingValue) {
-        values.push({ property: propertyId, value: serializedValue });
-      }
-    }
-
-    // TODO: handle added or removed relations
-    // TODO: handle updated relations
-    // TODO: handle added or removed types
-    if (values.length > 0) {
-      const { ops: updateEntityOps } = Graph.updateEntity({ id: entity.id, values });
-      ops.push(...updateEntityOps);
-    }
+  // TODO: handle added or removed relations
+  // TODO: handle updated relations
+  // TODO: handle added or removed types
+  if (values.length > 0) {
+    const { ops: updateEntityOps } = Graph.updateEntity({ id: entity.id, values });
+    ops.push(...updateEntityOps);
   }
 
   return { ops };

From dc9cc6ba37d0324b567b7dde8f70636f3fca5324 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 16:08:27 +0200
Subject: [PATCH 19/22] remove mapping and fix types

---
 apps/privy-login-example/src/Boot.tsx         |   7 +-
 apps/privy-login-example/src/mapping.ts       |  61 --------
 apps/template-nextjs/app/Providers.tsx        |   4 +-
 apps/template-nextjs/app/mapping.ts           |  66 ---------
 apps/template-nextjs/app/schema.ts            | 139 +++++++++++++-----
 apps/template-vite-react/src/main.tsx         |   5 +-
 apps/template-vite-react/src/mapping.ts       |  66 ---------
 apps/template-vite-react/src/schema.ts        | 139 +++++++++++++-----
 .../src/HypergraphAppContext.tsx              |  10 +-
 .../src/internal/use-entity-public.tsx        |   1 +
 .../src/internal/use-query-public.tsx         |   1 +
 packages/hypergraph-react/src/types.ts        |   6 -
 .../src/entity/getEntityRelations.ts          |  15 +-
 13 files changed, 221 insertions(+), 299 deletions(-)
 delete mode 100644 apps/privy-login-example/src/mapping.ts
 delete mode 100644 apps/template-nextjs/app/mapping.ts
 delete mode 100644 apps/template-vite-react/src/mapping.ts

diff --git a/apps/privy-login-example/src/Boot.tsx b/apps/privy-login-example/src/Boot.tsx
index a4eb2bba..06c7f1fe 100644
--- a/apps/privy-login-example/src/Boot.tsx
+++ b/apps/privy-login-example/src/Boot.tsx
@@ -1,7 +1,6 @@
 import { HypergraphAppProvider } from '@graphprotocol/hypergraph-react';
 import { PrivyProvider } from '@privy-io/react-auth';
 import { createRouter, RouterProvider } from '@tanstack/react-router';
-import { mapping } from './mapping.js';
 import { routeTree } from './routeTree.gen';
 
 // Create a new router instance
@@ -29,11 +28,7 @@ export function Boot() {
         },
       }}
     >
-      <HypergraphAppProvider
-        syncServerUri="http://localhost:3030"
-        mapping={mapping}
-        appId="93bb8907-085a-4a0e-83dd-62b0dc98e793"
-      >
+      <HypergraphAppProvider syncServerUri="http://localhost:3030" appId="93bb8907-085a-4a0e-83dd-62b0dc98e793">
         <RouterProvider router={router} />
       </HypergraphAppProvider>
     </PrivyProvider>
diff --git a/apps/privy-login-example/src/mapping.ts b/apps/privy-login-example/src/mapping.ts
deleted file mode 100644
index f811b62c..00000000
--- a/apps/privy-login-example/src/mapping.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import type { Mapping } from '@graphprotocol/hypergraph';
-import { Id } from '@graphprotocol/hypergraph';
-
-export const mapping: Mapping.Mapping = {
-  User: {
-    typeIds: [Id('bffa181e-a333-495b-949c-57f2831d7eca')],
-    properties: {
-      name: Id('c9c79675-850a-42c5-bbbd-9e5c55d3f4e7'),
-    },
-  },
-  Todo: {
-    typeIds: [Id('44fe82a9-e4c2-4330-a395-ce85ed78e421')],
-    properties: {
-      name: Id('c668aa67-bbca-4b2c-908c-9c5599035eab'),
-      completed: Id('71e7654f-2623-4794-88fb-841c8f3dd9b4'),
-    },
-    relations: {
-      assignees: Id('5b80d3ee-2463-4246-b628-44ba808ab3e1'),
-    },
-  },
-  Todo2: {
-    typeIds: [Id('210f4e94-234c-49d7-af0f-f3b74fb07650')],
-    properties: {
-      name: Id('e291f4da-632d-4b70-aca8-5c6c01dbf1ca'),
-      checked: Id('d1cc82ef-8bde-45f4-b31c-56b6d59279ec'),
-      due: Id('6a28f275-b31c-47bc-83cd-ad416aaa7073'),
-      amount: Id('0c8219be-e284-4738-bd95-91a1c113c78e'),
-      point: Id('7f032477-c60e-4c85-a161-019b70db05ca'),
-      website: Id('75b6a647-5c2b-41e7-92c0-b0a0c9b28b02'),
-    },
-    relations: {
-      assignees: Id('1115e9f8-db2e-41df-8969-c5d34c367c10'),
-    },
-  },
-  JobOffer: {
-    typeIds: [Id('f60585af-71b6-4674-9a26-b74ca6c1cceb')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      salary: Id('baa36ac9-78ac-4cf7-8394-6b2d3006bebe'),
-    },
-  },
-  Company: {
-    typeIds: [Id('6c504df5-1a8f-43d1-bf2d-1ef9fa5b08b5')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-    },
-    relations: {
-      jobOffers: Id('1203064e-9741-4235-89d4-97f4b22eddfb'),
-    },
-  },
-  Event: {
-    typeIds: [Id('7f9562d4-034d-4385-bf5c-f02cdebba47a')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-    },
-    relations: {
-      sponsors: Id('6860bfac-f703-4289-b789-972d0aaf3abe'),
-    },
-  },
-};
diff --git a/apps/template-nextjs/app/Providers.tsx b/apps/template-nextjs/app/Providers.tsx
index 5ab3d848..67c02bca 100644
--- a/apps/template-nextjs/app/Providers.tsx
+++ b/apps/template-nextjs/app/Providers.tsx
@@ -2,13 +2,11 @@
 
 import { HypergraphAppProvider } from '@graphprotocol/hypergraph-react';
 
-import { mapping } from './mapping';
-
 export default function Providers({ children }: Readonly<{ children: React.ReactNode }>) {
   const _storage = typeof window !== 'undefined' ? window.localStorage : (undefined as unknown as Storage);
 
   return (
-    <HypergraphAppProvider mapping={mapping} storage={_storage} appId="93bb8907-085a-4a0e-83dd-62b0dc98e793">
+    <HypergraphAppProvider storage={_storage} appId="93bb8907-085a-4a0e-83dd-62b0dc98e793">
       {children}
     </HypergraphAppProvider>
   );
diff --git a/apps/template-nextjs/app/mapping.ts b/apps/template-nextjs/app/mapping.ts
deleted file mode 100644
index 4c98dfab..00000000
--- a/apps/template-nextjs/app/mapping.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import type { Mapping } from '@graphprotocol/hypergraph';
-import { Id } from '@graphprotocol/hypergraph';
-
-export const mapping: Mapping.Mapping = {
-  Image: {
-    typeIds: [Id('ba4e4146-0010-499d-a0a3-caaa7f579d0e')],
-    properties: {
-      url: Id('8a743832-c094-4a62-b665-0c3cc2f9c7bc'),
-    },
-  },
-  Project: {
-    typeIds: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-      xUrl: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
-    },
-    relations: {
-      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
-    },
-  },
-  Dapp: {
-    typeIds: [Id('8ca136d0-698a-4bbf-a76b-8e2741b2dc8c')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-      xUrl: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
-      githubUrl: Id('9eedefa8-60ae-4ac1-9a04-805054a4b094'),
-    },
-    relations: {
-      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
-    },
-  },
-  Investor: {
-    typeIds: [Id('331aea18-973c-4adc-8f53-614f598d262d')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-    },
-  },
-  FundingStage: {
-    typeIds: [Id('8d35d217-3fa1-4686-b74f-fcb3e9438067')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-    },
-  },
-  InvestmentRound: {
-    typeIds: [Id('8f03f4c9-59e4-44a8-a625-c0a40b1ff330')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      raisedAmount: Id('16781706-dd9c-48bf-913e-cdf18b56034f'),
-    },
-    relations: {
-      investors: Id('9b8a610a-fa35-486e-a479-e253dbdabb4f'),
-      fundingStages: Id('e278c3d4-78b9-4222-b272-5a39a8556bd2'),
-      raisedBy: Id('b4878d1a-0609-488d-b8a6-e19862d6b62f'),
-    },
-  },
-  Asset: {
-    typeIds: [Id('f8780a80-c238-4a2a-96cb-567d88b1aa63')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      symbol: Id('ace1e96c-9b83-47b4-bd33-1d302ec0a0f5'),
-      blockchainAddress: Id('56b5944f-f059-48d1-b0fa-34abe84219da'),
-    },
-  },
-};
diff --git a/apps/template-nextjs/app/schema.ts b/apps/template-nextjs/app/schema.ts
index eee14ce1..fad1102e 100644
--- a/apps/template-nextjs/app/schema.ts
+++ b/apps/template-nextjs/app/schema.ts
@@ -1,42 +1,111 @@
-import { Entity, Type } from '@graphprotocol/hypergraph';
+import { EntitySchema, Id, Type } from '@graphprotocol/hypergraph';
 
-export class Image extends Entity.Class<Image>('Image')({
-  url: Type.String,
-}) {}
+export const Image = EntitySchema(
+  {
+    url: Type.String,
+  },
+  {
+    types: [Id('ba4e4146-0010-499d-a0a3-caaa7f579d0e')],
+    properties: {
+      url: Id('8a743832-c094-4a62-b665-0c3cc2f9c7bc'),
+    },
+  },
+);
 
-export class Project extends Entity.Class<Project>('Project')({
-  name: Type.String,
-  description: Type.optional(Type.String),
-  xUrl: Type.optional(Type.String),
-  avatar: Type.Relation(Image),
-}) {}
+export const Project = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    x: Type.optional(Type.String),
+    avatar: Type.Relation(Image),
+  },
+  {
+    types: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
+    properties: {
+      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 class Dapp extends Entity.Class<Dapp>('Dapp')({
-  name: Type.String,
-  description: Type.optional(Type.String),
-  xUrl: Type.optional(Type.String),
-  githubUrl: Type.optional(Type.String),
-  avatar: Type.Relation(Image),
-}) {}
+export const Dapp = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    x: Type.optional(Type.String),
+    github: Type.optional(Type.String),
+    avatar: Type.Relation(Image),
+  },
+  {
+    types: [Id('8ca136d0-698a-4bbf-a76b-8e2741b2dc8c')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
+      x: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
+      github: Id('9eedefa8-60ae-4ac1-9a04-805054a4b094'),
+      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
+    },
+  },
+);
 
-export class Investor extends Entity.Class<Investor>('Investor')({
-  name: Type.String,
-}) {}
+export const Investor = EntitySchema(
+  {
+    name: Type.String,
+  },
+  {
+    types: [Id('331aea18-973c-4adc-8f53-614f598d262d')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+    },
+  },
+);
 
-export class FundingStage extends Entity.Class<FundingStage>('FundingStage')({
-  name: Type.String,
-}) {}
+export const FundingStage = EntitySchema(
+  {
+    name: Type.String,
+  },
+  {
+    types: [Id('8d35d217-3fa1-4686-b74f-fcb3e9438067')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+    },
+  },
+);
 
-export class InvestmentRound extends Entity.Class<InvestmentRound>('InvestmentRound')({
-  name: Type.String,
-  raisedAmount: Type.optional(Type.Number),
-  investors: Type.Relation(Investor),
-  fundingStages: Type.Relation(FundingStage),
-  raisedBy: Type.Relation(Project),
-}) {}
+export const InvestmentRound = EntitySchema(
+  {
+    name: Type.String,
+    raisedAmount: Type.optional(Type.Number),
+    investors: Type.Relation(Investor),
+    fundingStages: Type.Relation(FundingStage),
+    raisedBy: Type.Relation(Project),
+  },
+  {
+    types: [Id('8f03f4c9-59e4-44a8-a625-c0a40b1ff330')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      raisedAmount: Id('16781706-dd9c-48bf-913e-cdf18b56034f'),
+      investors: Id('9b8a610a-fa35-486e-a479-e253dbdabb4f'),
+      fundingStages: Id('e278c3d4-78b9-4222-b272-5a39a8556bd2'),
+      raisedBy: Id('b4878d1a-0609-488d-b8a6-e19862d6b62f'),
+    },
+  },
+);
 
-export class Asset extends Entity.Class<Asset>('Asset')({
-  name: Type.String,
-  symbol: Type.optional(Type.String),
-  blockchainAddress: Type.optional(Type.String),
-}) {}
+export const Asset = EntitySchema(
+  {
+    name: Type.String,
+    symbol: Type.optional(Type.String),
+    blockchainAddress: Type.optional(Type.String),
+  },
+  {
+    types: [Id('f8780a80-c238-4a2a-96cb-567d88b1aa63')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      symbol: Id('ace1e96c-9b83-47b4-bd33-1d302ec0a0f5'),
+      blockchainAddress: Id('56b5944f-f059-48d1-b0fa-34abe84219da'),
+    },
+  },
+);
diff --git a/apps/template-vite-react/src/main.tsx b/apps/template-vite-react/src/main.tsx
index 0cfcb1ac..be4c0f8d 100644
--- a/apps/template-vite-react/src/main.tsx
+++ b/apps/template-vite-react/src/main.tsx
@@ -1,8 +1,7 @@
 import { HypergraphAppProvider } from '@graphprotocol/hypergraph-react';
-import { RouterProvider, createRouter } from '@tanstack/react-router';
+import { createRouter, RouterProvider } from '@tanstack/react-router';
 import ReactDOM from 'react-dom/client';
 import './index.css';
-import { mapping } from './mapping';
 
 // Import the generated route tree
 import { routeTree } from './routeTree.gen';
@@ -23,7 +22,7 @@ if (rootElement && !rootElement.innerHTML) {
   const root = ReactDOM.createRoot(rootElement);
   root.render(
     // <React.StrictMode>
-    <HypergraphAppProvider mapping={mapping} appId="93bb8907-085a-4a0e-83dd-62b0dc98e793">
+    <HypergraphAppProvider appId="93bb8907-085a-4a0e-83dd-62b0dc98e793">
       <RouterProvider router={router} />
     </HypergraphAppProvider>,
     // </React.StrictMode>,
diff --git a/apps/template-vite-react/src/mapping.ts b/apps/template-vite-react/src/mapping.ts
deleted file mode 100644
index 66aee2e1..00000000
--- a/apps/template-vite-react/src/mapping.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import type { Mapping } from '@graphprotocol/hypergraph';
-import { Id } from '@graphprotocol/hypergraph';
-
-export const mapping: Mapping.Mapping = {
-  Image: {
-    typeIds: [Id('ba4e4146-0010-499d-a0a3-caaa7f579d0e')],
-    properties: {
-      url: Id('8a743832-c094-4a62-b665-0c3cc2f9c7bc'),
-    },
-  },
-  Project: {
-    typeIds: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-      x: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
-    },
-    relations: {
-      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
-    },
-  },
-  Dapp: {
-    typeIds: [Id('8ca136d0-698a-4bbf-a76b-8e2741b2dc8c')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-      x: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
-      github: Id('9eedefa8-60ae-4ac1-9a04-805054a4b094'),
-    },
-    relations: {
-      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
-    },
-  },
-  Investor: {
-    typeIds: [Id('331aea18-973c-4adc-8f53-614f598d262d')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-    },
-  },
-  FundingStage: {
-    typeIds: [Id('8d35d217-3fa1-4686-b74f-fcb3e9438067')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-    },
-  },
-  InvestmentRound: {
-    typeIds: [Id('8f03f4c9-59e4-44a8-a625-c0a40b1ff330')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      raisedAmount: Id('16781706-dd9c-48bf-913e-cdf18b56034f'),
-    },
-    relations: {
-      investors: Id('9b8a610a-fa35-486e-a479-e253dbdabb4f'),
-      fundingStages: Id('e278c3d4-78b9-4222-b272-5a39a8556bd2'),
-      raisedBy: Id('b4878d1a-0609-488d-b8a6-e19862d6b62f'),
-    },
-  },
-  Asset: {
-    typeIds: [Id('f8780a80-c238-4a2a-96cb-567d88b1aa63')],
-    properties: {
-      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
-      symbol: Id('ace1e96c-9b83-47b4-bd33-1d302ec0a0f5'),
-      blockchainAddress: Id('56b5944f-f059-48d1-b0fa-34abe84219da'),
-    },
-  },
-};
diff --git a/apps/template-vite-react/src/schema.ts b/apps/template-vite-react/src/schema.ts
index d893c800..fad1102e 100644
--- a/apps/template-vite-react/src/schema.ts
+++ b/apps/template-vite-react/src/schema.ts
@@ -1,42 +1,111 @@
-import { Entity, Type } from '@graphprotocol/hypergraph';
+import { EntitySchema, Id, Type } from '@graphprotocol/hypergraph';
 
-export class Image extends Entity.Class<Image>('Image')({
-  url: Type.String,
-}) {}
+export const Image = EntitySchema(
+  {
+    url: Type.String,
+  },
+  {
+    types: [Id('ba4e4146-0010-499d-a0a3-caaa7f579d0e')],
+    properties: {
+      url: Id('8a743832-c094-4a62-b665-0c3cc2f9c7bc'),
+    },
+  },
+);
 
-export class Project extends Entity.Class<Project>('Project')({
-  name: Type.String,
-  description: Type.optional(Type.String),
-  x: Type.optional(Type.String),
-  avatar: Type.Relation(Image),
-}) {}
+export const Project = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    x: Type.optional(Type.String),
+    avatar: Type.Relation(Image),
+  },
+  {
+    types: [Id('484a18c5-030a-499c-b0f2-ef588ff16d50')],
+    properties: {
+      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 class Dapp extends Entity.Class<Dapp>('Dapp')({
-  name: Type.String,
-  description: Type.optional(Type.String),
-  x: Type.optional(Type.String),
-  github: Type.optional(Type.String),
-  avatar: Type.Relation(Image),
-}) {}
+export const Dapp = EntitySchema(
+  {
+    name: Type.String,
+    description: Type.optional(Type.String),
+    x: Type.optional(Type.String),
+    github: Type.optional(Type.String),
+    avatar: Type.Relation(Image),
+  },
+  {
+    types: [Id('8ca136d0-698a-4bbf-a76b-8e2741b2dc8c')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
+      x: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
+      github: Id('9eedefa8-60ae-4ac1-9a04-805054a4b094'),
+      avatar: Id('1155beff-fad5-49b7-a2e0-da4777b8792c'),
+    },
+  },
+);
 
-export class Investor extends Entity.Class<Investor>('Investor')({
-  name: Type.String,
-}) {}
+export const Investor = EntitySchema(
+  {
+    name: Type.String,
+  },
+  {
+    types: [Id('331aea18-973c-4adc-8f53-614f598d262d')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+    },
+  },
+);
 
-export class FundingStage extends Entity.Class<FundingStage>('FundingStage')({
-  name: Type.String,
-}) {}
+export const FundingStage = EntitySchema(
+  {
+    name: Type.String,
+  },
+  {
+    types: [Id('8d35d217-3fa1-4686-b74f-fcb3e9438067')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+    },
+  },
+);
 
-export class InvestmentRound extends Entity.Class<InvestmentRound>('InvestmentRound')({
-  name: Type.String,
-  raisedAmount: Type.optional(Type.Number),
-  investors: Type.Relation(Investor),
-  fundingStages: Type.Relation(FundingStage),
-  raisedBy: Type.Relation(Project),
-}) {}
+export const InvestmentRound = EntitySchema(
+  {
+    name: Type.String,
+    raisedAmount: Type.optional(Type.Number),
+    investors: Type.Relation(Investor),
+    fundingStages: Type.Relation(FundingStage),
+    raisedBy: Type.Relation(Project),
+  },
+  {
+    types: [Id('8f03f4c9-59e4-44a8-a625-c0a40b1ff330')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      raisedAmount: Id('16781706-dd9c-48bf-913e-cdf18b56034f'),
+      investors: Id('9b8a610a-fa35-486e-a479-e253dbdabb4f'),
+      fundingStages: Id('e278c3d4-78b9-4222-b272-5a39a8556bd2'),
+      raisedBy: Id('b4878d1a-0609-488d-b8a6-e19862d6b62f'),
+    },
+  },
+);
 
-export class Asset extends Entity.Class<Asset>('Asset')({
-  name: Type.String,
-  symbol: Type.optional(Type.String),
-  blockchainAddress: Type.optional(Type.String),
-}) {}
+export const Asset = EntitySchema(
+  {
+    name: Type.String,
+    symbol: Type.optional(Type.String),
+    blockchainAddress: Type.optional(Type.String),
+  },
+  {
+    types: [Id('f8780a80-c238-4a2a-96cb-567d88b1aa63')],
+    properties: {
+      name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
+      symbol: Id('ace1e96c-9b83-47b4-bd33-1d302ec0a0f5'),
+      blockchainAddress: Id('56b5944f-f059-48d1-b0fa-34abe84219da'),
+    },
+  },
+);
diff --git a/packages/hypergraph-react/src/HypergraphAppContext.tsx b/packages/hypergraph-react/src/HypergraphAppContext.tsx
index 12829e27..c6b8fd16 100644
--- a/packages/hypergraph-react/src/HypergraphAppContext.tsx
+++ b/packages/hypergraph-react/src/HypergraphAppContext.tsx
@@ -13,7 +13,6 @@ import {
   Inboxes,
   type InboxMessageStorageEntry,
   Key,
-  type Mapping,
   Messages,
   SpaceEvents,
   type SpaceStorageEntry,
@@ -229,7 +228,6 @@ export type HypergraphAppProviderProps = Readonly<{
   syncServerUri?: string;
   chainId?: number;
   children: ReactNode;
-  mapping: Mapping.Mapping;
   appId: string;
 }>;
 
@@ -247,7 +245,6 @@ export function HypergraphAppProvider({
   chainId = Connect.GEO_TESTNET.id,
   appId,
   children,
-  mapping,
 }: HypergraphAppProviderProps) {
   const [websocketConnection, setWebsocketConnection] = useState<WebSocket>();
   const [isConnecting, setIsConnecting] = useState(true);
@@ -280,11 +277,6 @@ export function HypergraphAppProvider({
   const initialRenderAuthCheckRef = useRef(false);
   // using a layout effect to avoid a re-render
   useLayoutEffect(() => {
-    store.send({
-      type: 'setMapping',
-      mapping,
-    });
-
     if (!initialRenderAuthCheckRef.current) {
       const identity = Identity.loadIdentity(storage);
       if (identity) {
@@ -304,7 +296,7 @@ export function HypergraphAppProvider({
       // set render auth check to true so next potential rerender doesn't try this again
       initialRenderAuthCheckRef.current = true;
     }
-  }, [storage, mapping]);
+  }, [storage]);
 
   useEffect(() => {
     if (identity === null && privyIdentity === null) {
diff --git a/packages/hypergraph-react/src/internal/use-entity-public.tsx b/packages/hypergraph-react/src/internal/use-entity-public.tsx
index 9990f4ba..e0455aba 100644
--- a/packages/hypergraph-react/src/internal/use-entity-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-entity-public.tsx
@@ -203,6 +203,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
     }
   }
 
+  // @ts-expect-error
   rawEntity = {
     ...rawEntity,
     ...convertRelations(queryEntity, ast),
diff --git a/packages/hypergraph-react/src/internal/use-query-public.tsx b/packages/hypergraph-react/src/internal/use-query-public.tsx
index 28793a28..5d33141e 100644
--- a/packages/hypergraph-react/src/internal/use-query-public.tsx
+++ b/packages/hypergraph-react/src/internal/use-query-public.tsx
@@ -217,6 +217,7 @@ export const parseResult = <S extends Schema.Schema.AnyNoContext>(queryData: Ent
       }
     }
 
+    // @ts-expect-error
     rawEntity = {
       ...rawEntity,
       ...convertRelations(queryEntity, ast),
diff --git a/packages/hypergraph-react/src/types.ts b/packages/hypergraph-react/src/types.ts
index 060590a4..e8400882 100644
--- a/packages/hypergraph-react/src/types.ts
+++ b/packages/hypergraph-react/src/types.ts
@@ -1,6 +1,4 @@
 import type { Op } from '@graphprotocol/grc-20';
-import type { Entity } from '@graphprotocol/hypergraph';
-import type * as Schema from 'effect/Schema';
 
 export type OmitStrict<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 
@@ -9,10 +7,6 @@ export type EntityLike = {
   [key: string]: unknown;
 };
 
-export type PartialEntity<S extends Schema.Schema.AnyNoContext> = Partial<Schema.Schema.Type<Entity.Update<S>>> & {
-  id: string;
-};
-
 export type DiffEntry = {
   [key: string]:
     | {
diff --git a/packages/hypergraph/src/entity/getEntityRelations.ts b/packages/hypergraph/src/entity/getEntityRelations.ts
index 9e68c550..0cf14059 100644
--- a/packages/hypergraph/src/entity/getEntityRelations.ts
+++ b/packages/hypergraph/src/entity/getEntityRelations.ts
@@ -19,14 +19,11 @@ export const getEntityRelations = <const S extends Schema.Schema.AnyNoContext>(
   for (const prop of ast.propertySignatures) {
     if (!isRelation(prop.type)) continue;
 
-    // TODO: should we add an empty array for relations that are not included?
-    // Currently we still add an empty array for relations that are not included.
-    // This is to ensure that the relation is not undefined in the decoded entity.
-    // In the future we might want to derive a schema based on the include object.
-    // if (!include?.[fieldName]) {
-    //   relations[fieldName] = [];
-    //   continue;
-    // }
+    const fieldName = String(prop.name);
+    if (!include?.[fieldName]) {
+      relations[fieldName] = [];
+      continue;
+    }
 
     const relationEntities: Array<Entity<Schema.Schema.AnyNoContext>> = [];
 
@@ -44,7 +41,7 @@ export const getEntityRelations = <const S extends Schema.Schema.AnyNoContext>(
         relationEntities.push({ ...decodedRelationEntity, id: relation.to, _relation: { id: relationId } });
       }
     }
-    relations[prop.name] = relationEntities;
+    relations[String(prop.name)] = relationEntities;
   }
 
   return relations;

From bb94bc6463e5a4e381c603d89ee3aa90a27940e4 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 19:17:57 +0200
Subject: [PATCH 20/22] cleanup

---
 apps/events/src/Boot.tsx                   |  7 +------
 packages/hypergraph/src/entity/create.ts   | 16 +++++++++-------
 packages/hypergraph/src/entity/findMany.ts |  1 +
 3 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/apps/events/src/Boot.tsx b/apps/events/src/Boot.tsx
index 91365ec8..c6f57958 100644
--- a/apps/events/src/Boot.tsx
+++ b/apps/events/src/Boot.tsx
@@ -1,6 +1,5 @@
 import { HypergraphAppProvider } from '@graphprotocol/hypergraph-react';
 import { createRouter, RouterProvider } from '@tanstack/react-router';
-import { mapping } from './mapping.js';
 import { routeTree } from './routeTree.gen';
 
 // Create a new router instance
@@ -15,11 +14,7 @@ declare module '@tanstack/react-router' {
 
 export function Boot() {
   return (
-    <HypergraphAppProvider
-      syncServerUri="http://localhost:3030"
-      mapping={mapping}
-      appId="93bb8907-085a-4a0e-83dd-62b0dc98e793"
-    >
+    <HypergraphAppProvider syncServerUri="http://localhost:3030" appId="93bb8907-085a-4a0e-83dd-62b0dc98e793">
       <RouterProvider router={router} />
     </HypergraphAppProvider>
   );
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index e14c0f41..9174200e 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -38,13 +38,15 @@ export const create = <const S extends Schema.Schema.AnyNoContext>(handle: DocHa
       const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
       if (Option.isSome(result) && isRelation(prop.type)) {
         const relationId = generateId();
-        for (const toEntityId of encoded[result.value] as string[]) {
-          relations[relationId] = {
-            from: entityId,
-            to: toEntityId as string,
-            fromPropertyId: result.value,
-            __deleted: false,
-          };
+        if (encoded[result.value]) {
+          for (const toEntityId of encoded[result.value] as string[]) {
+            relations[relationId] = {
+              from: entityId,
+              to: toEntityId as string,
+              fromPropertyId: result.value,
+              __deleted: false,
+            };
+          }
         }
         delete encoded[result.value];
       }
diff --git a/packages/hypergraph/src/entity/findMany.ts b/packages/hypergraph/src/entity/findMany.ts
index 9fcc0b72..4e19b2fb 100644
--- a/packages/hypergraph/src/entity/findMany.ts
+++ b/packages/hypergraph/src/entity/findMany.ts
@@ -91,6 +91,7 @@ const subscribeToDocumentChanges = (handle: DocHandle<DocumentContent>) => {
             id: entityId,
           });
           decoded = {
+            // @ts-expect-error
             ...decoded,
             ...relations,
           };

From 483af1330334868e089e8992814a4826695afa49 Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 19:41:45 +0200
Subject: [PATCH 21/22] handle optional properties

---
 packages/hypergraph/src/entity/entity.ts | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/packages/hypergraph/src/entity/entity.ts b/packages/hypergraph/src/entity/entity.ts
index ee6ea624..35f5b261 100644
--- a/packages/hypergraph/src/entity/entity.ts
+++ b/packages/hypergraph/src/entity/entity.ts
@@ -50,10 +50,14 @@ export function encodeToGrc20Json<T extends object, E>(schema: Schema.Schema<T,
   const out: Record<string, unknown> = {};
 
   for (const prop of ast.propertySignatures) {
-    // TODO: what about optional properties here? usually we use prop.type.types[0] but we don't here?
-    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
-    if (Option.isSome(result)) {
-      out[result.value] = (value as any)[prop.name];
+    const propType =
+      prop.isOptional && SchemaAST.isUnion(prop.type)
+        ? (prop.type.types.find((member) => !SchemaAST.isUndefinedKeyword(member)) ?? prop.type)
+        : prop.type;
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(propType);
+    const propertyValue: any = (value as any)[prop.name];
+    if (Option.isSome(result) && propertyValue !== undefined) {
+      out[result.value] = propertyValue;
     }
   }
 
@@ -71,7 +75,11 @@ export function decodeFromGrc20Json<T extends object, E>(
   const out: Record<string, unknown> = {};
 
   for (const prop of ast.propertySignatures) {
-    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(prop.type);
+    const propType =
+      prop.isOptional && SchemaAST.isUnion(prop.type)
+        ? (prop.type.types.find((member) => !SchemaAST.isUndefinedKeyword(member)) ?? prop.type)
+        : prop.type;
+    const result = SchemaAST.getAnnotation<string>(PropertyIdSymbol)(propType);
     if (Option.isSome(result)) {
       const grc20Key = result.value;
       if (grc20Key in grc20Data && typeof prop.name === 'string') {

From c7f41703d72a83795e70e8c9f96ee8a03dd3cf1a Mon Sep 17 00:00:00 2001
From: Nik Graf <nik@nikgraf.com>
Date: Tue, 7 Oct 2025 20:03:44 +0200
Subject: [PATCH 22/22] cleanup

---
 .../template-nextjs/Components/GraphImage.tsx |  1 +
 .../Components/Space/PrivateSpace.tsx         |  5 +++--
 .../Components/Space/PublicSpace.tsx          | 16 +++++++++-----
 .../projects/page.tsx                         | 22 ++++++++++++++-----
 .../src/routes/private-space/$space-id.tsx    |  3 ++-
 .../src/routes/public-space/$space-id.tsx     | 10 +++++++--
 docs/docs/query-public-data.md                |  6 ++---
 packages/hypergraph/src/entity/create.ts      |  5 +++--
 8 files changed, 48 insertions(+), 20 deletions(-)

diff --git a/apps/template-nextjs/Components/GraphImage.tsx b/apps/template-nextjs/Components/GraphImage.tsx
index 0e51364d..e038ded3 100644
--- a/apps/template-nextjs/Components/GraphImage.tsx
+++ b/apps/template-nextjs/Components/GraphImage.tsx
@@ -10,5 +10,6 @@ function getImageUrl(src: string | undefined | Blob) {
 export function GraphImage(
   props: React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>,
 ) {
+  // biome-ignore lint/a11y/useAltText: should be provided with the props
   return <img {...props} src={getImageUrl(props.src)} />;
 }
diff --git a/apps/template-nextjs/Components/Space/PrivateSpace.tsx b/apps/template-nextjs/Components/Space/PrivateSpace.tsx
index fce0a27d..d10bc82e 100644
--- a/apps/template-nextjs/Components/Space/PrivateSpace.tsx
+++ b/apps/template-nextjs/Components/Space/PrivateSpace.tsx
@@ -37,7 +37,7 @@ function PrivateSpace() {
     return (
       <div className="flex items-center justify-center min-h-screen">
         <div className="text-center">
-          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto mb-4"></div>
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto mb-4" />
           <p className="text-muted-foreground">Loading space...</p>
         </div>
       </div>
@@ -51,7 +51,7 @@ function PrivateSpace() {
     setProjectDescription('');
   };
 
-  const publishToPublicSpace = async (project: Project) => {
+  const publishToPublicSpace = async (project: typeof Project) => {
     if (!selectedSpace) {
       alert('No space selected');
       return;
@@ -191,6 +191,7 @@ function PrivateSpace() {
                       fill="none"
                       viewBox="0 0 24 24"
                       stroke="currentColor"
+                      aria-hidden="true"
                     >
                       <path
                         strokeLinecap="round"
diff --git a/apps/template-nextjs/Components/Space/PublicSpace.tsx b/apps/template-nextjs/Components/Space/PublicSpace.tsx
index 48378643..2e3eaafc 100644
--- a/apps/template-nextjs/Components/Space/PublicSpace.tsx
+++ b/apps/template-nextjs/Components/Space/PublicSpace.tsx
@@ -73,15 +73,15 @@ function PublicSpace() {
                   <p className="text-sm text-gray-600 mb-2 line-clamp-2">{project.description}</p>
                 )}
 
-                {/* Project xUrl */}
-                {project.xUrl && (
+                {/* Project x */}
+                {project.x && (
                   <a
-                    href={project.xUrl}
+                    href={project.x}
                     target="_blank"
                     rel="noopener noreferrer"
                     className="text-sm text-blue-600 hover:text-blue-800 transition-colors duration-200 flex items-center gap-1"
                   >
-                    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 24 24">
+                    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 24 24" aria-hidden="true">
                       <path d="M18.244 2.25h3.308l-7.227 8.26 8.502 11.24H16.17l-5.214-6.817L4.99 21.75H1.68l7.73-8.835L1.254 2.25H8.08l4.713 6.231zm-1.161 17.52h1.833L7.084 4.126H5.117z" />
                     </svg>
                     View on X
@@ -99,7 +99,13 @@ function PublicSpace() {
         {isPending === false && projects.length === 0 && (
           <div className="text-center py-16">
             <div className="w-24 h-24 bg-gradient-to-br from-blue-100 to-purple-100 rounded-full flex items-center justify-center mx-auto mb-6">
-              <svg className="w-12 h-12 text-blue-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <svg
+                className="w-12 h-12 text-blue-400"
+                fill="none"
+                stroke="currentColor"
+                viewBox="0 0 24 24"
+                aria-hidden="true"
+              >
                 <path
                   strokeLinecap="round"
                   strokeLinejoin="round"
diff --git a/apps/template-nextjs/app/explore-public-knowledge/projects/page.tsx b/apps/template-nextjs/app/explore-public-knowledge/projects/page.tsx
index 2a707cc6..6dab3b91 100644
--- a/apps/template-nextjs/app/explore-public-knowledge/projects/page.tsx
+++ b/apps/template-nextjs/app/explore-public-knowledge/projects/page.tsx
@@ -31,7 +31,13 @@ export default function ExploreProjectsPage() {
       <div className="max-w-md mx-auto mb-8">
         <div className="relative">
           <div className="absolute inset-y-0 left-0 pl-3 flex items-center pointer-events-none">
-            <svg className="h-5 w-5 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <svg
+              className="h-5 w-5 text-gray-400"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+              aria-hidden="true"
+            >
               <path
                 strokeLinecap="round"
                 strokeLinejoin="round"
@@ -81,14 +87,14 @@ export default function ExploreProjectsPage() {
 
               {project.description && <p className="text-sm text-gray-600 mb-2 line-clamp-2">{project.description}</p>}
 
-              {project.xUrl && (
+              {project.x && (
                 <a
-                  href={project.xUrl}
+                  href={project.x}
                   target="_blank"
                   rel="noopener noreferrer"
                   className="text-sm text-blue-600 hover:text-blue-800 transition-colors duration-200 flex items-center gap-1"
                 >
-                  <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 24 24">
+                  <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 24 24" aria-hidden="true">
                     <path d="M18.244 2.25h3.308l-7.227 8.26 8.502 11.24H16.17l-5.214-6.817L4.99 21.75H1.68l7.73-8.835L1.254 2.25H8.08l4.713 6.231zm-1.161 17.52h1.833L7.084 4.126H5.117z" />
                   </svg>
                   View on X
@@ -104,7 +110,13 @@ export default function ExploreProjectsPage() {
       {isPending === false && projects.length === 0 && (
         <div className="text-center py-16">
           <div className="w-24 h-24 bg-gradient-to-br from-blue-100 to-purple-100 rounded-full flex items-center justify-center mx-auto mb-6">
-            <svg className="w-12 h-12 text-blue-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <svg
+              className="w-12 h-12 text-blue-400"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+              aria-hidden="true"
+            >
               <path
                 strokeLinecap="round"
                 strokeLinejoin="round"
diff --git a/apps/template-vite-react/src/routes/private-space/$space-id.tsx b/apps/template-vite-react/src/routes/private-space/$space-id.tsx
index 35208ecf..e7cd73cd 100644
--- a/apps/template-vite-react/src/routes/private-space/$space-id.tsx
+++ b/apps/template-vite-react/src/routes/private-space/$space-id.tsx
@@ -42,7 +42,7 @@ function PrivateSpace() {
     return (
       <div className="flex items-center justify-center min-h-screen">
         <div className="text-center">
-          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto mb-4"></div>
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto mb-4" />
           <p className="text-muted-foreground">Loading space...</p>
         </div>
       </div>
@@ -171,6 +171,7 @@ function PrivateSpace() {
                       fill="none"
                       viewBox="0 0 24 24"
                       stroke="currentColor"
+                      aria-hidden="true"
                     >
                       <path
                         strokeLinecap="round"
diff --git a/apps/template-vite-react/src/routes/public-space/$space-id.tsx b/apps/template-vite-react/src/routes/public-space/$space-id.tsx
index 9a53c08b..23d61b93 100644
--- a/apps/template-vite-react/src/routes/public-space/$space-id.tsx
+++ b/apps/template-vite-react/src/routes/public-space/$space-id.tsx
@@ -85,7 +85,7 @@ function PublicSpace() {
                     rel="noopener noreferrer"
                     className="text-sm text-blue-600 hover:text-blue-800 transition-colors duration-200 flex items-center gap-1"
                   >
-                    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 24 24">
+                    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 24 24" aria-hidden="true">
                       <path d="M18.244 2.25h3.308l-7.227 8.26 8.502 11.24H16.17l-5.214-6.817L4.99 21.75H1.68l7.73-8.835L1.254 2.25H8.08l4.713 6.231zm-1.161 17.52h1.833L7.084 4.126H5.117z" />
                     </svg>
                     View on X
@@ -103,7 +103,13 @@ function PublicSpace() {
         {isPending === false && projects.length === 0 && (
           <div className="text-center py-16">
             <div className="w-24 h-24 bg-gradient-to-br from-blue-100 to-purple-100 rounded-full flex items-center justify-center mx-auto mb-6">
-              <svg className="w-12 h-12 text-blue-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <svg
+                className="w-12 h-12 text-blue-400"
+                fill="none"
+                stroke="currentColor"
+                viewBox="0 0 24 24"
+                aria-hidden="true"
+              >
                 <path
                   strokeLinecap="round"
                   strokeLinejoin="round"
diff --git a/docs/docs/query-public-data.md b/docs/docs/query-public-data.md
index 2216a406..068469eb 100644
--- a/docs/docs/query-public-data.md
+++ b/docs/docs/query-public-data.md
@@ -99,7 +99,7 @@ export const mapping: Mapping.Mapping = {
     properties: {
       name: Id('a126ca53-0c8e-48d5-b888-82c734c38935'),
       description: Id('9b1f76ff-9711-404c-861e-59dc3fa7d037'),
-      xUrl: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
+      x: Id('0d625978-4b3c-4b57-a86f-de45c997c73c'),
     },
   },
 };
@@ -141,8 +141,8 @@ export default function ProjectsExample() {
             {project.description && (
               <p>Description: {project.description}</p>
             )}
-             {project.xUrl && (
-                <a href={project.xUrl} target="_blank" rel="noopener noreferrer">
+             {project.x && (
+                <a href={project.x} target="_blank" rel="noopener noreferrer">
                  View on X
                 </a>
               )}
diff --git a/packages/hypergraph/src/entity/create.ts b/packages/hypergraph/src/entity/create.ts
index 9174200e..5fe5521e 100644
--- a/packages/hypergraph/src/entity/create.ts
+++ b/packages/hypergraph/src/entity/create.ts
@@ -12,15 +12,16 @@ import type { DocumentContent, DocumentRelation, Entity } from './types.js';
 /**
  * Type utility to transform relation fields to accept string arrays instead of their typed values
  * This specifically targets Type.Relation fields which are arrays of objects
+ * Relations can be provided as string arrays or left out completely (optional)
  */
 type WithRelationsAsStringArrays<T> = {
   [K in keyof T]: T[K] extends readonly (infer U)[]
     ? U extends object
-      ? string[]
+      ? string[] | undefined
       : T[K]
     : T[K] extends (infer U)[]
       ? U extends object
-        ? string[]
+        ? string[] | undefined
         : T[K]
       : T[K];
 };