@astrale-os/shell-react 0.2.10-beta.3 → 0.3.1

package/src/components/can.tsx

@@ -1,5 +1,5 @@
 import type { PathLike } from '@astrale-os/sdk/graph/path'
-import type { schema } from '@astrale-os/sdk/schema'
+import type { PolicyRef } from '@astrale-os/sdk/schema'
 import type { ReactElement, ReactNode } from 'react'
 
 import type { PolicyObject } from '../auth/can.hook.js'
@@ -7,7 +7,7 @@ import type { PolicyObject } from '../auth/can.hook.js'
 import { useCan } from '../auth/can.hook.js'
 
 export function Can(props: {
-  readonly policy: PathLike | schema.PolicyRef
+  readonly policy: PathLike | PolicyRef
   readonly object: PolicyObject
   readonly children: ReactNode
   readonly fallback?: ReactNode

package/src/graph/call/call.hook.ts

@@ -1,5 +1,5 @@
-import type { Call } from '@astrale-os/kernel-client'
-import type { SessionRequestOptions } from '@astrale-os/kernel-client/session'
+import type { Call } from '@astrale-os/sdk/client'
+import type { SessionRequestOptions } from '@astrale-os/sdk/client/session'
 import type { Value } from '@astrale-os/sdk/value'
 
 import type { Action } from '../action.js'

package/src/graph/call/stream.hook.ts

@@ -1,5 +1,5 @@
-import type { Call } from '@astrale-os/kernel-client'
-import type { SessionRequestOptions } from '@astrale-os/kernel-client/session'
+import type { Call } from '@astrale-os/sdk/client'
+import type { SessionRequestOptions } from '@astrale-os/sdk/client/session'
 import type { Value } from '@astrale-os/sdk/value'
 import type { KernelClient } from '@astrale-os/shell'
 

package/src/graph/graph.context.ts

@@ -1,4 +1,4 @@
-import type { GraphStore } from '@astrale-os/kernel-client/store'
+import type { GraphStore } from '@astrale-os/sdk/client/store'
 
 import { createContext } from 'react'
 

package/src/graph/guards.error.ts

@@ -4,12 +4,12 @@ export {
   ResponseError,
   StaleRouteError,
   TransportError,
-} from '@astrale-os/kernel-client'
-export { NodeUnavailableError } from '@astrale-os/kernel-client/graph'
+} from '@astrale-os/sdk/client'
+export { NodeUnavailableError } from '@astrale-os/sdk/client'
 export { UnsupportedFeatureError } from './memory/read/envelope.js'
 
-import { ClientError } from '@astrale-os/kernel-client'
-import { NodeUnavailableError } from '@astrale-os/kernel-client/graph'
+import { ClientError } from '@astrale-os/sdk/client'
+import { NodeUnavailableError } from '@astrale-os/sdk/client'
 
 export function isClientError(error: unknown): error is ClientError {
   return error instanceof ClientError

package/src/graph/query-definition.hook.ts

@@ -1,18 +1,12 @@
-import type { GraphStore, StoreQueryResponse, StoreSnapshot } from '@astrale-os/kernel-client/store'
-import type {
-  QueryAstExecutionOptions,
-  QueryDefinition,
-  QueryValueBinder,
-} from '@astrale-os/sdk/query'
-import type { QueryAST } from '@astrale-os/sdk/query'
-import type { DomainBinding } from '@astrale-os/shell'
+import type { QueryPageRequest } from '@astrale-os/sdk/client'
+import type { GraphStore, StoreQueryResponse, StoreSnapshot } from '@astrale-os/sdk/client/store'
+import type { QueryAST, QueryDefinition } from '@astrale-os/sdk/query'
 
-import { bindQueries } from '@astrale-os/sdk/query'
+import { executeQuery } from '@astrale-os/sdk/query'
 import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react'
 
 import type { GraphResource, GraphResourceState } from './resource.js'
 
-import { useDynamicDomain } from '../schema/domain.hook.js'
 import { retainRefreshScheduler } from './resource.js'
 import { useGraphStore } from './store.js'
 
@@ -24,7 +18,7 @@ export interface QueryResourceOptions {
 
 interface TouchedShape {
   readonly ast: QueryAST
-  readonly options: QueryAstExecutionOptions
+  readonly options: { readonly page: QueryPageRequest }
 }
 
 interface DefinitionSnapshot<Output> {
@@ -33,7 +27,7 @@ interface DefinitionSnapshot<Output> {
   readonly error?: unknown
 }
 
-class DefinitionObserver<Input, Output, Query extends QueryAST> {
+class DefinitionObserver<Input, Output> {
   private readonly listeners = new Set<() => void>()
   private subscriptions: readonly (() => void)[] = Object.freeze([])
   private touched: readonly TouchedShape[] = Object.freeze([])
@@ -45,8 +39,7 @@ class DefinitionObserver<Input, Output, Query extends QueryAST> {
 
   constructor(
     private readonly store: GraphStore,
-    private readonly binding: DomainBinding,
-    private readonly definition: QueryDefinition<Input, Output, Query>,
+    private readonly definition: QueryDefinition<Input, Output>,
     private readonly input: Input,
   ) {}
 
@@ -82,14 +75,12 @@ class DefinitionObserver<Input, Output, Query extends QueryAST> {
     })
     const execute = async <Ast extends QueryAST>(
       ast: Ast,
-      options: QueryAstExecutionOptions,
+      options: { readonly page: QueryPageRequest },
     ): Promise<StoreQueryResponse<Ast>> => {
       touched.push(Object.freeze({ ast, options }))
       return this.store.read(ast, { ...options, freshness })
     }
-    const bind = this.binding.$.bind as unknown as QueryValueBinder
-    const query = bindQueries(execute, { bind })
-    const running = query(this.definition, this.input)
+    const running = executeQuery({ query: execute }, this.definition, this.input)
       .then((data) => {
         if (!this.started || generation !== this.generation) return
         this.touched = dedupeShapes(touched)
@@ -157,17 +148,16 @@ class DefinitionObserver<Input, Output, Query extends QueryAST> {
 }
 
 /** Execute one named SDK Query definition exclusively through the current GraphStore. */
-export function useQuery<Input, Output, Query extends QueryAST>(
-  definition: QueryDefinition<Input, Output, Query> | null,
+export function useQuery<Input, Output>(
+  definition: QueryDefinition<Input, Output> | null,
   input: Input,
   options: QueryResourceOptions = {},
 ): GraphResource<Output> {
   const store = useGraphStore()
-  const binding = useDynamicDomain()
   const inputIdentity = stableIdentity(input)
   const observer = useMemo(
-    () => (definition === null ? null : new DefinitionObserver(store, binding, definition, input)),
-    [store, binding, definition, inputIdentity],
+    () => (definition === null ? null : new DefinitionObserver(store, definition, input)),
+    [store, definition, inputIdentity],
   )
   const idle = useMemo<DefinitionSnapshot<Output>>(() => Object.freeze({ state: 'idle' }), [])
   const subscribe = useCallback(

package/src/graph/resource.ts

@@ -1,4 +1,4 @@
-import type { GraphStore, StoreQueryResponse, StoreSnapshot } from '@astrale-os/kernel-client/store'
+import type { GraphStore, StoreQueryResponse, StoreSnapshot } from '@astrale-os/sdk/client/store'
 import type { QueryAST } from '@astrale-os/sdk/query'
 
 import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from 'react'

package/src/graph/store.ts

@@ -1,8 +1,8 @@
-import type { GraphApi } from '@astrale-os/kernel-client/graph'
-import type { GraphStore as GraphStoreValue } from '@astrale-os/kernel-client/store'
+import type { GraphApi } from '@astrale-os/sdk/client'
+import type { GraphStore as GraphStoreValue } from '@astrale-os/sdk/client/store'
 import type { Shell } from '@astrale-os/shell'
 
-import { GraphStore } from '@astrale-os/kernel-client/store'
+import { GraphStore } from '@astrale-os/sdk/client/store'
 import { useContext } from 'react'
 
 import { GraphContext } from './graph.context.js'

package/src/index.ts

@@ -178,7 +178,6 @@ export {
   AppLogo,
   useApps,
   useCurrentSpace,
-  useInstalledDomains,
   useOpenApp,
   useSpace,
   useSpaces,
@@ -190,7 +189,6 @@ export type {
   AppLogoProps,
   AppsResult,
   CurrentSpaceResult,
-  DomainsResult,
   SpaceResult,
   SpacesResult,
 } from './application/index.js'
@@ -200,16 +198,14 @@ export { NodeId } from '@astrale-os/sdk/graph/node'
 export { NodePath, Path } from '@astrale-os/sdk/graph/path'
 export type { Node } from '@astrale-os/sdk/graph/node'
 export type { PathLike } from '@astrale-os/sdk/graph/path'
-export type { AuthApi, Identity, PolicyDecisionInput } from '@astrale-os/kernel-client/auth'
-export type { DomainBinding, DomainInvokeOptions } from '@astrale-os/shell'
+export type { AuthApi, Identity, PolicyDecisionInput } from '@astrale-os/sdk/auth'
+export type { DomainBinding } from '@astrale-os/shell'
 
 // Shell contracts retained at the package root for custom full-app composition.
 export type {
-  ApplicationNode,
-  AppSession,
+  App,
   CloseResult,
   CredentialSnapshot,
-  DomainSearchResult,
   HostCapabilities,
   IntentRegistry,
   KernelClient,

package/src/navigation/adapters/url.adapter.ts

@@ -1,5 +1,4 @@
 import { NodePath } from '@astrale-os/sdk/graph/path'
-import { Key } from '@astrale-os/sdk/schema'
 
 /**
  * urlAdapter (API §8.1) — the History-API adapter: mirrors the location into the
@@ -9,6 +8,8 @@ import { Key } from '@astrale-os/sdk/schema'
 import type { SerializedLocation } from '../history.js'
 import type { NavAdapter } from './adapter.js'
 
+import { viewKey } from '../view-key.js'
+
 const VIEW_KEY = 'astrale.view'
 const PARAM_PREFIX = 'astrale.param.'
 
@@ -55,9 +56,7 @@ export function urlAdapter(opts?: { param?: string }): NavAdapter {
         node = NodePath(rawNode)
         const rawView = sp.get(VIEW_KEY)
         if (rawView !== null) {
-          const admitted = Key(rawView)
-          if (!Key.ref(admitted).startsWith('view.')) throw new TypeError('Invalid View key.')
-          view = admitted as Key.View
+          view = viewKey(rawView)
         }
       } catch {
         return null

package/src/navigation/codec.ts

@@ -2,7 +2,6 @@ import type { Key } from '@astrale-os/sdk/schema'
 import type { ReactElement, ReactNode } from 'react'
 
 import { Path } from '@astrale-os/sdk/graph/path'
-import { Key as admitKey } from '@astrale-os/sdk/schema'
 import { createElement } from 'react'
 
 import type { NavAdapter } from './adapters/adapter.js'
@@ -11,6 +10,7 @@ import type { NavSnapshot, SerializedLocation } from './history.js'
 import { NavScope } from './scope.context.js'
 import { useNavCtx } from './scope.context.js'
 import { useHistoryVersion } from './scope.context.js'
+import { viewKey } from './view-key.js'
 
 export interface NavigationParam<Value> {
   encode(value: Value): string
@@ -182,9 +182,3 @@ export function useNavigation<Routes extends NavigationRoutes>(
 
 export type NavigationTarget<Definition> =
   Definition extends NavigationDefinition<infer Routes> ? RouteTarget<Routes> : never
-
-function viewKey(input: string): Key.View {
-  const key = admitKey(input)
-  if (!admitKey.ref(key).startsWith('view.')) throw new TypeError(`Invalid View key '${input}'.`)
-  return key as Key.View
-}

package/src/navigation/link.tsx

@@ -50,7 +50,7 @@ export function Link(props: LinkProps): ReactElement {
   const nodeRef = target.node
 
   const preload = useCallback(() => {
-    const query = Query.from({ kind: 'node', paths: [nodeRef] }).select({ kind: 'graph' })
+    const query = Query.from({ nodes: [nodeRef] }).select({ kind: 'graph' })
     void ctx.store.preload(query, { page: { size: 1 } }).catch(() => {})
   }, [ctx.store, nodeRef])
 

package/src/navigation/scope.context.tsx

@@ -1,9 +1,9 @@
-import type { GraphStore, StoreQueryResponse } from '@astrale-os/kernel-client/store'
+import type { GraphStore, StoreQueryResponse } from '@astrale-os/sdk/client/store'
+import type { Key } from '@astrale-os/sdk/schema'
 import type { ReactElement, ReactNode } from 'react'
 
 import { NodePath } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
-import { Key } from '@astrale-os/sdk/schema'
 import {
   createContext,
   startTransition,
@@ -28,6 +28,7 @@ import { memoryAdapter } from './adapters/memory.adapter.js'
 import { NavHistory, seedEntries } from './history.js'
 import { buildLocation } from './location.js'
 import { revalidateAndPrune, serializeTarget } from './snapshot.js'
+import { viewKey } from './view-key.js'
 
 export interface Navigate {
   (to: NavTarget, opts?: { replace?: boolean }): void
@@ -85,7 +86,7 @@ export function useGraphPoint(target: NodePath | null): PointResult | null {
     () =>
       target === null
         ? null
-        : Query.from({ kind: 'node', paths: [target], binding: 'navigation_target' }).select({
+        : Query.from({ nodes: [target], binding: 'navigation_target' }).select({
             kind: 'graph',
           }),
     [target],
@@ -253,9 +254,7 @@ function admitLocation(location: SerializedLocation): SerializedLocation {
   const node = NodePath(location.node)
   let view: Key.View | undefined
   if (location.view !== undefined) {
-    const key = Key(location.view)
-    if (!Key.ref(key).startsWith('view.')) throw new TypeError('Navigation View key is invalid.')
-    view = key as Key.View
+    view = viewKey(location.view)
   }
   const params: Record<string, string> = {}
   if (location.params !== undefined) {

package/src/navigation/snapshot.ts

@@ -1,4 +1,4 @@
-import type { GraphStore } from '@astrale-os/kernel-client/store'
+import type { GraphStore } from '@astrale-os/sdk/client/store'
 import type { Node } from '@astrale-os/sdk/graph/node'
 import type { NodePath, PathLike } from '@astrale-os/sdk/graph/path'
 import type { Key } from '@astrale-os/sdk/schema'
@@ -6,10 +6,11 @@ import type { Shell } from '@astrale-os/shell'
 
 import { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
-import { Key as admitKey } from '@astrale-os/sdk/schema'
 
 import type { NavHistory, SerializedLocation } from './history.js'
 
+import { viewKey } from './view-key.js'
+
 /** Canonical navigation inputs; there is no implicit slash-tree or bare-id grammar. */
 export type NavTarget =
   | PathLike
@@ -44,12 +45,6 @@ export function serializeTarget(target: NavTarget): SerializedLocation {
   }
 }
 
-function viewKey(input: string): Key.View {
-  const key = admitKey(input)
-  if (!admitKey.ref(key).startsWith('view.')) throw new TypeError(`Invalid View key '${input}'.`)
-  return key as Key.View
-}
-
 /** Drop restored entries that no longer resolve under the authenticated Graph capability. */
 export async function revalidateAndPrune(
   history: NavHistory,
@@ -81,7 +76,7 @@ async function resolves(
   entry: SerializedLocation,
 ): Promise<boolean> {
   try {
-    const query = Query.from({ kind: 'node', paths: [entry.node] }).select({ kind: 'graph' })
+    const query = Query.from({ nodes: [entry.node] }).select({ kind: 'graph' })
     const response = await store.read(query, { page: { size: 1 } })
     if (
       response.result.kind !== 'graph' ||

package/src/navigation/view-key.ts

@@ -0,0 +1,11 @@
+import type { Key } from '@astrale-os/sdk/schema'
+
+import { Key as admitKey } from '@astrale-os/sdk/schema'
+
+export function viewKey(input: string): Key.View {
+  const key = admitKey(input)
+  if (!key.slice(key.indexOf(':') + 1).startsWith('view.')) {
+    throw new TypeError(`Invalid View key '${input}'.`)
+  }
+  return key as Key.View
+}

package/src/schema/action.hook.ts

@@ -1,25 +1,33 @@
-import type {
-  InputOf,
-  InstanceMethod,
-  OutputOf,
-  ReceiverOf,
-  RemoteCallableOf,
-} from '@astrale-os/sdk/domain'
+import type { BoundNodeFor } from '@astrale-os/sdk/client'
+import type { SessionRequestOptions } from '@astrale-os/sdk/client/session'
 import type { NodeId } from '@astrale-os/sdk/graph/node'
 import type { QueryAST } from '@astrale-os/sdk/query'
-import type { schema } from '@astrale-os/sdk/schema'
-import type { DomainInvokeOptions } from '@astrale-os/shell'
-
+import type {
+  CallableInputOf,
+  CallableResultOf,
+  MethodOwnerKeyOf,
+  MethodInheritance,
+  ResolvedFunction,
+  ResolvedMethod,
+} from '@astrale-os/sdk/schema'
+
+import { reference } from '@astrale-os/sdk/client/session'
 import { Path } from '@astrale-os/sdk/graph/path'
 import { useCallback, useMemo, useRef } from 'react'
 
 import type { Action as AsyncAction } from '../graph/action.js'
 
+import { useSessionKernel } from '../auth/session-kernel.js'
 import { useAction as useAsyncAction } from '../graph/action.js'
 import { useGraphStore } from '../graph/store.js'
 import { bindingFor } from './domain.hook.js'
 
-type Callable = RemoteCallableOf<schema.DomainSchema> | InstanceMethod
+type ExecutableInheritance = Exclude<MethodInheritance, 'abstract'>
+type InstanceMethod = ResolvedMethod<unknown, unknown, false, ExecutableInheritance>
+type StaticMethod = ResolvedMethod<unknown, unknown, true, ExecutableInheritance>
+type Callable = ResolvedFunction | InstanceMethod | StaticMethod
+type Receiver = { readonly id: NodeId }
+type MethodReceiver<C extends InstanceMethod> = BoundNodeFor<MethodOwnerKeyOf<C>>
 
 const QUERY_REFRESH = Symbol('shell-react.query-refresh')
 
@@ -59,14 +67,14 @@ export type ActionRefresh =
       readonly queries: readonly QueryRefresh[]
     }
 
-export interface ActionOptions extends DomainInvokeOptions {
+export interface ActionOptions extends SessionRequestOptions {
   readonly refresh?: ActionRefresh
   readonly onError?: (error: unknown) => void
 }
 
 type ActionArgs<C extends Callable> = C extends InstanceMethod
-  ? [receiver: ReceiverOf<C>, input: InputOf<C>]
-  : [input: InputOf<C>]
+  ? [receiver: MethodReceiver<C>, input: CallableInputOf<C>]
+  : [input: CallableInputOf<C>]
 
 export interface DomainAction<Args extends unknown[], Result> {
   run(...args: Args): Promise<Result>
@@ -80,8 +88,9 @@ export interface DomainAction<Args extends unknown[], Result> {
 export function useAction<C extends Callable>(
   callable: C,
   options: ActionOptions = {},
-): DomainAction<ActionArgs<C>, OutputOf<C>> {
+): DomainAction<ActionArgs<C>, CallableResultOf<C>> {
   const binding = bindingFor(callable)
+  const kernel = useSessionKernel()
   const store = useGraphStore()
   const callableRef = useRef(callable)
   callableRef.current = callable
@@ -91,18 +100,22 @@ export function useAction<C extends Callable>(
   optionsRef.current = options
 
   const invoke = useCallback(
-    async (...args: ActionArgs<C>): Promise<OutputOf<C>> => {
+    async (...args: ActionArgs<C>): Promise<CallableResultOf<C>> => {
       const current = callableRef.current
       const policy = optionsRef.current
       const { refresh: _refresh, onError: _onError, ...request } = policy
       try {
-        const invokeExact = bindingRef.current.$.invoke as (
-          ...values: readonly unknown[]
-        ) => Promise<OutputOf<C>>
-        const result =
-          'on' in current
-            ? await invokeExact(current, receiverPath(args[0] as ReceiverOf<C>), args[1], request)
-            : await invokeExact(current, args[0], request)
+        const result = isInstanceMethod(current)
+          ? await kernel.session.invoke(
+              reference(bindingRef.current.domain, current)(receiverPath(args[0] as Receiver)),
+              args[1] as never,
+              request,
+            )
+          : await kernel.session.invoke(
+              reference(bindingRef.current.domain, current),
+              args[0] as never,
+              request,
+            )
         const refresh = policy.refresh ?? 'all'
         if (refresh === 'all') store.invalidate()
         else if (refresh !== 'none') {
@@ -111,15 +124,15 @@ export function useAction<C extends Callable>(
             store.invalidate(target.ast, { page: target.page })
           })
         }
-        return result
+        return result as CallableResultOf<C>
       } catch (error) {
         policy.onError?.(error)
         throw error
       }
     },
-    [store],
+    [kernel, store],
   )
-  const action = useAsyncAction(invoke as (...args: ActionArgs<C>) => Promise<OutputOf<C>>)
+  const action = useAsyncAction(invoke)
   return useMemo(() => projectAction(action), [action])
 }
 
@@ -141,6 +154,10 @@ function projectAction<Args extends unknown[], Result>(
   }
 }
 
-function receiverPath(receiver: { readonly id: NodeId }): string {
-  return Path.id(receiver.id).raw
+function isInstanceMethod(callable: Callable): callable is InstanceMethod {
+  return 'owner' in callable && callable.static === false
+}
+
+function receiverPath(receiver: Receiver): Path {
+  return Path.id(receiver.id)
 }

package/src/schema/domain.hook.ts

@@ -89,17 +89,16 @@ export function bindingFor(value: object): DomainBinding {
 }
 
 function registerBinding(binding: DomainBinding): void {
-  const seen = new WeakSet<object>()
-  const visit = (value: unknown, depth: number): void => {
-    if (depth > 4 || value === null || typeof value !== 'object' || seen.has(value)) return
-    seen.add(value)
-    bindingByValue.set(value, binding)
-    for (const [key, child] of Object.entries(value)) {
-      if (key === 'schema' || key === 'publication' || key === 'session') continue
-      visit(child, depth + 1)
-    }
+  bindingByValue.set(binding, binding)
+  bindingByValue.set(binding.domain, binding)
+  for (const definition of Object.values(binding.domain.classes)) {
+    bindingByValue.set(definition, binding)
+    for (const method of definition.methods) bindingByValue.set(method, binding)
+    for (const method of definition.static.methods) bindingByValue.set(method, binding)
+  }
+  for (const callable of Object.values(binding.domain.functions)) {
+    bindingByValue.set(callable, binding)
   }
-  visit(binding, 0)
 }
 
 function createResource<T>(promise: Promise<T>): Resource<T> {

package/src/schema/kernel.hook.ts

@@ -1,6 +1,6 @@
 import type { DomainBinding } from '@astrale-os/shell'
 
-import { KernelSchema } from '@astrale-os/sdk/schema/kernel'
+import { KernelSchema } from '@astrale-os/sdk/schema'
 
 import { useDomain } from './domain.hook.js'
 

package/src/schema/mutation.hook.ts

@@ -1,6 +1,6 @@
-import type { MutationDefinition } from '@astrale-os/sdk/mutation'
+import type { Mutation } from '@astrale-os/sdk/mutation'
 
-import { bindMutations } from '@astrale-os/sdk/mutation'
+import { executeMutation } from '@astrale-os/sdk/mutation'
 import { useCallback, useMemo, useRef } from 'react'
 
 import type { Action as AsyncAction } from '../graph/action.js'
@@ -16,7 +16,7 @@ export interface MutationOptions {
 
 /** Execute one named SDK Mutation definition through GraphStore optimism/invalidation. */
 export function useMutation<Input, Output>(
-  definition: MutationDefinition<Input, Output>,
+  definition: Mutation<Input, Output>,
   options: MutationOptions = {},
 ): DomainAction<[Input], Output> {
   const store = useGraphStore()
@@ -26,13 +26,17 @@ export function useMutation<Input, Output>(
   optionsRef.current = options
   const run = useCallback(
     async (input: Input): Promise<Output> => {
-      const execute = bindMutations((ast) =>
-        store.mutate(ast, {
-          optimistic: optionsRef.current.optimistic ?? true,
-        }),
-      )
       try {
-        return await execute(definitionRef.current, input)
+        return await executeMutation(
+          {
+            mutate: (ast) =>
+              store.mutate(ast, {
+                optimistic: optionsRef.current.optimistic ?? true,
+              }),
+          },
+          definitionRef.current,
+          input,
+        )
       } catch (error) {
         optionsRef.current.onError?.(error)
         throw error

package/src/schema/object.hook.ts

@@ -1,7 +1,8 @@
-import type { StoreQueryResponse } from '@astrale-os/kernel-client/store'
-import type { BoundInstanceOf, Definition } from '@astrale-os/sdk/domain'
+import type { BoundNode } from '@astrale-os/sdk/client'
+import type { StoreQueryResponse } from '@astrale-os/sdk/client/store'
 import type { Node } from '@astrale-os/sdk/graph/node'
 import type { PathLike } from '@astrale-os/sdk/graph/path'
+import type { ResolvedClass } from '@astrale-os/sdk/schema'
 
 import { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
@@ -16,25 +17,20 @@ export interface RichReadOptions {
   readonly pageSize?: number
 }
 
-type ObjectDefinition = Pick<
-  Definition<'class' | 'interface'>,
-  'kind' | 'origin' | 'name' | 'key' | 'schemaRef' | 'definition'
-> & { readonly family: 'node' }
-
 /** Read and bind one exact rich object definition exclusively through GraphStore. */
-export function useObject<RichDefinition extends ObjectDefinition>(
-  definition: RichDefinition,
+export function useObject<Class extends ResolvedClass<'node'>>(
+  definition: Class,
   target: PathLike | null | undefined,
   options: RichReadOptions = {},
-): GraphResource<BoundInstanceOf<RichDefinition> | null> {
+): GraphResource<BoundNode<Class> | null> {
   const binding = bindingFor(definition)
   const path = target === null || target === undefined ? null : Path.from(target)
   const query = useMemo(
     () =>
       path === null
         ? null
-        : Query.from({ kind: 'node', paths: [path], binding: 'object' })
-            .filter({ satisfies: definition.schemaRef })
+        : Query.from({ nodes: [path], binding: 'object' })
+            .filter({ class: definition })
             .select({ kind: 'graph' }),
     [definition, path?.raw],
   )
@@ -47,11 +43,7 @@ export function useObject<RichDefinition extends ObjectDefinition>(
         id === undefined
           ? undefined
           : result.graph.nodes.find((candidate: { readonly id: unknown }) => candidate.id === id)
-      const bind = binding.$.bind as unknown as (
-        expected: RichDefinition,
-        value: Node,
-      ) => BoundInstanceOf<RichDefinition>
-      return node === undefined ? null : bind(definition, node)
+      return node === undefined ? null : binding.wrapNode(definition, node)
     },
     [binding, definition],
   )
@@ -68,7 +60,7 @@ export function useDynamicObject(
     () =>
       path === null
         ? null
-        : Query.from({ kind: 'node', paths: [path], binding: 'dynamic_object' }).select({
+        : Query.from({ nodes: [path], binding: 'dynamic_object' }).select({
             kind: 'graph',
           }),
     [path?.raw],