@dxos/echo-solid 0.8.4-main.fcfe5033a5 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-solid",
-  "version": "0.8.4-main.fcfe5033a5",
+  "version": "0.9.0",
   "description": "Solid.js integration for ECHO.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "DXOS.org",
   "sideEffects": false,
   "type": "module",
@@ -20,26 +20,22 @@
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@effect-atom/atom": "^0.5.1",
+    "@effect-atom/atom": "^0.5.3",
     "@solid-primitives/utils": "^6.3.2",
-    "@dxos/echo": "0.8.4-main.fcfe5033a5",
-    "@dxos/echo-atom": "0.8.4-main.fcfe5033a5",
-    "@dxos/effect-atom-solid": "0.8.4-main.fcfe5033a5"
+    "@dxos/echo": "0.9.0",
+    "@dxos/effect-atom-solid": "0.9.0"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",
     "solid-js": "^1.9.11",
-    "vite-plugin-solid": "^2.11.10",
-    "vitest": "3.2.4",
-    "@dxos/echo-db": "0.8.4-main.fcfe5033a5"
+    "vite-plugin-solid": "^2.11.12",
+    "vitest": "4.1.7",
+    "@dxos/echo-client": "0.9.0"
   },
   "peerDependencies": {
     "solid-js": "^1.9.11"

package/src/index.ts

@@ -4,4 +4,4 @@
 
 export * from './useObject';
 export * from './useQuery';
-export * from './useSchema';
+export * from './useType';

package/src/useObject.test.tsx

@@ -8,7 +8,7 @@ import { describe, expect, test } from 'vitest';
 
 import type { Entity } from '@dxos/echo';
 import { Obj } from '@dxos/echo';
-import { createObject } from '@dxos/echo-db';
+import { createObject } from '@dxos/echo-client';
 import { TestSchema } from '@dxos/echo/testing';
 import { Registry } from '@dxos/effect-atom-solid';
 import { RegistryProvider } from '@dxos/effect-atom-solid';
@@ -86,8 +86,8 @@ describe('useObject', () => {
     expect(result).toBe('Test');
     expect(getByTestId('value').textContent).toBe('Test');
 
-    // Update the property via Obj.change.
-    Obj.change(obj, (obj) => {
+    // Update the property via Obj.update.
+    Obj.update(obj, (obj) => {
       obj.name = 'Updated';
     });
 
@@ -118,8 +118,8 @@ describe('useObject', () => {
     expect(valueAccessor?.()?.name).toBe('Test');
     expect(getByTestId('name').textContent).toBe('Test');
 
-    // Update a property via Obj.change.
-    Obj.change(obj, (obj) => {
+    // Update a property via Obj.update.
+    Obj.update(obj, (obj) => {
       obj.name = 'Updated';
     });
 
@@ -149,8 +149,8 @@ describe('useObject', () => {
 
     expect(result).toBe('Test');
 
-    // Update a different property via Obj.change.
-    Obj.change(obj, (obj) => {
+    // Update a different property via Obj.update.
+    Obj.update(obj, (obj) => {
       obj.email = 'newemail@example.com';
     });
 

package/src/useObject.ts

@@ -6,7 +6,6 @@ import { type MaybeAccessor, access } from '@solid-primitives/utils';
 import { type Accessor, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 
 import { Obj, Ref } from '@dxos/echo';
-import { AtomObj } from '@dxos/echo-atom';
 import { type Registry, useRegistry } from '@dxos/effect-atom-solid';
 
 export interface ObjectUpdateCallback<T> {
@@ -146,10 +145,36 @@ export function useObject<T extends Obj.Unknown, K extends keyof T>(
   // Determine if input is a ref.
   const isRef = createMemo(() => Ref.isRef(resolvedInput()));
 
+  // Signal to notify when a ref's target loads.
+  // Incremented by the ref.atom subscription below so that liveObj re-evaluates.
+  const [refLoadVersion, setRefLoadVersion] = createSignal(0, { equals: false });
+
+  // Subscribe to ref.atom (load-only) to detect when the ref target becomes available.
+  // This drives liveObj reactivity for the property-subscription case.
+  createEffect(() => {
+    const input = resolvedInput();
+    if (!input || !Ref.isRef(input)) {
+      return;
+    }
+    const unsubscribe = registry.subscribe(
+      input.atom,
+      () => {
+        setRefLoadVersion((v) => v + 1);
+      },
+      { immediate: false },
+    );
+    onCleanup(unsubscribe);
+  });
+
   // Get the live object for the callback (refs need to dereference).
+  // For refs, depends on refLoadVersion so it re-evaluates when the target loads.
   const liveObj = createMemo(() => {
     const input = resolvedInput();
-    return isRef() ? (input as Ref.Ref<T>)?.target : (input as T | undefined);
+    if (!isRef()) {
+      return input as T | undefined;
+    }
+    refLoadVersion();
+    return (input as Ref.Ref<T>)?.target;
   });
 
   // Create a stable callback that handles both object and property updates.
@@ -160,7 +185,7 @@ export function useObject<T extends Obj.Unknown, K extends keyof T>(
       return;
     }
 
-    Obj.change(obj, (obj: any) => {
+    Obj.update(obj, (obj: any) => {
       if (typeof updateOrValue === 'function') {
         const returnValue = (updateOrValue as (obj: unknown) => unknown)(property !== undefined ? obj[property] : obj);
         if (returnValue !== undefined) {
@@ -179,16 +204,15 @@ export function useObject<T extends Obj.Unknown, K extends keyof T>(
   };
 
   if (property !== undefined) {
-    // For property subscriptions on refs, we subscribe to trigger re-render on load.
-    useObjectValue(registry, objOrRef);
     return [useObjectProperty(registry, liveObj, property), callback as ObjectPropUpdateCallback<T[K]>];
+  } else {
+    return [useObjectValue(registry, objOrRef), callback as ObjectUpdateCallback<T>];
   }
-  return [useObjectValue(registry, objOrRef), callback as ObjectUpdateCallback<T>];
 }
 
 /**
  * Internal function for subscribing to an Echo object or Ref.
- * AtomObj.make handles both objects and refs, returning snapshots.
+ * Obj.atom handles both objects and refs, returning snapshots.
  */
 function useObjectValue<T extends Obj.Unknown>(
   registry: Registry.Registry,
@@ -199,7 +223,9 @@ function useObjectValue<T extends Obj.Unknown>(
 
   // Initialize with the current value (if available).
   const initialInput = resolvedInput();
-  const initialValue = initialInput ? registry.get(AtomObj.make(initialInput)) : undefined;
+  const initialValue = initialInput
+    ? registry.get(Ref.isRef(initialInput) ? Obj.atom(initialInput) : Obj.atom(initialInput as T))
+    : undefined;
   const [value, setValue] = createSignal<T | undefined>(initialValue as T | undefined);
 
   // Subscribe to atom updates.
@@ -211,7 +237,7 @@ function useObjectValue<T extends Obj.Unknown>(
       return;
     }
 
-    const atom = AtomObj.make(input);
+    const atom = Ref.isRef(input) ? Obj.atom(input) : Obj.atom(input as T);
     const currentValue = registry.get(atom);
     setValue(() => currentValue as unknown as T);
 
@@ -239,7 +265,7 @@ function useObjectProperty<T extends Obj.Unknown, K extends keyof T>(
 ): Accessor<T[K] | undefined> {
   // Initialize with the current value (if available).
   const initialObj = obj();
-  const initialValue = initialObj ? registry.get(AtomObj.makeProperty(initialObj, property)) : undefined;
+  const initialValue = initialObj ? registry.get(Obj.atomProperty(initialObj, property)) : undefined;
   const [value, setValue] = createSignal<T[K] | undefined>(initialValue);
 
   // Subscribe to atom updates.
@@ -251,7 +277,7 @@ function useObjectProperty<T extends Obj.Unknown, K extends keyof T>(
       return;
     }
 
-    const atom = AtomObj.makeProperty(currentObj, property);
+    const atom = Obj.atomProperty(currentObj, property);
     const currentValue = registry.get(atom);
     setValue(() => currentValue);
 
@@ -301,7 +327,7 @@ export const useObjects = <T extends Obj.Unknown>(refs: MaybeAccessor<readonly R
     const subscribeToTarget = (ref: Ref.Ref<T>) => {
       const target = ref.target;
       if (target) {
-        const key = ref.dxn.toString();
+        const key = ref.uri;
         if (!targetUnsubscribes.has(key)) {
           targetUnsubscribes.set(key, Obj.subscribe(target, triggerUpdate));
         }

package/src/useQuery.test.tsx

@@ -7,7 +7,7 @@ import { type JSX, createSignal } from 'solid-js';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Filter, Obj, Query } from '@dxos/echo';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { EchoTestBuilder } from '@dxos/echo-client/testing';
 import { TestSchema } from '@dxos/echo/testing';
 
 import { useQuery } from './useQuery';
@@ -148,7 +148,7 @@ describe('useQuery', () => {
 
   test('accepts Filter directly', async () => {
     // Register schema first
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const obj = Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' });
     db.add(obj);
@@ -233,7 +233,7 @@ describe('useQuery', () => {
 
   test('accepts reactive query accessor', async () => {
     // Register schema first
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const obj1 = Obj.make(TestSchema.Expando, { name: 'Test1' });
     const obj2 = Obj.make(TestSchema.Person, { name: 'Test2', username: 'test', email: 'test@example.com' });

package/src/{useSchema.test.tsx → useType.test.tsx}

@@ -6,13 +6,13 @@ import { render, waitFor } from '@solidjs/testing-library';
 import { type JSX, createMemo } from 'solid-js';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Type } from '@dxos/echo';
-import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { DXN, Type, URI } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-client/testing';
 import { TestSchema } from '@dxos/echo/testing';
 
-import { useSchema } from './useSchema';
+import { useType } from './useType';
 
-describe('useSchema', () => {
+describe('useType', () => {
   let testBuilder: EchoTestBuilder;
   let db: any;
 
@@ -30,7 +30,7 @@ describe('useSchema', () => {
     let result: any;
 
     render(() => {
-      const schema = useSchema(undefined, 'dxos.test.Person');
+      const schema = useType(undefined, DXN.make('dxos.test.Person'));
       result = schema();
       return (<div>test</div>) as JSX.Element;
     });
@@ -42,7 +42,7 @@ describe('useSchema', () => {
     let result: any;
 
     render(() => {
-      const schema = useSchema(db, undefined);
+      const schema = useType(db, undefined);
       result = schema();
       return (<div>test</div>) as JSX.Element;
     });
@@ -54,7 +54,7 @@ describe('useSchema', () => {
     let result: any;
 
     render(() => {
-      const schema = useSchema(db, 'dxos.test.NonExistent');
+      const schema = useType(db, DXN.make('dxos.test.NonExistent'));
       result = schema();
       return (<div>test</div>) as JSX.Element;
     });
@@ -66,13 +66,13 @@ describe('useSchema', () => {
 
   test('returns schema when it exists', async () => {
     // Register a schema to the database
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
     await db.flush({ indexes: true });
 
     let schemaAccessor: (() => any) | undefined;
 
     function TestComponent() {
-      const schema = useSchema(db, registeredSchema.typename);
+      const schema = useType(db, Type.getURI(registeredSchema));
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -84,26 +84,24 @@ describe('useSchema', () => {
     const { getByTestId } = render(() => <TestComponent />);
 
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
     const result = schemaAccessor?.();
     expect(result).toBeDefined();
-    expect(result?.typename).toBe(registeredSchema.typename);
+    expect(Type.getTypename(result!)).toBe(Type.getTypename(registeredSchema)!);
   });
 
   test.skip('updates when schema is added', async () => {
     // TODO: This test is skipped because runtime schema registry is not reactive to newly registered schemas.
-    // The query reads from db.graph.schemaRegistry.schemas (runtime registry), but when a schema is registered
-    // via db.schemaRegistry.register(), it's added to the database registry, not the runtime registry.
-    // The runtime registry query subscription doesn't fire when schemas are registered.
-    // See: packages/core/echo/echo-db/src/proxy-db/runtime-schema-registry.ts:57
+    // The query reads from db.graph.registry.types (shared registry), but when a schema is added
+    // via db.add(), the runtime registry query subscription doesn't fire reactively.
     let schemaAccessor: (() => any) | undefined;
-    const typename = 'com.example.type.person';
+    const typename = DXN.make('com.example.type.person');
 
     function TestComponent() {
-      const schema = useSchema(db, typename);
+      const schema = useType(db, typename);
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -119,29 +117,29 @@ describe('useSchema', () => {
     });
 
     // Register the schema
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
     await db.flush({ indexes: true });
 
     // The schema registry query should pick up the new schema
-    // It reads from db.graph.schemaRegistry.schemas which should include the newly registered schema
+    // db.graph.registry.types should include the newly registered schema
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
     const result = schemaAccessor?.();
     expect(result).toBeDefined();
-    expect(result?.typename).toBe(registeredSchema.typename);
+    expect(Type.getTypename(result!)).toBe(Type.getTypename(registeredSchema)!);
   });
 
   test('accepts reactive database accessor', async () => {
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
 
     let schemaAccessor: (() => any) | undefined;
     let dbAccessor: any = db;
 
     function TestComponent() {
-      const schema = useSchema(() => dbAccessor, registeredSchema.typename);
+      const schema = useType(() => dbAccessor, Type.getURI(registeredSchema));
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -153,7 +151,7 @@ describe('useSchema', () => {
     const { getByTestId } = render(() => <TestComponent />);
 
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
@@ -169,13 +167,13 @@ describe('useSchema', () => {
   });
 
   test('accepts reactive typename accessor', async () => {
-    const [registeredSchema] = await db.schemaRegistry.register([TestSchema.Person]);
+    const registeredSchema = await db.addType(TestSchema.Person);
 
     let schemaAccessor: (() => any) | undefined;
-    let typename: string | undefined = registeredSchema.typename;
+    let typeUri: URI.URI | undefined = Type.getURI(registeredSchema);
 
     function TestComponent() {
-      const schema = useSchema(db, () => typename);
+      const schema = useType(db, () => typeUri);
       schemaAccessor = schema;
       const t = createMemo(() => {
         const s = schema();
@@ -187,20 +185,20 @@ describe('useSchema', () => {
     const { getByTestId } = render(() => <TestComponent />);
 
     await waitFor(() => {
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
 
     // Get the actual result from the accessor
     let result = schemaAccessor?.();
     expect(result).toBeDefined();
-    expect(result?.typename).toBe(registeredSchema.typename);
+    expect(Type.getTypename(result!)).toBe(Type.getTypename(registeredSchema)!);
 
-    // Change typename
-    typename = undefined;
+    // Change typeUri
+    typeUri = undefined;
 
     await waitFor(() => {
-      // Should keep previous value when typename becomes undefined
-      expect(getByTestId('typename').textContent).toBe(registeredSchema.typename);
+      // Should keep previous value when typeUri becomes undefined
+      expect(getByTestId('typename').textContent).toBe(Type.getTypename(registeredSchema)!);
     });
     result = schemaAccessor?.();
     expect(result).toBeDefined();

package/src/useType.ts

@@ -0,0 +1,83 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Accessor, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
+
+import { DXN, EID, URI, type Database, Filter, Query, Scope, Type } from '@dxos/echo';
+
+type MaybeAccessor<T> = T | Accessor<T>;
+
+/**
+ * Subscribe to and retrieve a type by its URI from a space: a static schema's typename DXN, or a
+ * persisted (database) schema's `echo:` EID (what `Type.getURI` / `getTypeURIFromQuery` produce).
+ * Accepts either values or accessors for db and typeUri.
+ *
+ * Fans across the owning space db (persisted custom types) and the shared
+ * registry (static/runtime plugin types). Persisted types live only in the db,
+ * so a registry-only lookup misses them.
+ *
+ * @param db - The database instance (can be reactive)
+ * @param typeUri - The type URI to query (can be reactive)
+ * @returns An accessor that returns the current type or undefined
+ */
+export const useType = (
+  db?: MaybeAccessor<Database.Database | undefined>,
+  typeUri?: MaybeAccessor<URI.URI | undefined>,
+): Accessor<Type.AnyEntity | undefined> => {
+  // Derive resolved values reactively.
+  const resolved = createMemo(() => {
+    const resolvedDb = typeof db === 'function' ? db() : db;
+    const resolvedTypeUri = typeof typeUri === 'function' ? typeUri() : typeUri;
+    if (!resolvedTypeUri || !resolvedDb) {
+      return undefined;
+    }
+    return { db: resolvedDb, typeUri: resolvedTypeUri };
+  });
+
+  // Store the current type in a signal.
+  const [type, setType] = createSignal<Type.AnyEntity | undefined>(undefined);
+
+  // Subscribe to registry changes.
+  createEffect(() => {
+    const r = resolved();
+    if (!r) {
+      setType(() => undefined);
+      return;
+    }
+
+    const { db: resolvedDb, typeUri: resolvedTypeUri } = r;
+
+    const searchEid = EID.isEID(resolvedTypeUri) ? EID.tryParse(resolvedTypeUri) : undefined;
+    const searchDxn = DXN.isDXN(resolvedTypeUri) ? DXN.tryMake(resolvedTypeUri) : undefined;
+    const queryResult = resolvedDb.query(Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry()));
+    const update = () =>
+      setType(() =>
+        queryResult.results.find((type) => {
+          const uri = Type.getURI(type);
+          if (uri === resolvedTypeUri) {
+            return true;
+          }
+          // EID matching is space-agnostic: echo:/<id> matches echo://<space>/<id>.
+          if (searchEid && EID.isEID(uri)) {
+            const typeEid = EID.tryParse(uri);
+            return typeEid != null && EID.getEntityId(typeEid) === EID.getEntityId(searchEid);
+          }
+          // DXN matching is version-agnostic so callers may pass an unversioned DXN.
+          if (searchDxn && DXN.isDXN(uri)) {
+            const typeDxn = DXN.tryMake(uri);
+            return typeDxn != null && DXN.getName(typeDxn) === DXN.getName(searchDxn);
+          }
+          return false;
+        }),
+      );
+
+    // Subscribe before reading `.results` — the query requires at least one subscriber.
+    const unsubscribe = queryResult.subscribe(update);
+    update();
+
+    onCleanup(unsubscribe);
+  });
+
+  return type;
+};

package/dist/types/src/useSchema.d.ts

@@ -1,14 +0,0 @@
-import { type Accessor } from 'solid-js';
-import { type Database, type Type } from '@dxos/echo';
-type MaybeAccessor<T> = T | Accessor<T>;
-/**
- * Subscribe to and retrieve schema changes from a database's schema registry.
- * Accepts either values or accessors for db and typename.
- *
- * @param db - The database instance (can be reactive)
- * @param typename - The schema typename to query (can be reactive)
- * @returns An accessor that returns the current schema or undefined
- */
-export declare const useSchema: <T extends Type.AnyEntity = Type.AnyEntity>(db?: MaybeAccessor<Database.Database | undefined>, typename?: MaybeAccessor<string | undefined>) => Accessor<T | undefined>;
-export {};
-//# sourceMappingURL=useSchema.d.ts.map

package/dist/types/src/useSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSchema.d.ts","sourceRoot":"","sources":["../../../src/useSchema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,QAAQ,EAAqD,MAAM,UAAU,CAAC;AAE5F,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAEtD,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAExC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,EACjE,KAAK,aAAa,CAAC,QAAQ,CAAC,QAAQ,GAAG,SAAS,CAAC,EACjD,WAAW,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,KAC3C,QAAQ,CAAC,CAAC,GAAG,SAAS,CAqCxB,CAAC"}

package/dist/types/src/useSchema.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=useSchema.test.d.ts.map

package/dist/types/src/useSchema.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSchema.test.d.ts","sourceRoot":"","sources":["../../../src/useSchema.test.tsx"],"names":[],"mappings":""}

package/src/useSchema.ts

@@ -1,59 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type Accessor, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
-
-import { type Database, type Type } from '@dxos/echo';
-
-type MaybeAccessor<T> = T | Accessor<T>;
-
-/**
- * Subscribe to and retrieve schema changes from a database's schema registry.
- * Accepts either values or accessors for db and typename.
- *
- * @param db - The database instance (can be reactive)
- * @param typename - The schema typename to query (can be reactive)
- * @returns An accessor that returns the current schema or undefined
- */
-export const useSchema = <T extends Type.AnyEntity = Type.AnyEntity>(
-  db?: MaybeAccessor<Database.Database | undefined>,
-  typename?: MaybeAccessor<string | undefined>,
-): Accessor<T | undefined> => {
-  // Derive the schema query reactively
-  const query = createMemo(() => {
-    const resolvedDb = typeof db === 'function' ? db() : db;
-    const resolvedTypename = typeof typename === 'function' ? typename() : typename;
-    if (!resolvedTypename || !resolvedDb) {
-      return undefined;
-    }
-    return resolvedDb.schemaRegistry.query({ typename: resolvedTypename, location: ['database', 'runtime'] });
-  });
-
-  // Store the current schema in a signal
-  const [schema, setSchema] = createSignal<T | undefined>(undefined);
-
-  // Subscribe to query changes
-  createEffect(() => {
-    const q = query();
-    if (!q) {
-      // Keep previous value during transitions to prevent flickering
-      return;
-    }
-
-    // Subscribe to updates with immediate fire to get initial result and track changes
-    // The subscription will automatically start the reactive query
-    const unsubscribe = q.subscribe(
-      () => {
-        // Access results inside the callback to ensure query is running
-        const results = q.results;
-        setSchema(() => results[0] as T | undefined);
-      },
-      { fire: true },
-    );
-
-    onCleanup(unsubscribe);
-  });
-
-  return schema;
-};