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

package/src/navigation/codec.ts

@@ -0,0 +1,190 @@
+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'
+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'
+
+export interface NavigationParam<Value> {
+  encode(value: Value): string
+  decode(value: string | undefined): Value
+}
+
+export function pathParam(_name: string): NavigationParam<Path> {
+  return Object.freeze({
+    encode: (value: Path) => Path.from(value).raw,
+    decode(value: string | undefined) {
+      if (value === undefined) throw new TypeError('Navigation target is missing.')
+      return Path.parse(value)
+    },
+  })
+}
+
+export function enumParam<const Values extends readonly [string, ...string[]]>(
+  values: Values,
+  fallback: Values[number],
+): NavigationParam<Values[number]> {
+  if (!values.includes(fallback)) throw new TypeError('Navigation enum fallback is not admitted.')
+  return Object.freeze({
+    encode(value: Values[number]) {
+      if (!values.includes(value)) throw new TypeError(`Invalid navigation enum value '${value}'.`)
+      return value
+    },
+    decode(value: string | undefined) {
+      if (value === undefined) return fallback
+      if (!values.includes(value)) throw new TypeError(`Invalid navigation enum value '${value}'.`)
+      return value as Values[number]
+    },
+  })
+}
+
+export type NavigationParams = Readonly<Record<string, NavigationParam<unknown>>>
+
+export interface LocationDefinition<Target, Params extends NavigationParams> {
+  readonly view: Key.View
+  readonly target: NavigationParam<Target>
+  readonly params: Params
+}
+
+export function location<
+  Target,
+  const Params extends NavigationParams = Readonly<Record<never, never>>,
+>(input: {
+  readonly view: Key.View | { readonly key: Key.View }
+  readonly target: NavigationParam<Target>
+  readonly params?: Params
+}): LocationDefinition<Target, Params> {
+  return Object.freeze({
+    view: viewKey(typeof input.view === 'string' ? input.view : input.view.key),
+    target: input.target,
+    params: Object.freeze({ ...input.params }) as Params,
+  })
+}
+
+type ValueOf<Codec> = Codec extends NavigationParam<infer Value> ? Value : never
+type RouteTarget<
+  Routes extends Readonly<Record<string, LocationDefinition<unknown, NavigationParams>>>,
+> = {
+  [Name in keyof Routes]: Readonly<{
+    name: Name
+    target: ValueOf<Routes[Name]['target']>
+    params: Readonly<{
+      [Param in keyof Routes[Name]['params']]: ValueOf<Routes[Name]['params'][Param]>
+    }>
+  }>
+}[keyof Routes]
+
+export type NavigationRoutes = Readonly<
+  Record<string, LocationDefinition<unknown, NavigationParams>>
+>
+
+export interface NavigationDefinition<Routes extends NavigationRoutes = NavigationRoutes> {
+  readonly routes: Routes
+  encode(target: RouteTarget<Routes>): SerializedLocation
+  decode(location: SerializedLocation): RouteTarget<Routes> | null
+  admit(location: SerializedLocation): SerializedLocation | null
+}
+
+export function defineNavigation<const Routes extends NavigationRoutes>(
+  routes: Routes,
+): NavigationDefinition<Routes> {
+  const names = Object.keys(routes).sort() as (keyof Routes)[]
+  const byView = new Map(names.map((name) => [routes[name]!.view, name] as const))
+  if (byView.size !== names.length) throw new TypeError('Navigation Views must be unique.')
+  const definition: NavigationDefinition<Routes> = {
+    routes: Object.freeze({ ...routes }),
+    encode(target) {
+      const route = routes[target.name]
+      if (route === undefined)
+        throw new TypeError(`Unknown navigation location '${String(target.name)}'.`)
+      const params = Object.fromEntries(
+        Object.entries(route.params).map(([name, codec]) => [
+          name,
+          codec.encode((target.params as Record<string, unknown>)[name]),
+        ]),
+      )
+      return Object.freeze({
+        node: Path.parse(route.target.encode(target.target)).raw,
+        view: route.view,
+        ...(Object.keys(params).length === 0 ? {} : { params: Object.freeze(params) }),
+      })
+    },
+    decode(serialized) {
+      if (serialized.view === undefined) return null
+      const name = byView.get(serialized.view)
+      if (name === undefined) return null
+      const route = routes[name]!
+      try {
+        const params = Object.fromEntries(
+          Object.entries(route.params).map(([param, codec]) => [
+            param,
+            codec.decode(serialized.params?.[param]),
+          ]),
+        )
+        if (Object.keys(serialized.params ?? {}).some((param) => !(param in route.params)))
+          return null
+        return Object.freeze({
+          name,
+          target: route.target.decode(serialized.node),
+          params: Object.freeze(params),
+        }) as RouteTarget<Routes>
+      } catch {
+        return null
+      }
+    },
+    admit(serialized) {
+      const decoded = definition.decode(serialized)
+      return decoded === null ? null : definition.encode(decoded)
+    },
+  }
+  return Object.freeze(definition)
+}
+
+export function NavigationScope<Routes extends NavigationRoutes>(props: {
+  readonly navigation: NavigationDefinition<Routes>
+  readonly adapter?: NavAdapter
+  readonly restore?: NavSnapshot
+  readonly initial?: RouteTarget<Routes>
+  readonly children: ReactNode
+}): ReactElement {
+  return createElement(NavScope, {
+    ...(props.adapter === undefined ? {} : { adapter: props.adapter }),
+    ...(props.restore === undefined ? {} : { restore: props.restore }),
+    ...(props.initial === undefined ? {} : { initial: props.navigation.encode(props.initial) }),
+    admit: props.navigation.admit,
+    children: props.children,
+  })
+}
+
+export function useNavigation<Routes extends NavigationRoutes>(
+  navigation: NavigationDefinition<Routes>,
+) {
+  const context = useNavCtx()
+  useHistoryVersion(context.history)
+  const current = context.history.current
+  return Object.freeze({
+    location: current === null ? null : navigation.decode(current),
+    push: (target: RouteTarget<Routes>) => context.navigate(navigation.encode(target)),
+    replace: (target: RouteTarget<Routes>) =>
+      context.navigate(navigation.encode(target), { replace: true }),
+    back: context.navigate.back,
+    forward: context.navigate.forward,
+    snapshot: () => context.history.snapshot(),
+  })
+}
+
+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/history.ts

@@ -4,19 +4,21 @@
  * (`SerializedLocation`/`NavSnapshot` + equality/clone), and the seed precedence.
  * Source of truth for back/forward; the adapter is a projection sink around it.
  */
+import type { NodePath } from '@astrale-os/sdk/graph/path'
+import type { Key } from '@astrale-os/sdk/schema'
 
 /** The serializable projection persisted in history / URLs / snapshots. */
 export interface SerializedLocation {
-  node: string
-  view?: string
-  params?: Record<string, string>
+  readonly node: NodePath
+  readonly view?: Key.View
+  readonly params?: Readonly<Record<string, string>>
 }
 
 /** A versioned history snapshot — round-trips through `NavScope.restore`. */
 export interface NavSnapshot {
-  v: 1
-  entries: SerializedLocation[]
-  cursor: number
+  readonly v: 1
+  readonly entries: readonly SerializedLocation[]
+  readonly cursor: number
 }
 
 /** Structural equality of two serialized locations (node + view + params). */
@@ -24,7 +26,10 @@ export function sameLocation(a: SerializedLocation, b: SerializedLocation): bool
   return a.node === b.node && a.view === b.view && sameParams(a.params, b.params)
 }
 
-function sameParams(a?: Record<string, string>, b?: Record<string, string>): boolean {
+function sameParams(
+  a?: Readonly<Record<string, string>>,
+  b?: Readonly<Record<string, string>>,
+): boolean {
   if (a === b) return true
   const ak = a ? Object.keys(a) : []
   const bk = b ? Object.keys(b) : []
@@ -74,7 +79,11 @@ export class NavHistory {
   }
 
   snapshot(): NavSnapshot {
-    return { v: 1, entries: this.entries.map(cloneLocation), cursor: this.cursor }
+    return Object.freeze({
+      v: 1 as const,
+      entries: Object.freeze(this.entries.map(cloneLocation)),
+      cursor: this.cursor,
+    })
   }
 
   /** Push (or replace the current entry with) a location. No-op on same location. */
@@ -129,8 +138,8 @@ export class NavHistory {
   }
 
   /** Replace the whole stack (restore revalidation prune). */
-  reset(entries: SerializedLocation[], cursor: number): void {
-    this.entries = entries
+  reset(entries: readonly SerializedLocation[], cursor: number): void {
+    this.entries = [...entries]
     this.cursor = cursor
     this.emit()
   }
@@ -151,7 +160,7 @@ export class NavHistory {
  */
 export function seedEntries(
   fromAdapter: SerializedLocation | null,
-  restore: { entries: SerializedLocation[]; cursor: number } | undefined,
+  restore: { readonly entries: readonly SerializedLocation[]; readonly cursor: number } | undefined,
   initialSerialized: SerializedLocation | null,
 ): { entries: SerializedLocation[]; cursor: number } {
   if (restore !== undefined && restore.entries.length > 0) {

package/src/navigation/hooks/ancestors.hook.ts

@@ -1,71 +1,21 @@
-import type { PathLike } from '@astrale-os/kernel-client/graph'
-import type { LiveResult, ShapeInput } from '@astrale-os/kernel-client/store'
-
-/**
- * useAncestors (API §8.2) — the live, inclusive root-first ancestor chain of a
- * node (a move re-renders it). Defaults to the nearest scope's location node;
- * passing a node/path makes it usable outside a scope. Drops any masked ancestor.
- */
-import { useMemo } from 'react'
+import type { Node } from '@astrale-os/sdk/graph/node'
+import type { PathLike } from '@astrale-os/sdk/graph/path'
 
 import type { ReadState } from '../../graph/memory/read/envelope.js'
-import type { Node } from '../location.js'
 
-import { idleReadState } from '../../graph/memory/read/idle.js'
-import { useMemory } from '../../graph/memory/scope.js'
-import { chainPaths, pathHint, pathOf } from '../location.js'
-import { useHistoryVersion, useOptionalNavCtx, useMemoryShape } from '../scope.context.js'
-import { serializeTarget } from '../snapshot.js'
+import { unsupportedReadState } from '../../graph/memory/read/envelope.js'
+
+const EMPTY_CHAIN: readonly Node[] = Object.freeze([])
 
 /**
- * The root-first ancestor chain (inclusive of the node itself), live: a move
- * re-renders it. `node` defaults to the nearest scope's location node; passing a
- * node/path makes it usable outside a scope. The chain drops any ancestor whose
- * record is masked/absent.
+ * Retained public concern with an explicit failed state: V2 has no implicit
+ * slash-tree ancestry. Callers must query a declared Edge Class instead.
  */
 export function useAncestors(
-  node?: Node | PathLike,
+  _node?: Node | PathLike,
 ): ReadState & { readonly chain: readonly Node[] } {
-  const memory = useMemory()
-  const ctx = useOptionalNavCtx()
-  useHistoryVersion(ctx?.history ?? null)
-
-  const baseRef =
-    node !== undefined ? serializeTarget(node).node : (ctx?.history.current?.node ?? null)
-  const baseResult = useMemoryShape(memory, baseRef)
-  const basePath = baseResult?.node ? pathOf(baseResult.node) : pathHint(baseRef ?? '')
-
-  const paths = useMemo(() => (basePath !== '' ? chainPaths(basePath) : EMPTY_PATHS), [basePath])
-  const shape = useMemo<ShapeInput | null>(
-    () => (basePath !== '' ? (q) => q.from(...chainPaths(basePath)) : null),
-    [basePath],
-  )
-  const chainResult = useMemoryShape(memory, shape)
-  const chain = useMemo<readonly Node[]>(() => {
-    if (chainResult === null) return EMPTY_CHAIN
-    const byPath = new Map<string, Node>()
-    for (const n of chainResult.roots) byPath.set(pathOf(n), n)
-    const out: Node[] = []
-    for (const p of paths) {
-      const hit = byPath.get(p)
-      if (hit !== undefined) out.push(hit)
-    }
-    return out
-  }, [paths, chainResult])
-
-  return { ...readStateOf(chainResult), chain }
-}
-
-const EMPTY_PATHS: readonly string[] = Object.freeze([])
-const EMPTY_CHAIN: readonly Node[] = Object.freeze([])
-
-function readStateOf(result: LiveResult | null): ReadState {
-  if (result === null) return idleReadState()
   return {
-    pending: result.pending,
-    error: result.error,
-    live: result.live,
-    seq: result.seq,
-    refetch: result.refetch,
+    ...unsupportedReadState('navigation.ancestors requires an explicit parent Edge Class'),
+    chain: EMPTY_CHAIN,
   }
 }

package/src/navigation/hooks/location.hook.ts

@@ -6,16 +6,14 @@ import { useMemo } from 'react'
 
 import type { NavLocation } from '../location.js'
 
-import { buildLocation, useSettled } from '../location.js'
-import { useHistoryVersion, useNavCtx, useMemoryShape } from '../scope.context.js'
+import { buildLocation } from '../location.js'
+import { useGraphPoint, useHistoryVersion, useNavCtx } from '../scope.context.js'
 
 /** The nearest scope's live location. Throws outside any {@link NavScope}. */
 export function useLocation(): NavLocation {
   const ctx = useNavCtx()
   useHistoryVersion(ctx.history)
   const entry = ctx.history.current
-  const shape = entry?.node ?? null
-  const result = useMemoryShape(ctx.memory, shape)
-  const settled = useSettled(result, shape)
-  return useMemo(() => buildLocation(entry, result, settled), [entry, result, settled])
+  const result = useGraphPoint(entry?.node ?? null)
+  return useMemo(() => buildLocation(entry, result), [entry, result])
 }

package/src/navigation/hooks/scope.hook.ts

@@ -9,8 +9,8 @@ import type { NavSnapshot } from '../history.js'
 import type { NavLocation } from '../location.js'
 import type { Navigate } from '../scope.context.js'
 
-import { buildLocation, useSettled } from '../location.js'
-import { useNavCtx, useMemoryShape } from '../scope.context.js'
+import { buildLocation } from '../location.js'
+import { useGraphPoint, useNavCtx } from '../scope.context.js'
 import { useNavigateHandle } from './navigate.hook.js'
 
 /** The nearest scope, for chrome/persistence (API §8.2). */
@@ -25,10 +25,8 @@ export function useNavScope(): NavScopeHandle {
   const ctx = useNavCtx()
   const navigate = useNavigateHandle(ctx)
   const entry = ctx.history.current
-  const shape = entry?.node ?? null
-  const result = useMemoryShape(ctx.memory, shape)
-  const settled = useSettled(result, shape)
-  const location = useMemo(() => buildLocation(entry, result, settled), [entry, result, settled])
+  const result = useGraphPoint(entry?.node ?? null)
+  const location = useMemo(() => buildLocation(entry, result), [entry, result])
   const snapshot = useCallback(() => ctx.history.snapshot(), [ctx.history])
   return { location, snapshot, navigate }
 }

package/src/navigation/index.ts

@@ -7,8 +7,24 @@ export { useNavigate } from './hooks/navigate.hook.js'
 export { useAncestors } from './hooks/ancestors.hook.js'
 export { useNavScope } from './hooks/scope.hook.js'
 export type { NavScopeHandle } from './hooks/scope.hook.js'
-export { Link } from './link.js'
-export type { LinkProps } from './link.js'
+export { Link, NodeLink, ViewLink } from './link.js'
+export type { LinkProps, NodeLinkProps, ViewLinkProps } from './link.js'
+export {
+  NavigationScope,
+  defineNavigation,
+  enumParam,
+  location,
+  pathParam,
+  useNavigation,
+} from './codec.js'
+export type {
+  LocationDefinition,
+  NavigationDefinition,
+  NavigationParam,
+  NavigationParams,
+  NavigationRoutes,
+  NavigationTarget,
+} from './codec.js'
 export { memoryAdapter } from './adapters/memory.adapter.js'
 export { urlAdapter } from './adapters/url.adapter.js'
 export type { NavAdapter } from './adapters/adapter.js'

package/src/navigation/link.tsx

@@ -8,6 +8,7 @@ import type {
   ReactNode,
 } from 'react'
 
+import { Query } from '@astrale-os/sdk/query'
 /**
  * Link (API §8.2) — navigates the nearest scope. Renders `<a href>` when the
  * scope's adapter exposes a URL form (cmd/ctrl/middle-click then falls through
@@ -16,6 +17,7 @@ import type {
  */
 import { useCallback, useEffect } from 'react'
 
+import type { NavigationDefinition, NavigationTarget } from './codec.js'
 import type { NavTarget } from './snapshot.js'
 
 import { useNavCtx } from './scope.context.js'
@@ -48,8 +50,9 @@ export function Link(props: LinkProps): ReactElement {
   const nodeRef = target.node
 
   const preload = useCallback(() => {
-    void ctx.memory?.preload(nodeRef)
-  }, [ctx.memory, nodeRef])
+    const query = Query.from({ kind: 'node', paths: [nodeRef] }).select({ kind: 'graph' })
+    void ctx.store.preload(query, { page: { size: 1 } }).catch(() => {})
+  }, [ctx.store, nodeRef])
 
   useEffect(() => {
     if (prefetch === 'render') preload()
@@ -108,3 +111,25 @@ export function Link(props: LinkProps): ReactElement {
     </a>
   )
 }
+
+export type ViewLinkProps<Definition extends NavigationDefinition> = Omit<LinkProps, 'to'> & {
+  readonly navigation: Definition
+  readonly to: NavigationTarget<Definition>
+}
+
+/** Codec-admitted link for one declared View location. */
+export function ViewLink<Definition extends NavigationDefinition>(
+  props: ViewLinkProps<Definition>,
+): ReactElement {
+  const { navigation, to, ...link } = props
+  return <Link {...link} to={navigation.encode(to)} />
+}
+
+export type NodeLinkProps = Omit<LinkProps, 'to'> & {
+  readonly to: Extract<NavTarget, string | object>
+}
+
+/** Canonical node-only link; use ViewLink when a View/params contract exists. */
+export function NodeLink(props: NodeLinkProps): ReactElement {
+  return <Link {...props} />
+}

package/src/navigation/location.ts

@@ -1,122 +1,55 @@
-import type { LiveResult } from '@astrale-os/kernel-client/store'
+import type { Node, NodeId } from '@astrale-os/sdk/graph/node'
+import type { NodePath } from '@astrale-os/sdk/graph/path'
+import type { Key } from '@astrale-os/sdk/schema'
 
-import { rawOf } from '@astrale-os/kernel-client/graph'
-/**
- * NavLocation projection (API §8.1) — the live, id-anchored location a scope
- * points at (live path, missing flag), its `buildLocation` assembly, the
- * `useSettled` guard against a one-render false-empty, and the framework-free
- * path math (parent/chain) the scope and hooks share.
- */
-import { useEffect, useRef } from 'react'
+import { Path } from '@astrale-os/sdk/graph/path'
 
+import type { ReadState } from '../graph/memory/read/envelope.js'
 import type { SerializedLocation } from './history.js'
 
-/**
- * The rich graph `Node`, derived from the memory's read envelope — kernel-client
- * does not re-export `Node` at its root yet (API §14 G8), so shell-react reads it
- * off `LiveResult` rather than taking a direct kernel-core dependency.
- */
-export type Node = NonNullable<LiveResult['node']>
-export type NodeId = Node['id']
+export interface PointResult extends ReadState {
+  readonly node: Node | null
+}
 
-/** The live, id-anchored location a scope currently points at (API §8.1). */
+/** One canonical location and its current caller-visible point projection. */
 export interface NavLocation {
-  /** The anchor — survives rename/move. */
-  readonly id: NodeId
-  /** LIVE projection of the node's current path (empty until first resolve). */
-  readonly path: string
-  /** Live memory node — null while cold, or after the anchor stops resolving. */
+  readonly target: NodePath | null
+  readonly id: NodeId | null
   readonly node: Node | null
-  /** View function ref rendering it, when one is open. */
-  readonly view?: string
+  readonly view?: Key.View
   readonly params: Readonly<Record<string, string>>
-  /** The anchor no longer resolves (deleted / masked). */
   readonly missing: boolean
 }
 
 const EMPTY_PARAMS: Readonly<Record<string, string>> = Object.freeze({})
 
-/** The idle location a scope with no current entry projects (inert / boot). */
-export const IDLE_LOCATION: NavLocation = {
-  id: '' as NodeId,
-  path: '',
+export const IDLE_LOCATION: NavLocation = Object.freeze({
+  target: null,
+  id: null,
   node: null,
   params: EMPTY_PARAMS,
   missing: false,
-}
+})
 
-/** Project a serialized entry + its live read into the public {@link NavLocation}. */
 export function buildLocation(
   entry: SerializedLocation | null,
-  result: LiveResult | null,
-  settled: boolean,
+  result: PointResult | null,
 ): NavLocation {
   if (entry === null) return IDLE_LOCATION
   const node = result?.node ?? null
   return {
-    id: (node?.id ?? idHint(entry.node)) as NodeId,
-    path: node ? pathOf(node) : pathHint(entry.node),
+    target: entry.node,
+    id: node?.id ?? idAnchor(entry.node),
     node,
-    ...(entry.view !== undefined ? { view: entry.view } : {}),
-    params: entry.params ?? IDLE_LOCATION.params,
-    missing: settled && node === null,
+    ...(entry.view === undefined ? {} : { view: entry.view }),
+    params: entry.params ?? EMPTY_PARAMS,
+    missing: result !== null && !result.pending && node === null,
   }
 }
 
-/**
- * Whether a read has definitively settled — data present, a hard error, or a
- * completed empty fetch. Guards `missing` (and the missing policy) against the
- * one-render false-empty before a cold shape's first fetch is even in flight.
- */
-export function useSettled(result: LiveResult | null, key: string | null): boolean {
-  const sawPending = useRef(new Map<string, boolean>())
-  useEffect(() => {
-    if (key !== null && result?.pending === true) sawPending.current.set(key, true)
-  }, [key, result?.pending])
-  if (key === null || result === null) return false
-  if (result.node !== null) return true
-  if (result.error !== undefined) return true
-  return !result.pending && sawPending.current.get(key) === true
-}
-
-// ── path math ──────────────────────────────────────────────────────────────
-
-/** The raw path of a live node (empty when cold). */
-export function pathOf(node: Node | null): string {
-  return node ? rawOf(node.path) : ''
-}
-
-/** Best-effort anchor id from a stored ref (`@<id>` → id, else the raw ref). */
-export function idHint(ref: string): string {
-  return ref.startsWith('@') ? ref.slice(1) : ref
-}
-
-/** Best-effort path from a stored ref (a `/…` ref is already a path). */
-export function pathHint(ref: string): string {
-  return ref.startsWith('/') ? ref : ''
+function idAnchor(target: NodePath): NodeId | null {
+  const path = Path.from(target)
+  return path.ast.anchor.kind === 'id' && path.ast.steps.length === 0 ? path.ast.anchor.id : null
 }
 
-/** The parent absolute path, or null at (or above) root. */
-export function parentPath(raw: string): string | null {
-  const norm = raw.replace(/\/+$/, '')
-  if (norm === '' || norm === '/') return null
-  const idx = norm.lastIndexOf('/')
-  return idx <= 0 ? '/' : norm.slice(0, idx)
-}
-
-/**
- * The inclusive, root-first path chain for an absolute path — the ancestry the
- * kernel tree encodes in the slug path (`/a/b/c` → `/`, `/a`, `/a/b`, `/a/b/c`).
- * The node itself is the last element, so breadcrumbs map the chain directly.
- */
-export function chainPaths(raw: string): string[] {
-  const norm = raw.replace(/\/+$/, '')
-  if (norm === '' || norm === '/') return ['/']
-  const out = ['/']
-  let acc = ''
-  for (const seg of norm.split('/').filter(Boolean)) {
-    acc += `/${seg}`
-    out.push(acc)
-  }
-  return out
-}
+export type { Node, NodeId }