@xyo-network/modules 5.1.22 → 5.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/modules",
-  "version": "5.1.22",
+  "version": "5.1.23",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,41 +30,44 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src"
+    "src",
+    "!**/*.bench.*",
+    "!**/*.spec.*",
+    "!**/*.test.*"
   ],
   "dependencies": {
-    "@xyo-network/archivist": "~5.1.22",
-    "@xyo-network/bridge": "~5.1.22",
-    "@xyo-network/diviner": "~5.1.22",
-    "@xyo-network/module": "~5.1.22",
-    "@xyo-network/node": "~5.1.22",
-    "@xyo-network/sentinel": "~5.1.22",
-    "@xyo-network/witness": "~5.1.22"
+    "@xyo-network/archivist": "~5.1.23",
+    "@xyo-network/bridge": "~5.1.23",
+    "@xyo-network/diviner": "~5.1.23",
+    "@xyo-network/module": "~5.1.23",
+    "@xyo-network/node": "~5.1.23",
+    "@xyo-network/sentinel": "~5.1.23",
+    "@xyo-network/witness": "~5.1.23"
   },
   "devDependencies": {
-    "@xylabs/delay": "~5.0.24",
-    "@xylabs/hex": "~5.0.24",
+    "@xylabs/delay": "~5.0.33",
+    "@xylabs/hex": "~5.0.33",
     "@xylabs/ts-scripts-yarn3": "~7.2.8",
     "@xylabs/tsconfig": "~7.2.8",
-    "@xylabs/vitest-extended": "~5.0.24",
-    "@xyo-network/archivist-memory": "~5.1.22",
-    "@xyo-network/archivist-model": "~5.1.22",
-    "@xyo-network/diviner-address-history": "~5.1.22",
-    "@xyo-network/diviner-jsonpatch-memory": "~5.1.22",
-    "@xyo-network/diviner-jsonpath-aggregate-memory": "~5.1.22",
-    "@xyo-network/diviner-jsonpath-memory": "~5.1.22",
-    "@xyo-network/diviner-model": "~5.1.22",
-    "@xyo-network/manifest": "~5.1.22",
-    "@xyo-network/module-factory-locator": "~5.1.22",
-    "@xyo-network/module-resolver": "~5.1.22",
-    "@xyo-network/node-memory": "~5.1.22",
-    "@xyo-network/node-model": "~5.1.22",
-    "@xyo-network/payload-model": "~5.1.22",
-    "@xyo-network/wallet": "~5.1.22",
-    "@xyo-network/witness-adhoc": "~5.1.22",
-    "@xyo-network/witness-model": "~5.1.22",
+    "@xylabs/vitest-extended": "~5.0.33",
+    "@xyo-network/archivist-memory": "~5.1.23",
+    "@xyo-network/archivist-model": "~5.1.23",
+    "@xyo-network/diviner-address-history": "~5.1.23",
+    "@xyo-network/diviner-jsonpatch-memory": "~5.1.23",
+    "@xyo-network/diviner-jsonpath-aggregate-memory": "~5.1.23",
+    "@xyo-network/diviner-jsonpath-memory": "~5.1.23",
+    "@xyo-network/diviner-model": "~5.1.23",
+    "@xyo-network/manifest": "~5.1.23",
+    "@xyo-network/module-factory-locator": "~5.1.23",
+    "@xyo-network/module-resolver": "~5.1.23",
+    "@xyo-network/node-memory": "~5.1.23",
+    "@xyo-network/node-model": "~5.1.23",
+    "@xyo-network/payload-model": "~5.1.23",
+    "@xyo-network/wallet": "~5.1.23",
+    "@xyo-network/witness-adhoc": "~5.1.23",
+    "@xyo-network/witness-model": "~5.1.23",
     "typescript": "~5.9.3",
-    "vitest": "~4.0.8"
+    "vitest": "~4.0.9"
   },
   "publishConfig": {
     "access": "public"

package/dist/neutral/spec/MultiSegmentResolve.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=MultiSegmentResolve.spec.d.ts.map

package/dist/neutral/spec/MultiSegmentResolve.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MultiSegmentResolve.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/MultiSegmentResolve.spec.ts"],"names":[],"mappings":""}

package/dist/neutral/spec/ParentsPrivates.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=ParentsPrivates.spec.d.ts.map

package/dist/neutral/spec/ParentsPrivates.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParentsPrivates.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/ParentsPrivates.spec.ts"],"names":[],"mappings":"AAUA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/spec/Sentinel.Interval.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=Sentinel.Interval.spec.d.ts.map

package/dist/neutral/spec/Sentinel.Interval.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sentinel.Interval.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/Sentinel.Interval.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/spec/UpDown.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=UpDown.spec.d.ts.map

package/dist/neutral/spec/UpDown.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"UpDown.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/UpDown.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/spec/VariousNodeConfigurations.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=VariousNodeConfigurations.spec.d.ts.map

package/dist/neutral/spec/VariousNodeConfigurations.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VariousNodeConfigurations.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/VariousNodeConfigurations.spec.ts"],"names":[],"mappings":"AACA,OAAO,yBAAyB,CAAA"}

package/dist/neutral/spec/XyoModuleResolver.spec.d.ts

@@ -1,2 +0,0 @@
-import '@xylabs/vitest-extended';
-//# sourceMappingURL=XyoModuleResolver.spec.d.ts.map

package/dist/neutral/spec/XyoModuleResolver.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoModuleResolver.spec.d.ts","sourceRoot":"","sources":["../../../src/spec/XyoModuleResolver.spec.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAA"}

package/src/spec/MultiSegmentResolve.spec.ts

@@ -1,65 +0,0 @@
-import type { Address } from '@xylabs/hex'
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import { ArchivistConfigSchema } from '@xyo-network/archivist-model'
-import { MemoryNode } from '@xyo-network/node-memory'
-import { NodeConfigSchema } from '@xyo-network/node-model'
-import {
-  describe, expect, test,
-} from 'vitest'
-
-const rootNodeName = 'root'
-const nodeAName = 'nodeA'
-const nodeBName = 'nodeB'
-const moduleAName = 'module'
-const moduleBName = 'module'
-const moduleCName = 'moduleC'
-
-/**
- * @group module
- */
-
-describe('SimpleModuleResolverDeep', () => {
-  test('two archivists same name, different nodes', async () => {
-    const rootNode = await MemoryNode.create({ account: 'random', config: { name: rootNodeName, schema: NodeConfigSchema } })
-    const nodeA = await MemoryNode.create({ account: 'random', config: { name: nodeAName, schema: NodeConfigSchema } })
-    const nodeB = await MemoryNode.create({ account: 'random', config: { name: nodeBName, schema: NodeConfigSchema } })
-    const moduleA = await MemoryArchivist.create({ account: 'random', config: { name: moduleAName, schema: ArchivistConfigSchema } })
-    const moduleB = await MemoryArchivist.create({ account: 'random', config: { name: moduleBName, schema: ArchivistConfigSchema } })
-    const moduleC = await MemoryArchivist.create({ account: 'random', config: { name: moduleCName, schema: ArchivistConfigSchema } })
-
-    await nodeA.register(moduleA)
-    await nodeA.attach(moduleA.address, true)
-
-    const resolvedModuleAFromNodeA = await nodeA.resolve(moduleAName)
-    expect(resolvedModuleAFromNodeA?.address).toBe(moduleA.address)
-
-    await nodeB.register(moduleB)
-    await nodeB.register(moduleC)
-    await nodeB.attach(moduleB.address, true)
-    await nodeB.attach(moduleC.address)
-
-    const resolvedModuleBFromNodeB = await nodeB.resolve(moduleBName)
-    expect(resolvedModuleBFromNodeB?.address).toBe(moduleB.address)
-
-    await rootNode.register(nodeA)
-    await rootNode.attach(nodeA.address, true)
-    await rootNode.register(nodeB)
-    await rootNode.attach(nodeB.address, true)
-
-    const rootNodeResolve = await rootNode.resolve(`${rootNodeName}`)
-    expect(rootNodeResolve?.address).toBe(rootNode.address)
-
-    const resolvedModuleA = await rootNode.resolve(moduleAName)
-    expect([moduleA.address, moduleB.address].includes(resolvedModuleA?.address ?? '' as Address)).toBe(true)
-    const resolvedModuleB = await rootNode.resolve(moduleBName)
-    expect([moduleA.address, moduleB.address].includes(resolvedModuleB?.address ?? '' as Address)).toBe(true)
-
-    const resolvedModuleAMulti = await rootNode.resolve(`${nodeAName}:${moduleAName}`)
-    expect(resolvedModuleAMulti?.address).toBe(moduleA.address)
-    const resolvedModuleBMulti = await rootNode.resolve(`${nodeBName}:${moduleBName}`)
-    expect(resolvedModuleBMulti?.address).toBe(moduleB.address)
-
-    const resolvedModuleAMultiTooFar = await rootNode.resolve(`${rootNodeName}:${moduleAName}`)
-    expect(!!resolvedModuleAMultiTooFar).toBe(false)
-  })
-})

package/src/spec/ParentsPrivates.spec.ts

@@ -1,50 +0,0 @@
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import { ArchivistConfigSchema } from '@xyo-network/archivist-model'
-import { MemoryNode } from '@xyo-network/node-memory'
-import { NodeConfigSchema } from '@xyo-network/node-model'
-
-const nodeAName = 'nodeA'
-const rootPrivateNodeName = 'rootPrivateNode'
-const rootPrivateName = 'rootPrivate'
-const moduleAName = 'module'
-
-import '@xylabs/vitest-extended'
-
-import {
-  describe, expect, test,
-} from 'vitest'
-
-/**
- * @group module
- */
-
-describe('ParentsPrivates', () => {
-  test("children should be able to see parent's privates", async () => {
-    const rootNode = await MemoryNode.create({ account: 'random' })
-    const rootPrivateNode = await MemoryNode.create({ account: 'random', config: { name: rootPrivateNodeName, schema: NodeConfigSchema } })
-    const rootPrivate = await MemoryArchivist.create({ account: 'random', config: { name: rootPrivateName, schema: ArchivistConfigSchema } })
-    const nodeA = await MemoryNode.create({ account: 'random', config: { name: nodeAName, schema: NodeConfigSchema } })
-    const moduleA = await MemoryArchivist.create({ account: 'random', config: { name: moduleAName, schema: ArchivistConfigSchema } })
-
-    await rootPrivateNode.register(rootPrivate)
-    await rootPrivateNode.attach(rootPrivate.address, false)
-
-    await nodeA.register(moduleA)
-    await nodeA.attach(moduleA.address, true)
-
-    const resolvedModuleAFromNodeA = await nodeA.resolve(moduleAName)
-    expect(resolvedModuleAFromNodeA?.address).toBe(moduleA.address)
-
-    await rootNode.register(rootPrivateNode)
-    await rootNode.attach(rootPrivateNode.address, false)
-
-    await rootNode.register(nodeA)
-    await rootNode.attach(nodeA.address, true)
-
-    const resolveRootPrivateNode = await nodeA.resolve(rootPrivateNodeName)
-    expect(resolveRootPrivateNode).toBeDefined()
-
-    const resolveRootPrivate = await nodeA.resolve(rootPrivateName)
-    expect(resolveRootPrivate).toBeUndefined()
-  })
-})

package/src/spec/Sentinel.Interval.spec.json

@@ -1,138 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/XYOracleNetwork/sdk-xyo-client-js/main/packages/manifest/src/schema.json",
-  "nodes": [
-    {
-      "config": {
-        "name": "DivinerTest",
-        "schema": "network.xyo.node.config",
-        "language": "javascript"
-      },
-      "modules": {
-        "public": [
-          {
-            "config": {
-              "name": "AddressStateArchivist",
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "archivist": "AddressStateArchivist",
-              "name": "AddressStateBoundWitnessDiviner",
-              "schema": "network.xyo.diviner.boundwitness.config"
-            }
-          },
-          {
-            "config": {
-              "archivist": "AddressStateArchivist",
-              "name": "AddressStatePayloadDiviner",
-              "schema": "network.xyo.diviner.payload.config"
-            }
-          },
-          {
-            "config": {
-              "name": "Archivist",
-              "schema": "network.xyo.archivist.config"
-            }
-          },
-          {
-            "config": {
-              "archivist": "Archivist",
-              "name": "BoundWitnessDiviner",
-              "schema": "network.xyo.diviner.boundwitness.config"
-            }
-          },
-          {
-            "config": {
-              "archivist": "Archivist",
-              "name": "PayloadDiviner",
-              "schema": "network.xyo.diviner.payload.config"
-            }
-          },
-          {
-            "config": {
-              "name": "JsonPatch",
-              "schema": "network.xyo.diviner.jsonpatch.config"
-            }
-          },
-          {
-            "config": {
-              "name": "PayloadDivinerQueryTemplateWitness",
-              "schema": "network.xyo.witness.adhoc.config",
-              "payload": {
-                "limit": 1,
-                "order": "asc",
-                "schema": "network.xyo.diviner.payload.query",
-                "schemas": ["network.xyo.test"]
-              }
-            }
-          },
-          {
-            "config": {
-              "destinationSchema": "network.xyo.diviner.payload.query",
-              "excludeSources": true,
-              "name": "PayloadDivinerQueryBuilder",
-              "schema": "network.xyo.diviner.jsonpath.aggregate.config",
-              "schemaTransforms": {
-                "network.xyo.diviner.payload.query": [
-                  {
-                    "destinationField": "limit",
-                    "sourcePathExpression": "$.limit"
-                  },
-                  {
-                    "destinationField": "order",
-                    "sourcePathExpression": "$.order"
-                  },
-                  {
-                    "destinationField": "schemas",
-                    "sourcePathExpression": "$.schemas"
-                  }
-                ]
-              }
-            }
-          },
-          {
-            "config": {
-              "archiving": {
-                "archivists": ["Results"]
-              },
-              "automations": [
-                {
-                  "frequency": 1,
-                  "frequencyUnits": "second",
-                  "schema": "network.xyo.automation.interval",
-                  "start": 0,
-                  "type": "interval"
-                }
-              ],
-              "name": "Sentinel",
-              "schema": "network.xyo.sentinel.config",
-              "synchronous": "true",
-              "tasks": [
-                {
-                  "input": true,
-                  "mod": "PayloadDivinerQueryTemplateWitness"
-                },
-                {
-                  "input": ["PayloadDivinerQueryTemplateWitness"],
-                  "mod": "PayloadDivinerQueryBuilder"
-                },
-                {
-                  "input": ["PayloadDivinerQueryBuilder"],
-                  "mod": "PayloadDiviner"
-                }
-              ]
-            }
-          },
-          {
-            "config": {
-              "name": "Results",
-              "schema": "network.xyo.archivist.config"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "schema": "network.xyo.manifest"
-}

package/src/spec/Sentinel.Interval.spec.ts

@@ -1,117 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { delay } from '@xylabs/delay'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
-import { JsonPatchDiviner } from '@xyo-network/diviner-jsonpatch-memory'
-import { JsonPathAggregateDiviner } from '@xyo-network/diviner-jsonpath-aggregate-memory'
-import { JsonPathDiviner } from '@xyo-network/diviner-jsonpath-memory'
-import { asDivinerInstance } from '@xyo-network/diviner-model'
-import type { PackageManifestPayload } from '@xyo-network/manifest'
-import { ManifestWrapper } from '@xyo-network/manifest'
-import { ModuleFactoryLocator } from '@xyo-network/module-factory-locator'
-import type { MemoryNode } from '@xyo-network/node-memory'
-import type { Payload } from '@xyo-network/payload-model'
-import { HDWallet } from '@xyo-network/wallet'
-import {
-  beforeAll,
-  describe, expect, it,
-} from 'vitest'
-
-import SentinelManifest from './Sentinel.Interval.spec.json' with { type: 'json' }
-
-/**
- * @group sentinel
- * @group module
- * @group slow
- */
-
-const NETWORK_XYO_TEST = 'network.xyo.test' as const
-
-describe('Sentinel.Interval', () => {
-  let node: MemoryNode
-
-  beforeAll(async () => {
-    const wallet = await HDWallet.random()
-    const locator = new ModuleFactoryLocator()
-    locator.register(JsonPatchDiviner.factory())
-    locator.register(JsonPathDiviner.factory())
-    locator.register(JsonPathAggregateDiviner.factory())
-    const manifest = SentinelManifest as PackageManifestPayload
-    const manifestWrapper = new ManifestWrapper(manifest, wallet, locator)
-    node = await manifestWrapper.loadNodeFromIndex(0)
-    await node.start()
-
-    const publicModules = manifest.nodes[0].modules?.public ?? []
-    const mods = await node.resolve('*')
-    expect(mods.length).toBe(publicModules.length + 1)
-
-    // Add some test data
-    const testPayloads = [
-      {
-        schema: NETWORK_XYO_TEST,
-        value: 1,
-      },
-      {
-        schema: NETWORK_XYO_TEST,
-        value: 2,
-      },
-    ]
-    const archivist = asArchivistInstance(await node.resolve('Archivist'))
-    expect(archivist).toBeDefined()
-    await archivist?.insert(testPayloads)
-  })
-
-  it('sentinel query', async () => {
-    let payloads: Payload[] = []
-    const archivist = asArchivistInstance(await node.resolve('Results'))
-    expect(archivist).toBeDefined()
-    while (payloads.length === 0) {
-      await delay(500)
-      const all = await archivist?.all?.() ?? []
-      const filtered = all.filter(p => p.schema === NETWORK_XYO_TEST)
-      if (filtered.length > 0) payloads.push(...filtered)
-    }
-    expect(payloads.some(p => p.schema === NETWORK_XYO_TEST)).toBeTrue()
-  }, 3000)
-  it.skip('manual query', async () => {
-    const testPayloads = [
-      {
-        schema: NETWORK_XYO_TEST,
-        value: 1,
-      },
-      {
-        schema: NETWORK_XYO_TEST,
-        value: 2,
-      },
-    ]
-    const archivist = asArchivistInstance(await node.resolve('Archivist'))
-    expect(archivist).toBeDefined()
-    await archivist?.insert(testPayloads)
-    // const addressStateArchivist = asArchivistInstance(await node.resolve('AddressStateArchivist'))
-    // const addressStateBoundWitnessDiviner = asDivinerInstance(await node.resolve('AddressStateBoundWitnessDiviner'))
-    const addressStatePayloadDiviner = asDivinerInstance(await node.resolve('AddressStatePayloadDiviner'))
-    const lastStateQuery = {
-      limit: 1,
-      offset: 0,
-      order: 'desc',
-      schema: 'network.xyo.diviner.payload.query',
-      // schema: 'network.xyo.diviner.boundwitness.query',
-      // payload_schemas: ['network.xyo.module.state'],
-      schemas: ['network.xyo.module.state'],
-    }
-    const initialState = await addressStatePayloadDiviner?.divine([lastStateQuery])
-    const statePayloads
-      = initialState?.filter((p): p is { offset?: number; schema: string } => p.schema === 'network.xyo.module.state') ?? []
-    const offset = statePayloads?.[0]?.offset ?? 0
-    const payloadDiviner = asDivinerInstance(await node.resolve('PayloadDiviner'))
-    const payloadDivinerQuery = {
-      limit: 1,
-      offset,
-      order: 'asc',
-      schema: 'network.xyo.diviner.payload.query',
-      schemas: [NETWORK_XYO_TEST],
-    }
-    const payloadBatch = await payloadDiviner?.divine([payloadDivinerQuery])
-    expect(payloadBatch?.length).toBe(1)
-  })
-})

package/src/spec/UpDown.spec.ts

@@ -1,50 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import { ArchivistConfigSchema } from '@xyo-network/archivist-model'
-import { MemoryNode } from '@xyo-network/node-memory'
-import { NodeConfigSchema } from '@xyo-network/node-model'
-import {
-  describe, expect, test,
-} from 'vitest'
-
-const rootNodeName = 'root'
-const nodeAName = 'nodeA'
-const nodeBName = 'nodeB'
-const moduleAName = 'module'
-const moduleBName = 'module'
-const moduleCName = 'moduleC'
-
-/**
- * @group module
- */
-
-describe('UpDown', () => {
-  test('two archivists same name, different nodes', async () => {
-    const rootNode = await MemoryNode.create({ account: 'random', config: { name: rootNodeName, schema: NodeConfigSchema } })
-    const nodeA = await MemoryNode.create({ account: 'random', config: { name: nodeAName, schema: NodeConfigSchema } })
-    const nodeB = await MemoryNode.create({ account: 'random', config: { name: nodeBName, schema: NodeConfigSchema } })
-    const moduleA = await MemoryArchivist.create({ account: 'random', config: { name: moduleAName, schema: ArchivistConfigSchema } })
-    const moduleB = await MemoryArchivist.create({ account: 'random', config: { name: moduleBName, schema: ArchivistConfigSchema } })
-    const moduleC = await MemoryArchivist.create({ account: 'random', config: { name: moduleCName, schema: ArchivistConfigSchema } })
-
-    await nodeA.register(moduleA)
-    await nodeA.attach(moduleA.address, true)
-
-    await nodeB.register(moduleB)
-    await nodeB.register(moduleC)
-    await nodeB.attach(moduleB.address, true)
-    await nodeB.attach(moduleC.address)
-
-    await rootNode.register(nodeA)
-    await rootNode.attach(nodeA.address, true)
-    await rootNode.register(nodeB)
-    await rootNode.attach(nodeB.address, true)
-
-    const upAndDownResolve = await moduleA.resolve(`${nodeAName}:${moduleAName}`)
-    expect(upAndDownResolve?.address).toBe(moduleA.address)
-
-    const upAndDownResolvePrivate = await moduleA.resolvePrivate(`${nodeBName}:${moduleCName}`)
-    expect(upAndDownResolvePrivate?.address).toBe(moduleC.address)
-  })
-})

package/src/spec/VariousNodeConfigurations.spec.ts

@@ -1,197 +0,0 @@
-/* eslint-disable max-statements */
-import '@xylabs/vitest-extended'
-
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import type { AttachableArchivistInstance } from '@xyo-network/archivist-model'
-import { AddressHistoryDiviner, AddressHistoryDivinerConfigSchema } from '@xyo-network/diviner-address-history'
-import type { AttachableDivinerInstance } from '@xyo-network/diviner-model'
-import { MemoryNode } from '@xyo-network/node-memory'
-import {
-  isNodeInstance, isNodeModule, NodeConfigSchema,
-} from '@xyo-network/node-model'
-import { AdhocWitness, AdhocWitnessConfigSchema } from '@xyo-network/witness-adhoc'
-import type { AttachableWitnessInstance } from '@xyo-network/witness-model'
-import {
-  beforeAll,
-  describe, expect, test,
-} from 'vitest'
-
-/**
- * @group module
- */
-
-describe('MultiNodeConfiguration', () => {
-  let primaryArchivist: AttachableArchivistInstance
-  let primaryNode: MemoryNode
-
-  let leftInternalArchivist: AttachableArchivistInstance
-  let leftInternalArchivist2: AttachableArchivistInstance
-  let leftExternalArchivist: AttachableArchivistInstance
-  let leftDiviner: AttachableDivinerInstance
-  let leftNode: MemoryNode
-
-  let rightNode: MemoryNode
-  let rightInternalArchivist: AttachableArchivistInstance
-  let rightExternalArchivist: AttachableArchivistInstance
-  let rightWitness: AttachableWitnessInstance
-
-  beforeAll(async () => {
-    primaryNode = await MemoryNode.create({ account: 'random', config: { name: 'primaryNode', schema: NodeConfigSchema } })
-    expect(isNodeModule(primaryNode)).toBe(true)
-    expect(isNodeInstance(primaryNode)).toBe(true)
-    primaryArchivist = await MemoryArchivist.create({
-      account: 'random',
-      config: { name: 'primaryArchivist', schema: MemoryArchivist.defaultConfigSchema },
-    })
-    await primaryNode.register(primaryArchivist)
-    await primaryNode.attach(primaryArchivist.address, true)
-
-    rightNode = await MemoryNode.create({ account: 'random', config: { name: 'rightNode', schema: NodeConfigSchema } })
-    rightInternalArchivist = await MemoryArchivist.create({
-      account: 'random',
-      config: { name: 'rightInternalArchivist', schema: MemoryArchivist.defaultConfigSchema },
-    })
-    rightExternalArchivist = await MemoryArchivist.create({
-      account: 'random',
-      config: { name: 'archivist', schema: MemoryArchivist.defaultConfigSchema },
-    })
-    rightWitness = await AdhocWitness.create({
-      account: 'random',
-      config: { name: 'rightWitness', schema: AdhocWitnessConfigSchema },
-    })
-    await rightNode.register(rightInternalArchivist)
-    await rightNode.attach(rightInternalArchivist.address)
-    await rightNode.register(rightExternalArchivist)
-    await rightNode.attach(rightExternalArchivist.address, true)
-    await rightNode.register(rightWitness)
-    await rightNode.attach(rightWitness.address, true)
-
-    leftNode = await MemoryNode.create({ account: 'random', config: { name: 'leftNode', schema: NodeConfigSchema } })
-    leftInternalArchivist = await MemoryArchivist.create({
-      account: 'random',
-      config: { name: 'leftInternalArchivist', schema: MemoryArchivist.defaultConfigSchema },
-    })
-    leftInternalArchivist2 = await MemoryArchivist.create({
-      account: 'random',
-      config: { name: 'leftInternalArchivist2', schema: MemoryArchivist.defaultConfigSchema },
-    })
-    leftExternalArchivist = await MemoryArchivist.create({
-      account: 'random',
-      config: { name: 'archivist', schema: MemoryArchivist.defaultConfigSchema },
-    })
-    leftDiviner = await AddressHistoryDiviner.create({
-      account: 'random',
-      config: {
-        address: leftNode.address, name: 'leftDiviner', schema: AddressHistoryDivinerConfigSchema,
-      },
-    })
-    await leftNode.register(leftInternalArchivist)
-    await leftNode.attach(leftInternalArchivist.address)
-    await leftNode.register(leftInternalArchivist2)
-    await leftNode.attach(leftInternalArchivist2.address)
-    await leftNode.register(leftExternalArchivist)
-    await leftNode.attach(leftExternalArchivist.address, true)
-    await leftNode.register(leftDiviner)
-    await leftNode.attach(leftDiviner.address, true)
-
-    await primaryNode.register(leftNode)
-    await primaryNode.register(rightNode)
-  })
-  test('leftNode', async () => {
-    await primaryNode.attach(leftNode.address, true)
-    // await primaryNode.detach(rightNode.address)
-    expect((await primaryNode.resolve(primaryArchivist.address))).toBeDefined()
-    expect((await primaryNode.resolve('primaryArchivist'))).toBeDefined()
-
-    expect((await leftNode.resolve(leftDiviner.address))).toBeDefined()
-    expect((await leftNode.resolve('leftDiviner'))).toBeDefined()
-
-    // internal: should be resolvable by leftNode children
-    expect((await leftInternalArchivist2.resolve(leftInternalArchivist.address))).toBeDefined()
-    expect((await leftInternalArchivist2.resolve('leftInternalArchivist'))).toBeDefined()
-
-    expect((await leftInternalArchivist2.resolve(leftExternalArchivist.address))).toBeDefined()
-    expect((await leftInternalArchivist2.resolve('archivist'))).toBeDefined()
-
-    expect((await leftInternalArchivist2.resolve(rightWitness.address))).toBeUndefined()
-    expect((await leftInternalArchivist2.resolve('rightWitness'))).toBeUndefined()
-
-    // internal: should not be resolvable by anyone outside of node, including wrapper
-
-    expect((await rightNode.resolve(rightInternalArchivist.address))).toBeUndefined()
-    expect((await rightNode.resolve('rightInternalArchivist'))).toBeUndefined()
-
-    expect((await rightNode.resolve(rightInternalArchivist.address))).toBeUndefined()
-    expect((await rightNode.resolve('rightInternalArchivist'))).toBeUndefined()
-
-    expect((await rightNode.resolve(rightExternalArchivist.address))).toBeDefined()
-    expect((await rightNode.resolve('archivist'))).toBeDefined()
-
-    expect((await primaryNode.resolve(leftNode.address))).toBeDefined()
-    expect((await primaryNode.resolve('leftNode'))).toBeDefined()
-
-    expect((await primaryNode.resolve(rightNode.address))).toBeUndefined()
-    expect((await primaryNode.resolve('rightNode'))).toBeUndefined()
-
-    expect((await primaryNode.resolve(leftDiviner.address))).toBeDefined()
-    expect((await primaryNode.resolve('leftDiviner'))).toBeDefined()
-
-    expect((await primaryNode.resolve(rightWitness.address))).toBeUndefined()
-    expect((await primaryNode.resolve('rightWitness'))).toBeUndefined()
-
-    // internal: should NOT be resolvable by primaryNode
-    expect((await primaryNode.resolve(leftInternalArchivist.address))).toBeUndefined()
-    expect((await primaryNode.resolve('leftInternalArchivist'))).toBeUndefined()
-
-    // internal: should NOT be resolvable by node
-    expect((await primaryNode.resolve(rightInternalArchivist.address))).toBeUndefined()
-    expect((await primaryNode.resolve('rightInternalArchivist'))).toBeUndefined()
-
-    // external: should be resolvable by primaryNode
-    expect((await primaryNode.resolve(leftExternalArchivist.address))).toBeDefined()
-
-    // external: should be NOT be resolvable by node
-    expect((await primaryNode.resolve(rightExternalArchivist.address))).toBeUndefined()
-
-    // external: should be resolvable by node
-    expect((await primaryNode.resolve('archivist'))).toBeDefined()
-    expect((await primaryNode.resolve('archivist'))?.address).toBe(leftExternalArchivist.address)
-  })
-
-  test('rightNode', async () => {
-    await primaryNode.attach(rightNode.address, true)
-    await primaryNode.detach(leftNode.address)
-    expect((await primaryNode.resolve(primaryArchivist.address))).toBeDefined()
-    expect((await leftNode.resolve(leftDiviner.address))).toBeDefined()
-    expect((await rightNode.resolve(rightWitness.address))).toBeDefined()
-    expect((await primaryNode.resolve(rightNode.address))).toBeDefined()
-    expect((await primaryNode.resolve(leftNode.address))).toBeDefined()
-    expect((await primaryNode.resolve(rightWitness.address))).toBeDefined()
-    expect((await primaryNode.resolve(leftDiviner.address))).toBeDefined()
-    expect((await primaryNode.resolve('archivist'))).toBeDefined()
-  })
-
-  test('leftNode', async () => {
-    // await primaryNode.detach(leftNode.address)
-    await primaryNode.detach(rightNode.address)
-    await primaryNode.attach(leftNode.address, true)
-    await primaryNode.attach(rightNode.address, true)
-
-    // internal: should NOT be resolvable by primaryNode
-    expect((await primaryNode.resolve(leftInternalArchivist.address))).toBeUndefined()
-    expect((await primaryNode.resolve('leftInternalArchivist'))).toBeUndefined()
-
-    // internal: should NOT be resolvable by node
-    expect((await primaryNode.resolve(rightInternalArchivist.address))).toBeUndefined()
-    expect((await primaryNode.resolve('rightInternalArchivist'))).toBeUndefined()
-
-    // external: should be resolvable by primaryNode
-    expect((await primaryNode.resolve(leftExternalArchivist.address))).toBeDefined()
-
-    // external: should be resolvable by node
-    expect((await primaryNode.resolve(rightExternalArchivist.address))).toBeDefined()
-
-    // external: should be resolvable by node
-    expect((await primaryNode.resolve('archivist'))).toBeDefined()
-  })
-})

package/src/spec/XyoModuleResolver.spec.ts

@@ -1,38 +0,0 @@
-import '@xylabs/vitest-extended'
-
-import { MemoryArchivist } from '@xyo-network/archivist-memory'
-import type { ArchivistInstance } from '@xyo-network/archivist-model'
-import { CompositeModuleResolver } from '@xyo-network/module-resolver'
-import { AdhocWitness, AdhocWitnessConfigSchema } from '@xyo-network/witness-adhoc'
-import type { WitnessInstance } from '@xyo-network/witness-model'
-import {
-  beforeAll,
-  describe, expect, test,
-} from 'vitest'
-
-/**
- * @group module
- */
-
-describe('ModuleResolver', () => {
-  let archivist: ArchivistInstance
-  let witness: WitnessInstance
-  let resolver: CompositeModuleResolver
-  beforeAll(async () => {
-    archivist = await MemoryArchivist.create({
-      account: 'random',
-      config: { name: 'memory-archivist', schema: MemoryArchivist.defaultConfigSchema },
-    })
-    witness = await AdhocWitness.create({ account: 'random', config: { schema: AdhocWitnessConfigSchema } })
-    resolver = new CompositeModuleResolver({ root: archivist })
-    resolver.add(archivist)
-    resolver.add(witness)
-  })
-  test('simple by address', async () => {
-    expect((await resolver.resolve(archivist.address))).toBeDefined()
-    expect((await resolver.resolve(witness.address))).toBeDefined()
-  })
-  test('simple by name', async () => {
-    expect((await resolver.resolve('memory-archivist'))).toBeDefined()
-  })
-})