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

package/src/schema/relation.hook.ts

@@ -1,14 +1,11 @@
-import type { StoreQueryResponse } from '@astrale-os/kernel-client/store'
-import type {
-  BoundInstanceOf,
-  Definition,
-  EdgeEndpointAcceptedDefinitionsOf,
-} from '@astrale-os/sdk/domain'
-import type { LinkedCountOf } from '@astrale-os/sdk/query'
+import type { BoundNode } from '@astrale-os/sdk/client'
+import type { StoreQueryResponse } from '@astrale-os/sdk/client/store'
+import type { NodeId } from '@astrale-os/sdk/graph/node'
+import type { ClassKey as ClassKeyValue, ClassRef, ResolvedClass } from '@astrale-os/sdk/schema'
 
-import { NodeId } from '@astrale-os/sdk/graph/node'
 import { Path } from '@astrale-os/sdk/graph/path'
 import { Query } from '@astrale-os/sdk/query'
+import { ClassKey } from '@astrale-os/sdk/schema'
 import { useCallback, useMemo } from 'react'
 
 import type { GraphResource } from '../graph/resource.js'
@@ -16,42 +13,61 @@ import type { GraphResource } from '../graph/resource.js'
 import { useStoreResource } from '../graph/resource.js'
 import { bindingFor } from './domain.hook.js'
 
-type DefinitionCoordinates = Pick<
-  Definition<'class' | 'interface'>,
-  'kind' | 'origin' | 'name' | 'key' | 'schemaRef' | 'definition'
->
-type NodeDefinition = DefinitionCoordinates & { readonly family: 'node' }
-type EdgeDefinition = DefinitionCoordinates & { readonly family: 'edge' }
 type EndpointRole = 'source' | 'target'
 type RelationCardinality = '1' | '0..1' | '0..*' | '1..*'
 type RuntimeEndpoint = {
-  readonly accepts: readonly {
-    readonly origin: string
-    readonly kind: 'class' | 'interface'
-    readonly name: string
-  }[]
+  readonly accepts: readonly ClassRef[]
   readonly outgoing?: RelationCardinality
   readonly incoming?: RelationCardinality
 }
+type DefinitionOf<Relation> =
+  Relation extends ResolvedClass<
+    'edge',
+    infer _Properties,
+    infer _Methods,
+    infer _StaticMethods,
+    infer _SelfProperties,
+    infer _SelfMethods,
+    infer _SelfStaticMethods,
+    infer Definition
+  >
+    ? Definition
+    : never
+type EndpointsOf<Relation> =
+  DefinitionOf<Relation> extends {
+    readonly orientation: 'directed'
+    readonly endpoints: infer Endpoints
+  }
+    ? Endpoints
+    : never
 type Opposite<Role extends EndpointRole> = Role extends 'source' ? 'target' : 'source'
-type Accepted<
-  Definition extends EdgeDefinition,
-  Role extends EndpointRole,
-> = EdgeEndpointAcceptedDefinitionsOf<Definition, Opposite<Role>>
-type StartingDefinition<
-  Relation extends EdgeDefinition,
-  Role extends EndpointRole,
-> = EdgeEndpointAcceptedDefinitionsOf<Relation, Role> & NodeDefinition
-type RelatedDefinition<Relation extends EdgeDefinition, Role extends EndpointRole> = Accepted<
-  Relation,
-  Role
-> &
-  NodeDefinition
-type EffectiveCardinality<
-  Relation extends EdgeDefinition,
-  Role extends EndpointRole,
-  To extends RelatedDefinition<Relation, Role>,
-> = LinkedCountOf<Relation, Role, To>
+type AcceptedAt<Relation, Role extends EndpointRole> = Role extends keyof EndpointsOf<Relation>
+  ? EndpointsOf<Relation>[Role] extends { readonly accepts: readonly (infer Accepted)[] }
+    ? Accepted
+    : never
+  : never
+type DeclaredCardinality<Relation, Role extends EndpointRole> = Role extends 'source'
+  ? EndpointsOf<Relation> extends { readonly source: { readonly outgoing: infer Count } }
+    ? Extract<Count, RelationCardinality>
+    : RelationCardinality
+  : EndpointsOf<Relation> extends { readonly target: { readonly incoming: infer Count } }
+    ? Extract<Count, RelationCardinality>
+    : RelationCardinality
+type CoversOpposite<Relation, Role extends EndpointRole, To extends ResolvedClass<'node'>> = [
+  AcceptedAt<Relation, Opposite<Role>>,
+] extends [To['ref']]
+  ? true
+  : false
+type EffectiveCardinality<Relation, Role extends EndpointRole, To extends ResolvedClass<'node'>> =
+  DeclaredCardinality<Relation, Role> extends infer Count extends RelationCardinality
+    ? CoversOpposite<Relation, Role, To> extends true
+      ? Count
+      : Count extends '1'
+        ? '0..1'
+        : Count extends '1..*'
+          ? '0..*'
+          : Count
+    : RelationCardinality
 
 export interface RelationUnavailable {
   readonly kind: 'required-hidden-or-invalid'
@@ -68,59 +84,50 @@ export class RelationUnavailableError extends Error {
   }
 }
 
-export type RelationResource<T, C extends string> = C extends '1' | '0..1'
+export type RelationResource<T, Cardinality extends RelationCardinality> = Cardinality extends
+  | '1'
+  | '0..1'
   ? GraphResource<T | null> & {
-      readonly cardinality: C
+      readonly cardinality: Cardinality
       readonly unavailable?: RelationUnavailable
       require(): T
     }
   : GraphResource<readonly T[]> & {
-      readonly cardinality: C
+      readonly cardinality: Cardinality
       readonly unavailable?: RelationUnavailable
       require(): readonly T[]
     }
 
 export interface RelationOptions<Role extends EndpointRole, To> {
   readonly from: Role
-  /** Exact rich opposite-endpoint definition used to admit and brand returned nodes. */
   readonly to: To
   readonly page?: { readonly size: number }
 }
 
-/** Traverse one exact rich Edge definition with endpoint and cardinality inference. */
+/** Traverse one directed resolved Edge Class and bind the selected opposite Nodes. */
 export function useRelation<
-  Definition extends EdgeDefinition,
+  Relation extends ResolvedClass<'edge'>,
   Role extends EndpointRole,
-  To extends RelatedDefinition<Definition, Role>,
+  To extends ResolvedClass<'node'>,
+  Source extends ResolvedClass<'node'>,
 >(
-  definition: Definition,
-  source: BoundInstanceOf<StartingDefinition<Definition, Role>> | null | undefined,
+  relation: Relation,
+  source: BoundNode<Source> | null | undefined,
   options: RelationOptions<Role, To>,
-): RelationResource<BoundInstanceOf<To>, EffectiveCardinality<Definition, Role, To>> {
-  const binding = bindingFor(definition)
-  if (source !== null && source !== undefined) {
-    admitSource(binding, definition, options.from, source)
-  }
-  admitRelatedDefinition(binding, definition, options.from, options.to)
-  const path = source === null || source === undefined ? null : Path.id(NodeId(source.id))
+): RelationResource<BoundNode<To>, EffectiveCardinality<Relation, Role, To>> {
+  const binding = bindingFor(relation)
+  if (source !== null && source !== undefined) admitSource(binding, relation, options.from, source)
+  admitRelatedDefinition(binding, relation, options.from, options.to)
+  const path = source === null || source === undefined ? null : Path.id(source.id as NodeId)
   const query = useMemo(() => {
     if (path === null) return null
-    const root = Query.from({ kind: 'node', paths: [path], binding: 'relation_source' })
-    const admitted = root.filter({ satisfies: source!.$.definition.schemaRef })
-    const expanded = admitted.expand({
-      via: [definition.schemaRef],
+    const expanded = Query.from({ nodes: [path] }).expand({
+      via: [relation],
       direction: options.from === 'source' ? 'outgoing' : 'incoming',
     })
-    return expanded
-      .filter({ satisfies: options.to.schemaRef })
-      .select({ kind: 'graph', binding: expanded.node })
-  }, [definition, options.from, options.to, path?.raw, source])
-  const cardinality: RelationCardinality = effectiveCardinality(
-    binding,
-    definition,
-    options.from,
-    options.to,
-  )
+    return expanded.filter({ class: options.to }).select({ kind: 'graph', binding: expanded.node })
+  }, [relation, options.from, options.to, path?.raw])
+  const cardinality = effectiveCardinality(binding, relation, options.from, options.to)
   const project = useCallback(
     (response: StoreQueryResponse<NonNullable<typeof query>>) => {
       const result = response.result
@@ -134,30 +141,21 @@ export function useRelation<
       const byId = new Map(result.graph.nodes.map((node) => [node.id, node]))
       const values = result.selection.ids.flatMap((id) => {
         const node = byId.get(id)
-        if (node === undefined) return []
-        const bind = binding.$.bind as unknown as (
-          expected: To,
-          value: typeof node,
-        ) => BoundInstanceOf<To>
-        return [bind(options.to, node)]
+        return node === undefined ? [] : [binding.wrapNode(options.to, node)]
       })
       if (cardinality === '0..1') return values[0] ?? null
       if (cardinality === '1') return values[0]
       if (cardinality === '1..*' && values.length === 0) return undefined
       return Object.freeze(values)
     },
-    [binding, cardinality, options.to, query],
+    [binding, cardinality, options.to],
   )
   const resource = useStoreResource(query, options.page?.size ?? 50, project)
   const unavailable =
-    (cardinality === '1' &&
-      resource.data === undefined &&
-      resource.state !== 'idle' &&
-      resource.state !== 'loading') ||
-    (cardinality === '1..*' &&
-      resource.data === undefined &&
-      resource.state !== 'idle' &&
-      resource.state !== 'loading')
+    (cardinality === '1' || cardinality === '1..*') &&
+    resource.data === undefined &&
+    resource.state !== 'idle' &&
+    resource.state !== 'loading'
       ? Object.freeze({ kind: 'required-hidden-or-invalid' as const, cardinality })
       : undefined
   const require = () => {
@@ -172,82 +170,66 @@ export function useRelation<
     cardinality,
     ...(unavailable === undefined ? {} : { unavailable }),
     require,
-  }) as RelationResource<BoundInstanceOf<To>, EffectiveCardinality<Definition, Role, To>>
+  }) as RelationResource<BoundNode<To>, EffectiveCardinality<Relation, Role, To>>
 }
 
-function admitSource<Relation extends EdgeDefinition, Role extends EndpointRole>(
+function admitSource(
   binding: ReturnType<typeof bindingFor>,
-  relation: Relation,
-  from: Role,
-  source: BoundInstanceOf<StartingDefinition<Relation, Role>>,
+  relation: ResolvedClass<'edge'>,
+  from: EndpointRole,
+  source: { readonly id: NodeId; readonly class: ClassKeyValue },
 ): void {
-  const accepted = edgeEndpoints(relation)[from].accepts
-  const matches = accepted.some((ref) => {
-    const candidate = binding.$.inspect(ref) as Definition<'class' | 'interface'>
-    return source.$.definition.satisfies(candidate)
-  })
+  const exact = binding.domain.definition(ClassKey.ref(ClassKey(source.class)))
+  const matches =
+    exact?.ref.kind === 'class' &&
+    exact.kind === 'node' &&
+    edgeEndpoints(relation)[from].accepts.some((ref) => {
+      const accepted = binding.domain.definition(ref)
+      return accepted?.ref.kind === 'class' && accepted.kind === 'node' && exact.satisfies(accepted)
+    })
   if (!matches) throw new TypeError('Relation source does not satisfy the selected endpoint.')
 }
 
-function endpointCardinality(definition: EdgeDefinition, side: EndpointRole): RelationCardinality {
-  const endpoint = edgeEndpoints(definition)[side]
-  const cardinality = side === 'source' ? endpoint.outgoing : endpoint.incoming
-  if (cardinality === undefined) {
-    throw new TypeError(`Relation ${side} endpoint does not expose its traversal cardinality.`)
-  }
-  return cardinality
-}
-
-function effectiveCardinality<
-  Relation extends EdgeDefinition,
-  Role extends EndpointRole,
-  To extends RelatedDefinition<Relation, Role>,
->(
+function admitRelatedDefinition(
   binding: ReturnType<typeof bindingFor>,
-  relation: Relation,
-  from: Role,
-  to: To,
-): EffectiveCardinality<Relation, Role, To> {
-  const base = endpointCardinality(relation, from)
-  if (base !== '1' && base !== '1..*') {
-    return base as EffectiveCardinality<Relation, Role, To>
-  }
-  const opposite: EndpointRole = from === 'source' ? 'target' : 'source'
-  const coversEndpoint = edgeEndpoints(relation)[opposite].accepts.every((ref) => {
-    const candidate = binding.$.inspect(ref) as Definition<'class' | 'interface'>
-    return candidate.satisfies(to)
+  relation: ResolvedClass<'edge'>,
+  from: EndpointRole,
+  to: ResolvedClass<'node'>,
+): void {
+  const opposite = from === 'source' ? 'target' : 'source'
+  const matches = edgeEndpoints(relation)[opposite].accepts.some((ref) => {
+    const accepted = binding.domain.definition(ref)
+    return accepted?.ref.kind === 'class' && accepted.kind === 'node' && to.satisfies(accepted)
   })
-  return (coversEndpoint ? base : base === '1' ? '0..1' : '0..*') as EffectiveCardinality<
-    Relation,
-    Role,
-    To
-  >
+  if (!matches) {
+    throw new TypeError('Relation target Class is not admitted by the opposite endpoint.')
+  }
 }
 
-function admitRelatedDefinition<
-  Relation extends EdgeDefinition,
-  Role extends EndpointRole,
-  To extends RelatedDefinition<Relation, Role>,
->(binding: ReturnType<typeof bindingFor>, relation: Relation, from: Role, to: To): void {
-  const opposite: EndpointRole = from === 'source' ? 'target' : 'source'
-  const accepted = edgeEndpoints(relation)[opposite].accepts
-  const matches = accepted.some((ref) => {
-    const candidate = binding.$.inspect(ref) as Definition<'class' | 'interface'>
-    return to.satisfies(candidate)
+function effectiveCardinality(
+  binding: ReturnType<typeof bindingFor>,
+  relation: ResolvedClass<'edge'>,
+  from: EndpointRole,
+  to: ResolvedClass<'node'>,
+): RelationCardinality {
+  const endpoint = edgeEndpoints(relation)[from]
+  const base = from === 'source' ? endpoint.outgoing : endpoint.incoming
+  if (base === undefined) throw new TypeError(`Relation ${from} cardinality is absent.`)
+  if (base !== '1' && base !== '1..*') return base
+  const opposite = from === 'source' ? 'target' : 'source'
+  const covers = edgeEndpoints(relation)[opposite].accepts.every((ref) => {
+    const accepted = binding.domain.definition(ref)
+    return accepted?.ref.kind === 'class' && accepted.kind === 'node' && accepted.satisfies(to)
   })
-  if (!matches)
-    throw new TypeError('Relation target definition is not admitted by the opposite endpoint.')
+  return covers ? base : base === '1' ? '0..1' : '0..*'
 }
 
-function edgeEndpoints(relation: EdgeDefinition): Readonly<Record<EndpointRole, RuntimeEndpoint>> {
-  const declaration = relation.definition as unknown as {
-    readonly family?: unknown
-    readonly endpoints?: Partial<Record<EndpointRole, RuntimeEndpoint>>
-  }
-  const source = declaration.endpoints?.source
-  const target = declaration.endpoints?.target
-  if (declaration.family !== 'edge' || source === undefined || target === undefined) {
-    throw new TypeError('Relation definition does not expose admitted Edge endpoints.')
+function edgeEndpoints(
+  relation: ResolvedClass<'edge'>,
+): Readonly<Record<EndpointRole, RuntimeEndpoint>> {
+  const definition = relation.definition
+  if (definition.orientation !== 'directed') {
+    throw new TypeError('useRelation currently requires a directed Edge Class.')
   }
-  return Object.freeze({ source, target })
+  return definition.endpoints
 }

package/src/selection/live.ts

@@ -1,6 +1,5 @@
 import type { Node, NodeId } from '@astrale-os/sdk/graph/node'
 
-import { Path } from '@astrale-os/sdk/graph/path'
 import { useCallback, useEffect, useRef, useState } from 'react'
 
 import { useSessionKernel } from '../auth/session-kernel.js'
@@ -58,7 +57,7 @@ export function useResolvedNodes(orderedIds: readonly NodeId[]): ResolvedSelecti
     }
     setState({ key: currentKey, aliveIds: ids, nodes: [], pending: true, error: undefined })
     try {
-      const values = await Promise.all(ids.map((nodeId) => graph.get(Path.id(nodeId))))
+      const values = await Promise.all(ids.map((nodeId) => graph.get(nodeId)))
       if (!alive.current || id !== generation.current) return
       const aliveIds: NodeId[] = []
       const nodes: Node[] = []

package/src/session/session.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 type { KernelClient, Shell } from '@astrale-os/shell'
 
 /**
@@ -11,9 +11,8 @@ import { createContext } from 'react'
 import type { GraphStoreScope } from '../graph/store.js'
 
 /**
- * whoami's node type, derived from the auth surface so shell-react needs no
- * direct `@astrale-os/kernel-core` dependency (`Node` is not yet re-exported by
- * kernel-client — API §14 G8). Swap for the blessed re-export when it lands.
+ * whoami's node type, derived from the SDK auth surface so this package does
+ * not duplicate the canonical Client node projection.
  */
 export type SelfNode = Awaited<ReturnType<KernelClient['auth']['whoami']>>
 

package/dist/application/apps/domains.hook.d.ts

@@ -1,7 +0,0 @@
-import type { DomainSearchResult } from '@astrale-os/shell';
-import type { ReadState } from '../../graph/memory/read/envelope.js';
-export interface DomainsResult extends ReadState {
-    readonly domains: readonly DomainSearchResult[];
-}
-export declare function useInstalledDomains(): DomainsResult;
-//# sourceMappingURL=domains.hook.d.ts.map

package/dist/application/apps/domains.hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"domains.hook.d.ts","sourceRoot":"","sources":["../../../src/application/apps/domains.hook.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAI3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAA;AAQpE,MAAM,WAAW,aAAc,SAAQ,SAAS;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAA;CAChD;AAED,wBAAgB,mBAAmB,IAAI,aAAa,CAoBnD"}

package/dist/application/apps/domains.hook.js

@@ -1,18 +0,0 @@
-import { useMemo } from 'react';
-import { useAsyncResource } from '../../graph/async.js';
-import { useShell } from '../../session/shell.hook.js';
-import { isOsPlaneAvailable } from '../user/user.store.js';
-const NO_DOMAINS = [];
-export function useInstalledDomains() {
-    const shell = useShell();
-    const available = isOsPlaneAvailable(shell);
-    const result = useAsyncResource(available ? () => shell.apps.searchDomains() : null, NO_DOMAINS, [shell, available]);
-    return useMemo(() => ({
-        domains: result.data,
-        pending: result.pending,
-        error: result.error,
-        live: false,
-        seq: 0,
-        refetch: result.refetch,
-    }), [result]);
-}

package/src/application/apps/domains.hook.ts

@@ -1,37 +0,0 @@
-import type { DomainSearchResult } from '@astrale-os/shell'
-
-import { useMemo } from 'react'
-
-import type { ReadState } from '../../graph/memory/read/envelope.js'
-
-import { useAsyncResource } from '../../graph/async.js'
-import { useShell } from '../../session/shell.hook.js'
-import { isOsPlaneAvailable } from '../user/user.store.js'
-
-const NO_DOMAINS: readonly DomainSearchResult[] = []
-
-export interface DomainsResult extends ReadState {
-  readonly domains: readonly DomainSearchResult[]
-}
-
-export function useInstalledDomains(): DomainsResult {
-  const shell = useShell()
-  const available = isOsPlaneAvailable(shell)
-  const result = useAsyncResource<readonly DomainSearchResult[]>(
-    available ? () => shell.apps.searchDomains() : null,
-    NO_DOMAINS,
-    [shell, available],
-  )
-
-  return useMemo(
-    () => ({
-      domains: result.data,
-      pending: result.pending,
-      error: result.error,
-      live: false,
-      seq: 0,
-      refetch: result.refetch,
-    }),
-    [result],
-  )
-}