@xyo-network/os-runtime 3.0.0

package/src/classes/cache/RunningDappCache.ts

@@ -0,0 +1,50 @@
+import { assertEx } from '@xylabs/assert'
+import type { DappId, RegisteredDapp, WindowDappNodeSet, XyOsContext } from '@xyo-network/os-model'
+import { Mutex } from 'async-mutex'
+
+import { XyOs } from '../../XyOs.ts'
+import { createDappContext, DappContextCreator } from '../node/index.ts'
+
+const findOrCreateMutex = new Mutex()
+
+/**
+ * A cache for running node instances
+ */
+export class RunningDappCache {
+  private static _cache: { [key: DappId]: WindowDappNodeSet } = {}
+
+  static async findOrCreate(dapp: RegisteredDapp, xyOs: XyOsContext, allowedNames: string[], xnsNodeUrl: string | undefined, xnsNetwork: string | undefined): Promise<WindowDappNodeSet> {
+    const dappId = dapp.config.name
+
+    return await XyOs.monitor<WindowDappNodeSet>(
+      async () =>
+        await findOrCreateMutex.runExclusive(async () => {
+          const existingWindowDappSet = RunningDappCache.get(dappId)
+          if (existingWindowDappSet) {
+            console.debug('[DEBUG]', `RunningDappCache, using existing node for ${dappId}`)
+            const existingDappContext = assertEx(existingWindowDappSet.context, () => 'No context found in existing dapp node')
+            await DappContextCreator.primeDappArchivist(existingDappContext, xyOs, dappId)
+            return existingWindowDappSet
+          }
+          console.debug('[DEBUG]', 'RunningDappCache:creating', dappId)
+          const windowDappSet = await createDappContext(dapp, xyOs, allowedNames, xnsNodeUrl, xnsNetwork)
+          RunningDappCache.set(dappId, windowDappSet)
+
+          return windowDappSet
+        }),
+      { additionalProperties: { dappId }, name: 'Loading dApp' },
+    )
+  }
+
+  static get(key: DappId): WindowDappNodeSet | undefined {
+    return this._cache[key]
+  }
+
+  static has(key?: DappId) {
+    return key ? !!this._cache[key] : false
+  }
+
+  static set(key: DappId, value: WindowDappNodeSet) {
+    this._cache[key] = value
+  }
+}

package/src/classes/cache/index.ts

@@ -0,0 +1,2 @@
+export * from './RunningAccessDappCache.ts'
+export * from './RunningDappCache.ts'

package/src/classes/dapp/DefaultsResource.ts

@@ -0,0 +1,65 @@
+import { assertEx } from '@xylabs/assert'
+import type { DappInjectableParams, NodeOsInfo, XyOsContext } from '@xyo-network/os-model'
+import { isDappInjectableParams, isNodeOsInfo } from '@xyo-network/os-model'
+
+import { DappCallerBase } from '../../DappCallerBase.ts'
+import { DappDefaultsResourceQueries } from '../../DefaultsQueries.ts'
+import type { Listener, ResourceStore } from '../../lib/index.ts'
+import { PayloadStore } from '../../lib/index.ts'
+
+export type DappDefaultsResourceViews = 'nodeOsInfo' | 'dappInjectableParamsFromRoute'
+
+/**
+ * A resource for interacting with Dapp Defaults
+ */
+export class DappDefaultsResource extends DappCallerBase implements ResourceStore<DappDefaultsResourceViews> {
+  private _dappInjectableParamsFromRouteListener: PayloadStore<DappInjectableParams> | undefined
+  private _nodeOsInfoListener: PayloadStore<NodeOsInfo> | undefined
+
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  get dappInjectableParamsFromRouteListener() {
+    return assertEx(this._dappInjectableParamsFromRouteListener, () => 'DappInjectableParams not found')
+  }
+
+  get nodeOsInfoListener() {
+    return assertEx(this._nodeOsInfoListener, () => 'NodeOsInfo not found')
+  }
+
+  get subscriptions() {
+    return {
+      dappInjectableParamsFromRoute: (cb: Listener) => this.dappInjectableParamsFromRouteListener.subscribe(cb),
+      nodeOsInfo: (cb: Listener) => this.nodeOsInfoListener.subscribe(cb),
+    }
+  }
+
+  get views() {
+    return {
+      dappInjectableParamsFromRoute: () => this.dappInjectableParamsFromRouteListener.getSnapshot(),
+      nodeOsInfo: () => this.nodeOsInfoListener.getSnapshot(),
+    }
+  }
+
+  cleanupListeners() {
+    this.nodeOsInfoListener.cleanupListeners()
+  }
+
+  async start() {
+    const archivist = await this.getDappArchivist()
+    const diviner = await this.getDappArchivistPayloadDiviner()
+
+    this._nodeOsInfoListener = await PayloadStore.create<NodeOsInfo>({
+      archivist,
+      getLatest: async () => await DappDefaultsResourceQueries.getNodeOsInfo(diviner),
+      idFunction: isNodeOsInfo,
+    })
+
+    this._dappInjectableParamsFromRouteListener = await PayloadStore.create<DappInjectableParams>({
+      archivist,
+      getLatest: async () => await DappDefaultsResourceQueries.getDappInjectableParamsFromRoute(diviner),
+      idFunction: isDappInjectableParams,
+    })
+  }
+}

package/src/classes/dapp/access/Caller.ts

@@ -0,0 +1,73 @@
+import { assertEx } from '@xylabs/assert'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import { asNodeInstance } from '@xyo-network/node-model'
+import type {
+  PostRegistrationHandler,
+  RegisteredDappAccess,
+  RegisteredDappSet,
+  RegisteredDappSetResult,
+  XyOsContext } from '@xyo-network/os-model'
+import {
+  isRegisteredDappAccessDappSet,
+} from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+
+import { OsCallerBase } from '../../../OsCallerBase.ts'
+import { RunningDappAccessCache, RunningDappCache } from '../../cache/index.ts'
+
+/**
+ * Caller for managing Dapp Access Nodes
+ * Start nodes that have been registered as accessible
+ * Grab their Access Node(s)
+ * Put RegisteredDappAccess payloads in RegisteredDappInterfacesArchivist
+ * Keep Service running that can service requests for Access Nodes
+ **/
+export class DappAccessCaller extends OsCallerBase implements PostRegistrationHandler {
+  constructor(
+    context: XyOsContext,
+    private registeredDapps: RegisteredDappSetResult[],
+    private allowedNames: string[],
+    private xnsNodeUrl: string | undefined,
+    private xnsNetwork: string | undefined,
+    private platformLocator = new ModuleFactoryLocator(),
+  ) {
+    super(context)
+  }
+
+  async start() {
+    const registeredDappAccessDappSets = this.registeredDapps.filter(isRegisteredDappAccessDappSet)
+    for (const registeredDappSet of registeredDappAccessDappSets) {
+      const context = await this.buildRunningDappCache(registeredDappSet, this.allowedNames)
+
+      for (const dappAccessor of registeredDappSet.dapp.accessors) {
+        await this.cacheAccessNode(dappAccessor, context)
+        await this.saveRegisteredDappInterfaces(dappAccessor)
+      }
+    }
+  }
+
+  private async buildRunningDappCache(registeredDappSet: RegisteredDappSet, allowedNames: string[]) {
+    const { context } = await RunningDappCache.findOrCreate(registeredDappSet.dapp, this.context, allowedNames, this.xnsNodeUrl, this.xnsNetwork)
+    if (!context) throw new Error('Dapp context not found')
+    return context
+  }
+
+  private async cacheAccessNode(dappAccessor: RegisteredDappAccess, context: XyOsContext) {
+    const accessNodeId = dappAccessor.rootModuleId
+    const accessNodeModule = assertEx(await context.root.resolve(accessNodeId), () => 'Access Node Module not found')
+    const accessNode = asNodeInstance(accessNodeModule, () => 'Access Node Module is not a NodeInstance')
+
+    RunningDappAccessCache.set(dappAccessor.registeringDappId, accessNode)
+  }
+
+  private async saveRegisteredDappInterfaces(registeredDappAccess: RegisteredDappAccess) {
+    const archivist = await this.getRegisteredDappInterfacesArchivist()
+
+    const hash = await PayloadBuilder.dataHash(registeredDappAccess)
+    const [existing] = await archivist.get([hash])
+    if (existing) return
+
+    await archivist.insert([registeredDappAccess])
+    console.debug('[DEBUG] -', `Registered ${registeredDappAccess.registeringDappId} with ${registeredDappAccess.name} interface`)
+  }
+}

package/src/classes/dapp/access/Queries.ts

@@ -0,0 +1,38 @@
+import type { DivinerInstance } from '@xyo-network/diviner-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type { DappAccessRequest, RegisteredDappAccess } from '@xyo-network/os-model'
+import { DappAccessRequestSchema, RegisteredDappAccessSchema } from '@xyo-network/os-model'
+import type { WithMeta } from '@xyo-network/payload-model'
+
+const noResults: unknown[] = []
+
+export const DappAccessRequestQueries = {
+  async getAccessRequests(diviner: DivinerInstance) {
+    const query = {
+      limit: 1,
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappAccessRequestSchema],
+    }
+
+    const results = (await diviner.divine([query])) as WithMeta<DappAccessRequest>[]
+
+    if (results.length === 0) {
+      return noResults as WithMeta<DappAccessRequest>[]
+    }
+    return results
+  },
+  async getRegisteredInterfaces(diviner: DivinerInstance) {
+    const query = {
+      limit: 1,
+      schema: PayloadDivinerQuerySchema,
+      schemas: [RegisteredDappAccessSchema],
+    }
+
+    const results = (await diviner.divine([query])) as WithMeta<RegisteredDappAccess>[]
+
+    if (results.length === 0) {
+      return noResults as WithMeta<RegisteredDappAccess>[]
+    }
+    return results
+  },
+}

package/src/classes/dapp/access/Resource.ts

@@ -0,0 +1,63 @@
+import { assertEx } from '@xylabs/assert'
+import type { DappAccessRequest, RegisteredDappAccess, XyOsContext } from '@xyo-network/os-model'
+import { isDappAccessRequestWithMeta, isRegisteredDappAccess } from '@xyo-network/os-model'
+
+import { DappCallerBase } from '../../../DappCallerBase.ts'
+import type { Listener, ResourceStore } from '../../../lib/index.ts'
+import { PayloadStore } from '../../../lib/index.ts'
+import { DappAccessRequestQueries } from './Queries.ts'
+
+export type DappAccessRequestViews = 'accessRequests' | 'registeredInterfaces'
+
+export class DappAccessRequestResource extends DappCallerBase implements ResourceStore<DappAccessRequestViews> {
+  private _accessRequestListener: PayloadStore<DappAccessRequest> | undefined
+  private _registeredInterfacesListener: PayloadStore<RegisteredDappAccess> | undefined
+
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  get accessRequestListener() {
+    return assertEx(this._accessRequestListener, () => 'accessRequests note found')
+  }
+
+  get registeredInterfacesListener() {
+    return assertEx(this._registeredInterfacesListener, () => 'registeredInterfaces note found')
+  }
+
+  get subscriptions() {
+    return {
+      accessRequests: (cb: Listener) => this.accessRequestListener.subscribe(cb),
+      registeredInterfaces: (cb: Listener) => this.registeredInterfacesListener.subscribe(cb),
+    }
+  }
+
+  get views() {
+    return {
+      accessRequests: () => this.accessRequestListener.getSnapshot(),
+      registeredInterfaces: () => this.registeredInterfacesListener.getSnapshot(),
+    }
+  }
+
+  cleanupListeners(): void {
+    this.accessRequestListener.cleanupListeners()
+  }
+
+  // Start the resource
+  async start() {
+    const archivist = await this.getDappArchivist()
+    const diviner = await this.getDappArchivistPayloadDiviner()
+
+    this._accessRequestListener = await PayloadStore.create<DappAccessRequest>({
+      archivist,
+      getLatest: async () => await DappAccessRequestQueries.getAccessRequests(diviner),
+      idFunction: isDappAccessRequestWithMeta,
+    })
+
+    this._registeredInterfacesListener = await PayloadStore.create<RegisteredDappAccess>({
+      archivist,
+      getLatest: async () => await DappAccessRequestQueries.getRegisteredInterfaces(diviner),
+      idFunction: isRegisteredDappAccess,
+    })
+  }
+}

package/src/classes/dapp/access/index.ts

@@ -0,0 +1,3 @@
+export * from './Caller.ts'
+export * from './Queries.ts'
+export * from './Resource.ts'

package/src/classes/dapp/index.ts

@@ -0,0 +1,2 @@
+export * from './access/index.ts'
+export * from './DefaultsResource.ts'

package/src/classes/index.ts

@@ -0,0 +1,8 @@
+export * from './cache/index.ts'
+export * from './dapp/index.ts'
+export * from './lib/index.ts'
+export * from './menu/index.ts'
+export * from './node/index.ts'
+export * from './registration/index.ts'
+export * from './settings/index.ts'
+export * from './system/index.ts'

package/src/classes/lib/DappCreatorParams.ts

@@ -0,0 +1,16 @@
+import type { ModuleManifest } from '@xyo-network/manifest'
+import type { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { DappName, DappPackageManifestPayload, XyOsContext } from '@xyo-network/os-model'
+import type { WalletInstance } from '@xyo-network/wallet-model'
+
+export type DappNodesCreatorParams = {
+  config: {
+    dappName: DappName
+    payload: DappPackageManifestPayload
+    privateChildren?: ModuleManifest[]
+    publicChildren?: ModuleManifest[]
+  }
+  context: XyOsContext
+  locator?: ModuleFactoryLocator
+  wallet: WalletInstance
+}

package/src/classes/lib/Insertable.ts

@@ -0,0 +1,14 @@
+import type { DappName, XyOsContext } from '@xyo-network/os-model'
+import type { Payload } from '@xyo-network/payload-model'
+
+export interface InsertableConstructor {
+  new (_xyOs: XyOsContext, dappName: DappName): DefaultPayloadsInsertable
+}
+
+type InsertableConstructorParams = ConstructorParameters<InsertableConstructor>
+
+export interface DefaultPayloadsInsertable {
+  payloads(): Promise<Payload[]>
+}
+
+export const createInsertable = (insertable: InsertableConstructor, ...params: InsertableConstructorParams) => new insertable(...params)

package/src/classes/lib/index.ts

@@ -0,0 +1,2 @@
+export * from './DappCreatorParams.ts'
+export * from './Insertable.ts'

package/src/classes/menu/Caller.ts

@@ -0,0 +1,76 @@
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type {
+  DappInjectableParams,
+  DappNavItemSelection,
+  XyOsContext } from '@xyo-network/os-model'
+import {
+  DappInjectableParamsSchema,
+  DappNavItemSelectionSchema,
+} from '@xyo-network/os-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, WithMeta } from '@xyo-network/payload-model'
+
+import { DappCaller } from '../../Caller.ts'
+
+export class DappMenuCaller extends DappCaller {
+  constructor(context: XyOsContext) {
+    super(context)
+  }
+
+  /**
+   * Add new Payloads to the dappArchivist if they haven't already
+   *
+   * @param  {Payload[]} payloads
+   */
+  async add(payloads: Payload[], force = false) {
+    const dappArchivist = await this.getDappArchivist()
+
+    for (const payload of payloads) {
+      const hash = await PayloadBuilder.dataHash(payload)
+      const [existing] = await dappArchivist.get([hash])
+      if (!existing || force) {
+        await dappArchivist.insert(payloads)
+      }
+    }
+  }
+
+  async currentNavSelection(): Promise<DappNavItemSelection[] | undefined> {
+    const diviner = await this.getDappArchivistPayloadDiviner()
+    const query = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappNavItemSelectionSchema],
+    }
+
+    return (await diviner.divine([query])) as WithMeta<DappNavItemSelection>[]
+  }
+
+  /*
+   * Indicate to the system that a nav item was selected
+   *
+   * @param  {string} path
+   * @params {string} injectableParamsPath
+   * @returns Promise
+   */
+  async makeNavItemSelection(path: string, injectableParamsPath?: string): Promise<void> {
+    const dappArchivist = await this.getDappArchivist()
+    const payload: DappNavItemSelection = {
+      path,
+      schema: DappNavItemSelectionSchema,
+      timestamp: Date.now(),
+    }
+    await dappArchivist.insert([payload])
+
+    if (injectableParamsPath) {
+      const injectableParams: DappInjectableParams = {
+        params: {},
+        path: injectableParamsPath,
+        schema: DappInjectableParamsSchema,
+        source: 'route',
+        timestamp: Date.now(),
+      }
+      await dappArchivist.insert([injectableParams])
+    }
+  }
+}

package/src/classes/menu/Queries.ts

@@ -0,0 +1,59 @@
+import type { DivinerInstance } from '@xyo-network/diviner-model'
+import type { PayloadDivinerQueryPayload } from '@xyo-network/diviner-payload-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import type {
+  DappNavItem,
+  DappNavItemSelection,
+  DappNavMenuConfig } from '@xyo-network/os-model'
+import {
+  DappNavItemSchema,
+  DappNavItemSelectionSchema,
+  DappNavMenuConfigSchema,
+} from '@xyo-network/os-model'
+import type { WithMeta, WithSources } from '@xyo-network/payload-model'
+
+const NO_ITEMS: unknown[] = []
+
+export const DappMenuQueries = {
+  async getMenuConfigs(diviner: DivinerInstance): Promise<WithSources<WithMeta<DappNavMenuConfig>>[]> {
+    const query: PayloadDivinerQueryPayload = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappNavMenuConfigSchema],
+    }
+    return (await diviner.divine([query])) as WithMeta<WithSources<DappNavMenuConfig>>[]
+  },
+
+  async getMenuItems(diviner: DivinerInstance) {
+    const query: PayloadDivinerQueryPayload = {
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappNavItemSchema],
+    }
+
+    const results = (await diviner.divine([query])) as WithMeta<WithSources<DappNavItem>>[]
+    return results.length > 0 ? results : (NO_ITEMS as WithMeta<WithSources<DappNavItem>>[])
+  },
+
+  async getNavItemSelections(diviner: DivinerInstance) {
+    const query: PayloadDivinerQueryPayload = {
+      limit: 1,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappNavItemSelectionSchema],
+    }
+    const results = (await diviner.divine([query])) as WithMeta<WithSources<DappNavItemSelection>>[]
+    return results.length > 0 ? results : (NO_ITEMS as WithMeta<WithSources<DappNavItemSelection>>[])
+  },
+
+  async getVisibleMenuItems(diviner: DivinerInstance) {
+    const query: PayloadDivinerQueryPayload = {
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [DappNavItemSchema],
+    }
+    const results = (await diviner.divine([query])) as WithMeta<WithSources<DappNavItem>>[]
+    return results.filter(menuItem => menuItem.hidden !== true).sort((a, b) => ((a.weight ?? 0) > (b.weight ?? 0) ? 1 : -1))
+  },
+}

package/src/classes/menu/Resource.ts

@@ -0,0 +1,103 @@
+import { assertEx } from '@xylabs/assert'
+import type { DappNavItem, DappNavItemSelection, DappNavMenuConfig, XyOsContext } from '@xyo-network/os-model'
+import { isDappNavItemSelection, isDappNavMenuConfig } from '@xyo-network/os-model'
+import type { Payload, WithMeta, WithSources } from '@xyo-network/payload-model'
+
+import { DappCaller } from '../../Caller.ts'
+import type { Listener, ResourceStore } from '../../lib/index.ts'
+import { PayloadStore } from '../../lib/index.ts'
+import { DappMenuQueries } from './Queries.ts'
+
+export type DappMenuResourceViews = 'menuConfigs' | 'menuItems' | 'menuItemsVisible' | 'menuItemSelections'
+
+export type NavPayloadType<T extends Payload = Payload> = WithMeta<WithSources<T>>[]
+
+/**
+ * A Repository for interacting with dapp menu items and config
+ */
+export class DappMenuResource extends DappCaller implements ResourceStore<DappMenuResourceViews> {
+  private _menuConfigListener: PayloadStore<DappNavMenuConfig> | undefined
+  private _menuItemListener: PayloadStore<DappNavItem> | undefined
+  private _menuItemSelectionListener: PayloadStore<DappNavItemSelection> | undefined
+  private _menuItemVisibleListener: PayloadStore<DappNavItem> | undefined
+
+  constructor(xyOsContext: XyOsContext) {
+    super(xyOsContext)
+  }
+
+  get menuConfigListener() {
+    return assertEx(this._menuConfigListener, () => 'menuConfigListener note found')
+  }
+
+  get menuItemListener() {
+    return assertEx(this._menuItemListener, () => 'menuItemListener note found')
+  }
+
+  get menuItemSelectionListener() {
+    return assertEx(this._menuItemSelectionListener, () => 'menuItemSelectionListener note found')
+  }
+
+  get menuItemVisibleListener() {
+    return assertEx(this._menuItemVisibleListener, () => 'menuItemVisibleListener note found')
+  }
+
+  /** subscribe to latest set of payloads */
+  get subscriptions() {
+    return {
+      menuConfigs: (cb: Listener) => this.menuConfigListener.subscribe(cb),
+      menuItemSelections: (cb: Listener) => this.menuItemSelectionListener.subscribe(cb),
+      menuItems: (cb: Listener) => this.menuItemListener.subscribe(cb),
+      menuItemsVisible: (cb: Listener) => this.menuItemVisibleListener.subscribe(cb),
+    }
+  }
+
+  /**
+   * Return the latest menu payloads from the repository
+   */
+  get views() {
+    return {
+      menuConfigs: () => this.menuConfigListener.getSnapshot(),
+      menuItemSelections: () => this.menuItemSelectionListener.getSnapshot(),
+      menuItems: () => this.menuItemListener.getSnapshot(),
+      menuItemsVisible: () => this.menuItemVisibleListener.getSnapshot(),
+    }
+  }
+
+  /**
+   * Remove all listeners and reset their class members
+   */
+  cleanupListeners() {
+    this.menuConfigListener.cleanupListeners()
+    this.menuItemListener.cleanupListeners()
+    this.menuItemSelectionListener.cleanupListeners()
+  }
+
+  /**
+   * Start the resource
+   */
+  async start(): Promise<void> {
+    const dappArchivist = await this.getDappArchivist()
+    const dappArchivistPayloadDiviner = await this.getDappArchivistPayloadDiviner()
+
+    this._menuConfigListener = await PayloadStore.create<DappNavMenuConfig>({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getMenuConfigs(dappArchivistPayloadDiviner),
+      idFunction: isDappNavMenuConfig,
+    })
+    this._menuItemListener = await PayloadStore.create<DappNavItem>({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getMenuItems(dappArchivistPayloadDiviner),
+      idFunction: isDappNavMenuConfig,
+    })
+    this._menuItemVisibleListener = await PayloadStore.create<DappNavItem>({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getVisibleMenuItems(dappArchivistPayloadDiviner),
+      idFunction: isDappNavMenuConfig,
+    })
+    this._menuItemSelectionListener = await PayloadStore.create<DappNavItemSelection>({
+      archivist: dappArchivist,
+      getLatest: async () => await DappMenuQueries.getNavItemSelections(dappArchivistPayloadDiviner),
+      idFunction: isDappNavItemSelection,
+    })
+  }
+}

package/src/classes/menu/index.ts

@@ -0,0 +1,2 @@
+export * from './Caller.ts'
+export * from './Resource.ts'