@astrale-os/sdk 0.1.10 → 0.3.0

package/src/dispatch/dispatcher.ts

@@ -11,13 +11,18 @@
 
 import type { AuthedKernelAPI, DispatchResult, KernelAPI } from '@astrale-os/kernel-api'
 import type { AuthPolicy } from '@astrale-os/kernel-api/routed'
-import type { CredentialInput, Path } from '@astrale-os/kernel-core'
+import type { NodeBinder } from '@astrale-os/kernel-client/schema'
+import type { CredentialInput } from '@astrale-os/kernel-core'
 import type { BoundMethod, CompiledDomain } from '@astrale-os/kernel-core/domain'
+import type { Schema } from '@astrale-os/kernel-dsl'
+
+import { createNodeBinder } from '@astrale-os/kernel-client/schema'
 
 import type { RemoteIdentityConfig } from '../auth/identity'
 import type { AnyRemoteHandler } from '../method/single'
 import type { MethodIndex } from './resolve'
 
+import { makeIssuerMint } from '../auth/issuer-mint'
 import { resolveInboundAuth } from '../auth/resolve'
 import { runAuthorize } from './authorize'
 import { makeCallRemote } from './call-remote'
@@ -25,9 +30,11 @@ import { MethodNotFoundError, SdkResultValidationError, SdkValidationError } fro
 import { executeHandler } from './execute'
 import { buildIdentityMap } from './identity'
 import { resolveMethod } from './resolve'
-import { resolveSelf, withNode, type ParsedSelf } from './self'
+import { resolveSelf, withBoundNode, withNode, type ParsedSelf } from './self'
 import { validateParams, validateResult } from './validate'
 
+type PathInput = string | { raw: string }
+
 export type SdkDispatcherConfig<TDeps> = {
   /** The compiled domain — source of the method layout and origin-addressed subs. */
   compiled: CompiledDomain
@@ -46,6 +53,12 @@ export type SdkDispatcherConfig<TDeps> = {
   issuer: string
   /** The worker's serving URL (`config.url`) — exposed to handlers as `ctx.url`. */
   url: string
+  /**
+   * The domain schema. When present, non-static handlers receive the rich,
+   * schema-typed `self` ({@link withBoundNode}: `self.node()` → `BoundNode<D>`,
+   * typed `self.call`); absent, they fall back to the untyped {@link withNode}.
+   */
+  schema?: Schema
 }
 
 export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
@@ -55,6 +68,8 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
   private readonly issuer: string
   private readonly url: string
   private readonly privateKey: JsonWebKey
+  /** Built once when a schema is supplied — drives the rich typed `self`. */
+  private readonly binder: NodeBinder<Schema> | null
 
   constructor(config: SdkDispatcherConfig<TDeps>) {
     this.methods = config.methods
@@ -62,6 +77,7 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
     this.issuer = config.issuer
     this.url = config.url
     this.privateKey = config.privateKey
+    this.binder = config.schema ? createNodeBinder(config.schema) : null
     const methodList = Array.from(new Set(config.methods.values()))
     const identityMethods = methodList.filter((bound) => methodAuthPolicy(bound) !== 'public')
     this.identities =
@@ -71,7 +87,7 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
   }
 
   async call(
-    path: Path | string,
+    path: PathInput,
     credential: CredentialInput,
     params: unknown,
     opts?: { self?: string },
@@ -80,7 +96,7 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
   }
 
   async stream(
-    path: Path | string,
+    path: PathInput,
     credential: CredentialInput,
     params: unknown,
     opts?: { self?: string },
@@ -98,7 +114,7 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
    * and hand it back to the kernel-api orchestrator.
    */
   async dispatch(
-    path: Path | string,
+    path: PathInput,
     credential: CredentialInput,
     params: unknown,
     opts?: { self?: string },
@@ -117,12 +133,12 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
   }
 
   private async run(
-    path: Path | string,
+    path: PathInput,
     credential: CredentialInput,
     params: unknown,
     selfRef?: string,
   ): Promise<unknown> {
-    const bound = resolveMethod(this.methods, path)
+    const bound = resolveMethod(this.methods, pathToString(path))
     if (!bound) throw new MethodNotFoundError(pathToString(path))
 
     const authPolicy: AuthPolicy = (bound.handler as { auth?: AuthPolicy }).auth ?? 'required'
@@ -177,7 +193,13 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
     // Enrich the parsed self with the lazy `node()` accessor, bound to this
     // request's kernel (null when the auth policy yields none — `node()` then
     // rejects). Done here, not in `resolveSelf`, so the parse stays kernel-free.
-    const self = parsedSelf ? withNode(parsedSelf, kernel) : undefined
+    // With a schema the handler gets the rich typed `self` keyed by its owner
+    // (class/interface); without one, the untyped fallback.
+    const self = parsedSelf
+      ? this.binder
+        ? withBoundNode(parsedSelf, kernel, this.binder, bound.owner)
+        : withNode(parsedSelf, kernel)
+      : undefined
     const ctx = {
       params: handlerParams,
       auth,
@@ -185,6 +207,7 @@ export class SdkDispatcher<TDeps = unknown> implements KernelAPI {
       deps: this.deps,
       url: this.url,
       kernel,
+      issuer: makeIssuerMint(fnIdentity),
       callRemote,
     }
 
@@ -213,7 +236,7 @@ function methodAuthPolicy(bound: BoundMethod<AnyRemoteHandler>): AuthPolicy {
   return (bound.handler as { auth?: AuthPolicy }).auth ?? 'required'
 }
 
-function pathToString(path: Path | string): string {
+function pathToString(path: PathInput): string {
   return typeof path === 'string' ? path : path.raw
 }
 

package/src/dispatch/execute.ts

@@ -11,8 +11,9 @@ import type { FnMap } from '@astrale-os/kernel-client'
 import type { BoundClientSessionView } from '@astrale-os/kernel-client/session'
 import type { AuthContext } from '@astrale-os/kernel-core'
 
+import type { DomainIssuer } from '../auth/issuer-mint'
 import type { CallRemoteFn } from './call-remote'
-import type { SelfResult } from './self'
+import type { SelfResult, TypedSelf } from './self'
 
 // oxlint-disable-next-line no-explicit-any
 type HandlerFn = (...args: any[]) => any
@@ -25,10 +26,13 @@ export type ExecuteParams = {
   ref?: string
   params: Record<string, unknown>
   auth: AuthContext | null
-  self: SelfResult | undefined
+  /** Untyped fallback ({@link withNode}) or the rich typed self ({@link withBoundNode}). */
+  self: SelfResult | TypedSelf<unknown> | undefined
   deps: unknown
   url: string
   kernel: BoundClientSessionView<FnMap> | null
+  /** Mint seam for identities this domain issues (`ctx.issuer`). */
+  issuer: DomainIssuer
   callRemote: CallRemoteFn
 }
 
@@ -46,6 +50,7 @@ export async function executeHandler(ctx: ExecuteParams): Promise<unknown> {
     deps: ctx.deps,
     url: ctx.url,
     kernel: ctx.kernel,
+    issuer: ctx.issuer,
     callRemote: ctx.callRemote,
   })
 }

package/src/dispatch/identity.ts

@@ -1,10 +1,11 @@
 /**
  * Per-callable identity — dispatcher runtime + install-time wiring.
  *
- * Two flavors of callable get an identity per the install-time identity
- * binding: Methods on classes/interfaces (sub = MethodPath) and auto-
- * materialized core function nodes — RemoteFunctions and Views (sub =
- * AbsolutePath of the node under `core/{functions,views}/<slug>`).
+ * Three flavors of callable get an identity per the install-time identity
+ * binding, each keyed by its mount-stable semantic sub: Methods on
+ * classes/interfaces (sub = MethodPath), standalone-function MEMBERS
+ * (sub = FunctionPath `/:<origin>:function.<slug>`), and view MEMBERS
+ * (sub = ViewPath `/:<origin>:view.<slug>`).
  *
  * At server startup the method dispatcher and the View / RemoteFunction
  * route mounter pre-compute, for every materialized callable, the
@@ -54,11 +55,12 @@ export type AuxBuckets<T> = {
 }
 
 /**
- * slug → `AbsolutePath.raw` for each auto-materialized aux node
- * (RemoteFunction / View). These nodes live at
- * `/<origin>/core/{functions,views}/<slug>` and have no class+method
- * decomposition that would justify a MethodPath — their identity is their
- * graph position.
+ * slug → mount-stable semantic `sub` for each aux callable MEMBER node:
+ *   - standalone-function members (`kind: 'function'`) → FunctionPath;
+ *   - view members (`kind: 'view'`) → ViewPath (plus any hand-authored/legacy
+ *     core `View` nodes, `kind: 'core'` className `View`, keyed by their AbsolutePath).
+ * The value is `resolveCallables(...).sub` — the exact subject the kernel stamped on
+ * the node at install, so an outbound-signing worker matches its own function identity.
  */
 export type AuxIdentityPaths = AuxBuckets<string>
 
@@ -66,20 +68,13 @@ export function collectAuxIdentityPaths(compiled: CompiledDomain): AuxIdentityPa
   const views: Record<string, string> = {}
   const remoteFunctions: Record<string, string> = {}
   for (const c of resolveCallables(compiled)) {
-    if (c.kind !== 'core' || !c.slug) continue
-    if (c.className === 'View') {
-      views[c.slug] = c.sub
-    } else if (c.className === 'Function') {
-      // Standalone callables (the former `RemoteFunction`) materialize as the
-      // canonical kernel `Function` class.
+    if (!c.slug) continue
+    if (c.kind === 'function') {
       remoteFunctions[c.slug] = c.sub
-    } else {
-      throw new Error(
-        `collectAuxIdentityPaths: unrecognised aux callable className "${c.className}" ` +
-          `at ${c.ref}. If you've added a new auto-materialized Function class to extendCore, ` +
-          `extend this collector + the kernel walker (resolveCallables) to handle it.`,
-      )
+    } else if (c.kind === 'view' || (c.kind === 'core' && c.className === 'View')) {
+      views[c.slug] = c.sub
     }
+    // Methods (`kind: 'method'`) get their identity via `collectMethodPaths`.
   }
   return { views, remoteFunctions }
 }
@@ -88,7 +83,7 @@ export function collectAuxIdentityPaths(compiled: CompiledDomain): AuxIdentityPa
  * slug → `RemoteIdentityConfig` for each auto-materialized View /
  * RemoteFunction. Built once at server startup; consumed by
  * `mountAuxiliaryRoutes` so each handler signs outbound `kernel.call(...)`
- * with its own `sub` (the node's AbsolutePath). Mirrors `buildIdentityMap`.
+ * with its own `sub` (its FunctionPath/ViewPath). Mirrors `buildIdentityMap`.
  */
 export type AuxIdentityMap = AuxBuckets<RemoteIdentityConfig>
 

package/src/dispatch/index.ts

@@ -6,7 +6,7 @@ export {
   type ValidationResult,
   type ResultValidationResult,
 } from './validate'
-export { resolveSelf, type SelfResult } from './self'
+export { resolveSelf, withBoundNode, type SelfResult, type TypedSelf } from './self'
 export { executeHandler, type ExecuteParams } from './execute'
 export { makeCallRemote, type CallRemoteFn, type KernelCaller } from './call-remote'
 export {

package/src/dispatch/self.ts

@@ -1,30 +1,26 @@
 /**
- * Self resolution — pipeline step 3.
- *
- * `_self` is a path reference to the node the non-static method runs on.
- * `resolveSelf` is a thin PARSE: the caller's string becomes a `Path`, and
- * handlers build recursive paths as `${self.path}::method` (the `Path`'s
- * `toString` yields its raw form, so template literals work unchanged). It does
- * NOT touch the graph — the whole dispatch pipeline (resolve → authenticate →
- * validate → self → execute) reaches the handler without a single `Node::get`.
- *
- * `resolveSelf` receives the bare self target (`@<id>` or a tree path) — the
- * method ref travels in a separate dispatch channel, so `::method` never
- * reaches here. For the `@<id>` form the parsed `Path` is an `IdPath` which
- * already carries the node id; surfacing it on `SelfResult.id` saves every
- * worker handler from parsing `self.path.raw` by hand to recover the id of the
- * node it is already operating on.
- *
- * `withNode` enriches the parsed self with the lazy `node()` accessor — the one
- * place a handler can fetch its own node's full record (`{ id, class, props }`)
- * without hand-rolling a `::get`. Construction stays split from parsing so
- * `resolveSelf` remains pure and trivially testable; the dispatcher attaches the
- * accessor once it holds the request's kernel.
+ * Self resolution stays parse-only: `_self` becomes a Path/IdPath with no graph
+ * read. The dispatcher later attaches lazy node()/call helpers once it has a kernel.
  */
 
+import type {
+  BindCtx,
+  BoundNode,
+  InstanceDispatch,
+  NodeBinder,
+  ProxyCaller,
+  TypeMethods,
+  TypeNames,
+} from '@astrale-os/kernel-client/schema'
 import type { Node } from '@astrale-os/kernel-core/graph'
+import type { Schema } from '@astrale-os/kernel-dsl'
 
-import { IdPath, Path, type NodeId } from '@astrale-os/kernel-core'
+import {
+  createInstanceProxy,
+  defaultCaller,
+  extractMethodsByType,
+} from '@astrale-os/kernel-client/schema'
+import { IdPath, K, Path, type NodeId } from '@astrale-os/kernel-core'
 import { classPathSchema } from '@astrale-os/kernel-core/domain'
 import { absolutePathSchema } from '@astrale-os/kernel-core/tree'
 import { z } from 'zod'
@@ -43,32 +39,31 @@ export type ParsedSelf = {
 
 export type SelfResult = ParsedSelf & {
   /**
-   * Lazily read THIS node's full record via one `::get` on the handler's
-   * kernel. Memoized for the dispatch: repeated and concurrent calls share a
-   * single in-flight fetch, and a failure clears the cache so it stays
-   * retryable. Pass `{ reload: true }` to force a fresh read.
-   *
-   * The result is a point-in-time SNAPSHOT, not a live view — for
-   * read-modify-write, treat it as the value as of the read (or `reload`).
-   * `props` is returned structurally validated only, NOT typed against the
-   * node's declared schema: the kernel does not hydrate declared props at
-   * runtime, so a node-typed `self` would be unsound. Read the concrete backend
-   * off `node.class` (a `ClassPath`) — that is the persisted discriminator.
+   * Lazy point-in-time self read. Memoized per dispatch; `{ reload: true }`
+   * forces a fresh `function.get`.
    */
   node(opts?: { reload?: boolean }): Promise<ResolvedSelfNode>
 }
 
+/** Schema-typed self: short-keyed props and typed same-instance call proxy. */
+export type TypedSelf<D, S extends Schema = Schema> = ParsedSelf & {
+  /**
+   * Fetch THIS node as a typed `BoundNode<D>`. Memoized exactly like
+   * {@link SelfResult.node} — one in-flight `function.get`, rejection-clearing,
+   * `{ reload: true }` refetches — so the zero-extra-graph-read dispatch
+   * invariant holds: nothing is read until called, then at most once.
+   */
+  node(opts?: { reload?: boolean }): Promise<BoundNode<D, S>>
+  /** Own instance methods — typed, address-only (`<selfPath>::method`), no read. */
+  readonly call: InstanceDispatch<D>
+}
+
 export function resolveSelf(ref: string): ParsedSelf {
   const path = Path.parse(ref)
   return path instanceof IdPath ? { path, id: path.id } : { path }
 }
 
-/**
- * Attach the memoized `node()` accessor, binding it to the handler's kernel.
- * `kernel` is `null` for methods whose auth policy yields none (`public`, or an
- * unauthenticated `optional`) — there `node()` rejects with a clear error
- * rather than reading the graph unauthenticated.
- */
+/** Attach memoized node(); unauthenticated contexts reject instead of reading. */
 export function withNode(parsed: ParsedSelf, kernel: Kernel | null): SelfResult {
   let cached: Promise<ResolvedSelfNode> | undefined
   const node = (opts?: { reload?: boolean }): Promise<ResolvedSelfNode> => {
@@ -84,6 +79,73 @@ export function withNode(parsed: ParsedSelf, kernel: Kernel | null): SelfResult
   return { ...parsed, node }
 }
 
+const EMPTY_METHODS: TypeMethods = { kind: 'class', methods: new Set() }
+const methodMapCache = new WeakMap<object, Map<string, TypeMethods>>()
+
+/** The type's method allow-list + kind, computed once per binder. */
+function methodsFor<S extends Schema>(binder: NodeBinder<S>, typeName: string): TypeMethods {
+  let map = methodMapCache.get(binder)
+  if (!map) {
+    map = extractMethodsByType(binder.schema)
+    methodMapCache.set(binder, map)
+  }
+  return map.get(typeName) ?? EMPTY_METHODS
+}
+
+function noKernelCaller(ref: string): ProxyCaller {
+  return () =>
+    Promise.reject(
+      new Error(
+        `self.call needs an authenticated kernel to dispatch on "${ref}", but this method ran ` +
+          `without one (its auth policy yields no kernel — e.g. 'public').`,
+      ),
+    )
+}
+
+/**
+ * Schema-typed self helper: lazy BoundNode plus address-only call proxy. With no
+ * kernel, both node() and call thunks fail loudly.
+ */
+export function withBoundNode<S extends Schema>(
+  parsed: ParsedSelf,
+  kernel: Kernel | null,
+  binder: NodeBinder<S>,
+  typeName: string,
+): TypedSelf<unknown, S> {
+  const ctx: BindCtx = kernel
+    ? { caller: defaultCaller(kernel), read: kernel }
+    : { caller: null, read: null }
+
+  let cached: Promise<BoundNode<unknown, S>> | undefined
+  const node = (opts?: { reload?: boolean }): Promise<BoundNode<unknown, S>> => {
+    if (opts?.reload) cached = undefined
+    if (!cached) {
+      cached = fetchSelfNode(parsed.path, kernel)
+        .then(
+          (record) =>
+            binder.bind(typeName as TypeNames<S>, record, ctx, {
+              validate: 'warn',
+            }) as unknown as BoundNode<unknown, S>,
+        )
+        .catch((err: unknown) => {
+          cached = undefined // never cache a rejection — a later call may succeed
+          throw err
+        })
+    }
+    return cached
+  }
+
+  const info = methodsFor(binder, typeName)
+  const call = createInstanceProxy(
+    ctx.caller ?? noKernelCaller(parsed.path.raw),
+    parsed.path.raw,
+    info.methods,
+    info.kind === 'class' ? typeName : undefined,
+  ) as InstanceDispatch<unknown>
+
+  return { ...parsed, node, call }
+}
+
 /**
  * Boundary schema for a node record off the wire. Structurally identical to
  * kernel-core's `nodeSchema`, re-declared here from its public coercers
@@ -108,9 +170,23 @@ async function fetchSelfNode(path: Path, kernel: Kernel | null): Promise<Resolve
         `method whose auth is 'required', or supply a credential.`,
     )
   }
-  const record = nodeRecordSchema.parse(await kernel.call(`${path.raw}::get`, {}))
+  // function.get soft-masks missing/unreadable roots; empty page means no self node.
+  const result = (await kernel.call(K.$.f('get').path.domain.raw, {
+    roots: [path.raw],
+    depth: 0,
+  })) as {
+    nodes?: unknown[]
+  }
+  const first = result?.nodes?.[0]
+  if (first === undefined) {
+    throw new Error(
+      `self.node(): "${path.raw}" was not found or is not visible to the caller ` +
+        `(function.get returned no node).`,
+    )
+  }
+  const record = nodeRecordSchema.parse(first)
   if (record.id === undefined) {
-    throw new Error(`self.node(): "${path.raw}::get" returned a record with no id`)
+    throw new Error(`self.node(): "${path.raw}" returned a record with no id`)
   }
   // Validated at the wire boundary: id is now known-present, props are
   // structurally checked. Bridge the parse output to the canonical `Node`.

package/src/domain/binding.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared binding helpers for auto-materialized members (functions + views).
+ *
+ * The worker ROUTE URL a member is served at — `<url>/<folderSlug>/<slug>` — is
+ * decoupled from the member's GRAPH layout (`/<origin>/{functions,views}/<slug>`,
+ * a fixed kernel convention). `folderSlug` names only the URL segment.
+ */
+
+import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
+
+/** Join a worker-relative mount path onto the serving url (single slash). */
+export function joinWorkerPath(url: string, mount: string): string {
+  const base = url.replace(/\/+$/, '')
+  return `${base}/${mount.replace(/^\/+/, '')}`
+}
+
+/**
+ * Resolve a member's effective binding against the serving `url`. An explicit
+ * `override.remoteUrl` wins; otherwise defaults to `<url>/<folderSlug>/<slug>`.
+ * Same trailing-slash discipline as {@link joinWorkerPath} — a `url` ending in
+ * `/` must not produce `//` (the kernel pins `iss` by exact string).
+ */
+export function resolveBinding(
+  override: FunctionBinding | undefined,
+  url: string,
+  folderSlug: string,
+  slug: string,
+): FunctionBinding {
+  const base = url.replace(/\/+$/, '')
+  if (override) {
+    return {
+      ...override,
+      remoteUrl: override.remoteUrl ?? `${base}/${folderSlug}/${slug}`,
+    }
+  }
+  return { remoteUrl: `${base}/${folderSlug}/${slug}` }
+}

package/src/domain/build-spec.ts

@@ -18,9 +18,10 @@
  */
 
 import type { Graph, WireGraph } from '@astrale-os/kernel-core'
-import type { BoundMethod, FunctionSchema } from '@astrale-os/kernel-core/domain'
+import type { BoundMethod, FunctionSchema, ViewSchema } from '@astrale-os/kernel-core/domain'
 import type { Schema } from '@astrale-os/kernel-dsl'
 
+import { AbsolutePath } from '@astrale-os/kernel-core'
 import { hashInstallGraph, serialize, zodToJsonSchema } from '@astrale-os/kernel-core/domain'
 
 import type { AnyRemoteHandler } from '../method/single'
@@ -41,8 +42,23 @@ export function buildInstallGraph<S extends Schema>(
   domain: RemoteDomain<S>,
   url: string,
 ): WireGraph {
-  const { compiled } = materializeRemoteDomain(domain, url)
-  return buildSpecInternal(compiled, domain.methods, url).toWire() as WireGraph
+  const { compiled, auxiliary } = materializeRemoteDomain(domain, url)
+  // Two-axis placement: `parent` = the folder the Domain node physically lives
+  // under. `path` names the FULL node path (basename === origin);
+  // unset defaults to /domains/<origin> — the "/domains" placement policy lives
+  // HERE (the kernel default is Root → /<origin>). `mount` is deliberately NOT
+  // passed: installed_in + typed addresses stay root-mounted (kernel default).
+  const parent = domain.path
+    ? AbsolutePath.parse(domain.path).parent()
+    : AbsolutePath.from('domains')
+  return buildSpecInternal(
+    compiled,
+    domain.methods,
+    url,
+    auxiliary?.functionSchemas ?? [],
+    auxiliary?.viewSchemas ?? [],
+    parent,
+  ).toWire() as WireGraph
 }
 
 /**
@@ -63,12 +79,21 @@ function buildSpecInternal(
   compiled: RemoteDomain['compiled'],
   methods: BoundMethod<AnyRemoteHandler>[],
   url: string,
+  functionSchemas: FunctionSchema[],
+  viewSchemas: ViewSchema[],
+  parent: AbsolutePath,
 ): Graph {
   const serialized = serializeMethodsWithStubs(compiled, methods, url)
-  const tree = serialize(compiled, serialized)
-  // Views / RemoteFunctions are auto-materialized into the Core BEFORE
-  // `compileDomain` runs (see `extend-core.ts`). By the time we reach
-  // `serialize` here the Tree already contains their nodes/edges.
+  // Method impls + standalone-function-member impls travel in the same callable
+  // array (distinct refs: `class.X.method.y` vs `function.<slug>`); view-member
+  // impls travel in `options.views` (a view differs structurally — handshake,
+  // view_for, View class). The serializer emits method nodes from the IR,
+  // function/view members from `compiled.$.refs.{functions,views}`, pulling each
+  // impl by ref.
+  const tree = serialize(compiled, [...serialized, ...functionSchemas], {
+    views: viewSchemas,
+    parent,
+  })
   return tree.toGraph()
 }