@xyo-network/bridge-http 5.3.22 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/bridge-http",
-  "version": "5.3.22",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,63 +30,59 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "README.md",
     "LICENSE",
     "package.json"
   ],
   "dependencies": {
-    "@xyo-network/account": "~5.3.22",
-    "@xyo-network/boundwitness-model": "~5.3.22",
-    "@xyo-network/bridge-abstract": "~5.3.22",
-    "@xyo-network/bridge-model": "~5.3.22",
-    "@xyo-network/config-payload-plugin": "~5.3.22",
-    "@xyo-network/manifest-model": "~5.3.22",
-    "@xyo-network/module-model": "~5.3.22",
-    "@xyo-network/node-model": "~5.3.22",
-    "@xyo-network/payload-model": "~5.3.22",
     "async-mutex": "~0.5.0",
-    "lru-cache": "~11.2.7"
+    "lru-cache": "~11.2.7",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/bridge-abstract": "~5.3.24",
+    "@xyo-network/config-payload-plugin": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24",
+    "@xyo-network/bridge-model": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/manifest-model": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.8",
-    "@xylabs/ts-scripts-yarn3": "~7.6.8",
-    "@xylabs/tsconfig": "~7.6.8",
-    "@xylabs/vitest-extended": "~5.0.91",
-    "@xyo-network/account": "~5.3.22",
-    "@xyo-network/api-models": "~5.3.22",
-    "@xyo-network/archivist-model": "~5.3.22",
-    "@xyo-network/boundwitness-model": "~5.3.22",
-    "@xyo-network/bridge-abstract": "~5.3.22",
-    "@xyo-network/bridge-model": "~5.3.22",
-    "@xyo-network/config-payload-plugin": "~5.3.22",
-    "@xyo-network/diviner-model": "~5.3.22",
-    "@xyo-network/manifest-model": "~5.3.22",
-    "@xyo-network/module-model": "~5.3.22",
-    "@xyo-network/module-resolver": "~5.3.22",
-    "@xyo-network/node-memory": "~5.3.22",
-    "@xyo-network/node-model": "~5.3.22",
-    "@xyo-network/payload-builder": "~5.3.22",
-    "@xyo-network/payload-model": "~5.3.22",
-    "@xyo-network/payload-wrapper": "~5.3.22",
-    "@xyo-network/wallet": "~5.3.22",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
+    "@xylabs/vitest-extended": "~5.0.93",
     "acorn": "^8.16.0",
     "async-mutex": "~0.5.0",
     "axios": "^1.14.0",
-    "cosmiconfig": "^9.0.1",
-    "esbuild": "^0.27.4",
-    "eslint": "^10.1.0",
+    "esbuild": "^0.28.0",
     "ethers": "^6.16.0",
-    "lru-cache": "^11.2.7",
-    "rollup": "^4.60.1",
+    "lru-cache": "~11.2.7",
     "tslib": "^2.8.1",
     "typescript": "~5.9.3",
     "vite": "^8.0.3",
     "vitest": "~4.1.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/account": "~5.3.24",
+    "@xyo-network/boundwitness-model": "~5.3.24",
+    "@xyo-network/bridge-abstract": "~5.3.24",
+    "@xyo-network/archivist-model": "~5.3.24",
+    "@xyo-network/api-models": "~5.3.24",
+    "@xyo-network/config-payload-plugin": "~5.3.24",
+    "@xyo-network/bridge-model": "~5.3.24",
+    "@xyo-network/manifest-model": "~5.3.24",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/diviner-model": "~5.3.24",
+    "@xyo-network/module-resolver": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24",
+    "@xyo-network/payload-model": "~5.3.24",
+    "@xyo-network/payload-builder": "~5.3.24",
+    "@xyo-network/node-memory": "~5.3.24",
+    "@xyo-network/payload-wrapper": "~5.3.24",
+    "@xyo-network/wallet": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
@@ -98,4 +94,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/HttpBridge.ts

@@ -1,224 +0,0 @@
-import {
-  Address, assertEx,
-  axiosJsonConfig,
-  exists,
-  forget,
-  Promisable, toSafeJsonString,
-} from '@xylabs/sdk-js'
-import { ApiEnvelope } from '@xyo-network/api-models'
-import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { AbstractBridge } from '@xyo-network/bridge-abstract'
-import {
-  BridgeExposeOptions,
-  BridgeModule,
-  BridgeParams,
-  BridgeUnexposeOptions,
-  QuerySendFinishedEventArgs,
-  QuerySendStartedEventArgs,
-} from '@xyo-network/bridge-model'
-import {
-  ModuleManifestPayload, NodeManifestPayload, NodeManifestPayloadSchema,
-} from '@xyo-network/manifest-model'
-import {
-  AnyConfigSchema,
-  creatableModule,
-  ModuleInstance,
-  ModuleQueryResult,
-  ModuleResolverInstance,
-  ModuleStateQuery,
-  ModuleStateQuerySchema,
-} from '@xyo-network/module-model'
-import { asAttachableNodeInstance } from '@xyo-network/node-model'
-import {
-  isPayloadOfSchemaType, Payload, Schema,
-} from '@xyo-network/payload-model'
-import { Mutex, Semaphore } from 'async-mutex'
-import { Axios, AxiosError } from 'axios'
-import { LRUCache } from 'lru-cache'
-
-import { HttpBridgeConfig, HttpBridgeConfigSchema } from './HttpBridgeConfig.ts'
-import { HttpBridgeModuleResolver } from './HttpBridgeModuleResolver.ts'
-import { BridgeQuerySender } from './ModuleProxy/index.ts'
-
-export interface HttpBridgeParams extends BridgeParams<AnyConfigSchema<HttpBridgeConfig>> {
-  axios?: Axios
-}
-
-@creatableModule()
-export class HttpBridge<TParams extends HttpBridgeParams> extends AbstractBridge<TParams> implements BridgeModule<TParams>, BridgeQuerySender {
-  static readonly axios = new Axios(axiosJsonConfig())
-  static override readonly configSchemas: Schema[] = [...super.configSchemas, HttpBridgeConfigSchema]
-  static override readonly defaultConfigSchema: Schema = HttpBridgeConfigSchema
-  static readonly defaultFailureRetryTime = 1000 * 60
-  static readonly defaultMaxConnections = 4
-  static readonly defaultMaxPayloadSizeWarning = 256 * 256
-  static readonly maxFailureCacheSize = 1000
-
-  private _axios?: Axios
-  private _discoverRootsMutex = new Mutex()
-  private _failureTimeCache = new LRUCache<Address, number>({ max: HttpBridge.maxFailureCacheSize })
-  private _querySemaphore?: Semaphore
-  private _resolver?: HttpBridgeModuleResolver
-
-  get axios() {
-    this._axios = this._axios ?? this.params.axios ?? HttpBridge.axios
-    return this._axios
-  }
-
-  get clientUrl() {
-    return assertEx(this.config.client?.url, () => 'No Url Set')
-  }
-
-  get failureRetryTime() {
-    return this.config.failureRetryTime ?? HttpBridge.defaultFailureRetryTime
-  }
-
-  get maxConnections() {
-    return this.config.maxConnections ?? HttpBridge.defaultMaxConnections
-  }
-
-  get maxPayloadSizeWarning() {
-    return this.config.maxPayloadSizeWarning ?? HttpBridge.defaultMaxPayloadSizeWarning
-  }
-
-  get querySemaphore() {
-    this._querySemaphore = this._querySemaphore ?? new Semaphore(this.maxConnections)
-    return this._querySemaphore
-  }
-
-  override get resolver() {
-    this._resolver
-      = this._resolver
-        ?? new HttpBridgeModuleResolver({
-          additionalSigners: this.additionalSigners,
-          archiving: { ...this.archiving, resolveArchivists: this.resolveArchivingArchivists.bind(this) },
-          bridge: this,
-          onQuerySendFinished: (args: Omit<QuerySendFinishedEventArgs, 'mod'>) => {
-            forget(this.emit('querySendFinished', { mod: this, ...args }))
-          },
-          onQuerySendStarted: (args: Omit<QuerySendStartedEventArgs, 'mod'>) => {
-            forget(this.emit('querySendStarted', { mod: this, ...args }))
-          },
-          querySender: this,
-          root: this,
-          rootUrl: this.clientUrl,
-          wrapperAccount: this.account,
-        })
-    return this._resolver
-  }
-
-  override exposeHandler(_id: string, _options?: BridgeExposeOptions | undefined): Promisable<ModuleInstance[]> {
-    throw new Error('Unsupported')
-  }
-
-  override exposedHandler(): Promisable<Address[]> {
-    throw new Error('Unsupported')
-  }
-
-  async getRoots(force?: boolean): Promise<ModuleInstance[]> {
-    return await this._discoverRootsMutex.runExclusive(async () => {
-      if (this._roots === undefined || force) {
-        const state = await this.getRootState()
-        this.logger?.debug(`HttpBridge:discoverRoots.state [${state?.length}]`)
-        const nodeManifest = state?.find(isPayloadOfSchemaType<NodeManifestPayload>(NodeManifestPayloadSchema))
-        if (nodeManifest) {
-          const mods = (await this.resolveRootNode(nodeManifest)).filter(exists)
-          this.logger?.debug(`HttpBridge:discoverRoots [${mods.length}]`)
-          this._roots = mods
-        } else {
-          this._roots = []
-        }
-      }
-      return this._roots
-    })
-  }
-
-  moduleUrl(address: Address) {
-    return new URL(address, this.clientUrl)
-  }
-
-  async sendBridgeQuery<TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(
-    targetAddress: Address,
-    query: TQuery,
-    payloads?: TIn[],
-  ): Promise<ModuleQueryResult<TOut>> {
-    const lastFailureTime = this._failureTimeCache.get(targetAddress)
-    if (lastFailureTime !== undefined) {
-      const now = Date.now()
-      const timeSincePreviousFailure = now - lastFailureTime
-      if (timeSincePreviousFailure > this.failureRetryTime) {
-        throw new Error(`target module failed recently [${targetAddress}] [${timeSincePreviousFailure}ms ago]`)
-      }
-      this._failureTimeCache.delete(targetAddress)
-    }
-    try {
-      await this.querySemaphore.acquire()
-      const payloadSize = JSON.stringify([query, payloads]).length
-      if (payloadSize > this.maxPayloadSizeWarning) {
-        this.logger?.warn(
-          `Large targetQuery being sent: ${payloadSize} bytes [${this.address}][${this.moduleAddress}] [${query.schema}] [${payloads?.length}]`,
-        )
-      }
-      const moduleUrl = this.moduleUrl(targetAddress).href
-      const result = await this.axios.post<ApiEnvelope<ModuleQueryResult<TOut>>>(moduleUrl, [query, payloads])
-      if (result.status === 404) {
-        throw `target module not found [${moduleUrl}] [${result.status}]`
-      }
-      if (result.status >= 400) {
-        this.logger?.error(`targetQuery failed [${moduleUrl}]`)
-        throw `targetQuery failed [${moduleUrl}] [${result.status}]`
-      }
-      return result.data?.data
-    } catch (ex) {
-      const error = ex as AxiosError
-      this.logger?.error(`Error: ${toSafeJsonString(error)}`)
-      throw error
-    } finally {
-      this.querySemaphore.release()
-    }
-  }
-
-  override unexposeHandler(_id: string, _options?: BridgeUnexposeOptions | undefined): Promisable<ModuleInstance[]> {
-    throw new Error('Unsupported')
-  }
-
-  private async getRootState() {
-    const queryPayload: ModuleStateQuery = { schema: ModuleStateQuerySchema }
-    const boundQuery = await this.bindQuery(queryPayload)
-    try {
-      const response = await this.axios.post<ApiEnvelope<ModuleQueryResult>>(this.clientUrl.toString(), boundQuery)
-      if (response.status === 404) {
-        return []
-      }
-      const [, payloads, errors] = response.data.data
-      if (errors.length > 0) {
-        throw new Error(`getRootState failed: ${JSON.stringify(errors, null, 2)}`)
-      }
-      return payloads
-    } catch (ex) {
-      const error = ex as Error
-      this.logger?.warn(`Unable to connect to remote node: ${error.message} [${this.clientUrl}]`)
-    }
-  }
-
-  private async resolveRootNode(nodeManifest: ModuleManifestPayload): Promise<ModuleInstance[]> {
-    const rootModule = assertEx(
-      (
-        await this.resolver.resolveHandler(
-          assertEx(nodeManifest.status?.address, () => 'Root has no address'),
-          undefined,
-          { manifest: nodeManifest },
-        )
-      ).at(0),
-      () => `Root not found [${nodeManifest.status?.address}]`,
-    )
-    assertEx(rootModule.constructor.name !== 'HttpModuleProxy', () => 'rootModule is not a Wrapper')
-    const rootNode = asAttachableNodeInstance(rootModule, 'Root modules is not a node')
-    if (rootNode) {
-      this.logger?.debug(`rootNode: ${rootNode.id}`)
-      this.downResolver.addResolver(rootNode as unknown as ModuleResolverInstance)
-      return [rootNode]
-    }
-    return []
-  }
-}

package/src/HttpBridgeConfig.ts

@@ -1,24 +0,0 @@
-import type { EmptyObject } from '@xylabs/sdk-js'
-import type { BridgeConfig } from '@xyo-network/bridge-model'
-import type { Schema } from '@xyo-network/payload-model'
-import { asSchema } from '@xyo-network/payload-model'
-
-export const HttpBridgeConfigSchema = asSchema('network.xyo.bridge.http.config', true)
-export type HttpBridgeConfigSchema = typeof HttpBridgeConfigSchema
-
-export type HttpBridgeConfig<TConfig extends EmptyObject = EmptyObject, TSchema extends string | void = void> = BridgeConfig<
-  {
-    client?: BridgeConfig['client'] & {
-      url: string
-    }
-    failureRetryTime?: number
-    failureTimeCacheMax?: number
-    host?: {
-      port: number
-    }
-    maxConnections?: number
-    maxPayloadSizeWarning?: number
-    schema: HttpBridgeConfigSchema
-  } & TConfig,
-  TSchema extends Schema ? TSchema : HttpBridgeConfigSchema
->

package/src/HttpBridgeModuleResolver.ts

@@ -1,129 +0,0 @@
-import type { Address, CreatableName } from '@xylabs/sdk-js'
-import {
-  assertEx, isAddress, isDefined,
-} from '@xylabs/sdk-js'
-import { Account } from '@xyo-network/account'
-import type { BridgeModuleResolverParams } from '@xyo-network/bridge-abstract'
-import { AbstractBridgeModuleResolver, wrapModuleWithType } from '@xyo-network/bridge-abstract'
-import type { ConfigPayload } from '@xyo-network/config-payload-plugin'
-import { ConfigSchema } from '@xyo-network/config-payload-plugin'
-import type {
-  ModuleConfig,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-} from '@xyo-network/module-model'
-import {
-  asModuleInstance,
-  isModuleInstance,
-  ModuleConfigSchema,
-  ResolveHelper,
-} from '@xyo-network/module-model'
-import type { Payload } from '@xyo-network/payload-model'
-import { Mutex } from 'async-mutex'
-import { LRUCache } from 'lru-cache'
-
-import type { BridgeQuerySender, HttpModuleProxyParams } from './ModuleProxy/index.ts'
-import { HttpModuleProxy } from './ModuleProxy/index.ts'
-
-const NotFoundModule = { notFound: true }
-
-export interface HttpBridgeModuleResolverParams extends BridgeModuleResolverParams {
-  querySender: BridgeQuerySender
-  rootUrl: string
-}
-
-export class HttpBridgeModuleResolver<
-  T extends HttpBridgeModuleResolverParams = HttpBridgeModuleResolverParams,
-> extends AbstractBridgeModuleResolver<T> {
-  protected _resolvedCache = new LRUCache<Address, ModuleInstance | typeof NotFoundModule>({ max: 1000 })
-  protected _resolvedCacheMutex = new Mutex()
-
-  get querySender() {
-    return this.params.querySender
-  }
-
-  moduleUrl(address: Address) {
-    return new URL(address, this.params.rootUrl)
-  }
-
-  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier,
-    options?: ModuleFilterOptions<T>,
-    params?: Partial<HttpModuleProxyParams>,
-  ): Promise<T[]> {
-    const parentResult = await super.resolveHandler(id, options)
-    if (parentResult.length > 0) {
-      return parentResult
-    }
-    const idParts = id.split(':')
-    const untransformedFirstPart = assertEx(idParts.shift(), () => 'Missing module identifier')
-    const firstPart = await ResolveHelper.transformModuleIdentifier(untransformedFirstPart)
-    assertEx(isAddress(firstPart), () => `Invalid module address: ${firstPart}`)
-    const remainderParts = idParts.join(':')
-    const instance: T | undefined = await this._resolvedCacheMutex.runExclusive(async () => {
-      const cachedMod = this._resolvedCache.get(firstPart as Address)
-      if (cachedMod) {
-        if (isModuleInstance(cachedMod)) {
-          const result = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, { ...options, maxDepth: (options?.maxDepth ?? 5) - 1 })
-          return result as T
-        } else {
-          // return cached 404
-          return
-        }
-      }
-      const account = await Account.random()
-      const finalParams: HttpModuleProxyParams = {
-        name: 'HttpBridgeModuleResolver' as CreatableName,
-        account,
-        archiving: this.params.archiving,
-        config: { schema: ModuleConfigSchema },
-        host: this,
-        moduleAddress: firstPart as Address,
-        onQuerySendFinished: this.params.onQuerySendFinished,
-        onQuerySendStarted: this.params.onQuerySendStarted,
-        querySender: this.params.querySender,
-        ...params,
-      }
-
-      this.logger?.debug(`creating HttpProxy [${firstPart}] ${id}`)
-
-      let proxy: HttpModuleProxy | undefined
-
-      let state: Payload[] | undefined
-
-      try {
-        proxy = await HttpModuleProxy.create(finalParams)
-        state = await proxy.state()
-      } catch (ex) {
-        const error = ex as Error
-        this.logger?.error(error.message)
-      }
-
-      if (isDefined(proxy)) {
-        if (!state) {
-        // cache the fact that it was not found
-          this._resolvedCache.set(firstPart as Address, NotFoundModule)
-          return
-        }
-
-        const configSchema = (state.find(payload => payload.schema === ConfigSchema) as ConfigPayload | undefined)?.config
-        const config = assertEx(
-          state.find(payload => payload.schema === configSchema),
-          () => 'Unable to locate config',
-        ) as ModuleConfig
-        proxy.setConfig(config)
-
-        this.logger?.log(`created HttpProxy [${firstPart}] ${proxy.id}`)
-
-        await proxy.start?.()
-        const wrapped = wrapModuleWithType(proxy, account) as unknown as T
-        assertEx(asModuleInstance<T>(wrapped, {}), () => `Failed to asModuleInstance [${id}]`)
-        this._resolvedCache.set(wrapped.address, wrapped)
-        return wrapped as ModuleInstance as T
-      }
-    })
-    const result = remainderParts.length > 0 ? await instance?.resolve(remainderParts, options) : instance
-    return result ? [result] : []
-  }
-}

package/src/ModuleProxy/ModuleProxy.ts

@@ -1,105 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import {
-  exists, forget,
-  isAddress, isString,
-} from '@xylabs/sdk-js'
-import type { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import type { ModuleProxyParams } from '@xyo-network/bridge-abstract'
-import { AbstractModuleProxy } from '@xyo-network/bridge-abstract'
-import type {
-  AttachableModuleInstance,
-  ModuleFilterOptions,
-  ModuleIdentifier,
-  ModuleInstance,
-  ModuleQueryResult,
-  ResolveHelperConfig,
-} from '@xyo-network/module-model'
-import { creatableModule, ResolveHelper } from '@xyo-network/module-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-export interface BridgeQuerySender {
-  sendBridgeQuery: <TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(
-    targetAddress: Address,
-    query: TQuery,
-    payloads?: TIn[],
-  ) => Promise<ModuleQueryResult<TOut>>
-}
-
-export type HttpModuleProxyParams = ModuleProxyParams & {
-  querySender: BridgeQuerySender
-}
-
-@creatableModule()
-export class HttpModuleProxy<
-  TWrappedModule extends ModuleInstance = ModuleInstance,
-  TParams extends Omit<HttpModuleProxyParams, 'config'> & { config: TWrappedModule['config'] } = Omit<HttpModuleProxyParams, 'config'> & {
-    config: TWrappedModule['config']
-  },
->
-  extends AbstractModuleProxy<TWrappedModule, TParams>
-  implements AttachableModuleInstance<TParams, TWrappedModule['eventData']> {
-  async proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads: Payload[] = []): Promise<ModuleQueryResult> {
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget(this.storeToArchivists([query, ...(payloads ?? [])]))
-    }
-    const result = await this.params.querySender.sendBridgeQuery(this.params.moduleAddress, query, payloads)
-    if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-      forget(this.storeToArchivists(result.flat()))
-    }
-    return result
-  }
-
-  override async publicChildren(): Promise<ModuleInstance[]> {
-    return (
-      await Promise.all(
-        Object.values(await this.childAddressMap())
-          .filter(exists)
-          .map(address => this.resolve(address)),
-      )
-    ).filter(exists)
-  }
-
-  /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
-  override async resolve(): Promise<ModuleInstance[]>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
-  override async resolve<T extends ModuleInstance = ModuleInstance>(
-    id: ModuleIdentifier = '*',
-    options: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    const config: ResolveHelperConfig = {
-      address: this.address,
-      dead: this.dead,
-      downResolver: this.downResolver,
-      logger: this.logger,
-      mod: this,
-      transformers: this.moduleIdentifierTransformers,
-      upResolver: this.upResolver,
-    }
-    if (id === '*') {
-      return [...(await this.publicChildren()), await this.params.host.resolve(this.address)] as T[]
-    }
-    switch (typeof id) {
-      case 'string': {
-        const parts = id.split(':')
-        const first = parts.shift()
-        if (isString(first)) {
-          const remainingPath = parts.length > 0 ? parts.join(':') : undefined
-          const address
-            = isAddress(first)
-              ? first
-              : this.id === first
-                ? this.address
-                : this.childAddressByName(first)
-          if (!isAddress(address)) return undefined
-          const firstInstance = (await this.params.host.resolve(address)) as ModuleInstance | undefined
-          return (isString(remainingPath) ? await firstInstance?.resolve(remainingPath) : firstInstance) as T | undefined
-        }
-        return undefined
-      }
-      default: {
-        return (await ResolveHelper.resolve(config, id, options)).filter(mod => mod.address !== this.address)
-      }
-    }
-  }
-}

package/src/ModuleProxy/index.ts

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

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './HttpBridge.ts'
-export * from './HttpBridgeConfig.ts'

package/src/spec/HttpBridge.baddns.spec.ts

@@ -1,43 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { MemoryNode } from '@xyo-network/node-memory'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { HttpBridge } from '../HttpBridge.ts'
-import { HttpBridgeConfigSchema } from '../HttpBridgeConfig.ts'
-
-/**
- * @group module
- * @group bridge
- */
-
-describe('HttpBridge', () => {
-  const baseUrl = 'https://sfjhskjdsfhdsk.com'
-
-  console.log(`HttpBridge:baseUrl ${baseUrl}`)
-  const cases = [
-    ['/', `${baseUrl}`],
-    /* ['/node', `${baseUrl}/node`], */
-  ]
-
-  it.each(cases)('HttpBridge: %s', async (_, nodeUrl) => {
-    const memNode = await MemoryNode.create({ account: 'random' })
-
-    const bridge = await HttpBridge.create({
-      account: 'random',
-      config: {
-        client: { url: nodeUrl }, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true },
-      },
-    })
-
-    await bridge?.start?.()
-
-    await memNode.register(bridge)
-    await memNode.attach(bridge.address, true)
-
-    const modules = await memNode.resolve('*')
-    expect(modules.length).toBe(2)
-  })
-})

package/src/spec/HttpBridge.legacy.spec.ts

@@ -1,56 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { MemoryNode } from '@xyo-network/node-memory'
-import type { NodeInstance } from '@xyo-network/node-model'
-import { NodeConfigSchema } from '@xyo-network/node-model'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { HttpBridge } from '../HttpBridge.ts'
-import { HttpBridgeConfigSchema } from '../HttpBridgeConfig.ts'
-
-/**
- * @group module
- * @group bridge
- */
-
-describe('HttpBridge', () => {
-  const baseUrl = `${process.env.API_DOMAIN ?? 'http://localhost:8080'}`
-
-  console.log(`HttpBridge:baseUrl ${baseUrl}`)
-  it('Discover', async () => {
-    const nodeUrl = `${baseUrl}/`
-    const memNode = await MemoryNode.create({ account: 'random', config: { name: 'MemoryNode', schema: NodeConfigSchema } })
-
-    const bridge = await HttpBridge.create({
-      account: 'random',
-      config: {
-        name: 'HttpBridge', client: { url: nodeUrl, discoverRoots: 'start' }, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true },
-      },
-    })
-
-    await memNode.register(bridge)
-    await memNode.attach(bridge.address, true)
-
-    const publicNode = await bridge.resolve<NodeInstance>('XYOPublic')
-    expect(publicNode).toBeDefined()
-
-    if (publicNode) {
-      console.log(`publicNode[${publicNode.address}]: ${publicNode.modName}`)
-      const publicNodeModules = await publicNode.resolve('*', { direction: 'down' })
-      expect(publicNodeModules).toBeArray()
-      expect(publicNodeModules.length).toBeGreaterThan(0)
-    }
-
-    const bridgeModules = await bridge.resolve('*', { direction: 'down' })
-    expect(bridgeModules).toBeArray()
-    expect(bridgeModules.length).toBeGreaterThan(0)
-
-    /*
-    const modules = await memNode.resolve('*')
-    expect(modules).toBeArray()
-    expect(modules.length).toBeGreaterThan(20)
-    */
-  })
-})

package/src/spec/HttpBridge.spec.ts

@@ -1,208 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-
-import '@xylabs/vitest-extended'
-
-import { assertEx } from '@xylabs/sdk-js'
-import type { ApiConfig } from '@xyo-network/api-models'
-import type { AttachableArchivistInstance } from '@xyo-network/archivist-model'
-import {
-  asArchivistInstance,
-  asAttachableArchivistInstance,
-  isAttachableArchivistInstance,
-} from '@xyo-network/archivist-model'
-import type { ModuleDescriptionPayload } from '@xyo-network/module-model'
-import {
-  isModuleInstance, isQueryableModule, isQueryableModuleObject,
-  ModuleDescriptionSchema,
-} from '@xyo-network/module-model'
-import { MemoryNode } from '@xyo-network/node-memory'
-import { asAttachableNodeInstance, isNodeInstance } from '@xyo-network/node-model'
-import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
-import { asSchema, isPayloadOfSchemaType } from '@xyo-network/payload-model'
-import { PayloadWrapper } from '@xyo-network/payload-wrapper'
-import { HDWallet } from '@xyo-network/wallet'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { HttpBridge } from '../HttpBridge.ts'
-import { HttpBridgeConfigSchema } from '../HttpBridgeConfig.ts'
-
-const archivistName = 'XYOPublic:Archivist' // TODO: This should be configurable
-const discoverRoots = 'start'
-const schema = HttpBridgeConfigSchema
-const security = { allowAnonymous: true }
-
-export const getApiConfig = (): ApiConfig => {
-  return { apiDomain: process.env.ARCHIVIST_API_DOMAIN || 'https://beta.api.archivist.xyo.network' }
-}
-
-export const getArchivist = async (config: ApiConfig = getApiConfig()): Promise<AttachableArchivistInstance> => {
-  return assertEx(await tryGetArchivist(config), () => 'Archivist not found')
-}
-
-export const tryGetArchivist = async (config: ApiConfig = getApiConfig()): Promise<AttachableArchivistInstance | undefined> => {
-  const url = config.root ? `${config.apiDomain}/${config.root}` : config.apiDomain
-  const account = await HDWallet.random()
-  const bridge = await HttpBridge.create({
-    account,
-    config: {
-      client: { discoverRoots, url }, schema, security,
-    },
-  })
-  await bridge.start()
-  const mod = await bridge.resolve(archivistName)
-  return isAttachableArchivistInstance(mod) ? mod : undefined
-}
-
-/**
- * @group module
- * @group bridge
- */
-
-describe('HttpBridge', () => {
-  const baseUrl = `${process.env.API_DOMAIN ?? 'http://localhost:8080'}`
-
-  console.log(`HttpBridge:baseUrl ${baseUrl}`)
-  const cases = [
-    ['/', `${baseUrl}`],
-    /* ['/node', `${baseUrl}/node`], */
-  ]
-
-  it.each(cases)('HttpBridge: %s', async (_, nodeUrl) => {
-    const memNode = await MemoryNode.create({ account: 'random' })
-    const extraMemNode = await MemoryNode.create({ account: 'random' })
-
-    const bridge = await HttpBridge.create({
-      account: 'random',
-      config: {
-        name: 'TestBridge', client: { url: nodeUrl, discoverRoots: 'start' }, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true },
-      },
-    })
-
-    await bridge?.start?.()
-    await memNode.register(bridge)
-    await memNode.attach(bridge?.address, true)
-
-    const resolvedBridge = await memNode.resolve(bridge.id)
-    expect(resolvedBridge).toBeDefined()
-
-    const rootModule = await bridge?.resolve('XYOPublic')
-    expect(rootModule).toBeDefined()
-
-    const remoteNode = asAttachableNodeInstance(
-      rootModule,
-      () => `Failed to resolve correct object type [XYOPublic] [${rootModule?.constructor.name}]`,
-      { required: true },
-    )
-
-    const state = await remoteNode.state()
-    const description = state.find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
-    expect(description?.children).toBeArray()
-    expect(description?.children?.length).toBeGreaterThan(0)
-    expect(description?.queries).toBeArray()
-    expect(description?.queries?.length).toBeGreaterThan(0)
-
-    const archivistByName1 = await rootModule?.resolve('Archivist')
-    expect(archivistByName1).toBeDefined()
-    const archivistByName2 = await bridge.resolve('XYOPublic:Archivist')
-    expect(archivistByName2).toBeDefined()
-    const publicXyo = await bridge.resolve('XYOPublic')
-    expect(publicXyo).toBeDefined()
-    const publicXyoSelfResolve = publicXyo?.resolve('XYOPublic')
-    expect(publicXyoSelfResolve).toBeDefined()
-    if (publicXyo) {
-      const bridgedArchivist = await getArchivist()
-      expect(bridgedArchivist).toBeDefined()
-      if (bridgedArchivist) {
-        const attachablePublicXyo = asAttachableArchivistInstance(archivistByName2, 'Failed to cast publicXyo')
-        expect(attachablePublicXyo).toBeDefined()
-        await extraMemNode.register(bridgedArchivist)
-        await extraMemNode.attach(bridgedArchivist.address, true)
-        const publicXyoNodeResolveAddress = await extraMemNode?.resolve(bridgedArchivist.address)
-        expect(publicXyoNodeResolveAddress).toBeDefined()
-        const publicXyoNodeResolve = await extraMemNode?.resolve('Archivist')
-        expect(publicXyoNodeResolve).toBeDefined()
-      }
-    }
-    const archivistByName3 = await publicXyo?.resolve('Archivist')
-    expect(archivistByName3).toBeDefined()
-    expect(archivistByName3).toEqual(archivistByName1)
-    expect(archivistByName3).toEqual(archivistByName2)
-    expect(archivistByName2).toBeDefined()
-    const archivistInstance = asArchivistInstance(archivistByName2, 'Failed to cast archivist', { required: true })
-    expect(archivistInstance).toBeDefined()
-    const knownPayload = PayloadWrapper.parse({ schema: asSchema('network.xyo.test', true) })?.payload as Payload
-    expect(knownPayload).toBeDefined()
-    const knownHash = await PayloadBuilder.dataHash(knownPayload as Payload)
-    const insertResult = await archivistInstance.insert([knownPayload])
-    expect(insertResult).toBeDefined()
-    const roundTripPayload = (await archivistInstance.get([knownHash]))[0]
-    expect(roundTripPayload).toBeDefined()
-  })
-  it.each(cases)('HttpBridge - Nested: %s', async (_, nodeUrl) => {
-    const memNode1 = await MemoryNode.create({ account: 'random', config: { schema: asSchema('network.xyo.node.config', true) } })
-    const memNode2 = await MemoryNode.create({ account: 'random', config: { schema: asSchema('network.xyo.node.config', true) } })
-    const memNode3 = await MemoryNode.create({ account: 'random', config: { schema: asSchema('network.xyo.node.config', true) } })
-
-    await memNode1.register(memNode2)
-    await memNode1.attach(memNode2.address, true)
-    await memNode2.register(memNode3)
-    await memNode2.attach(memNode3.address, true)
-
-    const bridge = await HttpBridge.create({
-      account: 'random',
-      config: {
-        client: { url: nodeUrl }, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true },
-      },
-    })
-
-    await bridge.getRoots()
-    const mod = await bridge.resolve('XYOPublic')
-
-    expect(mod).toBeDefined()
-    expect(isQueryableModule(mod)).toBeTrue()
-    expect(isQueryableModuleObject(mod)).toBeTrue()
-
-    const remoteNode = asAttachableNodeInstance(
-      mod,
-      `Failed to resolve [XYOPublic] - ${mod?.address} [${mod?.id}] [${mod?.constructor.name}]`,
-      { required: true },
-    )
-
-    expect(isNodeInstance(remoteNode)).toBeTrue()
-    expect(isModuleInstance(remoteNode)).toBeTrue()
-
-    await memNode3.register(remoteNode)
-    await memNode3.attach(remoteNode?.address, true)
-    const description = (await remoteNode.state()).find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
-    expect(description?.children).toBeArray()
-    expect(description?.children?.length).toBeGreaterThan(0)
-    expect(description?.queries).toBeArray()
-    expect(description?.queries?.length).toBeGreaterThan(0)
-
-    // Works if you supply the known address for 'Archivist'
-    // const [archivistByAddress] = await memNode.resolve({ address: ['461fd6970770e97d9f66c71658f4b96212581f0b'] })
-    // expect(archivistByAddress).toBeDefined()
-
-    /* const mods = await bridge.resolve('*')
-    for (const mod of mods) {
-      console.log(`module [${mod.address}]: ${mod.modName}`)
-    } */
-
-    const node = await bridge.resolve('XYOPublic')
-    expect(node).toBeDefined()
-
-    const archivistByName1 = await node?.resolve('Archivist')
-    expect(archivistByName1).toBeDefined()
-
-    const archivistByName2 = (await node?.resolve('Archivist'))
-    expect(archivistByName2).toBeDefined()
-    const payloadStatsDivinerByName = (await node?.resolve('PayloadStatsDiviner'))
-    expect(payloadStatsDivinerByName).toBeDefined()
-    const boundwitnessStatsDivinerByName = (await node?.resolve('BoundWitnessStatsDiviner'))
-    expect(boundwitnessStatsDivinerByName).toBeDefined()
-  })
-})

package/src/spec/HttpBridge.tests.spec.ts

@@ -1,85 +0,0 @@
-/* eslint-disable max-nested-callbacks */
-import '@xylabs/vitest-extended'
-
-import type { AbstractBridge } from '@xyo-network/bridge-abstract'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-// TODO: Implement standard test suite for all Bridges here and then run
-// against specific bridges
-export const generateBridgeTests = (title: string, _bridge: AbstractBridge) => {
-  describe(title, () => {
-    describe('HttpBridge', () => {
-      describe('By name', () => {
-        it('should handle the case by name', () => {
-          // Add your test logic here
-        })
-      })
-
-      describe('By address', () => {
-        it('should handle the case by address', () => {
-          // Add your test logic here
-        })
-      })
-
-      describe('By exposed/unexposed', () => {
-        describe('Pre Exposed', () => {
-          it('should handle the case when pre exposed', () => {
-            // Add your test logic here
-          })
-        })
-
-        describe('Post Exposed', () => {
-          it('should handle the case when post exposed', () => {
-            // Add your test logic here
-          })
-        })
-
-        describe('Post Unexposed', () => {
-          it('should handle the case when post unexposed', () => {
-            // Add your test logic here
-          })
-        })
-      })
-
-      describe('By parent/sibling/child/grandchild', () => {
-        describe('ParentNode', () => {
-          it('should handle the case for ParentNode', () => {
-            // Add your test logic here
-          })
-
-          describe('Bridge', () => {
-            it('should handle the case for Bridge', () => {
-              // Add your test logic here
-            })
-          })
-
-          describe('SiblingNode', () => {
-            it('should handle the case for SiblingNode', () => {
-              // Add your test logic here
-            })
-
-            describe('ChildNode', () => {
-              it('should handle the case for ChildNode', () => {
-                // Add your test logic here
-              })
-            })
-          })
-        })
-
-        describe('GrandchildNode', () => {
-          it('should handle the case for GrandchildNode', () => {
-            // Add your test logic here
-          })
-        })
-      })
-    })
-  })
-}
-
-describe('HttpBridge', () => {
-  it('No tests', () => {
-    expect(true).toBeTruthy()
-  })
-})

package/src/spec/HttpBridge.xns.spec.ts

@@ -1,58 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { asDivinerInstance } from '@xyo-network/diviner-model'
-import { ResolveHelper } from '@xyo-network/module-model'
-import { NameRegistrarTransformer } from '@xyo-network/module-resolver'
-import { MemoryNode } from '@xyo-network/node-memory'
-import { asAttachableNodeInstance } from '@xyo-network/node-model'
-import {
-  describe, expect, it,
-} from 'vitest'
-
-import { HttpBridge } from '../HttpBridge.ts'
-import { HttpBridgeConfigSchema } from '../HttpBridgeConfig.ts'
-
-/**
- * @group module
- * @group bridge
- */
-
-describe('HttpBridge - Xns', () => {
-  it('HttpBridge-Xns: Simple Resolve', async () => {
-    const memNode = await MemoryNode.create({ account: 'random' })
-
-    const bridge = await HttpBridge.create({
-      account: 'random',
-      config: {
-        name: 'TestBridge',
-        client: { url: 'https://beta.xns.xyo.network', discoverRoots: 'start' },
-        schema: HttpBridgeConfigSchema,
-        security: { allowAnonymous: true },
-      },
-    })
-
-    await bridge?.start?.()
-    await memNode.register(bridge)
-    await memNode.attach(bridge?.address, true)
-    const resolvedBridge = await memNode.resolve(bridge.id)
-    expect(resolvedBridge).toBeDefined()
-
-    const rootModule = await bridge?.resolve('XNS')
-    expect(rootModule).toBeDefined()
-
-    const remoteNode = asAttachableNodeInstance(
-      rootModule,
-      () => `Failed to resolve correct object type [XYO] [${rootModule?.constructor.name}]`,
-      { required: true },
-    )
-
-    const registrarDiviner = asDivinerInstance(await remoteNode.resolve('XNS:AddressRecords:AddressRecordIndexDiviner'))
-    expect(registrarDiviner).toBeDefined()
-    if (registrarDiviner) {
-      const transformer = new NameRegistrarTransformer(registrarDiviner, 'xyo')
-      ResolveHelper.transformers = [transformer]
-      const address = await transformer.transform('nippyflight.xyo')
-      expect(address).toBe('c5fa710300a8a43568678d0fe72810e34d880357')
-    }
-  })
-})