diff --git a/.vscode/settings.json b/.vscode/settings.json
index f9d1c86a..a81ed920 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -13,17 +13,18 @@
   },
 
   // Silent the stylistic rules in you IDE, but still auto fix them
-  // "eslint.rules.customizations": [
-  //   { "rule": "style/*", "severity": "off" },
-  //   { "rule": "*-indent", "severity": "off" },
-  //   { "rule": "*-spacing", "severity": "off" },
-  //   { "rule": "*-spaces", "severity": "off" },
-  //   { "rule": "*-order", "severity": "off" },
-  //   { "rule": "*-dangle", "severity": "off" },
-  //   { "rule": "*-newline", "severity": "off" },
-  //   { "rule": "*quotes", "severity": "off" },
-  //   { "rule": "*semi", "severity": "off" }
-  // ],
+  "eslint.rules.customizations": [
+    { "rule": "style/*", "severity": "off" },
+    { "rule": "format/*", "severity": "off" },
+    { "rule": "*-indent", "severity": "off" },
+    { "rule": "*-spacing", "severity": "off" },
+    { "rule": "*-spaces", "severity": "off" },
+    { "rule": "*-order", "severity": "off" },
+    { "rule": "*-dangle", "severity": "off" },
+    { "rule": "*-newline", "severity": "off" },
+    { "rule": "*quotes", "severity": "off" },
+    { "rule": "*semi", "severity": "off" }
+  ],
 
   // Enable eslint for all supported languages
   "eslint.validate": [
@@ -36,7 +37,8 @@
     "markdown",
     "json",
     "jsonc",
-    "yaml"
+    "yaml",
+    "toml"
   ],
 
   "vitest.commandLine": "pnpm exec vitest",
diff --git a/README.md b/README.md
index 5430f3cc..c9b6d47e 100644
--- a/README.md
+++ b/README.md
@@ -158,7 +158,7 @@ Typed and async emitter:
 
 ```ts
 interface MyEvents {
-  inc(count: number): number
+  inc: (count: number) => number
 }
 
 const counter = 0
@@ -188,7 +188,7 @@ You can also use a global emitter that will be available even over module bounda
 ```ts
 declare global {
   interface ZeedGlobalEmitter {
-    test(x: string): void
+    test: (x: string) => void
   }
 }
 
diff --git a/demos/sideeffects/README.md b/demos/sideeffects/README.md
index 7e0a5e9d..37689a54 100644
--- a/demos/sideeffects/README.md
+++ b/demos/sideeffects/README.md
@@ -4,7 +4,7 @@ Some rules to follow to keep code [sideEffects](https://webpack.js.org/guides/tr
 
 ## Never use `export enum`
 
-This is a major pain point because it will always create some code, i.e. an object to map values and names to. 
+This is a major pain point because it will always create some code, i.e. an object to map values and names to.
 
 Better use strings, like `type MyStates = 'sleep' | 'code' | 'eat'`.
 
@@ -84,7 +84,7 @@ function encode64(data) {
 }
 ```
 
-## Lazy logging 
+## Lazy logging
 
 Logging often follows this pattern at the top level of a file:
 
@@ -92,7 +92,7 @@ Logging often follows this pattern at the top level of a file:
 const log = Logger("fancy")
 ```
 
-This is a constant that stays, whether used or not. 
+This is a constant that stays, whether used or not.
 
 Avoid logging or do it lazily inside the function. As for [zeed](https://github.com/holtwick/zeed), I go even further and only use logging if the importing application uses logging, which looks like this
 
@@ -102,4 +102,4 @@ getGlobalLoggerIfExists()?.('fanzy')?.info('Just FYI')
 
 ## Conclusion
 
-There are some pitfalls, but by following some coding patterns it is doable and you will be rewarded by minimal code usage. This way I can cram even more code into a single library without worrying about the resulting app size ;)
\ No newline at end of file
+There are some pitfalls, but by following some coding patterns it is doable and you will be rewarded by minimal code usage. This way I can cram even more code into a single library without worrying about the resulting app size ;)
diff --git a/demos/sideeffects/index-with-log.ts b/demos/sideeffects/index-with-log.ts
index 7bb8e489..75eed3f6 100644
--- a/demos/sideeffects/index-with-log.ts
+++ b/demos/sideeffects/index-with-log.ts
@@ -1,11 +1,10 @@
-/* eslint-disable no-console */
+import type { LoggerInterface } from 'zeed'
+import { Logger, arrayUnion } from 'zeed'
 
-import { arrayUnion, Logger, LoggerInterface } from 'zeed'
+const log: LoggerInterface = Logger('test')
 
-const log: LoggerInterface = Logger("test")
-
-let a = [1,2,3,3]
-let aa = arrayUnion(a)
+const a = [1, 2, 3, 3]
+const aa = arrayUnion(a)
 
 log('result arrayUnion', aa)
 
diff --git a/demos/sideeffects/index.ts b/demos/sideeffects/index.ts
index 7fc07460..d5f340bb 100644
--- a/demos/sideeffects/index.ts
+++ b/demos/sideeffects/index.ts
@@ -5,8 +5,8 @@ import { arrayUnion } from 'zeed'
 // import { Logger, LoggerInterface } from "zeed"
 // const log: LoggerInterface = Logger("test")
 
-let a = [1,2,3,3]
-let aa = arrayUnion(a)
+const a = [1, 2, 3, 3]
+const aa = arrayUnion(a)
 
 console.log('result arrayUnion', aa)
 
diff --git a/demos/sideeffects/package.json b/demos/sideeffects/package.json
index 09dd6f36..8c03b219 100644
--- a/demos/sideeffects/package.json
+++ b/demos/sideeffects/package.json
@@ -4,8 +4,8 @@
   "version": "0.1.0",
   "description": "Just a demo",
   "author": "Dirk Holtwick",
-  "main": "index.js",
   "sideEffects": false,
+  "main": "index.js",
   "scripts": {
     "start": "pnpm run build && ZEED=* node dist/node/index.js",
     "build:zeed": "(cd ../.. && pnpm build)",
diff --git a/demos/tests/src/jest.ts b/demos/tests/src/jest.ts
index 3f27f7b5..df0d72b3 100644
--- a/demos/tests/src/jest.ts
+++ b/demos/tests/src/jest.ts
@@ -2,7 +2,7 @@
 /* eslint-disable no-console */
 /* eslint-disable eqeqeq */
 
-import { Buffer } from 'buffer'
+import { Buffer } from 'node:buffer'
 import { format } from 'pretty-format'
 import { fn } from 'jest-mock'
 import { Logger, deepEqual, isPromise } from '../../../src/index.browser'
diff --git a/demos/tests/src/shims-vue.d.ts b/demos/tests/src/shims-vue.d.ts
index 20e23f03..9a745726 100644
--- a/demos/tests/src/shims-vue.d.ts
+++ b/demos/tests/src/shims-vue.d.ts
@@ -1,5 +1,6 @@
-declare module "*.vue" {
-  import { DefineComponent } from "vue"
-  const component: DefineComponent<{}, {}, any>
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
+  const component: DefineComponent<object, object, any>
   export default component
 }
diff --git a/demos/tests/src/test-unit-all.ts b/demos/tests/src/test-unit-all.ts
index 412d07f5..9725cf6d 100644
--- a/demos/tests/src/test-unit-all.ts
+++ b/demos/tests/src/test-unit-all.ts
@@ -16,15 +16,15 @@ console.log('load all browser')
 
 {
   const candidates = import.meta.glob('../../../src/browser/*.spec.*')
-  handleCandidates(candidates)
+  void handleCandidates(candidates)
 }
 
 {
   const candidates = import.meta.glob('../../../src/common/*.spec.*')
-  handleCandidates(candidates)
+  void handleCandidates(candidates)
 }
 
 {
   const candidates = import.meta.glob('../../../src/common/**/*.spec.*')
-  handleCandidates(candidates)
+  void handleCandidates(candidates)
 }
diff --git a/demos/tests/tsconfig.json b/demos/tests/tsconfig.json
index 64d1347a..7a249363 100644
--- a/demos/tests/tsconfig.json
+++ b/demos/tests/tsconfig.json
@@ -1,17 +1,17 @@
 {
   "compilerOptions": {
     "target": "esnext",
+    "jsx": "preserve",
+    "lib": ["esnext", "dom"],
     "module": "esnext",
     "moduleResolution": "Bundler",
-    "strict": true,
+    "resolveJsonModule": true,
+    "types": ["vite/client"],
     "allowJs": true,
     "checkJs": false,
-    "jsx": "preserve",
+    "strict": true,
     "sourceMap": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "lib": ["esnext", "dom"],
-    "types": ["vite/client"]
+    "esModuleInterop": true
   },
   "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"]
 }
diff --git a/demos/vite/src/components/HelloWorld.vue b/demos/vite/src/components/HelloWorld.vue
index 7bc140f6..4a3ba8e5 100644
--- a/demos/vite/src/components/HelloWorld.vue
+++ b/demos/vite/src/components/HelloWorld.vue
@@ -1,6 +1,7 @@
 <script lang="ts">
 import { defineComponent, ref } from 'vue'
 import { Logger } from '../../../../src/index.browser'
+
 // import { Logger } from 'zeed'
 
 const log = Logger('hello')
diff --git a/demos/vite/src/main.ts b/demos/vite/src/main.ts
index ef8a5f46..93841b74 100644
--- a/demos/vite/src/main.ts
+++ b/demos/vite/src/main.ts
@@ -1,4 +1,5 @@
 import { createApp } from 'vue'
+
 // import { Logger } from 'zeed'
 import { Logger, LoggerConsoleHandler, getGlobalLogger } from '../../../src/index.browser'
 import App from './App.vue'
@@ -6,11 +7,12 @@ import App from './App.vue'
 if (!localStorage.zeed) {
   getGlobalLogger().setHandlers([
     LoggerConsoleHandler({
-      filter: '*'
-    })
+      filter: '*',
+    }),
   ])
   console.info('\n\nThis is the fallback logging. Type `on()` to activate original browser logging.\n\n')
-} else {
+}
+else {
   console.info('\n\nThis is the browser logging. Type `off()` to activate original fallback logging.\n\n')
 }
 
diff --git a/demos/vite/src/shims-vue.d.ts b/demos/vite/src/shims-vue.d.ts
index 20e23f03..b07a0596 100644
--- a/demos/vite/src/shims-vue.d.ts
+++ b/demos/vite/src/shims-vue.d.ts
@@ -1,5 +1,6 @@
-declare module "*.vue" {
-  import { DefineComponent } from "vue"
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+
   const component: DefineComponent<{}, {}, any>
   export default component
 }
diff --git a/demos/vite/tsconfig.json b/demos/vite/tsconfig.json
index 66178181..f77ca28d 100644
--- a/demos/vite/tsconfig.json
+++ b/demos/vite/tsconfig.json
@@ -1,15 +1,15 @@
 {
   "compilerOptions": {
     "target": "esnext",
+    "jsx": "preserve",
+    "lib": ["esnext", "dom"],
     "module": "esnext",
     "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "types": ["vite/client"],
     "strict": true,
-    "jsx": "preserve",
     "sourceMap": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "lib": ["esnext", "dom"],
-    "types": ["vite/client"]
+    "esModuleInterop": true
   },
   "include": ["src/**/*.ts", "src/**/*.d.ts", "src/**/*.tsx", "src/**/*.vue"]
 }
diff --git a/eslint.config.js b/eslint.config.js
index 7c75215e..b24451fa 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -2,35 +2,34 @@ import antfu from '@antfu/eslint-config'
 
 export default antfu(
   {
-    typescript: true,
     vue: true,
     ignores: [
       'dist',
       'node_modules',
       'build',
       'tmp',
-      'demos',
+      // 'demos',
       'docs',
       'coverage',
       '_archive',
-      '*.spec.*',
-      'vitest.config.ts',
+      // '*.md',
+      // '*.spec.*',
+      // 'vitest.config.ts',
     ],
-  },
-  {},
-  {
+    typescript: {
+      tsconfigPath: './tsconfig.json',
+    },
     rules: {
       'unused-imports/no-unused-vars': 'off',
-      'antfu/consistent-list-newline': 'off',
-      'eslint-disable-unused-imports/no-unused-imports': 'off',
-      '@typescript-eslint/no-unsafe-argument': 'off',
-      '@typescript-eslint/no-unsafe-assignment': 'off',
-      '@typescript-eslint/no-unsafe-call': 'off',
-      '@typescript-eslint/no-unsafe-member-access': 'off',
-      '@typescript-eslint/no-unsafe-return': 'off',
-      '@typescript-eslint/require-await': 'off',
-      '@typescript-eslint/restrict-template-expressions': 'off',
-      '@typescript-eslint/no-misused-promises': 'off',
+      'ts/no-unsafe-assignment': 'off',
+      'ts/no-unsafe-return': 'off',
+      'ts/no-unsafe-member-access': 'off',
+      'ts/no-unsafe-argument': 'off',
+      'ts/no-unsafe-call': 'off',
+      'ts/restrict-template-expressions': 'off',
+      'ts/no-misused-promises': 'off',
+      // 'ts/no-floating-promises': 'error',
+      // 'ts/require-await': 'error',
     },
   },
 )
diff --git a/package.json b/package.json
index f407d4b7..9bfa8adc 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "zeed",
   "type": "module",
-  "version": "0.16.6",
+  "version": "0.16.7",
   "description": "🌱 Simple foundation library",
   "author": {
     "name": "Dirk Holtwick",
@@ -65,15 +65,15 @@
     "watch": "nr build -- --watch"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^2.6.3",
+    "@antfu/eslint-config": "^2.6.4",
     "@antfu/ni": "^0.21.12",
-    "@types/node": "^20.11.5",
-    "@vitest/coverage-v8": "^1.2.1",
-    "esbuild": "^0.19.12",
+    "@types/node": "^20.11.16",
+    "@vitest/coverage-v8": "^1.2.2",
+    "esbuild": "^0.20.0",
     "eslint": "^8.56.0",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
     "vite": "^5.0.12",
-    "vitest": "^1.2.1"
+    "vitest": "^1.2.2"
   }
 }
diff --git a/src/browser/log/log-colors.ts b/src/browser/log/log-colors.ts
index 8019da54..b5b540cc 100644
--- a/src/browser/log/log-colors.ts
+++ b/src/browser/log/log-colors.ts
@@ -36,6 +36,7 @@ export function browserSupportsColors(): boolean {
     // @ts-expect-error xxx
     && (window.console.firebug
     // @ts-expect-error xxx
+    // eslint-disable-next-line ts/unbound-method
     || (window.console.exception && window.console.table)))
     // Is firefox >= v31?
     // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
diff --git a/src/common/crypto.spec.ts b/src/common/crypto.spec.ts
index 7aceeb59..268fbeb8 100644
--- a/src/common/crypto.spec.ts
+++ b/src/common/crypto.spec.ts
@@ -107,9 +107,46 @@ Uint8Array [
 
     const binFix = await decrypt(
       new Uint8Array([
-        1, 1, 27, 108, 252, 31, 238, 192, 61, 168, 45, 29, 128, 212, 215, 222,
-        205, 105, 178, 193, 150, 36, 24, 216, 180, 75, 168, 133, 37, 25, 124,
-        137, 221, 103, 214, 97, 218, 232, 248, 93,
+        1,
+        1,
+        27,
+        108,
+        252,
+        31,
+        238,
+        192,
+        61,
+        168,
+        45,
+        29,
+        128,
+        212,
+        215,
+        222,
+        205,
+        105,
+        178,
+        193,
+        150,
+        36,
+        24,
+        216,
+        180,
+        75,
+        168,
+        133,
+        37,
+        25,
+        124,
+        137,
+        221,
+        103,
+        214,
+        97,
+        218,
+        232,
+        248,
+        93,
       ]),
       key,
     )
diff --git a/src/common/data/array.spec.ts b/src/common/data/array.spec.ts
index 9ef39987..3e912bf2 100644
--- a/src/common/data/array.spec.ts
+++ b/src/common/data/array.spec.ts
@@ -37,10 +37,18 @@ describe('array', () => {
   it('should intersect', () => {
     expect(arrayIntersection([1, 1, 2, 2, 3], [2, 2, 3, 5, 6])).toEqual([2, 3])
     expect(arraySymmetricDifference([1, 1, 2, 2, 3], [2, 2, 3, 5, 6])).toEqual([
-      1, 5, 6,
+      1,
+      5,
+      6,
     ])
     expect(arrayUnion([1, 1, 2, 2, 3], [2, 2, 3, 5, 6], [7, 8])).toEqual([
-      1, 2, 3, 5, 6, 7, 8,
+      1,
+      2,
+      3,
+      5,
+      6,
+      7,
+      8,
     ])
     expect(arrayMinus([1, 1, 2, 2, 3], [2, 2, 3, 5, 6])).toEqual([1])
   })
@@ -96,7 +104,16 @@ describe('array', () => {
 
   it('should create array', () => {
     expect(createArray(10, i => i + 2)).toEqual([
-      2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
     ])
     expect(createArray(3)).toEqual([undefined, undefined, undefined])
     expect(createArray(3, 'hello')).toEqual(['hello', 'hello', 'hello'])
diff --git a/src/common/data/basex.spec.ts b/src/common/data/basex.spec.ts
index 5ad6b103..adc73971 100644
--- a/src/common/data/basex.spec.ts
+++ b/src/common/data/basex.spec.ts
@@ -30,15 +30,43 @@ describe('baseX', () => {
     const { encode, decode } = useBase(62)
     expect(
       encode([
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
       ]),
     ).toBe('7n42DGM5Tflk9n8mt7Fhc7')
 
     expect(decode('7n42DGM5Tflk9n8mt7Fhc7')).toEqual(
       new Uint8Array([
-        0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-        0xFF, 0xFF, 0xFF, 0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
+        0xFF,
       ]),
     )
 
diff --git a/src/common/data/basex.ts b/src/common/data/basex.ts
index 5d727915..30953396 100644
--- a/src/common/data/basex.ts
+++ b/src/common/data/basex.ts
@@ -228,8 +228,7 @@ export function decodeBase32(s: string, padding = -1) {
     .replaceAll('l', '1')
     .replaceAll('s', '5')
     .replaceAll('o', '0')
-    .replaceAll('i', '1'),
-  padding)
+    .replaceAll('i', '1'), padding)
 }
 
 export function encodeBase16(bin: BinInput, padding = -1) {
diff --git a/src/common/data/day-legacy.ts b/src/common/data/day-legacy.ts
index 4b8cf826..7d69cfb9 100644
--- a/src/common/data/day-legacy.ts
+++ b/src/common/data/day-legacy.ts
@@ -195,7 +195,6 @@ export async function forEachDay(
     const result = handler(start)
     if (isPromise(result))
       await result
-
     start = start.dayOffset(+1)
   }
 }
diff --git a/src/common/data/day.spec.ts b/src/common/data/day.spec.ts
index 7f9f75eb..95c257a7 100644
--- a/src/common/data/day.spec.ts
+++ b/src/common/data/day.spec.ts
@@ -45,7 +45,7 @@ describe('days', () => {
 
   it('should iterate days', () => {
     const list: any = []
-    forEachDay(20101230, 20110102, x => list.push(x.toString()))
+    void forEachDay(20101230, 20110102, x => list.push(x.toString()))
     expect(list).toEqual([
       '2010-12-30',
       '2010-12-31',
@@ -54,7 +54,7 @@ describe('days', () => {
     ])
 
     const list2: any = []
-    forEachDay(19991030, 19991102, x => list2.push(x.toString()))
+    void forEachDay(19991030, 19991102, x => list2.push(x.toString()))
     expect(list2).toEqual([
       '1999-10-30',
       '1999-10-31',
diff --git a/src/common/data/json.ts b/src/common/data/json.ts
index 726da0d0..a5167c6c 100644
--- a/src/common/data/json.ts
+++ b/src/common/data/json.ts
@@ -73,7 +73,8 @@ export function jsonStringifySafe(
   return JSON.stringify(
     obj,
     serializer(replacer ?? undefined, cycleReplacer),
-    spaces ?? undefined)
+    spaces ?? undefined,
+  )
 }
 
 export const jsonStringify = jsonStringifySafe
diff --git a/src/common/data/object.spec.ts b/src/common/data/object.spec.ts
index a8cc8add..b96a9457 100644
--- a/src/common/data/object.spec.ts
+++ b/src/common/data/object.spec.ts
@@ -36,7 +36,7 @@ describe('object.spec', () => {
     const m = objectMergeDisposable(emitter, obj)
     expect(m.f()).toBe(42)
     m.on('a', () => x++)
-    m.emit('a')
+    void m.emit('a')
     expect(x).toBe(2)
     await m.dispose()
     expect(x).toBe(3)
diff --git a/src/common/dispose-defer.spec.ts b/src/common/dispose-defer.spec.ts
index 5321a818..92179ad2 100644
--- a/src/common/dispose-defer.spec.ts
+++ b/src/common/dispose-defer.spec.ts
@@ -72,7 +72,7 @@ describe('dispose', () => {
     const obj = new Some()
     expect(x).toBe(1)
 
-    obj.dispose()
+    void obj.dispose()
     expect(x).toBe(2)
   })
 
@@ -83,7 +83,7 @@ describe('dispose', () => {
     defer.add(() => stack.push('b'))
     defer.add(() => stack.push('c'))
     expect(stack).toEqual([])
-    defer(true)
+    void defer(true)
     expect(stack).toEqual(['c', 'b', 'a'])
   })
 
diff --git a/src/common/exec/pool.ts b/src/common/exec/pool.ts
index 197db3b2..7b6fee65 100644
--- a/src/common/exec/pool.ts
+++ b/src/common/exec/pool.ts
@@ -61,17 +61,17 @@ export interface PoolTask<T> {
 }
 
 export interface PoolTaskEvents {
-  didUpdate(
+  didUpdate: (
     max: number,
     resolved: number,
     presentMax: number,
     presentResolved: number
-  ): void
-  didStart(id: string): void
-  didCancel(id: string): void
-  didFinish(): void
-  didResolve(id: string, value: any): void
-  didReject(id: string, error: any): void
+  ) => void
+  didStart: (id: string) => void
+  didCancel: (id: string) => void
+  didFinish: () => void
+  didResolve: (id: string, value: any) => void
+  didReject: (id: string, error: any) => void
 }
 
 // todo: barrier
diff --git a/src/common/exec/progress.ts b/src/common/exec/progress.ts
index 10c76c99..e0fab38b 100644
--- a/src/common/exec/progress.ts
+++ b/src/common/exec/progress.ts
@@ -23,9 +23,9 @@ interface ProgressOptions {
  * - On `dispose` child removes itself from parent.
  */
 export class Progress extends Emitter<{
-  progressCancelled(progress: Progress): void
-  progressChanged(progress: Progress): void
-  progressDispose(progress: Progress): void
+  progressCancelled: (progress: Progress) => void
+  progressChanged: (progress: Progress) => void
+  progressDispose: (progress: Progress) => void
 }> {
   private _totalUnits: number
   private _completedUnits: number
diff --git a/src/common/exec/promise.ts b/src/common/exec/promise.ts
index 4c686173..d4644829 100644
--- a/src/common/exec/promise.ts
+++ b/src/common/exec/promise.ts
@@ -1,7 +1,4 @@
-// (C)opyright 2021-07-15 Dirk Holtwick, holtwick.it. All rights reserved.
-
 /* eslint-disable ts/no-use-before-define */
-/* eslint-disable no-async-promise-executor */
 
 /**
  * Promise to be used with `await`. Example:
@@ -46,7 +43,7 @@ export async function timeout<T>(
   milliSeconds: number,
   timeoutValue = 'timeoutReached',
 ): Promise<T | typeof timeoutValue> {
-  return new Promise(async (resolve, reject) => {
+  return new Promise((resolve, reject) => {
     let done = false
 
     const timeout = setTimeout(() => {
@@ -54,17 +51,17 @@ export async function timeout<T>(
       resolve(timeoutValue)
     }, milliSeconds)
 
-    try {
-      const result = await promise
-      clearTimeout(timeout)
-      if (!done)
-        resolve(result)
-    }
-    catch (err) {
-      clearTimeout(timeout)
-      if (!done)
-        reject(err)
-    }
+    promise
+      .then((result) => {
+        clearTimeout(timeout)
+        if (!done)
+          resolve(result)
+      })
+      .catch((err) => {
+        clearTimeout(timeout)
+        if (!done)
+          reject(err)
+      })
   })
 }
 
@@ -79,7 +76,7 @@ export async function tryTimeout<T>(
   if (milliSeconds <= 0)
     return await promise
 
-  return new Promise(async (resolve, reject) => {
+  return new Promise((resolve, reject) => {
     let done = false
 
     const timeout = setTimeout(() => {
@@ -87,17 +84,17 @@ export async function tryTimeout<T>(
       reject(new Error('Timeout reached'))
     }, milliSeconds)
 
-    try {
-      const result = await promise
-      clearTimeout(timeout)
-      if (!done)
-        resolve(result)
-    }
-    catch (err) {
-      clearTimeout(timeout)
-      if (!done)
-        reject(err)
-    }
+    promise
+      .then((result) => {
+        clearTimeout(timeout)
+        if (!done)
+          resolve(result)
+      })
+      .catch((err) => {
+        clearTimeout(timeout)
+        if (!done)
+          reject(err)
+      })
   })
 }
 
diff --git a/src/common/exec/queue.spec.ts b/src/common/exec/queue.spec.ts
index 3b6d2cd8..0bc1e73a 100644
--- a/src/common/exec/queue.spec.ts
+++ b/src/common/exec/queue.spec.ts
@@ -11,15 +11,15 @@ describe('queue', () => {
 
     const list: any = []
     const queue = new SerialQueue() // { logLevel })
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(100)
       list.push('a')
     })
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(200)
       list.push('b')
     })
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(1)
       list.push('c')
     })
@@ -32,15 +32,15 @@ describe('queue', () => {
 
     const list: any = []
 
-    ;(async () => {
+    void (async () => {
       await sleep(100)
       list.push('a')
     })()
-    ;(async () => {
+    void (async () => {
       await sleep(200)
       list.push('b')
     })()
-    ;(async () => {
+    void (async () => {
       await sleep(1)
       list.push('c')
     })()
@@ -55,7 +55,7 @@ describe('queue', () => {
 
     const list: any = []
     const queue = new SerialQueue() // { logLevel })
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(100)
       list.push('a')
     })
@@ -80,15 +80,15 @@ describe('queue', () => {
     const events: any = []
     queue.onAny((...args) => events.push(args))
 
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(100)
       list.push('a')
     })
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(200)
       list.push('b')
     })
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(1)
       list.push('c')
     })
@@ -153,15 +153,15 @@ describe('queue', () => {
 
     await queue.pause()
 
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(100)
       list.push('a')
     })
-    queue.enqueue(async () => {
+    void queue.enqueue(async () => {
       await sleep(200)
       list.push('b')
     })
-    queue
+    void queue
       .enqueue(async () => {
         await sleep(1)
         list.push('c')
diff --git a/src/common/exec/queue.ts b/src/common/exec/queue.ts
index 5f91b53e..085eb9ab 100644
--- a/src/common/exec/queue.ts
+++ b/src/common/exec/queue.ts
@@ -19,10 +19,10 @@ interface TaskInfo {
 }
 
 export interface TaskEvents {
-  didUpdate(max: number, resolved: number): void
-  didStart(max: number): void
-  didCancel(): void
-  didFinish(): void
+  didUpdate: (max: number, resolved: number) => void
+  didStart: (max: number) => void
+  didCancel: () => void
+  didFinish: () => void
   // didResolve(value: any): void
   // didReject(error: any): void
   // didPause(max: number): void
diff --git a/src/common/exec/throttle-debounce.spec.ts b/src/common/exec/throttle-debounce.spec.ts
index 53079e81..eb8972f2 100644
--- a/src/common/exec/throttle-debounce.spec.ts
+++ b/src/common/exec/throttle-debounce.spec.ts
@@ -99,13 +99,13 @@ describe('throttle', () => {
     )
 
     expect(r).toBe(0)
-    fn(1)
+    void fn(1)
     expect(r).toBe(0)
     await sleep(50)
     expect(r).toBe(0)
-    fn(2)
+    void fn(2)
     await sleep(150)
-    fn(3)
+    void fn(3)
     expect(r).toBe(0)
     await sleep(150)
     expect(r).toBe(1)
diff --git a/src/common/exec/throttle-debounce.ts b/src/common/exec/throttle-debounce.ts
index 11849046..ee5d1df1 100644
--- a/src/common/exec/throttle-debounce.ts
+++ b/src/common/exec/throttle-debounce.ts
@@ -176,6 +176,7 @@ export function debounce<F extends (...args: any[]) => any | Promise<any>>(
         if (lastArguments != null) {
           clearExistingTimeout()
           // log('exec trigger next')
+
           timeoutID = setTimeout(exec, delay)
         }
       }
@@ -188,6 +189,7 @@ export function debounce<F extends (...args: any[]) => any | Promise<any>>(
     clearExistingTimeout()
     // log('trigger')
     if (running === false)
+
       timeoutID = setTimeout(exec, delay)
   }
 
diff --git a/src/common/log/log-base.ts b/src/common/log/log-base.ts
index ea4cb62b..9de219f7 100644
--- a/src/common/log/log-base.ts
+++ b/src/common/log/log-base.ts
@@ -53,13 +53,13 @@ export interface LoggerInterface {
 
   level: LogLevel
 
-  debug(...messages: any[]): void
+  debug: (...messages: any[]) => void
 
-  info(...messages: any[]): void
+  info: (...messages: any[]) => void
 
-  warn(...messages: any[]): void
+  warn: (...messages: any[]) => void
 
-  error(...messages: any[]): void
+  error: (...messages: any[]) => void
 
   /**
    * Throws if condition is not truthy.
@@ -73,7 +73,7 @@ export interface LoggerInterface {
    *
    * Bug https://github.com/microsoft/TypeScript/issues/50363#issuecomment-1219811447
    */
-  assert(condition: unknown, ...messages: any[]): asserts condition
+  assert: (condition: unknown, ...messages: any[]) => asserts condition
 
   /**
    * Always throws.
@@ -87,9 +87,9 @@ export interface LoggerInterface {
    *
    * Bug https://github.com/microsoft/TypeScript/issues/50363#issuecomment-1219811447
    */
-  fatal(...messages: any[]): never
+  fatal: (...messages: any[]) => never
 
-  extend(prefix: string): LoggerInterface
+  extend: (prefix: string) => LoggerInterface
 
   factory?: LoggerContextInterface
 
@@ -99,20 +99,20 @@ export interface LoggerInterface {
 export interface LoggerContextInterface {
   (name?: string, level?: LogLevelAliasType): LoggerInterface
 
-  registerHandler(handler: LogHandler): void
+  registerHandler: (handler: LogHandler) => void
 
-  setFilter(namespaces: string): void
+  setFilter: (namespaces: string) => void
 
-  setHandlers(handlers?: (LogHandler | undefined | null)[]): void
+  setHandlers: (handlers?: (LogHandler | undefined | null)[]) => void
 
-  setLock(lock: boolean): void
+  setLock: (lock: boolean) => void
 
   /** When true emits a short log message for each Logger when being set up first time. */
-  setDebug(debug: boolean): void
+  setDebug: (debug: boolean) => void
 
-  setLogLevel(level?: LogLevel): void
+  setLogLevel: (level?: LogLevel) => void
 
-  setFactory(factory: (name?: string) => LoggerInterface): void
+  setFactory: (factory: (name?: string) => LoggerInterface) => void
 }
 
 export interface LogHandlerOptions {
diff --git a/src/common/log/log-context.ts b/src/common/log/log-context.ts
index 318fbf0b..f71fee78 100644
--- a/src/common/log/log-context.ts
+++ b/src/common/log/log-context.ts
@@ -1,5 +1,4 @@
-// (C)opyright 2021-07-15 Dirk Holtwick, holtwick.it. All rights reserved.
-
+import { isNotNull } from '../data/is'
 import type { LogHandler, LogLevel, LogLevelAliasType, LogMessage, LoggerContextInterface, LoggerInterface } from './log-base'
 import { LogLevelAll, LogLevelDebug, LogLevelError, LogLevelFatal, LogLevelInfo, LogLevelWarn } from './log-base'
 import { LoggerConsoleHandler } from './log-console'
@@ -101,13 +100,11 @@ export function LoggerContext(_prefix = ''): LoggerContextInterface {
 
   Logger.setDebug = (debug = true) => (logDebug = debug)
 
-  Logger.setHandlers = function (handlers: LogHandler[] = []) {
+  Logger.setHandlers = (handlers?: (LogHandler | undefined | null)[]) => {
     if (logFactory !== LoggerBaseFactory)
       logFactory = LoggerBaseFactory
-
-    if (logLock)
-      return
-    logHandlers = [...handlers].filter(h => typeof h === 'function')
+    if (handlers != null && !logLock)
+      logHandlers = [...handlers].filter(isNotNull)
   }
 
   Logger.level = LogLevelAll
diff --git a/src/common/msg/README.md b/src/common/msg/README.md
index a7274abf..c049557a 100644
--- a/src/common/msg/README.md
+++ b/src/common/msg/README.md
@@ -31,7 +31,7 @@ Same API as `Emitter` for easily sending event like messages via a `Channel`. It
 
 ```ts
 interface MyProtocol {
-  doSomething(using: string, count: number): void
+  doSomething: (using: string, count: number) => void
 }
 
 const hub = usePubSub<MyProtocol>({ channel })
@@ -67,8 +67,8 @@ Messages are defined via `interface`. Typescript checks for valid calls:
 
 ```ts
 interface MyMessages {
-  echo(data: any): Promise<any>
-  pong(data: any): Promise<void>
+  echo: (data: any) => Promise<any>
+  pong: (data: any) => Promise<void>
 }
 ```
 
diff --git a/src/common/msg/channel.ts b/src/common/msg/channel.ts
index 453f6a18..dea6b8c4 100644
--- a/src/common/msg/channel.ts
+++ b/src/common/msg/channel.ts
@@ -20,11 +20,11 @@ export interface ChannelMessageEvent {
  * https://deno.com/deploy/docs/runtime-broadcast-channel
  */
 export abstract class Channel extends Emitter<{
-  message(event: ChannelMessageEvent): void
-  messageerror(event: ChannelMessageEvent): void // optional
-  connect(): void // optional
-  disconnect(): void // optional
-  close(): void
+  message: (event: ChannelMessageEvent) => void
+  messageerror: (event: ChannelMessageEvent) => void // optional
+  connect: () => void // optional
+  disconnect: () => void // optional
+  close: () => void
 }> {
   id: string = uuid()
   abstract isConnected?: boolean
diff --git a/src/common/msg/emitter.spec.ts b/src/common/msg/emitter.spec.ts
index 4dc30376..33f7142d 100644
--- a/src/common/msg/emitter.spec.ts
+++ b/src/common/msg/emitter.spec.ts
@@ -10,8 +10,8 @@ const platform = detect()
 
 declare global {
   interface ZeedGlobalEmitter {
-    a(n: number): void
-    b(n: number): void
+    a: (n: number) => void
+    b: (n: number) => void
   }
 }
 
@@ -108,8 +108,8 @@ describe('emitter', () => {
     expect.assertions(4)
 
     interface TestMessages {
-      test(x: number, y: number): void
-      long(): Promise<void>
+      test: (x: number, y: number) => void
+      long: () => Promise<void>
     }
 
     let ctr = 0
@@ -140,8 +140,8 @@ describe('emitter', () => {
 
   it('should work', async () => {
     interface TestMessages {
-      a(): void
-      b(): void
+      a: () => void
+      b: () => void
     }
 
     const e1 = new Emitter<TestMessages>()
@@ -154,21 +154,21 @@ describe('emitter', () => {
     e2.on('a', () => counter--)
     e2.on('b', () => counter--)
 
-    e1.emit('a')
+    void e1.emit('a')
 
     expect(counter).toBe(100)
 
-    e2.emit('a')
-    e2.emit('b')
+    void e2.emit('a')
+    void e2.emit('b')
 
     expect(counter).toBe(98)
 
     e1.on('a', () => counter++)
-    e1.emit('a') // twice!
+    void e1.emit('a') // twice!
     expect(counter).toBe(100)
 
     e1.removeAllListeners()
-    e1.emit('a') // no listeners!
+    void e1.emit('a') // no listeners!
     expect(counter).toBe(100)
   })
 
@@ -178,7 +178,7 @@ describe('emitter', () => {
     const e1 = new Emitter()
 
     setTimeout(() => {
-      e1.emit('f', 1)
+      void e1.emit('f', 1)
     }, 100)
 
     const v = await waitOn(e1, 'f')
@@ -233,9 +233,9 @@ describe('emitter', () => {
 
     e.once('a', v => expect(v).toBe(1))
 
-    e.emit('a', 1)
-    e.emit('a', 2)
-    e.emit('a', 3)
+    void e.emit('a', 1)
+    void e.emit('a', 2)
+    void e.emit('a', 3)
   })
 
   it('should mock events', async () => {
diff --git a/src/common/msg/emitter.ts b/src/common/msg/emitter.ts
index b2a71410..671d3476 100644
--- a/src/common/msg/emitter.ts
+++ b/src/common/msg/emitter.ts
@@ -1,7 +1,4 @@
-// (C)opyright 2021-07-15 Dirk Holtwick, holtwick.it. All rights reserved.
-
 import type { DisposerFunction } from '../dispose-types'
-import { promisify } from '../exec/promise'
 import { getGlobalContext } from '../global'
 import { DefaultLogger } from '../log'
 
@@ -60,7 +57,7 @@ export class Emitter<
       if (subscribers.length > 0) {
         const all = subscribers.map(({ fn }) => {
           try {
-            return promisify(fn(...args))
+            return Promise.resolve(fn(...args))
           }
           catch (err) {
             this._logEmitter.warn('emit warning:', err)
@@ -120,7 +117,7 @@ export class Emitter<
   ): DisposerFunction {
     const onceListener = async (...args: any[]) => {
       this.off(event, onceListener as any)
-      return await promisify(listener(...args))
+      return await Promise.resolve(listener(...args))
     }
     this.on(event, onceListener as any)
     return () => {
diff --git a/src/common/msg/encoder.ts b/src/common/msg/encoder.ts
index 6de2ede6..ffb708af 100644
--- a/src/common/msg/encoder.ts
+++ b/src/common/msg/encoder.ts
@@ -2,8 +2,8 @@ import { decrypt, encrypt } from '../crypto'
 import { Uint8ArrayToJson, jsonToUint8Array } from '../data/bin'
 
 export interface Encoder {
-  encode(data: any): Promise<Uint8Array>
-  decode(data: Uint8Array): Promise<any>
+  encode: (data: any) => Promise<Uint8Array>
+  decode: (data: Uint8Array) => Promise<any>
 }
 
 export class NoopEncoder implements Encoder {
diff --git a/src/common/msg/messages.spec.ts b/src/common/msg/messages.spec.ts
index 965e5ed5..9ba5eafe 100644
--- a/src/common/msg/messages.spec.ts
+++ b/src/common/msg/messages.spec.ts
@@ -5,11 +5,11 @@ import type { MessageDefinitions } from './messages'
 import { useMessageHub } from './messages'
 
 interface TestMessages1 extends MessageDefinitions {
-  ping(value: number): Promise<number>
+  ping: (value: number) => Promise<number>
 }
 
 interface TestMessages2 extends MessageDefinitions {
-  aping(value: number | string): Promise<number | string>
+  aping: (value: number | string) => Promise<number | string>
 }
 
 // interface TestMessages2 {
diff --git a/src/common/msg/messages.ts b/src/common/msg/messages.ts
index f0bcf678..3ebc72ec 100644
--- a/src/common/msg/messages.ts
+++ b/src/common/msg/messages.ts
@@ -27,9 +27,9 @@ export interface MessagesOptions {
 }
 
 export interface MessagesDefaultMethods<L> {
-  dispose(): void
-  connect?(channel: Channel): void
-  options(opt: MessagesOptions): L
+  dispose: () => void
+  connect?: (channel: Channel) => void
+  options: (opt: MessagesOptions) => L
 }
 
 export type MessagesMethods<L> = L & MessagesDefaultMethods<L>
@@ -41,16 +41,14 @@ export type MessagesMethods<L> = L & MessagesDefaultMethods<L>
 export type MessageDefinitions = Record<any, (...args: any) => Promise<any>>
 
 export interface MessageHub {
-  dispose(): void
+  dispose: () => void
   connect: (newChannel: Channel) => void
-  listen<L extends MessageDefinitions>(newHandlers: L): void
-  send<L extends MessageDefinitions>(): MessagesMethods<L>
+  listen: <L extends MessageDefinitions>(newHandlers: L) => void
+  send: <L extends MessageDefinitions>() => MessagesMethods<L>
 }
 
 // The async proxy, waiting for a response
-export function createPromiseProxy<P extends object>(fn: (name: string, args: any[], opt: any) => Promise<unknown>,
-  opt: MessagesOptions,
-  predefinedMethods: any = {}): P {
+export function createPromiseProxy<P extends object>(fn: (name: string, args: any[], opt: any) => Promise<unknown>, opt: MessagesOptions, predefinedMethods: any = {}): P {
   return new Proxy<P>(predefinedMethods, {
     get: (target: any, name: any) => {
       if (name in target)
@@ -119,6 +117,7 @@ export function useMessageHub(
         }
       }
       if (queue.length > 0 && retryAfter > 0)
+
         queueRetryTimer = setTimeout(postNext, retryAfter)
     }
   }
@@ -131,7 +130,9 @@ export function useMessageHub(
 
   const connect = async (newChannel: Channel) => {
     channel = newChannel
+
     channel.on('connect', postNext)
+
     channel.on('message', async (msg: any) => {
       log('onmessage', typeof msg)
       const { name, args, id, result, error } = await encoder.decode(msg.data)
@@ -229,6 +230,7 @@ export function useMessageHub(
 
   return {
     dispose,
+
     connect,
     listen<L extends object>(newHandlers: L) {
       Object.assign(handlers, newHandlers)
diff --git a/src/common/msg/pubsub.spec.ts b/src/common/msg/pubsub.spec.ts
index 8c00d055..d975b69d 100644
--- a/src/common/msg/pubsub.spec.ts
+++ b/src/common/msg/pubsub.spec.ts
@@ -6,7 +6,7 @@ import { usePubSub } from './pubsub'
 // const log = Logger('test:connection')
 
 interface SampleProtocol {
-  bla(a: string, b: number): void
+  bla: (a: string, b: number) => void
 }
 
 describe('connection', () => {
diff --git a/src/common/msg/rpc.spec.ts b/src/common/msg/rpc.spec.ts
index db79639a..41a71969 100644
--- a/src/common/msg/rpc.spec.ts
+++ b/src/common/msg/rpc.spec.ts
@@ -41,6 +41,7 @@ describe('rpc', () => {
 
     const bob = useRPC<BobFunctions, AliceFunctions>(Bob, {
       post: data => channel.port1.postMessage(data),
+
       on: data => channel.port1.on('message', data),
       serialize,
       deserialize,
@@ -50,6 +51,7 @@ describe('rpc', () => {
       // mark bob's `bump` as an event without response
       eventNames: ['bump'],
       post: data => channel.port2.postMessage(data),
+
       on: data => channel.port2.on('message', data),
       serialize,
       deserialize,
@@ -77,6 +79,7 @@ describe('rpc', () => {
 
     const bobHub = useRPCHub({
       post: data => channel.port1.postMessage(data),
+
       on: data => channel.port1.on('message', data),
       serialize,
       deserialize,
@@ -88,6 +91,7 @@ describe('rpc', () => {
       // mark bob's `bump` as an event without response
       eventNames: ['bump'],
       post: data => channel.port2.postMessage(data),
+
       on: data => channel.port2.on('message', data),
       serialize,
       deserialize,
diff --git a/src/common/msg/rpc.ts b/src/common/msg/rpc.ts
index b55fd346..e8bb772d 100644
--- a/src/common/msg/rpc.ts
+++ b/src/common/msg/rpc.ts
@@ -11,7 +11,7 @@ export interface RPCOptionsBasic {
   /** Function to post raw message */
   post: (data: any) => void
   /** Listener to receive raw message */
-  on: (fn: (data: any) => void) => void
+  on: (fn: (data: any) => void | Promise<void>) => void
   /** Custom function to serialize data */
   serialize?: (data: any) => any
   /** Custom function to deserialize data */
@@ -31,7 +31,7 @@ export interface RPCFn<T> {
   /** Call the remote function and wait for the result. */
   (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>>
   /** Send event without asking for response */
-  asEvent(...args: ArgumentsType<T>): void
+  asEvent: (...args: ArgumentsType<T>) => void
 }
 
 export type RPCReturn<RemoteFunctions> = {
@@ -66,10 +66,7 @@ function setupRPCBasic(options: RPCOptionsBasic, functions: any, eventNames: str
     log,
   } = options
 
-  const rpcPromiseMap = new Map<
-    number,
-    { resolve: (...args: any) => any, reject: (...args: any) => any }
-  >()
+  const rpcPromiseMap = new Map<number, { resolve: (...args: any) => any, reject: (...args: any) => any }>()
 
   on(async (data) => {
     try {
diff --git a/src/common/pipes/index.ts b/src/common/pipes/index.ts
new file mode 100644
index 00000000..7f0f3935
--- /dev/null
+++ b/src/common/pipes/index.ts
@@ -0,0 +1,2 @@
+export * from './types'
+export * from './rpc'
diff --git a/src/common/pipes/rpc.spec.ts b/src/common/pipes/rpc.spec.ts
new file mode 100644
index 00000000..d60b5b9e
--- /dev/null
+++ b/src/common/pipes/rpc.spec.ts
@@ -0,0 +1,114 @@
+import { MessageChannel } from 'node:worker_threads'
+import { decodeJson, encodeJson } from '../bin'
+import { useRPCAsync, useRPCAsyncHub } from './rpc'
+
+let bobCount = 0
+
+const Bob = {
+  hi(name: string) {
+    return `Hi ${name}, I am Bob`
+  },
+  bump() {
+    bobCount += 1
+  },
+  getCount() {
+    return bobCount
+  },
+}
+
+const Alice = {
+  hello(name: string) {
+    return `Hello ${name}, my name is Alice`
+  },
+}
+
+type BobFunctions = typeof Bob
+type AliceFunctions = typeof Alice
+
+describe('rpc async', () => {
+  beforeEach(() => {
+    bobCount = 0
+  })
+
+  it('basic', async () => {
+    const channel = new MessageChannel()
+
+    // const serialize = (data: any) => JSON.stringify(data)
+    // const deserialize = (data: any) => JSON.parse(data)
+
+    const serialize = async (data: any) => encodeJson(data)
+    const deserialize = async (data: any) => decodeJson(data)
+
+    const bob = useRPCAsync<BobFunctions, AliceFunctions>(Bob, {
+      post: async data => channel.port1.postMessage(data),
+
+      on: data => channel.port1.on('message', data),
+      serialize,
+      deserialize,
+    })
+
+    const alice = useRPCAsync<AliceFunctions, BobFunctions>(Alice, {
+      // mark bob's `bump` as an event without response
+      eventNames: ['bump'],
+      post: async data => channel.port2.postMessage(data),
+
+      on: data => channel.port2.on('message', data),
+      serialize,
+      deserialize,
+    })
+
+    // RPCs
+    expect(await bob.hello('Bob')).toEqual('Hello Bob, my name is Alice')
+    expect(await alice.hi('Alice')).toEqual('Hi Alice, I am Bob')
+
+    // one-way event
+    expect(await alice.bump()).toBeUndefined()
+
+    expect(Bob.getCount()).toBe(0)
+    await new Promise(resolve => setTimeout(resolve, 100))
+    expect(Bob.getCount()).toBe(1)
+
+    channel.port1.close()
+    channel.port2.close()
+  })
+
+  it('hub', async () => {
+    const channel = new MessageChannel()
+    const serialize = async (data: any) => encodeJson(data)
+    const deserialize = async (data: any) => decodeJson(data)
+
+    const bobHub = useRPCAsyncHub({
+      post: async data => channel.port1.postMessage(data),
+
+      on: data => channel.port1.on('message', data),
+      serialize,
+      deserialize,
+    })
+
+    const bob = bobHub<BobFunctions, AliceFunctions>(Bob)
+
+    const alice = useRPCAsync<AliceFunctions, BobFunctions>(Alice, {
+      // mark bob's `bump` as an event without response
+      eventNames: ['bump'],
+      post: async data => channel.port2.postMessage(data),
+
+      on: data => channel.port2.on('message', data),
+      serialize,
+      deserialize,
+    })
+
+    // RPCs
+    expect(await bob.hello('Bob')).toEqual('Hello Bob, my name is Alice')
+    expect(await alice.hi('Alice')).toEqual('Hi Alice, I am Bob')
+
+    // one-way event
+    expect(await alice.bump()).toBeUndefined()
+
+    expect(Bob.getCount()).toBe(0)
+    await new Promise(resolve => setTimeout(resolve, 100))
+    expect(Bob.getCount()).toBe(1)
+
+    channel.port1.close()
+    channel.port2.close()
+  })
+})
diff --git a/src/common/pipes/rpc.ts b/src/common/pipes/rpc.ts
new file mode 100644
index 00000000..0831388a
--- /dev/null
+++ b/src/common/pipes/rpc.ts
@@ -0,0 +1,172 @@
+// From https://github.com/antfu/birpc/blob/main/src/index.ts MIT
+
+import { createPromise } from '..'
+import type { LoggerInterface } from '../log/log-base'
+import type { PipeAsync } from './types'
+
+export type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never
+export type ReturnType<T> = T extends (...args: any) => infer R ? R : never
+
+export interface RPCOptionsBasic extends PipeAsync {
+  /** No return values expected */
+  onlyEvents?: boolean
+  /** Custom logger */
+  log?: LoggerInterface
+}
+
+export interface RPCOptions<Remote> extends RPCOptionsBasic {
+  // /** No return values expected */
+  // onlyEvents?: boolean
+  /** Names of remote functions that do not need response. */
+  eventNames?: (keyof Remote)[]
+}
+
+export interface RPCFn<T> {
+  /** Call the remote function and wait for the result. */
+  (...args: ArgumentsType<T>): Promise<Awaited<ReturnType<T>>>
+  /** Send event without asking for response */
+  asEvent: (...args: ArgumentsType<T>) => void
+}
+
+export type RPCReturn<RemoteFunctions> = {
+  [K in keyof RemoteFunctions]: RPCFn<RemoteFunctions[K]>
+}
+
+let rpcCounter = 1
+
+enum RPCMode {
+  request = 1,
+  event = 2,
+  resolve = 3,
+  reject = 4,
+}
+
+type RPCMessage = [
+  RPCMode,
+  any, // args
+  number | undefined | null, // id
+  string | undefined | null, // method
+]
+
+const defaultSerialize = async (i: any) => i
+const defaultDeserialize = defaultSerialize
+
+function setupRPCBasic(options: RPCOptionsBasic, functions: any, eventNames: string[] = []) {
+  const {
+    post,
+    on,
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    log,
+  } = options
+
+  const rpcPromiseMap = new Map<number, { resolve: (...args: any) => any, reject: (...args: any) => any }>()
+
+  on(async (data) => {
+    try {
+      const msg = await deserialize(data) as RPCMessage
+      const [mode, args, id, method] = msg
+      if (mode === RPCMode.request || mode === RPCMode.event) {
+        let result, error: any
+        if (method != null) {
+          try {
+            const fn = functions[method] as Function
+            result = await fn(...args)
+          }
+          catch (e) {
+            error = String(e)
+          }
+        }
+        else {
+          error = 'Method implementation missing'
+        }
+        if (error)
+          log?.warn('error', msg, error)
+        if (mode === RPCMode.request && id) {
+          const data = await serialize(error
+            ? [RPCMode.reject, error, id]
+            : [RPCMode.resolve, result, id])
+          await post(data)
+        }
+      }
+      else if (id) {
+        const promise = rpcPromiseMap.get(id)
+        if (promise != null) {
+          if (mode === RPCMode.reject)
+            promise.reject(args)
+          else promise.resolve(args)
+        }
+        rpcPromiseMap.delete(id)
+      }
+    }
+    catch (err) {
+      log?.warn('Error on handling RPC data. Invalid?', err, data)
+    }
+  })
+
+  const proxyHandler = {
+    get(_: any, method: string) {
+      const sendEvent = async (...args: any[]) => {
+        await post(await serialize([RPCMode.event, args, null, method]))
+      }
+      if (options.onlyEvents || eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent
+        return sendEvent
+      }
+      const sendCall = async (...args: any[]) => {
+        const [promise, resolve, reject] = createPromise()
+        const id = rpcCounter++
+        rpcPromiseMap.set(id, { resolve, reject })
+        const data = await serialize([RPCMode.request, args, id, method])
+        await post(data)
+        return promise
+      }
+      sendCall.asEvent = sendEvent
+      return sendCall
+    },
+  }
+
+  return { post, serialize, rpcPromiseMap, proxyHandler }
+}
+
+export function useRPCAsync<LocalFunctions, RemoteFunctions = LocalFunctions>(
+  functions: LocalFunctions,
+  options: RPCOptions<RemoteFunctions>,
+): RPCReturn<RemoteFunctions> {
+  const { eventNames = [] } = options
+  const { proxyHandler } = setupRPCBasic(options, functions, eventNames as any)
+
+  return new Proxy({}, proxyHandler)
+}
+
+export function useRPCAsyncHub(options: RPCOptionsBasic) {
+  const eventNames: string[] = []
+  const functions: Record<string, any> = {}
+
+  const { proxyHandler } = setupRPCBasic(options, functions)
+
+  function createRPCProxy() {
+    return new Proxy({}, proxyHandler)
+  }
+
+  return function<LocalFunctions, RemoteFunctions = LocalFunctions>(
+    additionalFunctions?: LocalFunctions,
+    additionalEventNames: string[] = [],
+  ): RPCReturn<RemoteFunctions> {
+    Object.assign(functions, additionalFunctions ?? {})
+    // log(`Registered functions:\n${Object.keys(functions).join('\n')}`)
+    eventNames.push(...additionalEventNames)
+    return createRPCProxy()
+  }
+}
+
+export type UseRPCAsyncHubType = ReturnType<typeof useRPCAsyncHub>
+
+// Syntax test case
+// const hub: UseRPCHubType = {} as any
+// const x = hub({
+//   test(name: string): string {
+//     return name
+//   },
+// })
+// await x.test('dsd')
diff --git a/src/common/platform.spec.ts b/src/common/platform.spec.ts
index fb2dea52..9223fd35 100644
--- a/src/common/platform.spec.ts
+++ b/src/common/platform.spec.ts
@@ -13,9 +13,8 @@ describe('platform', () => {
       expect(platform.test).toBe(true)
       expect(platform.browser).toBe(false)
 
-      const isBrowser = new Function(
-        'try {return this===window;}catch(e){ return false;}',
-      )
+      // eslint-disable-next-line ts/no-implied-eval
+      const isBrowser = new Function('try {return this===window;}catch(e){ return false;}')
       expect(isBrowser()).toBe(false)
     }
     else {
@@ -23,9 +22,8 @@ describe('platform', () => {
       expect(platform.test).toBe(false)
       expect(platform.browser).toBe(true)
 
-      const isBrowser = new Function(
-        'try {return this===window;}catch(e){ return false;}',
-      )
+      // eslint-disable-next-line ts/no-implied-eval
+      const isBrowser = new Function('try {return this===window;}catch(e){ return false;}')
       expect(isBrowser()).toBe(true)
     }
   })
diff --git a/src/common/platform.ts b/src/common/platform.ts
index d973e9fd..f3f19a56 100644
--- a/src/common/platform.ts
+++ b/src/common/platform.ts
@@ -1,8 +1,6 @@
 /* eslint-disable no-restricted-globals */
 /* eslint-disable node/prefer-global/process */
 
-// (C)opyright 2021-07-15 Dirk Holtwick, holtwick.it. All rights reserved.
-
 export function getWindow(): any | undefined {
   if (typeof window !== 'undefined')
     return window
@@ -20,10 +18,11 @@ export function getGlobal(): any {
     ? self
     : typeof global !== 'undefined'
       ? global
-      // eslint-disable-next-line no-new-func
+      // eslint-disable-next-line no-new-func, ts/no-implied-eval
       : Function('return this;')()
 }
 
+/** @deprecated */
 export function detect(
   info = {
     ios: false,
@@ -58,20 +57,16 @@ export function detect(
 
   info.pwa = _navigator?.serviceWorker != null
 
-  info.pwaInstalled = _navigator?.standalone
-  || _window?.matchMedia?.('(display-mode: standalone)')?.matches
+  info.pwaInstalled = _navigator?.standalone || _window?.matchMedia?.('(display-mode: standalone)')?.matches
 
-  info.node
-    = typeof process !== 'undefined' && process?.release?.name === 'node'
+  info.node = typeof process !== 'undefined' && process?.release?.name === 'node'
   info.browser = !info.electron && !info.wkwebview && !info.node
 
   // info.worker = typeof importScripts === 'function'
-  info.worker
-    // @ts-expect-error xxx
-    = typeof WorkerGlobalScope !== 'undefined'
-    // @ts-expect-error xxx
-    && self instanceof WorkerGlobalScope
   // @ts-expect-error xxx
+  info.worker = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope
+  // @ts-expect-error xxx
+
   info.jest = typeof jest !== 'undefined' || typeof vitest !== 'undefined'
   info.test = info.jest
 
@@ -80,31 +75,16 @@ export function detect(
   info.appleNative = info.wkwebview
 
   // https://github.com/viljamis/feature.js/blob/master/feature.js#L203
-  info.touch
-    = (_window && 'ontouchstart' in _window)
-    || (_navigator?.maxTouchPoints || 0) > 1
-    || (_navigator?.msPointerEnabled && _window?.MSGesture)
-    // @ts-expect-error xxx
-    || (_window?.DocumentTouch && document instanceof DocumentTouch)
+  // @ts-expect-error xxx
+  info.touch = (_window && 'ontouchstart' in _window) || (_navigator?.maxTouchPoints || 0) > 1 || (_navigator?.msPointerEnabled && _window?.MSGesture) || (_window?.DocumentTouch && document instanceof DocumentTouch)
 
   return info
 }
 
-// https://stackoverflow.com/a/31090240/140927
-// export const isBrowser = new Function(
-//   "try {return this===window;}catch(e){ return false;}"
-// )
-
-// export const isNode = new Function(
-//   "try {return this===global;}catch(e){return false;}"
-// )
-
 export function isBrowser() {
   return typeof window !== 'undefined' && globalThis === window
 }
 
-// export const platform = detect()
-
 /**
  * Before closing the tab/window or quitting the node process
  * allow to do something important first
diff --git a/src/common/types.ts b/src/common/types.ts
index 356d80c3..bb1682ed 100644
--- a/src/common/types.ts
+++ b/src/common/types.ts
@@ -30,11 +30,11 @@ export type Json =
 // Implemented by MemStorage, LocalStorage, FileStorage
 // Similar to https://github.com/unjs/unstorage
 export interface ObjectStorage<T = any> {
-  setItem(key: string, value: T): void
-  getItem(key: string): T | undefined
-  removeItem(key: string): void
-  clear(): void
-  allKeys(): string[]
+  setItem: (key: string, value: T) => void
+  getItem: (key: string) => T | undefined
+  removeItem: (key: string) => void
+  clear: () => void
+  allKeys: () => string[]
 }
 
 // https://stackoverflow.com/a/68349501/140927
diff --git a/src/common/uuid.spec.ts b/src/common/uuid.spec.ts
index 4249410c..39a0874f 100644
--- a/src/common/uuid.spec.ts
+++ b/src/common/uuid.spec.ts
@@ -69,7 +69,22 @@ describe('uuid', () => {
 
     // Extract the date from the suid
     const dateSuid = new Uint8Array([
-      0, 0, 141, 33, 250, 205, 174, 58, 31, 221, 187, 156, 31, 221, 187, 156,
+      0,
+      0,
+      141,
+      33,
+      250,
+      205,
+      174,
+      58,
+      31,
+      221,
+      187,
+      156,
+      31,
+      221,
+      187,
+      156,
     ])
     expect(suidBytesDate(dateSuid)).toEqual(
       new Date('2020-10-10T22:10:14.349Z'),
@@ -83,7 +98,22 @@ describe('uuid', () => {
 
     expect(decode('000FcTTJiOtjzrDGJVhfoa', 16)).toEqual(
       new Uint8Array([
-        0, 0, 141, 33, 250, 205, 174, 58, 31, 221, 187, 156, 31, 221, 187, 156,
+        0,
+        0,
+        141,
+        33,
+        250,
+        205,
+        174,
+        58,
+        31,
+        221,
+        187,
+        156,
+        31,
+        221,
+        187,
+        156,
       ]),
     )
 
diff --git a/src/node/clipboard.ts b/src/node/clipboard.ts
index a5630791..ac22fb7f 100644
--- a/src/node/clipboard.ts
+++ b/src/node/clipboard.ts
@@ -9,5 +9,6 @@ export function pbcopy(data: string) {
         proc.stdin.write(data)
         proc.stdin.end()
       }).catch(() => {})
-    })
+    },
+  )
 }
diff --git a/tsconfig.json b/tsconfig.json
index 9ca8dfbe..f1162f93 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -25,13 +25,17 @@
   },
   "include": [
     "src/**/*.ts",
-    "tsup.config.ts",
-    "vitest-setup.ts"
+    "demos/**/*.ts",
+    "*.ts"
+    // "tsup.config.ts",
+    // "vitest-setup.ts",
+    // "vitest.config.ts"
   ],
   "exclude": [
     "_archive",
     "node_modules",
     "dist",
-    "docs"
+    "docs",
+    "*.md"
   ]
 }
diff --git a/vitest.config.ts b/vitest.config.ts
index 6fc8d24f..890def65 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -1,5 +1,6 @@
 /// <reference types="vitest" />
-import { resolve } from 'path'
+import { resolve } from 'node:path'
+import process from 'node:process'
 import { defineConfig } from 'vite'
 
 export default defineConfig({