diff --git a/packages/block/src/base-block.ts b/packages/block/src/base-block.ts
new file mode 100644
index 0000000..f4f6c81
--- /dev/null
+++ b/packages/block/src/base-block.ts
@@ -0,0 +1,50 @@
+import type { Socket } from '@rallie/core'
+import { constant, errors } from './utils'
+
+export type BlockType = {
+  state?: Record<string, unknown>
+  events?: Record<string, Function>
+  methods?: Record<string, Function>
+}
+
+export class BaseBlock<T extends BlockType> {
+  public name: string
+  public state: T['state']
+  public events: T['events']
+  public methods: T['methods']
+
+  #socket: Socket
+
+  constructor(name: string, socket: Socket) {
+    this.name = name
+    this.#socket = socket
+    this.events = this.#socket.createBroadcaster()
+    this.methods = this.#socket.createUnicaster()
+    Reflect.defineProperty(this, 'state', {
+      get: () => this.#socket.getState<T['state'], T['state']>(constant.stateNamespace(this.name)),
+      set: () => {
+        throw new Error(errors.stateIsReadonly(this.name))
+      },
+    })
+  }
+
+  public setState(action: string, setter: (state: T['state']) => void | Promise<void>) {
+    if (this.#socket.existState(constant.stateNamespace(this.name))) {
+      return this.#socket.setState(constant.stateNamespace(this.name), action, setter)
+    } else {
+      throw new Error(errors.stateNotInitialized(this.name))
+    }
+  }
+
+  public watchState<P = any>(getter: (state: T['state']) => undefined | P) {
+    if (this.#socket.existState(constant.stateNamespace(this.name))) {
+      return this.#socket.watchState<T['state'], P>(constant.stateNamespace(this.name), getter)
+    } else {
+      throw new Error(errors.stateNotInitialized(this.name))
+    }
+  }
+
+  public listenEvents(events: Partial<T['events']>) {
+    return this.#socket.onBroadcast<Partial<T['events']>>(events)
+  }
+}
diff --git a/packages/block/src/block.ts b/packages/block/src/block.ts
deleted file mode 100644
index 88bf525..0000000
--- a/packages/block/src/block.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { touchBus } from '@rallie/core'
-import type { Socket } from '@rallie/core'
-import { constant, errors } from './utils'
-
-export type BlockService = {
-  state?: Record<string, any>
-  events?: Record<string, Function>
-  methods?: Record<string, Function>
-  exports?: Record<string, any>
-}
-
-export class Block<T extends BlockService> {
-  protected socket: Socket
-  public name: string
-  public state: T['state']
-  public events: T['events']
-  public methods: T['methods']
-
-  constructor(name: string) {
-    this.name = name
-    const [bus] = touchBus(constant.privateBus(name))
-    this.socket = bus.createSocket()
-    this.events = this.socket.createBroadcaster()
-    this.methods = this.socket.createUnicaster()
-    Reflect.defineProperty(this, 'state', {
-      get: () => this.socket.getState<T['state'], T['state']>(constant.stateNamespace(this.name)),
-      set: () => {
-        throw new Error(errors.stateIsReadonly(this.name))
-      },
-    })
-  }
-
-  public setState(action: string, setter: (state: T['state']) => void | Promise<void>) {
-    if (this.socket.existState(constant.stateNamespace(this.name))) {
-      return this.socket.setState(constant.stateNamespace(this.name), action, setter)
-    } else {
-      throw new Error(errors.stateNotInitialized(this.name))
-    }
-  }
-
-  public watchState<P = any>(getter: (state: T['state']) => undefined | P) {
-    if (this.socket.existState(constant.stateNamespace(this.name))) {
-      return this.socket.watchState<T['state'], P>(constant.stateNamespace(this.name), getter)
-    } else {
-      throw new Error(errors.stateNotInitialized(this.name))
-    }
-  }
-
-  public listenEvents(events: Partial<T['events']>) {
-    return this.socket.onBroadcast<Partial<T['events']>>(events)
-  }
-}
diff --git a/packages/block/src/connected-block.ts b/packages/block/src/connected-block.ts
deleted file mode 100644
index e7b4dc5..0000000
--- a/packages/block/src/connected-block.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { Block, BlockService } from './block'
-import { constant, SYMBOLS } from './utils'
-
-export class ConnectedBlock<T extends BlockService> extends Block<T> {
-  private innerMethods: {
-    [constant.exportMethodName]: () => T['exports']
-  }
-
-  public symbol = SYMBOLS.CONNECTED_BLOCK
-
-  constructor(name: string) {
-    super(name)
-    this.innerMethods = this.socket.createUnicaster()
-  }
-
-  import() {
-    return this.innerMethods[constant.exportMethodName]()
-  }
-}
diff --git a/packages/block/src/created-block.ts b/packages/block/src/created-block.ts
index 2409d44..c4c52da 100644
--- a/packages/block/src/created-block.ts
+++ b/packages/block/src/created-block.ts
@@ -1,8 +1,6 @@
-import { ConnectedBlock } from './connected-block'
-import type { Bus, Socket, MiddlewareFnType, ConfType } from '@rallie/core'
-import { constant, errors, SYMBOLS } from './utils'
-import { Block, type BlockService } from './block'
-import { socketsPool } from './sockets-pool'
+import { Bus, Socket, MiddlewareFnType, ConfType, touchBus, App } from '@rallie/core'
+import { constant } from './utils'
+import { BaseBlock, type BlockType } from './base-block'
 
 export interface Env {
   isEntry: boolean
@@ -13,53 +11,72 @@ export interface Env {
   unfreeze: () => void
 }
 
-export class CreatedBlock<T extends BlockService> extends Block<T> {
-  private globalBus: Bus
-  private globalSocket: Socket
-  private isEntry: boolean
-  private connectedBlocks: Record<string, BlockService> = {}
-  public exports: T['exports']
-  public symbol = SYMBOLS.CREATED_BLOCK
+export class CreatedBlock<T extends BlockType> extends BaseBlock<T> {
+  #globalBus: Bus
+  #globalSocket: Socket
+  #isEntry: boolean
+  #socket: Socket
+  #app: App
+  #connectedBlocks: Record<string, BlockType> = {}
 
   constructor(name: string, globalBus: Bus, globalSocket: Socket, isEntry: boolean) {
-    super(name)
-    this.globalBus = globalBus
-    this.globalSocket = globalSocket
-    this.isEntry = isEntry
-    socketsPool.set(name, this.socket)
+    const [bus] = touchBus(constant.privateBus(name))
+    const socket = bus.createSocket()
+    super(name, socket)
+    this.#socket = socket
+    this.#globalBus = globalBus
+    this.#globalSocket = globalSocket
+    this.#app = globalBus.createApp(name)
+    this.#isEntry = isEntry
+  }
+
+  public initState(state: T['state'], isPrivate?: boolean) {
+    this.#socket.initState(constant.stateNamespace(this.name), state as object, isPrivate)
+    return this
   }
 
   public addMethods(methods: Partial<T['methods']>) {
-    return this.socket.onUnicast<Partial<T['methods']>>(methods)
+    return this.#socket.onUnicast<Partial<T['methods']>>(methods)
+  }
+
+  public relyOn(dependencies: string[]) {
+    this.#app.relyOn(dependencies)
+    return this
+  }
+
+  public relateTo(relatedApps: string[]) {
+    this.#app.relateTo(relatedApps)
+    return this
+  }
+
+  public onActivate(callback: () => void | Promise<void>) {
+    this.#app.onActivate(callback)
+    return this
   }
 
-  public connect<P extends BlockService>(name: string) {
-    if (!this.connectedBlocks[name]) {
-      this.connectedBlocks[name] = new ConnectedBlock<P>(name)
+  public connect<P extends BlockType>(name: string) {
+    if (!this.#connectedBlocks[name]) {
+      const [bus] = touchBus(constant.privateBus(name))
+      const socket = bus.createSocket()
+      this.#connectedBlocks[name] = new BaseBlock<P>(name, socket)
     }
-    return this.connectedBlocks[name] as ConnectedBlock<P>
+    return this.#connectedBlocks[name] as BaseBlock<P>
   }
 
   public load(name: string) {
-    if (this.globalBus.existApp(this.name)) {
-      return this.globalBus.loadApp(name)
-    }
-    throw new Error(errors.operateBeforeRegister(this.name, 'load'))
+    return this.#globalBus.loadApp(name)
   }
 
   public activate(name: string) {
-    if (this.globalBus.existApp(this.name)) {
-      return this.globalBus.activateApp(name)
-    }
-    throw new Error(errors.operateBeforeRegister(this.name, 'activate'))
+    return this.#globalBus.activateApp(name)
   }
 
   public async run(callback: (env: Env) => void | Promise<void>) {
     const isBusAccessible =
-      this.isEntry || this.globalSocket.getState(constant.isGlobalBusAccessible)?.value
+      this.#isEntry || this.#globalSocket.getState(constant.isGlobalBusAccessible)?.value
     const setBusAccessible = (isAccessible: boolean) => {
-      if (this.isEntry) {
-        this.globalSocket.setState(
+      if (this.#isEntry) {
+        this.#globalSocket.setState(
           constant.isGlobalBusAccessible,
           isAccessible ? 'unfreeze the enviroment' : 'freeze the enviroment',
           (state) => {
@@ -69,15 +86,15 @@ export class CreatedBlock<T extends BlockService> extends Block<T> {
       }
     }
     const env: Omit<Env, 'conf'> = {
-      isEntry: this.isEntry,
+      isEntry: this.#isEntry,
       use: (middleware) => {
         if (isBusAccessible) {
-          this.globalBus.use(middleware)
+          this.#globalBus.use(middleware)
         }
       },
       config: (conf) => {
         if (isBusAccessible) {
-          this.globalBus.config(conf)
+          this.#globalBus.config(conf)
         }
       },
       freeze: () => {
@@ -91,7 +108,7 @@ export class CreatedBlock<T extends BlockService> extends Block<T> {
       new Proxy(env as Env, {
         get: (target, prop: keyof Env, receiver) => {
           if (prop === 'conf') {
-            return JSON.parse(JSON.stringify(this.globalBus.conf))
+            return JSON.parse(JSON.stringify(this.#globalBus.conf))
           }
           return Reflect.get(target, prop, receiver)
         },
diff --git a/packages/block/src/index.ts b/packages/block/src/index.ts
index 18d1073..0bbbaa2 100644
--- a/packages/block/src/index.ts
+++ b/packages/block/src/index.ts
@@ -1,10 +1,9 @@
 import { CreatedBlock } from './created-block'
-import type { BlockService } from './block'
+import { BlockType } from './base-block'
 import { touchBus } from '@rallie/core'
-import { errors, constant, SYMBOLS } from './utils'
-import { RegisteredBlock } from './registered-block'
+import { errors, constant } from './utils'
 
-export function createBlock<T extends BlockService = {}>(name: string) {
+export function createBlock<T extends BlockType = {}>(name: string) {
   const [globalBus, isEntry] = touchBus()
   if (globalBus.existApp(name)) {
     throw new Error(errors.duplicatedBlockName(name))
@@ -16,18 +15,8 @@ export function createBlock<T extends BlockService = {}>(name: string) {
   return new CreatedBlock<T>(name, globalBus, globalSocket, isEntry)
 }
 
-export function registerBlock<T extends CreatedBlock<unknown>>(block: T) {
-  if (block.symbol === SYMBOLS.CREATED_BLOCK) {
-    return new RegisteredBlock<T>(block)
-  } else {
-    throw new Error(errors.invalidBlock(block.name))
-  }
-}
-
-export type { Block } from './block'
+export type { BlockType, BaseBlock } from './base-block'
 export type { CreatedBlock, Env } from './created-block'
-export type { ConnectedBlock } from './connected-block'
-export type { RegisteredBlock } from './registered-block'
 
 export type {
   ScriptType,
diff --git a/packages/block/src/registered-block.ts b/packages/block/src/registered-block.ts
deleted file mode 100644
index 36568f0..0000000
--- a/packages/block/src/registered-block.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-import { App, getBus, Socket } from '@rallie/core'
-import { CreatedBlock } from './created-block'
-import { socketsPool } from './sockets-pool'
-import { constant, warnings } from './utils'
-export class RegisteredBlock<T extends CreatedBlock<unknown>> {
-  private socket: Socket
-  private app: App
-  private exports: T['exports'] = {}
-  private exported = false
-  constructor(private createdBlock: T) {
-    this.app = getBus().createApp(createdBlock.name)
-    this.socket = socketsPool.get(createdBlock.name)
-    this.socket.onUnicast({
-      [constant.exportMethodName]: () => this.exports,
-    })
-  }
-
-  relyOn(dependencies: string[]) {
-    this.app.relyOn(dependencies)
-    return this
-  }
-
-  relateTo(relatedApps: string[]) {
-    this.app.relateTo(relatedApps)
-    return this
-  }
-
-  initState(state: T['state'], isPrivate?: boolean) {
-    this.socket.initState(
-      constant.stateNamespace(this.createdBlock.name),
-      state as object,
-      isPrivate,
-    )
-    return this
-  }
-
-  export(exports: T['exports']) {
-    if (!this.exported) {
-      Object.freeze(exports)
-      this.exports = exports
-      this.createdBlock.exports = exports
-      this.exported = true
-    } else {
-      console.warn(warnings.duplicatedExports(this.createdBlock.name))
-    }
-    return this
-  }
-
-  onActivate(callback: () => void | Promise<void>) {
-    this.app.onActivate(callback)
-    return this
-  }
-}
diff --git a/packages/block/src/sockets-pool.ts b/packages/block/src/sockets-pool.ts
deleted file mode 100644
index 3a452d7..0000000
--- a/packages/block/src/sockets-pool.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-import type { Socket } from '@rallie/core'
-
-export const socketsPool = new Map<string, Socket>()
diff --git a/packages/block/src/utils.ts b/packages/block/src/utils.ts
index a632f39..593f7bb 100644
--- a/packages/block/src/utils.ts
+++ b/packages/block/src/utils.ts
@@ -1,10 +1,5 @@
 export type ConstraintedType<T, P, Default> = T extends P ? T : Default
 
-export const SYMBOLS = {
-  CREATED_BLOCK: Symbol('createBlock'),
-  CONNECTED_BLOCK: Symbol('connectedBlock'),
-}
-
 export const constant = {
   privateBus: (blockName: string) => `${blockName}.bus`,
   stateNamespace: (blockName: string) => `${blockName}.state`,
@@ -22,14 +17,5 @@ export const errors = {
     ),
   duplicatedBlockName: (blockName: string) =>
     message(`the block ${blockName} is already registered before, please rename your block`),
-  invalidBlock: (name: string) =>
-    message(`failed to register the block ${name} because it is not a valid created block`),
   stateIsReadonly: (blockName: string) => message(`the state of ${blockName} is readonly`),
-  operateBeforeRegister: (blockName: string, operate: 'activate' | 'load') =>
-    message(`the block ${blockName} can not ${operate} any other block unless it's registered`),
-}
-
-export const warnings = {
-  duplicatedExports: (blockName: string) =>
-    message(`you can only export once in the block ${blockName}`),
 }
diff --git a/packages/block/test/blocks/connect-testers/events.ts b/packages/block/test/blocks/connect-testers/events.ts
index f32b5e4..880e012 100644
--- a/packages/block/test/blocks/connect-testers/events.ts
+++ b/packages/block/test/blocks/connect-testers/events.ts
@@ -1,13 +1,11 @@
-import { createBlock, registerBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
 const block = createBlock<{
   events: {
     log: (text: string) => void
     cancelListen: () => void
   }
-}>('connect-testers/events')
-
-registerBlock(block).onActivate(() => {
+}>('connect-testers/events').onActivate(() => {
   const cancelListen = block.listenEvents({
     log: (text) => console.log(text),
     cancelListen: () => {
diff --git a/packages/block/test/blocks/connect-testers/exports.ts b/packages/block/test/blocks/connect-testers/exports.ts
deleted file mode 100644
index 8d09fe0..0000000
--- a/packages/block/test/blocks/connect-testers/exports.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { createBlock, registerBlock } from '../../../src'
-
-const block = createBlock<{
-  exports: {
-    testedValue: number
-  }
-}>('connect-testers/exports')
-
-registerBlock(block)
-  .export({
-    testedValue: 1,
-  })
-  .export({
-    testedValue: 2,
-  })
diff --git a/packages/block/test/blocks/connect-testers/methods.ts b/packages/block/test/blocks/connect-testers/methods.ts
index f8af7cb..130b9cd 100644
--- a/packages/block/test/blocks/connect-testers/methods.ts
+++ b/packages/block/test/blocks/connect-testers/methods.ts
@@ -1,4 +1,4 @@
-import { createBlock, registerBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
 let count = 0
 const block = createBlock<{
@@ -7,9 +7,7 @@ const block = createBlock<{
     addCount: (num: number) => number
     removeMethods: () => void
   }
-}>('connect-testers/methods')
-
-registerBlock(block).onActivate(() => {
+}>('connect-testers/methods').onActivate(() => {
   const removeMethods = block.addMethods({
     getCount() {
       return count
diff --git a/packages/block/test/blocks/connect-testers/private-state.ts b/packages/block/test/blocks/connect-testers/private-state.ts
index dc451cd..1c6b238 100644
--- a/packages/block/test/blocks/connect-testers/private-state.ts
+++ b/packages/block/test/blocks/connect-testers/private-state.ts
@@ -1,4 +1,4 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
 const blockWithPrivateState = createBlock<{
   state: {
@@ -7,7 +7,7 @@ const blockWithPrivateState = createBlock<{
   methods: {
     incrementCount: (num: number) => void
   }
-}>('connect-testers/private-state')
+}>('connect-testers/private-state').initState({ count: 0 }, true)
 
 blockWithPrivateState.addMethods({
   incrementCount: async (num) => {
@@ -16,5 +16,3 @@ blockWithPrivateState.addMethods({
     })
   },
 })
-
-registerBlock(blockWithPrivateState).initState({ count: 0 }, true)
diff --git a/packages/block/test/blocks/connect-testers/public-state.ts b/packages/block/test/blocks/connect-testers/public-state.ts
index 7bcdbfc..f96c690 100644
--- a/packages/block/test/blocks/connect-testers/public-state.ts
+++ b/packages/block/test/blocks/connect-testers/public-state.ts
@@ -1,11 +1,9 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
-const blockWithPublicState = createBlock<{
+createBlock<{
   state: {
     count: number
   }
-}>('connect-testers/public-state')
-
-registerBlock(blockWithPublicState).initState({
+}>('connect-testers/public-state').initState({
   count: 0,
 })
diff --git a/packages/block/test/blocks/dependency-testers/a.ts b/packages/block/test/blocks/dependency-testers/a.ts
index 3fa5880..134a069 100644
--- a/packages/block/test/blocks/dependency-testers/a.ts
+++ b/packages/block/test/blocks/dependency-testers/a.ts
@@ -1,3 +1,3 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
-registerBlock(createBlock('dependency-testers/a'))
+createBlock('dependency-testers/a')
diff --git a/packages/block/test/blocks/dependency-testers/b.ts b/packages/block/test/blocks/dependency-testers/b.ts
index eb926dc..29a6416 100644
--- a/packages/block/test/blocks/dependency-testers/b.ts
+++ b/packages/block/test/blocks/dependency-testers/b.ts
@@ -1,3 +1,3 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
-registerBlock(createBlock('dependency-testers/b'))
+createBlock('dependency-testers/b')
diff --git a/packages/block/test/blocks/dependency-testers/c.ts b/packages/block/test/blocks/dependency-testers/c.ts
index e4236c2..c3d99fb 100644
--- a/packages/block/test/blocks/dependency-testers/c.ts
+++ b/packages/block/test/blocks/dependency-testers/c.ts
@@ -1,3 +1,3 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
-registerBlock(createBlock('dependency-testers/c'))
+createBlock('dependency-testers/c')
diff --git a/packages/block/test/blocks/dependency-testers/main.ts b/packages/block/test/blocks/dependency-testers/main.ts
index 845589b..715f373 100644
--- a/packages/block/test/blocks/dependency-testers/main.ts
+++ b/packages/block/test/blocks/dependency-testers/main.ts
@@ -1,6 +1,6 @@
-import { registerBlock, createBlock } from '../../../src/index'
+import { createBlock } from '../../../src/index'
 
-registerBlock(createBlock('dependency-testers/main')).relyOn([
+createBlock('dependency-testers/main').relyOn([
   'dependency-testers/a',
   'dependency-testers/b',
   'dependency-testers/c',
diff --git a/packages/block/test/blocks/relate-testers/a.ts b/packages/block/test/blocks/relate-testers/a.ts
index d6368e9..0ecc38d 100644
--- a/packages/block/test/blocks/relate-testers/a.ts
+++ b/packages/block/test/blocks/relate-testers/a.ts
@@ -1,8 +1,6 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
-const block = createBlock('relate-testers/a')
-
-registerBlock(block).relateTo(['relate-testers/b'])
+const block = createBlock('relate-testers/a').relateTo(['relate-testers/b'])
 
 block.run((env) => {
   if (!env.isEntry) {
diff --git a/packages/block/test/blocks/relate-testers/b.ts b/packages/block/test/blocks/relate-testers/b.ts
index 8382001..83e4618 100644
--- a/packages/block/test/blocks/relate-testers/b.ts
+++ b/packages/block/test/blocks/relate-testers/b.ts
@@ -1,8 +1,8 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
 const block = createBlock('relate-testers/b')
-
-registerBlock(block).relateTo(['relate-testers/a', 'relate-testers/c']).relyOn(['relate-testers/a'])
+  .relateTo(['relate-testers/a', 'relate-testers/c'])
+  .relyOn(['relate-testers/a'])
 
 block.run((env) => {
   if (!env.isEntry) {
diff --git a/packages/block/test/blocks/relate-testers/c.ts b/packages/block/test/blocks/relate-testers/c.ts
index 3e66ecd..a46667c 100644
--- a/packages/block/test/blocks/relate-testers/c.ts
+++ b/packages/block/test/blocks/relate-testers/c.ts
@@ -1,10 +1,6 @@
-import { registerBlock, createBlock } from '../../../src'
+import { createBlock } from '../../../src'
 
-const block = createBlock('relate-testers/c')
-
-registerBlock(block)
-
-block.run((env) => {
+createBlock('relate-testers/c').run((env) => {
   if (!env.isEntry) {
     console.error('relate-testers/c is loaded')
   }
diff --git a/packages/block/test/blocks/relate-testers/main.ts b/packages/block/test/blocks/relate-testers/main.ts
index aecac8d..86d5e6b 100644
--- a/packages/block/test/blocks/relate-testers/main.ts
+++ b/packages/block/test/blocks/relate-testers/main.ts
@@ -1,7 +1,5 @@
-import { registerBlock, createBlock } from '../../../src/index'
+import { createBlock } from '../../../src/index'
 
-const block = createBlock('relate-testers/main')
-
-registerBlock(block)
+createBlock('relate-testers/main')
   .relyOn(['relate-testers/c'])
   .relateTo(['relate-testers/a', 'relate-testers/b', 'relate-testers/c'])
diff --git a/packages/block/test/connect.test.ts b/packages/block/test/connect.test.ts
index 3b2a909..270fc1d 100644
--- a/packages/block/test/connect.test.ts
+++ b/packages/block/test/connect.test.ts
@@ -1,6 +1,6 @@
 import { Errors } from '@rallie/core'
-import { createBlock, registerBlock } from '../src/index'
-import { errors, constant, warnings } from '../src/utils'
+import { createBlock } from '../src/index'
+import { errors, constant } from '../src/utils'
 import nativeLoader from './middlewares/native-loader'
 
 const hostApp = createBlock('host-app')
@@ -14,7 +14,6 @@ describe('Test state', () => {
   test('# case 1: test set, get and watch of public state', async () => {
     console.log = jest.fn()
     const app = createBlock('case1')
-    registerBlock(app)
     const blockWithPublicState = app.connect<{
       state: {
         count: number
@@ -48,7 +47,6 @@ describe('Test state', () => {
   test('# case 2: test set, get and watch of private state', async () => {
     console.log = jest.fn()
     const app = createBlock('case2')
-    registerBlock(app)
     const blockWithPrivateState = app.connect<{
       state: {
         count: number
@@ -106,8 +104,7 @@ describe('Test state', () => {
 })
 
 describe('Test Events', () => {
-  const app = createBlock('events-tester')
-  registerBlock(app).relyOn(['connect-testers/events'])
+  const app = createBlock('events-tester').relyOn(['connect-testers/events'])
 
   test('# case 1: test events', async () => {
     console.log = jest.fn()
@@ -128,8 +125,7 @@ describe('Test Events', () => {
 })
 
 describe('Test Methods', () => {
-  const app = createBlock('methods-tester')
-  registerBlock(app).relyOn(['connect-testers/methods'])
+  const app = createBlock('methods-tester').relyOn(['connect-testers/methods'])
 
   test('# case 1: test methods', async () => {
     const target = app.connect<{
@@ -151,20 +147,3 @@ describe('Test Methods', () => {
     }).toThrowError()
   })
 })
-
-describe('Test export and import', () => {
-  const app = createBlock('exports-tester')
-  registerBlock(app).relateTo(['connect-testers/exports'])
-  test('# case 1: test export and import', async () => {
-    console.warn = jest.fn()
-    await app.activate(app.name)
-    const targetApp = app.connect<{
-      exports: {
-        testedValue: number
-      }
-    }>('connect-testers/exports')
-    const { testedValue: testedValue1 } = targetApp.import()
-    expect(testedValue1).toEqual(1)
-    expect(console.warn).toBeCalledWith(warnings.duplicatedExports('connect-testers/exports'))
-  })
-})
diff --git a/packages/block/test/dependencies.test.ts b/packages/block/test/dependencies.test.ts
index 6eb9d1f..972f86e 100644
--- a/packages/block/test/dependencies.test.ts
+++ b/packages/block/test/dependencies.test.ts
@@ -1,12 +1,10 @@
-import { errors } from '../src/utils'
-import { createBlock, registerBlock } from '../src/index'
+import { createBlock } from '../src/index'
 import nativeLoader from './middlewares/native-loader'
 import logger from './middlewares/logger'
 
 describe('Test the dependencies', () => {
   const appsLoaded: string[] = []
   const hostApp = createBlock('host-app')
-  registerBlock(hostApp)
   hostApp.run((env) => {
     env.use(logger(appsLoaded))
     env.use(nativeLoader)
@@ -18,14 +16,4 @@ describe('Test the dependencies', () => {
     expect(appsLoaded.includes('dependency-testers/b')).toBeTruthy()
     expect(appsLoaded.includes('dependency-testers/c')).toBeTruthy()
   })
-
-  test('# case 2: only registered block can load or activate other block', () => {
-    const app = createBlock('case2')
-    expect(() => {
-      app.load('dependency-testers/a')
-    }).toThrow(errors.operateBeforeRegister(app.name, 'load'))
-    expect(() => {
-      app.activate('dependency-testers/a')
-    }).toThrow(errors.operateBeforeRegister(app.name, 'activate'))
-  })
 })
diff --git a/packages/block/test/env.test.ts b/packages/block/test/env.test.ts
index 001d3e8..38dfcf9 100644
--- a/packages/block/test/env.test.ts
+++ b/packages/block/test/env.test.ts
@@ -1,5 +1,5 @@
 import { Errors } from '@rallie/core'
-import { createBlock, registerBlock } from '../src/index'
+import { createBlock } from '../src/index'
 import { createBlockMiddleware } from './middlewares/create-block-middleware'
 import nativeLoader from './middlewares/native-loader'
 
@@ -10,7 +10,6 @@ hostApp.run((env) => {
 describe('Test env', () => {
   test('# case 1: the first-created block should run in entry mode, and other blocks should run in remote mode', async () => {
     const otherApp = createBlock('other-app')
-    registerBlock(otherApp)
     console.log = jest.fn()
     hostApp.run((env) => {
       expect(env.isEntry).toBeTruthy()
@@ -82,7 +81,6 @@ describe('Test env', () => {
     console.error = jest.fn()
     const app = createBlock('case4')
     const blocksCreatedByMiddleware: string[] = []
-    registerBlock(app)
     app.run((env) => {
       env.use(createBlockMiddleware(['anyApp1'], blocksCreatedByMiddleware))
     })
@@ -96,7 +94,6 @@ describe('Test env', () => {
     console.error = jest.fn()
     const app = createBlock('case5')
     const blocksCreatedByMiddleware: string[] = []
-    registerBlock(app)
     hostApp.run((env) => {
       env.freeze()
     })
diff --git a/packages/block/test/middlewares/create-block-middleware.ts b/packages/block/test/middlewares/create-block-middleware.ts
index b407f66..7b4e310 100644
--- a/packages/block/test/middlewares/create-block-middleware.ts
+++ b/packages/block/test/middlewares/create-block-middleware.ts
@@ -1,11 +1,11 @@
 import { MiddlewareFnType } from '@rallie/core'
-import { registerBlock, createBlock } from '../../src'
+import { createBlock } from '../../src'
 
 export const createBlockMiddleware =
   (blocksToRegister: string[], registeredBlocks: string[]): MiddlewareFnType =>
   async (ctx, next) => {
     if (blocksToRegister.includes(ctx.name)) {
-      registerBlock(createBlock(ctx.name))
+      createBlock(ctx.name)
       registeredBlocks.push(ctx.name)
     } else {
       await next()
diff --git a/packages/block/test/relate.test.ts b/packages/block/test/relate.test.ts
index 97b9542..c64220a 100644
--- a/packages/block/test/relate.test.ts
+++ b/packages/block/test/relate.test.ts
@@ -1,11 +1,10 @@
-import { createBlock, registerBlock } from '../src/index'
+import { createBlock } from '../src/index'
 import nativeLoader from './middlewares/native-loader'
 import logger from './middlewares/logger'
 
 describe('Test the dependencies', () => {
   const appsLoaded: string[] = []
   const hostApp = createBlock('host-app')
-  registerBlock(hostApp)
   hostApp.run((env) => {
     env.use(logger(appsLoaded))
     env.use(nativeLoader)
diff --git a/packages/block/test/utils.test.ts b/packages/block/test/utils.test.ts
index 8651832..8ee2902 100644
--- a/packages/block/test/utils.test.ts
+++ b/packages/block/test/utils.test.ts
@@ -1,36 +1,27 @@
-import { registerBlock, createBlock } from '../src'
+import { createBlock } from '../src'
 import { errors } from '../src/utils'
 
 describe('Test errors and warnings', () => {
   test('#case1: blocks can not have the same name', () => {
-    registerBlock(createBlock('case1'))
+    createBlock('case1')
     expect(() => {
-      registerBlock(createBlock('case1'))
+      createBlock('case1')
     }).toThrowError(errors.duplicatedBlockName('case1'))
   })
 
-  test('#case2: only created block can be registered', () => {
-    const block3 = createBlock('case2')
-    const block2 = block3.connect('block2')
-    expect(() => {
-      // @ts-ignore
-      registerBlock(block2)
-    }).toThrowError(errors.invalidBlock('block2'))
-  })
-
-  test('#case3: state should be readonly', () => {
+  test('#case2: state should be readonly', () => {
     const block = createBlock<{
       state: {
         count: number
       }
-    }>('case3')
-    registerBlock(block).initState({
+    }>('case2')
+    block.initState({
       count: 0,
     })
     expect(() => {
       block.state = {
         count: 1,
       }
-    }).toThrowError(errors.stateIsReadonly('case3'))
+    }).toThrowError(errors.stateIsReadonly('case2'))
   })
 })
diff --git a/packages/react/src/hooks.ts b/packages/react/src/hooks.ts
index 317be41..4d4420d 100644
--- a/packages/react/src/hooks.ts
+++ b/packages/react/src/hooks.ts
@@ -1,7 +1,7 @@
 import React from 'react'
-import type { Block, CreatedBlock } from '@rallie/block'
+import type { BaseBlock, CreatedBlock } from '@rallie/block'
 
-export function useBlockState<T extends Block<unknown>, U>(
+export function useBlockState<T extends BaseBlock<unknown>, U>(
   block: T,
   getter: (state: T['state']) => U,
   deps: any[] = [],
@@ -18,7 +18,7 @@ export function useBlockState<T extends Block<unknown>, U>(
   return value
 }
 
-export function useBlockEvents<T extends Block<unknown>>(
+export function useBlockEvents<T extends BaseBlock<unknown>>(
   block: T,
   events: Partial<T['events']>,
   deps: any[] = [],
diff --git a/packages/react/test/hooks.test.tsx b/packages/react/test/hooks.test.tsx
index bedc8a0..8b4bd92 100644
--- a/packages/react/test/hooks.test.tsx
+++ b/packages/react/test/hooks.test.tsx
@@ -1,9 +1,9 @@
 import React from 'react'
 import { block, Component, type BlockService } from './blocks'
 import { render, fireEvent, act, screen, cleanup } from '@testing-library/react'
-import { createBlock, registerBlock } from '@rallie/block'
+import { createBlock } from '@rallie/block'
 
-registerBlock(block)
+block
   .initState({
     locale: 'en',
     count: 0,
@@ -25,7 +25,6 @@ registerBlock(block)
   })
 
 const tester = createBlock('tester')
-registerBlock(tester)
 describe('Test React hooks', () => {
   beforeAll(async () => {
     await act(async () => {
diff --git a/packages/vue/package.json b/packages/vue/package.json
index 6cc755c..6a61bc7 100644
--- a/packages/vue/package.json
+++ b/packages/vue/package.json
@@ -5,9 +5,21 @@
   "author": "runnan <1608272694@qq.com>",
   "homepage": "https://github.com/ralliejs/rallie#readme",
   "license": "MIT",
-  "main": "./dist/index.umd.js",
-  "module": "./dist/index.es.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/hooks.umd.js",
+  "module": "./dist/hooks.es.js",
+  "types": "./dist/hooks.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/hooks.es.js",
+      "require": "./dist/hooks.umd.js",
+      "types": "./dist/hooks.d.ts"
+    },
+    "./mixins": {
+      "import": "./dist/mixins.es.js",
+      "require": "./dist/mixins.umd.js",
+      "types": "./dist/mixins.d.ts"
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ralliejs/rallie.git"
diff --git a/packages/vue/rollup.config.mjs b/packages/vue/rollup.config.mjs
index 84d08c7..c3bd14f 100644
--- a/packages/vue/rollup.config.mjs
+++ b/packages/vue/rollup.config.mjs
@@ -13,7 +13,7 @@ const commonConfigs = {
 
 export default [
   {
-    input: './src/index.ts',
+    input: './src/hooks.ts',
     output: [
       {
         file: pkg.main,
@@ -37,7 +37,7 @@ export default [
     input: './src/mixins.ts',
     output: [
       {
-        file: './dist/mixin.umd.js',
+        file: './dist/mixins.umd.js',
         format: 'umd',
         name: 'RallieVueMixin',
         exports: 'named',
@@ -46,7 +46,7 @@ export default [
         },
       },
       {
-        file: './dist/mixin.js',
+        file: './dist/mixins.es.js',
         format: 'es',
         exports: 'named',
       },
diff --git a/packages/vue/src/hooks.ts b/packages/vue/src/hooks.ts
index 1dc59d5..e163678 100644
--- a/packages/vue/src/hooks.ts
+++ b/packages/vue/src/hooks.ts
@@ -1,7 +1,10 @@
 import { onBeforeUnmount, onBeforeMount, ref, UnwrapRef } from 'vue'
-import type { Block, CreatedBlock } from '@rallie/block'
+import type { BaseBlock, CreatedBlock } from '@rallie/block'
 
-export function useBlockState<T extends Block<any>, U>(block: T, getter: (state: T['state']) => U) {
+export function useBlockState<T extends BaseBlock<unknown>, U>(
+  block: T,
+  getter: (state: T['state']) => U,
+) {
   const stateRef = ref<U>(getter(block.state))
   let unwatch: () => void
   onBeforeMount(() => {
@@ -15,7 +18,10 @@ export function useBlockState<T extends Block<any>, U>(block: T, getter: (state:
   return stateRef
 }
 
-export function useBlockEvents<T extends Block<any>>(block: T, events: Partial<T['events']>) {
+export function useBlockEvents<T extends BaseBlock<unknown>>(
+  block: T,
+  events: Partial<T['events']>,
+) {
   let off: () => void
   onBeforeMount(() => {
     off = block.listenEvents(events)
@@ -25,7 +31,7 @@ export function useBlockEvents<T extends Block<any>>(block: T, events: Partial<T
   })
 }
 
-export function useBlockMethods<T extends CreatedBlock<any>>(
+export function useBlockMethods<T extends CreatedBlock<unknown>>(
   block: T,
   methods: Partial<T['methods']>,
 ) {
diff --git a/packages/vue/src/index.ts b/packages/vue/src/index.ts
deleted file mode 100644
index 20725af..0000000
--- a/packages/vue/src/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './hooks'
-export * from './mixins'
diff --git a/packages/vue/src/mixins.ts b/packages/vue/src/mixins.ts
index efa38d8..66d6bc4 100644
--- a/packages/vue/src/mixins.ts
+++ b/packages/vue/src/mixins.ts
@@ -1,6 +1,6 @@
-import type { Block, CreatedBlock } from '@rallie/block'
+import type { BaseBlock, CreatedBlock } from '@rallie/block'
 
-export function mixinBlockState<T extends Block<any>, U>(
+export function mixinBlockState<T extends BaseBlock<unknown>, U>(
   block: T,
   mapStateToComputed: (state: T['state']) => U,
 ) {
@@ -38,7 +38,10 @@ export function mixinBlockState<T extends Block<any>, U>(
   }
 }
 
-export function mixinBlockEvents<T extends Block<any>>(block: T, events: Partial<T['events']>) {
+export function mixinBlockEvents<T extends BaseBlock<unknown>>(
+  block: T,
+  events: Partial<T['events']>,
+) {
   let offEvents: () => void
   return {
     methods: events,
@@ -60,7 +63,7 @@ export function mixinBlockEvents<T extends Block<any>>(block: T, events: Partial
   }
 }
 
-export function mixinBlockMethods<T extends CreatedBlock<any>>(
+export function mixinBlockMethods<T extends CreatedBlock<unknown>>(
   block: T,
   methods: Partial<T['methods']>,
 ) {
diff --git a/packages/vue/test/components/hooks-tester.vue b/packages/vue/test/components/hooks-tester.vue
index a790d19..8ec415b 100644
--- a/packages/vue/test/components/hooks-tester.vue
+++ b/packages/vue/test/components/hooks-tester.vue
@@ -1,7 +1,7 @@
 <script lang="ts">
 import { defineComponent } from 'vue'
 import { block } from '../blocks'
-import { useBlockState, useBlockEvents, useBlockMethods } from '../../src'
+import { useBlockState, useBlockEvents, useBlockMethods } from '../../src/hooks'
 
 export default defineComponent(function HooksTester() {
   const count = useBlockState(block, (state) => state.count)
diff --git a/packages/vue/test/components/mixins-tester.vue b/packages/vue/test/components/mixins-tester.vue
index 80a7822..8794a13 100644
--- a/packages/vue/test/components/mixins-tester.vue
+++ b/packages/vue/test/components/mixins-tester.vue
@@ -17,7 +17,7 @@
 
 <script lang="ts">
 import { defineComponent } from 'vue'
-import { mixinBlockEvents, mixinBlockMethods, mixinBlockState } from '../../src'
+import { mixinBlockEvents, mixinBlockMethods, mixinBlockState } from '../../src/mixins'
 import { block } from '../blocks'
 
 export default defineComponent({
diff --git a/packages/vue/test/hooks.test.ts b/packages/vue/test/hooks.test.ts
index 004c613..4f8d25c 100644
--- a/packages/vue/test/hooks.test.ts
+++ b/packages/vue/test/hooks.test.ts
@@ -2,9 +2,9 @@ import { render, fireEvent, screen, cleanup } from '@testing-library/vue'
 import { block, type BlockService } from './blocks'
 // @ts-ignore
 import HooksTester from './components/hooks-tester.vue'
-import { registerBlock, createBlock } from '@rallie/block'
+import { createBlock } from '@rallie/block'
 
-registerBlock(block)
+block
   .initState({
     locale: 'en',
     count: 0,
@@ -26,7 +26,6 @@ registerBlock(block)
   })
 
 const tester = createBlock('tester')
-registerBlock(tester)
 describe('Test Vue hooks', () => {
   beforeAll(async () => {
     await tester.activate(block.name)
diff --git a/packages/vue/test/mixins.test.ts b/packages/vue/test/mixins.test.ts
index 84deb83..82af5b5 100644
--- a/packages/vue/test/mixins.test.ts
+++ b/packages/vue/test/mixins.test.ts
@@ -1,8 +1,8 @@
 import { render, fireEvent, screen, cleanup } from '@testing-library/vue'
 import { block, type BlockService } from './blocks'
-import { registerBlock, createBlock } from '@rallie/block'
+import { createBlock } from '@rallie/block'
 
-registerBlock(block)
+block
   .initState({
     locale: 'en',
     count: 0,
@@ -26,7 +26,7 @@ registerBlock(block)
   })
 
 const tester = createBlock('tester')
-registerBlock(tester)
+
 describe('Test Vue hooks', () => {
   beforeAll(async () => {
     await tester.activate(block.name)
diff --git a/playground/apps/host-app/block.ts b/playground/apps/host-app/block.ts
index 36d747f..fa7b8b0 100644
--- a/playground/apps/host-app/block.ts
+++ b/playground/apps/host-app/block.ts
@@ -14,3 +14,8 @@ interface HostApp {
 }
 
 export const hostApp = createBlock<HostApp>('host-app')
+  .relyOn(['lib:vue'])
+  .onActivate(async () => {
+    console.log('host app is bootstrapped')
+    await import('./app')
+  })
diff --git a/playground/apps/host-app/index.tsx b/playground/apps/host-app/index.tsx
index 2bebb61..690a946 100644
--- a/playground/apps/host-app/index.tsx
+++ b/playground/apps/host-app/index.tsx
@@ -1,13 +1,5 @@
-import { registerBlock } from '@rallie/block'
 import { hostApp } from './block'
 
-registerBlock(hostApp)
-  .relyOn(['lib:vue'])
-  .onActivate(async () => {
-    console.log('host app is bootstrapped')
-    await import('./app')
-  })
-
 hostApp.run(async (env) => {
   if (env.isEntry) {
     env.use(async (ctx, next) => {
diff --git a/playground/apps/react-app/components/App.tsx b/playground/apps/react-app/components/App.tsx
index 81d1041..a5ec133 100644
--- a/playground/apps/react-app/components/App.tsx
+++ b/playground/apps/react-app/components/App.tsx
@@ -13,7 +13,7 @@ export function App() {
       state.count++
     })
   }
-  const messageTypes = ['info', 'error', 'warning', 'success', 'loading']
+  const messageTypes = ['info', 'error', 'warning', 'success', 'loading'] as const
   const hint = {
     currentEnv: 'entry',
     navigationEnv: 'non-entry',
diff --git a/playground/apps/react-app/index.tsx b/playground/apps/react-app/index.tsx
index 2cbbca0..f51dfa1 100644
--- a/playground/apps/react-app/index.tsx
+++ b/playground/apps/react-app/index.tsx
@@ -1,16 +1,13 @@
 import { reactApp } from './blocks/react-app'
-import { registerBlock } from '@rallie/block'
 
-registerBlock(reactApp)
-  .relyOn(['host-app', 'vue-app'])
-  .onActivate(() => {
-    reactApp.addMethods({
-      mount: async (container) => {
-        const app = await import('./app')
-        app.mount(container)
-      },
-    })
+reactApp.relyOn(['host-app', 'vue-app']).onActivate(() => {
+  reactApp.addMethods({
+    mount: async (container) => {
+      const app = await import('./app')
+      app.mount(container)
+    },
   })
+})
 
 reactApp.run(async (env) => {
   if (env.isEntry) {
diff --git a/playground/apps/vue-app/components/HelloWorld.vue b/playground/apps/vue-app/components/HelloWorld.vue
index 43d2c00..c22387c 100644
--- a/playground/apps/vue-app/components/HelloWorld.vue
+++ b/playground/apps/vue-app/components/HelloWorld.vue
@@ -3,6 +3,7 @@
 import { vueApp } from '../blocks/vue-app'
 import { useBlockState } from '@rallie/vue'
 
+
 defineProps({ msg: String })
 
 const count = useBlockState(vueApp, (state) => state.count)
diff --git a/playground/apps/vue-app/index.tsx b/playground/apps/vue-app/index.tsx
index 9192d4b..07ba19c 100644
--- a/playground/apps/vue-app/index.tsx
+++ b/playground/apps/vue-app/index.tsx
@@ -1,7 +1,6 @@
-import { registerBlock } from '@rallie/block'
 import { vueApp } from './blocks/vue-app'
 
-registerBlock(vueApp)
+vueApp
   .initState({
     count: 0,
   })
diff --git a/playground/index.ts b/playground/index.ts
index 9ee9cdd..99148e4 100644
--- a/playground/index.ts
+++ b/playground/index.ts
@@ -1,4 +1,4 @@
-import { registerBlock, createBlock } from '@rallie/block'
+import { createBlock } from '@rallie/block'
 import { jsdelivrLibraryLoader, dynamicImportLoader, htmlLoader } from './middlewares' // eslint-disable-line
 import loadHtml from '@rallie/load-html' // eslint-disable-line
 
@@ -16,7 +16,7 @@ starter.run((env) => {
   // env.use(loadHtml())
   // env.use(htmlLoader)
 
-  registerBlock(starter).onActivate(async () => {
+  starter.onActivate(async () => {
     const mountApp = async (name: string) => {
       await starter.activate(name)
       const reactApp = starter.connect<any>(name)