@xyo-network/node 4.2.1 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/node",
-  "version": "4.2.1",
+  "version": "5.0.0",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -28,29 +28,33 @@
   },
   "module": "dist/neutral/index.mjs",
   "types": "dist/neutral/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
   "dependencies": {
-    "@xyo-network/node-model": "^4.2.1",
-    "@xyo-network/node-wrapper": "^4.2.1"
+    "@xyo-network/node-model": "^5.0.0",
+    "@xyo-network/node-wrapper": "^5.0.0"
   },
   "devDependencies": {
-    "@xylabs/delay": "^4.14.1",
-    "@xylabs/ts-scripts-yarn3": "^7.0.1",
-    "@xylabs/tsconfig": "^7.0.1",
-    "@xylabs/vitest-extended": "^4.14.1",
-    "@xylabs/vitest-matchers": "^4.14.1",
-    "@xyo-network/account": "^4.2.1",
-    "@xyo-network/account-model": "^4.2.1",
-    "@xyo-network/archivist-memory": "^4.2.1",
-    "@xyo-network/archivist-model": "^4.2.1",
-    "@xyo-network/diviner-archivist": "^4.2.1",
-    "@xyo-network/diviner-huri": "^4.2.1",
-    "@xyo-network/diviner-model": "^4.2.1",
-    "@xyo-network/manifest-model": "^4.2.1",
-    "@xyo-network/module-model": "^4.2.1",
-    "@xyo-network/node-memory": "^4.2.1",
-    "@xyo-network/payload": "^4.2.1",
-    "@xyo-network/wallet": "^4.2.1",
-    "@xyo-network/witness-adhoc": "^4.2.1",
+    "@xylabs/delay": "^5.0.0",
+    "@xylabs/ts-scripts-yarn3": "^7.0.2",
+    "@xylabs/tsconfig": "^7.0.2",
+    "@xylabs/vitest-extended": "^5.0.0",
+    "@xylabs/vitest-matchers": "^5.0.0",
+    "@xyo-network/account": "^5.0.0",
+    "@xyo-network/account-model": "^5.0.0",
+    "@xyo-network/archivist-memory": "^5.0.0",
+    "@xyo-network/archivist-model": "^5.0.0",
+    "@xyo-network/diviner-archivist": "^5.0.0",
+    "@xyo-network/diviner-huri": "^5.0.0",
+    "@xyo-network/diviner-model": "^5.0.0",
+    "@xyo-network/manifest-model": "^5.0.0",
+    "@xyo-network/module-model": "^5.0.0",
+    "@xyo-network/node-memory": "^5.0.0",
+    "@xyo-network/payload": "^5.0.0",
+    "@xyo-network/wallet": "^5.0.0",
+    "@xyo-network/witness-adhoc": "^5.0.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },

package/src/spec/MemoryNode/Manifest.spec.ts

@@ -0,0 +1,57 @@
+import '@xylabs/vitest-extended'
+
+import type { NodeManifestPayload } from '@xyo-network/manifest-model'
+import { MemoryNode } from '@xyo-network/node-memory'
+import { AdhocWitness, AdhocWitnessConfigSchema } from '@xyo-network/witness-adhoc'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+/**
+ * @group node
+ * @group module
+ */
+
+describe('MemoryNode', () => {
+  // AbstractModule.defaultLogger = new ConsoleLogger(LogLevel.log)
+  it('Creates MemoryNode from Manifest', async () => {
+    const memoryNode = await MemoryNode.create({
+      account: 'random',
+      config: { name: 'MemoryNode', schema: 'network.xyo.node.config' },
+    })
+    const privateWitnesses = [
+      await AdhocWitness.create({ account: 'random', config: { name: 'PrivateWitness1', schema: AdhocWitnessConfigSchema } }),
+      await AdhocWitness.create({ account: 'random', config: { name: 'PrivateWitness2', schema: AdhocWitnessConfigSchema } }),
+      await AdhocWitness.create({ account: 'random', config: { name: 'PrivateWitness3', schema: AdhocWitnessConfigSchema } }),
+    ]
+    const publicWitnesses = [
+      await AdhocWitness.create({ account: 'random', config: { name: 'PublicWitness1', schema: AdhocWitnessConfigSchema } }),
+      await AdhocWitness.create({ account: 'random', config: { name: 'PublicWitness2', schema: AdhocWitnessConfigSchema } }),
+      await AdhocWitness.create({ account: 'random', config: { name: 'PublicWitness3', schema: AdhocWitnessConfigSchema } }),
+      await AdhocWitness.create({ account: 'random', config: { name: 'PublicWitness4', schema: AdhocWitnessConfigSchema } }),
+    ]
+    await Promise.all(
+      publicWitnesses.map(async (witness) => {
+        await memoryNode.register(witness)
+        await memoryNode.attach(witness.address, true)
+      }),
+    )
+    await Promise.all(
+      privateWitnesses.map(async (witness) => {
+        await memoryNode.register(witness)
+        await memoryNode.attach(witness.address, false)
+      }),
+    )
+    const publicModules = await memoryNode.resolve('*')
+    expect(publicModules).toBeArrayOfSize(8)
+    /* const privateModules = await memoryNode.resolve('*', { visibility: 'private' })
+    expect(privateModules).toBeArrayOfSize(3)
+    const allModules = await memoryNode.resolve('*', { visibility: 'all' })
+    expect(allModules).toBeArrayOfSize(8) */
+
+    const manifest = (await memoryNode.manifest()) as NodeManifestPayload
+    // console.log(`manifest: ${toSafeJsonString(manifest, 10)}`)
+    expect(manifest.modules?.public ?? []).toBeArrayOfSize(4)
+    // expect(manifest.modules?.private).toBeArrayOfSize(3)
+  })
+})

package/src/spec/MemoryNode/MemoryNode.spec.ts

@@ -0,0 +1,434 @@
+import { delay } from '@xylabs/delay'
+import { matchers } from '@xylabs/vitest-matchers'
+import type { AccountInstance } from '@xyo-network/account-model'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import type { AttachableArchivistInstance } from '@xyo-network/archivist-model'
+import type {
+  AddressPayload,
+  AttachableModuleInstance,
+  Module,
+  ModuleDescription,
+  ModuleDescriptionPayload,
+} from '@xyo-network/module-model'
+import {
+  AddressSchema,
+  ModuleDescriptionSchema,
+} from '@xyo-network/module-model'
+import { MemoryNode, MemoryNodeHelper } from '@xyo-network/node-memory'
+import type { ModuleAttachedEventArgs } from '@xyo-network/node-model'
+import { NodeConfigSchema } from '@xyo-network/node-model'
+import type { Payload } from '@xyo-network/payload'
+import { isPayloadOfSchemaType } from '@xyo-network/payload'
+import { HDWallet } from '@xyo-network/wallet'
+import {
+  beforeAll,
+  beforeEach,
+  describe, expect, it,
+} from 'vitest'
+
+expect.extend(matchers)
+
+/**
+ * @group node
+ * @group module
+ */
+
+describe('MemoryNode', () => {
+  let testAccount1: AccountInstance
+  let testAccount2: AccountInstance
+  let testAccount3: AccountInstance
+  let testAccount4: AccountInstance
+  const archivistConfig = { schema: MemoryArchivist.defaultConfigSchema }
+  const nodeConfig = { schema: NodeConfigSchema }
+  let node: MemoryNode
+  beforeAll(async () => {
+    testAccount1 = await HDWallet.fromPhrase('cushion student broken thing poet mistake item dutch traffic gloom awful still')
+    testAccount2 = await HDWallet.fromPhrase('siren tenant achieve enough tone roof album champion tiny civil lottery hundred')
+    testAccount3 = await HDWallet.fromPhrase('person wheat floor tumble pond develop sauce attract neither toilet build enrich')
+    testAccount4 = await HDWallet.fromPhrase('kit sound script century margin into guilt region engine garment lab rifle')
+  })
+  beforeEach(async () => {
+    const nodeModule = await MemoryNode.create({ account: testAccount1, config: nodeConfig })
+    node = nodeModule
+  })
+  /* describe('create', () => {
+    describe('with autoAttachExternallyResolved true', () => {
+      it('attaches external modules to internal resolver', async () => {
+        // Arrange
+        // Create a MemoryNode with no modules in the internal
+        // resolver and one module in the external resolver
+        const resolver = new CompositeModuleResolver({})
+        const internalResolver = new CompositeModuleResolver({})
+        const params: MemoryNodeParams = {
+          config: { schema: NodeConfigSchema },
+          internalResolver,
+          resolver,
+        }
+        const module = await MemoryArchivist.create()
+        const filter = { address: [module.address] }
+        resolver.add(module)
+        // No modules exist in internal resolver
+        expect(await internalResolver.resolve(filter)).toBeArrayOfSize(0)
+        // Module exists in external resolver
+        expect(await resolver.resolve(filter)).toBeArrayOfSize(1)
+        const node = await MemoryNode.create(params)
+        // No modules are attached
+        expect(await node.attached()).toBeArrayOfSize(0)
+
+        // Act
+        // Query for unattached module (by address) that exists in
+        // external resolver
+        expect(await node.resolve(filter)).toBeArrayOfSize(1)
+
+        // Assert
+        // Module is now attached
+        expect(await node.attached()).toBeArrayOfSize(1)
+        // Module exists in internal resolver
+        expect(await internalResolver.resolve(filter)).toBeArrayOfSize(1)
+        // Module still exists in external resolver
+        expect(await resolver.resolve(filter)).toBeArrayOfSize(1)
+      })
+    })
+  }) */
+  describe('register', () => {
+    it('registers module', async () => {
+      const mod = await MemoryArchivist.create({ account: 'random' })
+      await node.register(mod)
+    })
+  })
+  describe('registered', () => {
+    describe('with no modules registered', () => {
+      it('returns empty array', async () => {
+        const result = await node.registered()
+        expect(result).toBeArrayOfSize(0)
+      })
+    })
+    describe('with modules registered', () => {
+      let mod: AttachableModuleInstance
+      beforeEach(async () => {
+        mod = await MemoryArchivist.create({ account: 'random' })
+        await node.register(mod)
+      })
+      it('lists addresses of registered modules', async () => {
+        const result = await node.registered()
+        expect(result).toBeArrayOfSize(1)
+        expect(result).toEqual([mod.address])
+      })
+    })
+  })
+  describe('attach', () => {
+    let mod: AttachableModuleInstance
+    beforeEach(async () => {
+      mod = await MemoryArchivist.create({ account: 'random' })
+      await node.register(mod)
+    })
+    it('attaches module', async () => {
+      await node.attach(mod.address, true)
+    })
+    it('emits event on module attach', async () => {
+      let eventDone = false
+      return await new Promise<void>((resolve, reject) => {
+        node.on('moduleAttached', (args) => {
+          const { mod } = args as ModuleAttachedEventArgs
+          expect(mod).toBeObject()
+          expect(mod.address).toBe(mod.address)
+          expect(mod).toBe(mod)
+          eventDone = true
+        })
+        node
+          .attach(mod.address, true)
+          .then(async () => {
+            // wait for up to 5 seconds
+            let waitFrames = 50
+            while (waitFrames) {
+              if (eventDone) {
+                resolve()
+                return
+              }
+              await delay(100)
+              waitFrames--
+            }
+            reject('Event not fired [within 5 seconds]')
+          })
+          .catch(() => {
+            reject('Attach failed')
+          })
+      })
+    })
+  })
+  describe('attached', () => {
+    let mod: AttachableModuleInstance
+    beforeEach(async () => {
+      mod = await MemoryArchivist.create({ account: 'random' })
+      await node.register(mod)
+    })
+    describe('with no modules attached', () => {
+      it('returns empty array', async () => {
+        const result = await node.attached()
+        expect(result).toBeArrayOfSize(0)
+      })
+    })
+    describe('with modules attached', () => {
+      it('lists addresses of attached modules', async () => {
+        await node.attach(mod.address, true)
+        const result = await node.attached()
+        expect(result.length).toBe(1)
+        expect(result).toEqual([mod.address])
+      })
+    })
+  })
+  describe('detach', () => {
+    let mod: AttachableModuleInstance
+    beforeEach(async () => {
+      mod = await MemoryArchivist.create({ account: 'random' })
+      await node.register(mod)
+      await node.attach(mod.address, true)
+    })
+    it('deregisters existing module', async () => {
+      await node.detach(mod.address)
+    })
+    /* it('allows deregistering non-existent mod', () => {
+      node.detach('4a15a6c96665931b76c1d2a587ea1132dbfdc266')
+    }) */
+  })
+  describe('registeredModules', () => {
+    let mod: AttachableModuleInstance
+    beforeEach(async () => {
+      mod = await MemoryArchivist.create({ account: 'random' })
+    })
+    describe('with no mods registered', () => {
+      it('returns empty array', () => {
+        const mods = node.registeredModules()
+        expect(mods).toBeArrayOfSize(0)
+      })
+    })
+    describe('with modules registered', () => {
+      it('returns registered modules', async () => {
+        await node.register(mod)
+        const mods = node.registeredModules()
+        expect(mods).toBeArrayOfSize(1)
+        expect(mods).toContain(mod)
+      })
+    })
+  })
+  describe('unregister', () => {
+    it('un-registers module', async () => {
+      const mod = await MemoryArchivist.create({ account: 'random' })
+      await node.register(mod)
+      expect(node.registeredModules()).toContain(mod)
+      await node.unregister(mod)
+      expect(node.registeredModules()).not.toContain(mod)
+    })
+  })
+  describe('description', () => {
+    const validateModuleDescription = (description?: ModuleDescription) => {
+      expect(description).toBeObject()
+      expect(description?.address).toBeString()
+      expect(description?.queries).toBeArray()
+      description?.queries.map((query) => {
+        expect(query).toBeString()
+      })
+    }
+    describe('node without child modules', () => {
+      it('describes node alone', async () => {
+        const description = (await node.state()).find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
+        validateModuleDescription(description)
+        expect(description?.children).toBeArrayOfSize(0)
+      })
+      it('serializes to JSON consistently', async () => {
+        const description = (await node.state()).find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
+        expect(prettyPrintDescription(description)).toMatchSnapshot()
+      })
+    })
+    describe('node with child modules', () => {
+      beforeEach(async () => {
+        const mods = await Promise.all([
+          MemoryArchivist.create({ account: testAccount2, config: { ...archivistConfig, name: 'testAccount2' } }),
+          MemoryArchivist.create({ account: testAccount3, config: { ...archivistConfig, name: 'testAccount3' } }),
+        ])
+        await Promise.all(
+          mods.map(async (mod) => {
+            await node.register(mod)
+            expect(await node.attach(mod.address, true)).toEqual(mod.address)
+            expect(await node.detach(mod.address)).toEqual(mod.address)
+            if (mod.modName) {
+              expect(await node.attach(mod.modName, true)).toEqual(mod.address)
+              expect(await node.detach(mod.modName)).toEqual(mod.address)
+            }
+            expect(await node.attach(mod.address, true)).toEqual(mod.address)
+          }),
+        )
+      })
+      it('describes node and child mods', async () => {
+        const description = (await node.state()).find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
+        validateModuleDescription(description)
+        expect(description?.children).toBeArrayOfSize(2)
+        // description.children?.map(validateModuleDescription)
+      })
+      it('serializes to JSON consistently', async () => {
+        const description = (await node.state()).find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
+        expect(prettyPrintDescription(description)).toMatchSnapshot()
+      })
+    })
+    describe('node with nested nodes and mods', () => {
+      beforeEach(async () => {
+        const nestedNode = await MemoryNode.create({ account: testAccount2, config: nodeConfig })
+        const nestedModules: AttachableArchivistInstance[] = [await MemoryArchivist.create({ account: testAccount3, config: archivistConfig })]
+        await Promise.all(
+          nestedModules.map(async (mod) => {
+            await nestedNode.register?.(mod)
+            await nestedNode.attach(mod.address, true)
+          }),
+        )
+        const rootModules: AttachableModuleInstance[] = [await MemoryArchivist.create({ account: testAccount4, config: archivistConfig })]
+        rootModules.push(nestedNode)
+        await Promise.all(
+          rootModules.map(async (mod) => {
+            await node.register(mod)
+            await node.attach(mod.address, true)
+          }),
+        )
+      })
+      it('describes node and all nested nodes and child modules', async () => {
+        const memoryNode = await MemoryNode.create({ account: 'random' })
+        const archivist1 = await MemoryArchivist.create({ account: 'random' })
+        const archivist2 = await MemoryArchivist.create({ account: 'random' })
+        await memoryNode.register(archivist1)
+        await memoryNode.attach(archivist1.address, true)
+        await memoryNode.register(archivist2)
+        await memoryNode.attach(archivist2.address, true)
+        console.log('status:', memoryNode.status)
+        const description = (await memoryNode.state()).find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
+        validateModuleDescription(description)
+        expect(description?.children).toBeArrayOfSize(2)
+        // description.children?.map(validateModuleDescription)
+      })
+      it('serializes to JSON consistently', async () => {
+        const description = (await node.state()).find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
+        expect(prettyPrintDescription(description)).toMatchSnapshot()
+      })
+      it('clone-all', async () => {
+        const newNode = await MemoryNodeHelper.attachToNewNode(node, '*')
+        const newNodeChildren = await newNode.publicChildren()
+        const nodeChildren = await node.publicChildren()
+        expect(newNodeChildren.length).toEqual(nodeChildren.length)
+        expect(newNodeChildren.includes(nodeChildren[0])).toBe(true)
+      })
+      it('clone-one (public)', async () => {
+        const mod = await MemoryArchivist.create({ account: 'random', config: { ...archivistConfig, name: 'CloneModule' } })
+        await node.register(mod)
+        await node.attach(mod.address, true)
+
+        const newNode = await MemoryNodeHelper.attachToNewNode(node, 'CloneModule')
+        const newNodeChild = await newNode.resolve('CloneModule')
+        const nodeChild = await node.resolve('CloneModule', { maxDepth: 1 })
+        expect(newNodeChild?.id).toEqual(nodeChild?.id)
+        expect(newNodeChild?.address).toEqual(nodeChild?.address)
+        expect(newNodeChild).toEqual(nodeChild)
+      })
+      it('clone-one (private)', async () => {
+        const mod = await MemoryArchivist.create({ account: 'random', config: { ...archivistConfig, name: 'CloneModulePrivate' } })
+        await node.register(mod)
+        await node.attach(mod.address)
+
+        try {
+          // this should except
+          await MemoryNodeHelper.attachToNewNode(node, 'CloneModulePrivate')
+          expect(false).toBeTrue()
+        } catch (e) {
+          expect(e).toBeInstanceOf(Error)
+        }
+      })
+    })
+  })
+  describe('discover', () => {
+    const archivistConfig = { schema: MemoryArchivist.defaultConfigSchema }
+    const validateStateResponse = (mod: Module, response: Payload[]) => {
+      expect(response).toBeArray()
+      const address = response.find(p => p.schema === AddressSchema) as AddressPayload
+      expect(address).toBeObject()
+      expect(address.address).toEqual(mod.address)
+      const config = response.find(p => p.schema === mod.config.schema)
+      expect(config).toBeObject()
+      expect(config?.schema).toBe(mod.config.schema)
+      const queries = response.filter(p => mod.queries.includes(p.schema))
+      expect(queries.length).toBeGreaterThanOrEqual(0)
+      for (const query of queries) {
+        expect(query).toBeObject()
+      }
+    }
+    describe('node without child modules', () => {
+      it('describes node alone', async () => {
+        const state = await node.state()
+        validateStateResponse(node, state)
+      })
+    })
+    describe('node with child modules', () => {
+      it('describes node and child modules', async () => {
+        const memoryNode = await MemoryNode.create({ account: 'random' })
+        const modules = await Promise.all([
+          MemoryArchivist.create({ account: testAccount2, config: archivistConfig }),
+          MemoryArchivist.create({ account: testAccount3, config: archivistConfig }),
+        ])
+        await Promise.all(
+          modules.map(async (mod) => {
+            await memoryNode.register(mod)
+            await memoryNode.attach(mod.address, true)
+          }),
+        )
+        const state = await memoryNode.state()
+
+        const address0 = state.find(p => p.schema === AddressSchema && (p as AddressPayload).address === modules[0].address) as AddressPayload
+        expect(address0).toBeObject()
+        const address1 = state.find(p => p.schema === AddressSchema && (p as AddressPayload).address === modules[1].address) as AddressPayload
+        expect(address1).toBeObject()
+      })
+    })
+    describe('node with nested nodes and modules', () => {
+      beforeEach(async () => {
+        node = await MemoryNode.create({ account: 'random' })
+        const attachEvents: Module[] = []
+        node.on('moduleAttached', (args) => {
+          const { mod } = args as ModuleAttachedEventArgs
+          attachEvents.push(mod)
+        })
+        const nestedNode = await MemoryNode.create({ account: testAccount2, config: nodeConfig })
+        const nestedModules = [await MemoryArchivist.create({ account: testAccount3, config: archivistConfig })]
+        await Promise.all(
+          nestedModules.map(async (mod) => {
+            await nestedNode.register(mod)
+            await nestedNode.attach(mod.address, true)
+          }),
+        )
+        const rootModules: AttachableModuleInstance[] = [await MemoryArchivist.create({ account: testAccount4, config: archivistConfig })]
+        rootModules.push(nestedNode)
+        await Promise.all(
+          rootModules.map(async (mod) => {
+            await node.register(mod)
+            await node.attach(mod.address, true)
+          }),
+        )
+        expect(attachEvents.includes(nestedNode)).toBeTrue()
+        expect(attachEvents.includes(node)).toBeFalse()
+        expect(nestedModules.length).toBe(1)
+        for (const nestedModule of nestedModules) {
+          expect(attachEvents.includes(nestedModule)).toBeTrue()
+        }
+        expect(rootModules.length).toBe(2)
+        for (const rootModule of rootModules) {
+          expect(attachEvents.includes(rootModule)).toBeTrue()
+        }
+        const eventAddresses = attachEvents.map(mod => mod.address)
+        expect(eventAddresses.length).toBe(3)
+      })
+      it('describes node and all nested nodes and child modules', async () => {
+        const state = await node.state()
+        validateStateResponse(node, state)
+      })
+    })
+  })
+})
+
+const prettyPrintDescription = (description?: ModuleDescription) => {
+  return JSON.stringify(description, null, 2)
+}

package/src/spec/MemoryNode/WithArchivistAndDiviner.spec.ts

@@ -0,0 +1,115 @@
+/* eslint-disable max-statements */
+import '@xylabs/vitest-extended'
+
+import { MemoryArchivist, MemoryArchivistConfigSchema } from '@xyo-network/archivist-memory'
+import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { ArchivistPayloadDiviner, ArchivistPayloadDivinerConfigSchema } from '@xyo-network/diviner-archivist'
+import type { HuriPayload } from '@xyo-network/diviner-huri'
+import { HuriSchema } from '@xyo-network/diviner-huri'
+import { asDivinerInstance } from '@xyo-network/diviner-model'
+import { MemoryNode } from '@xyo-network/node-memory'
+import type { Payload } from '@xyo-network/payload'
+import { PayloadBuilder, PayloadSchema } from '@xyo-network/payload'
+import {
+  describe, expect,
+  it,
+} from 'vitest'
+
+/**
+ * @group node
+ * @group module
+ */
+
+describe('MemoryNode', () => {
+  it('WithArchivistAndDiviner', async () => {
+    const node = await MemoryNode.create({ account: 'random' })
+    const archivist = await MemoryArchivist.create({
+      account: 'random',
+      config: { name: 'Archivist', schema: MemoryArchivistConfigSchema },
+    })
+
+    await node.register(archivist)
+    await node.attach(archivist.address, true)
+
+    const privateArchivist = await MemoryArchivist.create({
+      account: 'random',
+      config: { name: 'PrivateArchivist', schema: MemoryArchivistConfigSchema },
+    })
+
+    await node.register(privateArchivist)
+    await node.attach(privateArchivist.address, false)
+
+    const diviner = await ArchivistPayloadDiviner.create({
+      account: 'random',
+      config: { archivist: archivist.address, schema: ArchivistPayloadDivinerConfigSchema },
+    })
+
+    await node.register(diviner)
+    await node.attach(diviner.address, true)
+
+    expect(await node.registered()).toBeArrayOfSize(3)
+    expect(await node.attached()).toBeArrayOfSize(3)
+
+    const foundArchivist = asArchivistInstance(await node.resolve(archivist.address))
+    expect(foundArchivist).toBeDefined()
+    const foundNamedArchivist = asArchivistInstance(await node.resolve('Archivist'))
+    expect(foundNamedArchivist).toBeDefined()
+    expect(foundArchivist?.address).toBe(archivist.address)
+    const testPayload = new PayloadBuilder<Payload<{ schema: PayloadSchema; test: boolean }>>({ schema: PayloadSchema })
+      .fields({ test: true })
+      .build()
+
+    await foundArchivist?.insert([testPayload])
+
+    const payloads = await foundArchivist?.all?.()
+    expect(payloads?.length).toBe(1)
+
+    if (payloads && payloads[0]) {
+      const huri = await PayloadBuilder.dataHash(payloads[0])
+      const huriPayload: HuriPayload = { huri: [huri], schema: HuriSchema }
+      const mod = await node.resolve(diviner.address)
+      const foundDiviner = asDivinerInstance(mod)
+      expect(foundDiviner).toBeDefined()
+      if (foundDiviner) {
+        const payloads = await foundDiviner.divine([huriPayload])
+        expect(payloads?.length).toBe(1)
+        expect(payloads[0]).toBeDefined()
+        if (payloads?.length === 1 && payloads[0]) {
+          expect(await PayloadBuilder.dataHash(payloads[0])).toBe(huri)
+        }
+      }
+    }
+
+    expect((await node.resolve('*', { direction: 'up' })).length).toBe(1)
+    expect((await node.resolve('*', { direction: 'up', maxDepth: 0 })).length).toBe(1)
+    expect((await node.resolve('*', { direction: 'up', maxDepth: 1 })).length).toBe(1)
+
+    const nodeDown = await node.resolve('*', { direction: 'down' })
+    expect(nodeDown.length).toBe(3)
+    expect(nodeDown.find(mod => mod.address === node.address)).toBeDefined()
+    expect(nodeDown.find(mod => mod.address === archivist.address)).toBeDefined()
+    expect(nodeDown.find(mod => mod.address === diviner.address)).toBeDefined()
+
+    expect((await node.resolvePrivate('*', { direction: 'down' })).length).toBe(1)
+    expect((await node.resolve('*', { direction: 'down', maxDepth: 0 })).length).toBe(1)
+    expect((await node.resolve('*', { direction: 'down', maxDepth: 1 })).length).toBe(3)
+
+    // this should be 3 here and not 4 since node is at the top and asking it to resolve its privates
+    // from outside should not include the private cousin
+    expect((await node.resolve('*', { direction: 'all' })).length).toBe(3)
+
+    const archivistUp = await archivist.resolve('*', { direction: 'up' })
+
+    expect(archivistUp.find(mod => mod.address === node.address)).toBeDefined()
+    expect(archivistUp.find(mod => mod.address === archivist.address)).toBeDefined()
+    expect(archivistUp.find(mod => mod.address === diviner.address)).toBeDefined()
+    // this is 4 here since it will include the one private cousin
+    expect(archivistUp.length).toBe(4)
+
+    expect((await archivist.resolve('*', { direction: 'up', maxDepth: 1 })).length).toBe(2)
+    expect((await archivist.resolve('*', { direction: 'down' })).length).toBe(1)
+
+    // this is 4 here since it will include the one private cousin
+    expect((await archivist.resolve('*', { direction: 'all' })).length).toBe(4)
+  })
+})

package/src/spec/MemoryNode/__snapshots__/MemoryNode.spec.ts.snap

@@ -0,0 +1,68 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`MemoryNode > description > node with child modules > serializes to JSON consistently 1`] = `
+"{
+  "address": "a1df01bbdaa05f2294cdd6fbd92aace3086fe408",
+  "queries": [
+    "network.xyo.query.node.attach",
+    "network.xyo.query.node.certify",
+    "network.xyo.query.node.detach",
+    "network.xyo.query.node.attached",
+    "network.xyo.query.node.registered",
+    "network.xyo.query.module.address",
+    "network.xyo.query.module.subscribe",
+    "network.xyo.query.module.manifest",
+    "network.xyo.query.module.state"
+  ],
+  "schema": "network.xyo.module.description",
+  "name": "Unnamed MemoryNode",
+  "children": [
+    "e8cae43b8ef15e6e2166b7560b2df802ac28fe53",
+    "ee84477649f67bcda3c604ad361313bdd9976c0f"
+  ]
+}"
+`;
+
+exports[`MemoryNode > description > node with nested nodes and mods > serializes to JSON consistently 1`] = `
+"{
+  "address": "a1df01bbdaa05f2294cdd6fbd92aace3086fe408",
+  "queries": [
+    "network.xyo.query.node.attach",
+    "network.xyo.query.node.certify",
+    "network.xyo.query.node.detach",
+    "network.xyo.query.node.attached",
+    "network.xyo.query.node.registered",
+    "network.xyo.query.module.address",
+    "network.xyo.query.module.subscribe",
+    "network.xyo.query.module.manifest",
+    "network.xyo.query.module.state"
+  ],
+  "schema": "network.xyo.module.description",
+  "name": "Unnamed MemoryNode",
+  "children": [
+    "4c3e913823664e68ce252e256b8c442172dbec4a",
+    "e8cae43b8ef15e6e2166b7560b2df802ac28fe53",
+    "ee84477649f67bcda3c604ad361313bdd9976c0f"
+  ]
+}"
+`;
+
+exports[`MemoryNode > description > node without child modules > serializes to JSON consistently 1`] = `
+"{
+  "address": "a1df01bbdaa05f2294cdd6fbd92aace3086fe408",
+  "queries": [
+    "network.xyo.query.node.attach",
+    "network.xyo.query.node.certify",
+    "network.xyo.query.node.detach",
+    "network.xyo.query.node.attached",
+    "network.xyo.query.node.registered",
+    "network.xyo.query.module.address",
+    "network.xyo.query.module.subscribe",
+    "network.xyo.query.module.manifest",
+    "network.xyo.query.module.state"
+  ],
+  "schema": "network.xyo.module.description",
+  "name": "Unnamed MemoryNode",
+  "children": []
+}"
+`;

package/src/spec/asModule.spec.ts

@@ -0,0 +1,42 @@
+/* eslint-disable unicorn/no-useless-undefined */
+import '@xylabs/vitest-extended'
+
+import { Account } from '@xyo-network/account'
+import { asModuleInstance } from '@xyo-network/module-model'
+import { MemoryNode } from '@xyo-network/node-memory'
+import {
+  describe, expect, test,
+} from 'vitest'
+
+// eslint-disable-next-line no-restricted-imports
+import {
+  asNodeInstance, NodeConfigSchema, NodeWrapper,
+} from '../index.ts'
+
+/**
+ * @group node
+ * @group module
+ */
+
+describe('identity check (as)', () => {
+  test('asModuleInstance', async () => {
+    const node = await MemoryNode.create({ account: 'random', config: { schema: NodeConfigSchema } })
+    expect(asModuleInstance(node)).toBeDefined()
+    expect(asModuleInstance(null)).toBeUndefined()
+    expect(asModuleInstance(undefined)).toBeUndefined()
+    expect(asModuleInstance({})).toBeUndefined()
+
+    const wrapper = NodeWrapper.wrap(node, await Account.random())
+    expect(asModuleInstance(wrapper)).toBeDefined()
+  })
+  test('isNodeInstance', async () => {
+    const node = await MemoryNode.create({ account: 'random', config: { schema: NodeConfigSchema } })
+    expect(asNodeInstance(node)).toBeDefined()
+    expect(asNodeInstance(null)).toBeUndefined()
+    expect(asNodeInstance(undefined)).toBeUndefined()
+    expect(asNodeInstance({})).toBeUndefined()
+
+    const wrapper = NodeWrapper.wrap(node, await Account.random())
+    expect(asNodeInstance(wrapper)).toBeDefined()
+  })
+})

package/src/spec/isModule.spec.ts

@@ -0,0 +1,42 @@
+/* eslint-disable unicorn/no-useless-undefined */
+import '@xylabs/vitest-extended'
+
+import { Account } from '@xyo-network/account'
+import { isModuleInstance } from '@xyo-network/module-model'
+import { MemoryNode } from '@xyo-network/node-memory'
+import {
+  describe, expect, test,
+} from 'vitest'
+
+// eslint-disable-next-line no-restricted-imports
+import {
+  isNodeInstance, NodeConfigSchema, NodeWrapper,
+} from '../index.ts'
+
+/**
+ * @group node
+ * @group module
+ */
+
+describe('identity check (is)', () => {
+  test('isModuleInstance', async () => {
+    const node = await MemoryNode.create({ account: 'random', config: { schema: NodeConfigSchema } })
+    expect(isModuleInstance(node)).toBeTrue()
+    expect(isModuleInstance(null)).toBeFalse()
+    expect(isModuleInstance(undefined)).toBeFalse()
+    expect(isModuleInstance({})).toBeFalse()
+
+    const wrapper = NodeWrapper.wrap(node, await Account.random())
+    expect(isModuleInstance(wrapper)).toBeTrue()
+  })
+  test('isNodeInstance', async () => {
+    const node = await MemoryNode.create({ account: 'random', config: { schema: NodeConfigSchema } })
+    expect(isNodeInstance(node)).toBeTrue()
+    expect(isNodeInstance(null)).toBeFalse()
+    expect(isNodeInstance(undefined)).toBeFalse()
+    expect(isNodeInstance({})).toBeFalse()
+
+    const wrapper = NodeWrapper.wrap(node, await Account.random())
+    expect(isNodeInstance(wrapper)).toBeTrue()
+  })
+})

package/xy.config.ts

@@ -1,10 +0,0 @@
-import type { XyTsupConfig } from '@xylabs/ts-scripts-yarn3'
-const config: XyTsupConfig = {
-  compile: {
-    browser: {},
-    neutral: { src: true },
-    node: {},
-  },
-}
-
-export default config

package/xyo-config.js

@@ -1 +0,0 @@
-module.exports = { version: 1 }