@xyo-network/os-runtime 3.0.0

package/src/XyOsBase.ts

@@ -0,0 +1,119 @@
+import { assertEx } from '@xylabs/assert'
+import type { BaseParams, JsonObject } from '@xylabs/object'
+import type { Promisable } from '@xylabs/promise'
+import type { WalletInstance } from '@xyo-network/account'
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import type { PackageManifest } from '@xyo-network/manifest'
+import { BaseEmitter } from '@xyo-network/module-abstract'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { NodeInstance } from '@xyo-network/node-model'
+import type { DappId, DappPackageManifestPayload, DappParams, EventBusInterface, StackInitializer, XyOsContext, XyOsDappContext } from '@xyo-network/os-model'
+import { Mutex } from 'async-mutex'
+
+export interface XyOsContextParams<TManifest extends PackageManifest = PackageManifest> extends BaseParams {
+  eventBus?: EventBusInterface
+  locator?: ModuleFactoryLocator
+  manifest?: TManifest
+  platformLocator?: ModuleFactoryLocator
+}
+
+export class XyOsContextBase<TParams extends XyOsContextParams | void = void> extends BaseEmitter<
+  TParams extends XyOsContextParams ? TParams : XyOsContextParams
+> {
+  protected _bootMutex = new Mutex()
+  protected _platformLocator: ModuleFactoryLocator | undefined
+  protected _root: NodeInstance | undefined
+
+  get bios(): KernelExternal['bios'] | undefined {
+    return this.kernel?.bios
+  }
+
+  get eventBus(): XyOsContext['eventBus'] {
+    return assertEx(this.params.eventBus, () => 'Missing event bus')
+  }
+
+  get exposedNode(): NodeInstance | undefined {
+    throw new Error('Method not implemented. [exposedNode]')
+  }
+
+  get exposedNodeOuter(): NodeInstance | undefined {
+    throw new Error('Method not implemented. [exposedNodeOuter]')
+  }
+
+  get installedDapps(): DappId[] {
+    return []
+  }
+
+  get kernel(): XyOsContext['kernel'] | undefined {
+    return undefined
+  }
+
+  get manifest() {
+    return assertEx(this.params.manifest, () => 'Missing manifest')
+  }
+
+  get platformLocator(): ModuleFactoryLocator {
+    this._platformLocator = this._platformLocator ?? this.params.platformLocator ?? new ModuleFactoryLocator()
+    return this._platformLocator
+  }
+
+  get possibleRoot(): NodeInstance | undefined {
+    return this._root
+  }
+
+  get root(): NodeInstance {
+    return assertEx(this._root, () => 'XyOs root not set (probably not yet booted)')
+  }
+
+  get runningDapps(): DappId[] {
+    return []
+  }
+
+  get state() {
+    return this._root ? 'running' : 'stopped'
+  }
+
+  boot(_wallet: WalletInstance, _locator: ModuleFactoryLocator) {
+    throw new Error('Method not implemented. [boot]')
+  }
+
+  buildDapp(_manifest: DappPackageManifestPayload, _dappId?: DappId): Promisable<XyOsDappContext> {
+    throw new Error('Method not implemented. [buildDapp]')
+  }
+
+  dappByName(_dappId: DappId): Promisable<XyOsDappContext | undefined> {
+    throw new Error('Method not implemented. [runningDapp]')
+  }
+
+  getDappParams(_dappId: DappId): DappParams | undefined {
+    throw new Error('Method not implemented. [getDappParams]')
+  }
+
+  getStack(_stackName: string): StackInitializer {
+    throw new Error('Method not implemented. [getStack]')
+  }
+
+  installDapp(_dappId: DappId) {
+    throw new Error('Method not implemented. [installDapp]')
+  }
+
+  monitor<T>(_fn: () => Promise<T>, _eventConfig: { additionalProperties?: JsonObject; name: string }): Promise<T> {
+    throw new Error('Method not implemented. [monitor]')
+  }
+
+  shutdown() {
+    throw new Error('Method not implemented. [shutdown]')
+  }
+
+  startDapp(_dappId: DappId): Promisable<XyOsDappContext> {
+    throw new Error('Method not implemented. [startDapp]')
+  }
+
+  stopDapp(_dappId: DappId) {
+    throw new Error('Method not implemented. [stopDapp]')
+  }
+
+  uninstallDapp(_dappId: DappId) {
+    throw new Error('Method not implemented. [uninstallDapp]')
+  }
+}

package/src/XyOsDapp.ts

@@ -0,0 +1,90 @@
+import { assertEx } from '@xylabs/assert'
+import type { WalletInstance } from '@xyo-network/account'
+import { ManifestWrapper } from '@xyo-network/manifest-wrapper'
+import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
+import type { DappPackageManifestPayload, XyOsContext, XyOsDappContext, XyOsDappDetails } from '@xyo-network/os-model'
+import { DappPackageManifestPayloadSchema } from '@xyo-network/os-model'
+
+import { DappWindowManifest } from './manifests/index.ts'
+import type { XyOsContextParams } from './XyOsBase.ts'
+import { XyOsContextBase } from './XyOsBase.ts'
+
+export interface XyOsDappContextParams extends XyOsContextParams<DappPackageManifestPayload> {
+  dapp: XyOsDappDetails
+  locator: ModuleFactoryLocator
+  parent: XyOsContext
+}
+
+export class XyOsDapp extends XyOsContextBase<XyOsDappContextParams> implements XyOsDappContext {
+  dapp: XyOsDappDetails
+
+  constructor(params: XyOsDappContextParams) {
+    super(params)
+    this.dapp = { ...params.dapp }
+  }
+
+  override get eventBus() {
+    return this.parent.eventBus
+  }
+
+  override get exposedNode() {
+    return this.parent.exposedNode
+  }
+
+  override get exposedNodeOuter() {
+    return this.parent.exposedNodeOuter
+  }
+
+  /**
+   * @deprecated Dapps should not have access to the bios. This is done for the
+   * settings dapp, but should be refactored out. Bios could possibly be an
+   * optional property of the parent context passed in for dapps that require
+   * elevated permissions.
+   * ^^^ I believe we may want this here in that is a dApp requests access to the bios it will optionally be there
+   */
+  override get kernel(): XyOsContextBase['kernel'] {
+    return assertEx(this.parent.kernel, () => 'Missing kernel')
+  }
+
+  get parent() {
+    return this.params.parent
+  }
+
+  override async boot(wallet: WalletInstance, locator?: ModuleFactoryLocator): Promise<void> {
+    return await this._bootMutex.runExclusive(async () => {
+      console.log('XyOsDapp:boot:start', wallet.address, this.dapp.id)
+      assertEx(this._root === undefined, () => 'Dapp already booted')
+
+      const finalLocator
+        = locator ? (this.params.locator ?? new ModuleFactoryLocator()).merge(locator) : (this.params.locator ?? new ModuleFactoryLocator())
+
+      console.log('XyOsDapp:boot:finalLocator', finalLocator)
+
+      const dappNodesWrapper = new ManifestWrapper({ ...this.manifest, schema: DappPackageManifestPayloadSchema }, wallet, finalLocator)
+      const dappNodes = await dappNodesWrapper.loadNodes()
+
+      // Derive a specific wallet for the dappManifestWrapper.
+      // If the dappNodes and dappManifest wrappers get the same wallet, there will be collisions.
+      const dappManifestWallet = await wallet.derivePath('99999')
+      DappWindowManifest.nodes[0].config.name = this.dapp.name + 'Root'
+      const wrapper = new ManifestWrapper<DappPackageManifestPayload>(
+        { ...DappWindowManifest, schema: DappPackageManifestPayloadSchema },
+        dappManifestWallet,
+        finalLocator,
+      )
+
+      const node = await wrapper.loadNodeFromIndex(0)
+      for (const dappNode of dappNodes) {
+        await node.register(dappNode)
+        await node.attach(dappNode.address, true)
+      }
+
+      this._root = node
+      console.log('XyOsDapp:boot:finish', wallet.address, this.dapp.id)
+    })
+  }
+
+  override getStack(stackName: string) {
+    return this.parent.getStack(stackName)
+  }
+}

package/src/access-interfaces/ValidDappAccessInterfaces.ts

@@ -0,0 +1,8 @@
+import type { DappAccessInterface } from '@xyo-network/os-model'
+import { RegisteredNames, RegisteredNamesInterface } from '@xyo-network/os-model'
+
+export type ValidDappAccessInterfaces = typeof RegisteredNames
+
+export const ValidDappAccessInterfaces: Record<string, DappAccessInterface> = {
+  [RegisteredNames]: RegisteredNamesInterface,
+}

package/src/access-interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './registered-names/index.ts'
+export * from './ValidDappAccessInterfaces.ts'

package/src/access-interfaces/registered-names/helpers/AccessNodeQueries.ts

@@ -0,0 +1,59 @@
+import { assertEx } from '@xylabs/assert'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import type { DappAccessRequest, RegisteredDappAccess, TemporalIndexRegistrationResults, XyOsContext } from '@xyo-network/os-model'
+import type { WithMeta, WithSources } from '@xyo-network/payload-model'
+
+import { RunningDappAccessCache } from '../../../classes/cache/index.ts'
+
+type IndexingResults = WithMeta<WithSources<TemporalIndexRegistrationResults>>[]
+
+export class AccessNodeQueries {
+  constructor(
+    protected xyOsContext: XyOsContext,
+    private accessRequest: DappAccessRequest,
+    private registeredDappAccess: RegisteredDappAccess,
+  ) {}
+
+  get nameServiceNamesAccessNode() {
+    return assertEx(RunningDappAccessCache.get(this.registeredDappAccess.registeringDappId), () => 'No access node found')
+  }
+
+  // Refresh the archivist in the dapp
+  async refresh() {
+    const archivist = await this.getArchivistFromDappNode()
+    await archivist.clear()
+    await this.run()
+    console.log('refreshed')
+  }
+
+  // Run the access node queries
+  async run() {
+    const payloads = await this.getPayloadsFromAccessNode()
+    await this.insertAccessNodePayloadsIntoDappNodeArchivist(payloads)
+  }
+
+  private async getArchivistFromDappNode() {
+    const archivistPath = this.accessRequest?.destinationArchivist || 'DappArchivist'
+    const mod = assertEx(await this.xyOsContext.root.resolve(archivistPath), () => `Unable to find archivist at ${archivistPath}`)
+    return asArchivistInstance(mod, () => `Module at ${archivistPath} is not an archivist`)
+  }
+
+  private async getPayloadsFromAccessNode() {
+    const archivistFromAccessNode = await this.resolveArchivistFromAccessNode()
+    return (await archivistFromAccessNode.all()) as IndexingResults
+  }
+
+  private async insertAccessNodePayloadsIntoDappNodeArchivist(payloads: IndexingResults) {
+    const archivist = await this.getArchivistFromDappNode()
+    await archivist.clear()
+    await archivist.insert(payloads)
+  }
+
+  private async resolveArchivistFromAccessNode() {
+    const archivist = assertEx(
+      await this.nameServiceNamesAccessNode.resolve('PublicXnsArchivist'),
+      () => 'Unable to find archivist at PublicXnsArchivist',
+    )
+    return asArchivistInstance(archivist, () => 'PublicXnsArchivist is not an archivist')
+  }
+}

package/src/access-interfaces/registered-names/helpers/index.ts

@@ -0,0 +1,2 @@
+export * from './AccessNodeQueries.ts'
+export * from './resource/index.ts'

package/src/access-interfaces/registered-names/helpers/resource/AbstractXnsCaller.ts

@@ -0,0 +1,38 @@
+import { assertEx } from '@xylabs/assert'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import type { XyOsContext } from '@xyo-network/os-model'
+
+export const XnsArchivistPayloadDivinerModuleName = 'XnsArchivistPayloadDiviner'
+export const XnsArchivistModuleName = 'XnsArchivist'
+export const XnsRegistrationsArchivistModuleName = 'XnsRegistrationsArchivist'
+
+export abstract class AbstractXnsCaller {
+  constructor(protected context: XyOsContext) {}
+  /**
+   * Get the XnsArchivist
+   */
+  async getXnsArchivist(pathPrefix?: string) {
+    const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistModuleName}` : XnsArchivistModuleName
+    const mod = assertEx(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`)
+    return asArchivistInstance(mod, () => `${fullyQualifiedPath} is not an archivist`)
+  }
+
+  /**
+   * Get the XnsArchivistPayloadDiviner
+   */
+  async getXnsArchivistPayloadDiviner(pathPrefix?: string) {
+    const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsArchivistPayloadDivinerModuleName}` : XnsArchivistPayloadDivinerModuleName
+    const mod = assertEx(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`)
+    return asDivinerInstance(mod, () => `${fullyQualifiedPath} is not an diviner`)
+  }
+
+  /**
+   * Get the XnsRegistrationsArchivist
+   */
+  async getXnsRegistrationsArchivist(pathPrefix?: string) {
+    const fullyQualifiedPath = pathPrefix ? `${pathPrefix}:${XnsRegistrationsArchivistModuleName}` : XnsRegistrationsArchivistModuleName
+    const mod = assertEx(await this.context.root.resolve(fullyQualifiedPath), () => `${fullyQualifiedPath} not found`)
+    return asArchivistInstance(mod, () => `${fullyQualifiedPath} is not an archivist`)
+  }
+}

package/src/access-interfaces/registered-names/helpers/resource/RegistrationsResource.ts

@@ -0,0 +1,54 @@
+import { assertEx } from '@xylabs/assert'
+import { isTemporalIndexingDivinerResultIndex } from '@xyo-network/diviner-temporal-indexing-model'
+import type { TemporalIndexRegistrationResults, XyOsContext } from '@xyo-network/os-model'
+import type { WithMeta, WithSources } from '@xyo-network/payload-model'
+import type { Listener } from 'ethers'
+
+import type { ResourceStore } from '../../../../lib/index.ts'
+import { PayloadStore } from '../../../../lib/index.ts'
+import { AbstractXnsCaller } from './AbstractXnsCaller.ts'
+import { XnsRegistrationsResourceQueries } from './RegistrationsResourceQueries.ts'
+
+export type XnsRegistrationsViews = 'allRegistrations'
+
+export class XnsRegistrationsResource extends AbstractXnsCaller implements ResourceStore<XnsRegistrationsViews> {
+  protected _allRegistrations: PayloadStore<WithMeta<WithSources<TemporalIndexRegistrationResults>>> | undefined
+
+  constructor(
+    context: XyOsContext,
+    private pathPrefix?: string,
+  ) {
+    super(context)
+  }
+
+  get allRegistrations() {
+    return assertEx(this._allRegistrations)
+  }
+
+  get subscriptions() {
+    return {
+      allRegistrations: (cb: Listener) => this.allRegistrations.subscribe(cb),
+    }
+  }
+
+  get views() {
+    return {
+      allRegistrations: () => this.allRegistrations.getSnapshot(),
+    }
+  }
+
+  cleanupListeners() {
+    this.allRegistrations.cleanupListeners()
+  }
+
+  async start() {
+    const xnsArchivistPayloadDiviner = await this.getXnsArchivistPayloadDiviner(this.pathPrefix)
+    const xnsArchivist = await this.getXnsArchivist(this.pathPrefix)
+
+    this._allRegistrations = await PayloadStore.create<WithMeta<WithSources<TemporalIndexRegistrationResults>>>({
+      archivist: xnsArchivist,
+      getLatest: async () => await XnsRegistrationsResourceQueries.getAllRegistrations(xnsArchivistPayloadDiviner),
+      idFunction: isTemporalIndexingDivinerResultIndex,
+    })
+  }
+}

package/src/access-interfaces/registered-names/helpers/resource/RegistrationsResourceQueries.ts

@@ -0,0 +1,22 @@
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import type { DivinerInstance } from '@xyo-network/diviner-model'
+import { PayloadDivinerQuerySchema } from '@xyo-network/diviner-payload-model'
+import { TemporalIndexingDivinerResultIndexSchema } from '@xyo-network/diviner-temporal-indexing-model'
+import type { TemporalIndexRegistrationResults } from '@xyo-network/os-model'
+
+export const XnsRegistrationsResourceQueries = {
+  getAllRegistrations: async (diviner: DivinerInstance) => {
+    const query = {
+      limit: 100,
+      order: 'desc',
+      schema: PayloadDivinerQuerySchema,
+      schemas: [TemporalIndexingDivinerResultIndexSchema],
+    }
+
+    return (await diviner.divine([query])) as TemporalIndexRegistrationResults[]
+  },
+
+  getRecentRegistrations: async (archivist: ArchivistInstance) => {
+    return (await archivist.all()).reverse() as TemporalIndexRegistrationResults[]
+  },
+}

package/src/access-interfaces/registered-names/helpers/resource/index.ts

@@ -0,0 +1,3 @@
+export * from './AbstractXnsCaller.ts'
+export * from './RegistrationsResource.ts'
+export * from './RegistrationsResourceQueries.ts'

package/src/access-interfaces/registered-names/index.ts

@@ -0,0 +1 @@
+export * from './helpers/index.ts'

package/src/adapter/Base.ts

@@ -0,0 +1,96 @@
+import { assertEx } from '@xylabs/assert'
+import { forget } from '@xylabs/forget'
+import type { BaseParams } from '@xylabs/object'
+import type { ArchivistModuleEventData } from '@xyo-network/archivist'
+import { asArchivistInstance } from '@xyo-network/archivist'
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import { BaseEmitter } from '@xyo-network/module-abstract'
+import { asAttachableNodeInstance } from '@xyo-network/node-model'
+import type { NodeAdapter, NodeAdapterBaseEvents } from '@xyo-network/os-model'
+import type { Payload, WithMeta } from '@xyo-network/payload-model'
+import { v4 as uuid } from 'uuid'
+
+type ModuleEventPayload = { event: string; name: string | undefined; schema: 'network.xyo.kernel.module.event' }
+
+export class NodeAdapterBase extends BaseEmitter<BaseParams, NodeAdapterBaseEvents> implements NodeAdapter {
+  initialized = false
+
+  private _id: string = ''
+
+  constructor(
+    private kernel: KernelExternal,
+    private driverName: string,
+  ) {
+    super({})
+    this._id = uuid()
+  }
+
+  get id() {
+    return assertEx(this._id, () => 'NodeAdapterBase id not initialized')
+  }
+
+  async start() {
+    try {
+      // listen to events inserted into the kernel events archivist
+      const moduleAttachedInsertListener = ({ payloads }: ArchivistModuleEventData['inserted']) => {
+        const moduleAttachedEvent = this.findModuleEventPayloads(payloads)
+
+        // loop through the event payloads
+        for (const payload of moduleAttachedEvent) {
+          // check if the event is for the driver
+          if (payload.name === this.driverName) {
+            this.validateAndReturnDriver()
+          }
+        }
+      }
+      // get the events archivist
+      const eventsArchivist = await this.getEventsArchivist()
+
+      // prepare the listener
+      const weakRefInsertListener = new WeakRef(moduleAttachedInsertListener)
+      const insertListenerRef = weakRefInsertListener.deref()
+
+      // attach the listener
+      if (insertListenerRef) eventsArchivist.on('inserted', insertListenerRef)
+
+      // check if the driver is already attached
+      const node = this.validateAndReturnDriver()
+      if (node) return node
+
+      // reset the initialized flag
+      this.initialized = false
+    } catch (error) {
+      // call the onError callbacks
+      await this.emit('driverError', { error: error as Error })
+    }
+  }
+
+  private findModuleEventPayloads(payloads: WithMeta<Payload>[]) {
+    return payloads.filter((payload) => {
+      const payloadToTest = payload as WithMeta<ModuleEventPayload>
+      return payloadToTest.event === 'driverReady' && payloadToTest.schema === 'network.xyo.kernel.module.event'
+    }) as WithMeta<ModuleEventPayload>[]
+  }
+
+  private async getEventsArchivist() {
+    const mod = assertEx(await this.kernel.node.resolve('KernelNode:ModuleEvents'), () => 'KernelNode:ModuleEvents not found')
+    return asArchivistInstance(mod, () => `${mod.id} is not an archivist`)
+  }
+
+  private validateAndReturnDriver() {
+    const mod = this.kernel.initialized[this.driverName]
+    if (mod) {
+      // confirm expected shape
+      const node = asAttachableNodeInstance(mod, () => `${mod.id} is not a node`)
+
+      // set the initialized flag
+      this.initialized = true
+
+      // call the next callbacks
+      const emit = async () => await this.emit('driverReady', { node })
+      forget(emit())
+
+      return node
+    }
+  }
+}

package/src/adapter/Network.ts

@@ -0,0 +1,31 @@
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import type { AttachableNodeInstance } from '@xyo-network/node-model'
+import type { NetworkAdapterBase } from '@xyo-network/os-model'
+
+import { NodeAdapterBase } from './Base.ts'
+
+/**
+ * Adapts Network Driver to the Operating System
+ */
+export class NetworkAdapter extends NodeAdapterBase implements NetworkAdapterBase {
+  _connection: AttachableNodeInstance | undefined
+
+  constructor(kernel: KernelExternal, driverName: string) {
+    super(kernel, driverName)
+    this.on('driverReady', ({ node }) => {
+      this._connection = node
+    })
+  }
+
+  get connection() {
+    return this._connection
+  }
+
+  get hasConnection() {
+    return !!this.connection
+  }
+
+  removeConnection() {
+    this._connection = undefined
+  }
+}

package/src/adapter/Settings.ts

@@ -0,0 +1,30 @@
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import type { AttachableNodeInstance } from '@xyo-network/node-model'
+
+import { NodeAdapterBase } from './Base.ts'
+
+/**
+ * Adapts Settings Driver to the Operating System
+ */
+export class SettingsAdapter extends NodeAdapterBase {
+  private _settings: AttachableNodeInstance | undefined = undefined
+
+  constructor(kernel: KernelExternal, driverName: string) {
+    super(kernel, driverName)
+    this.on('driverReady', ({ node }) => {
+      this._settings = node
+    })
+  }
+
+  get hasSettings() {
+    return !!this.settings
+  }
+
+  get settings() {
+    return this._settings
+  }
+
+  removeSettings() {
+    this._settings = undefined
+  }
+}

package/src/adapter/index.ts

@@ -0,0 +1,2 @@
+export * from './Network.ts'
+export * from './Settings.ts'

package/src/adapters/OsPubSubBridgeNetwork.ts

@@ -0,0 +1,10 @@
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import type { AdapterSetCreator } from '@xyo-network/os-model'
+import { ExposedNodeOuterNodeName, PubSubBridgeNodeNodeName } from '@xyo-network/os-model'
+
+import { NetworkAdapter } from '../adapter/index.ts'
+
+export const OsPubSubBridgeNetworkAdapters: AdapterSetCreator = (kernel: KernelExternal) => [
+  new NetworkAdapter(kernel, PubSubBridgeNodeNodeName),
+  new NetworkAdapter(kernel, ExposedNodeOuterNodeName),
+]

package/src/adapters/OsSettings.ts

@@ -0,0 +1,7 @@
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import type { AdapterSetCreator } from '@xyo-network/os-model'
+import { OsSettingsNodeName } from '@xyo-network/os-model'
+
+import { SettingsAdapter } from '../adapter/index.ts'
+
+export const OsSettingsAdapters: AdapterSetCreator = (kernel: KernelExternal) => [new SettingsAdapter(kernel, OsSettingsNodeName)]

package/src/adapters/OsXyoPublicNetwork.ts

@@ -0,0 +1,9 @@
+import type { KernelExternal } from '@xyo-network/kernel-model'
+import type { AdapterSetCreator } from '@xyo-network/os-model'
+import { XyoPublicNodeName } from '@xyo-network/os-model'
+
+import { NetworkAdapter } from '../adapter/index.ts'
+
+export const OsXyoPublicNetworkAdapters: AdapterSetCreator = (kernel: KernelExternal) => [
+  new NetworkAdapter(kernel, XyoPublicNodeName),
+]

package/src/adapters/index.ts

@@ -0,0 +1,3 @@
+export * from './OsPubSubBridgeNetwork.ts'
+export * from './OsSettings.ts'
+export * from './OsXyoPublicNetwork.ts'

package/src/classes/cache/RunningAccessDappCache.ts

@@ -0,0 +1,21 @@
+import type { NodeInstance } from '@xyo-network/node-model'
+import type { DappId } from '@xyo-network/os-model'
+
+/**
+ * A cache for running access node instances
+ */
+export class RunningDappAccessCache {
+  private static _cache: { [key: DappId]: NodeInstance } = {}
+
+  static get(key: DappId) {
+    return this._cache[key]
+  }
+
+  static has(key?: DappId) {
+    return key ? !!this._cache[key] : false
+  }
+
+  static set(key: DappId, value: NodeInstance) {
+    this._cache[key] = value
+  }
+}