add and format with prettier

eslint.config.js

···
-import { includeIgnoreFile } from '@eslint/compat'
+import {includeIgnoreFile} from '@eslint/compat'
 import js from '@eslint/js'
 import json from '@eslint/json'
 import restrictedGlobals from 'confusing-browser-globals'
-import tsdoc from 'eslint-plugin-tsdoc'
+import prettier from 'eslint-plugin-prettier/recommended'
 import react from 'eslint-plugin-react'
 import reactHooks from 'eslint-plugin-react-hooks'
+import tsdoc from 'eslint-plugin-tsdoc'
 import globals from 'globals'
+import path from 'node:path'
 import tseslint from 'typescript-eslint'
-import path from 'node:path'
 
 const gitignore = path.resolve(import.meta.dirname, '.gitignore')
 
···
   {
     name: 'javascript basics',
     files: ['**/*.@(js|jsx|ts|tsx)'],
-
-    plugins: {tsdoc},
     extends: [js.configs.recommended],
 
     languageOptions: {
···
     rules: {
       // eg, `open` is a global, but probably not really intended that way in our code
       'no-restricted-globals': ['error', ...restrictedGlobals],
-      'no-unused-vars': ['warn', { varsIgnorePattern: '(?:^_)' }],
-
-      'tsdoc/syntax': 'warn'
+      'no-unused-vars': ['warn', {varsIgnorePattern: '(?:^_)'}],
     },
   },
 
···
     name: 'typescript basics',
     files: ['**/*.@(ts|tsx)'],
     extends: [tseslint.configs.strictTypeChecked],
+    plugins: {tsdoc},
     languageOptions: {
       parserOptions: {
         projectService: true,
···
       },
     },
     rules: {
-      '@typescript-eslint/no-unused-vars': ['warn', { varsIgnorePattern: '(?:^_)' }],
+      '@typescript-eslint/no-unused-vars': ['warn', {varsIgnorePattern: '(?:^_)'}],
       '@typescript-eslint/no-unnecessary-condition': 'off',
       '@typescript-eslint/restrict-template-expressions': 'off',
-    }
+      'tsdoc/syntax': 'warn',
+    },
   },
 
   {
     name: 'node files',
-    files: [
-      'src/server/**/*.@(js|jsx|ts|tsx)',
-      'src/cmd/**/*.@(js|jsx|ts|tsx)'
-    ],
+    files: ['src/server/**/*.@(js|jsx|ts|tsx)', 'src/cmd/**/*.@(js|jsx|ts|tsx)'],
     languageOptions: {
       globals: {
         ...globals.es2024,
···
     // mostly cribbed from preact's config, but that's not setup to handle eslint9
     // https://github.com/preactjs/eslint-config-preact/blob/master/index.js
     name: 'client files',
-    files: [
-      'src/client/**/*.@(js|jsx|ts|tsx)',
-    ],
+    files: ['src/client/**/*.@(js|jsx|ts|tsx)'],
     languageOptions: {
       globals: {
         ...globals.es2024,
···
       // preact / jsx rules
       'react/no-deprecated': 2,
       'react/react-in-jsx-scope': 0, // handled this automatically
-      'react/display-name': [1, { ignoreTranspilerName: false }],
+      'react/display-name': [1, {ignoreTranspilerName: false}],
       'react/jsx-no-bind': [
         1,
         {
···
       'react/jsx-no-duplicate-props': 2,
       'react/jsx-no-target-blank': 2,
       'react/jsx-no-undef': 2,
-      'react/jsx-tag-spacing': [2, { beforeSelfClosing: 'always' }],
+      'react/jsx-tag-spacing': [2, {beforeSelfClosing: 'always'}],
       'react/jsx-uses-react': 1, // debatable
       'react/jsx-uses-vars': 2,
-      'react/jsx-key': [2, { checkFragmentShorthand: true }],
+      'react/jsx-key': [2, {checkFragmentShorthand: true}],
       'react/self-closing-comp': 2,
       'react/prefer-es6-class': 2,
       'react/prefer-stateless-function': 1,
···
     files: ['**/*.json'],
     ignores: ['package-lock.json'],
 
-    plugins: { json },
+    plugins: {json},
     language: 'json/json',
-    extends: [
-      json.configs.recommended
-    ],
+    extends: [json.configs.recommended],
   },
   {
     files: ['tsconfig.json'],
     language: 'json/jsonc',
   },
+
+  // prettier last, so it can turn everything off
+  prettier,
 )

jest.config.js

···
 import globToRegexp from 'glob-to-regexp'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
+import {fileURLToPath} from 'node:url'
 import gitignore from 'parse-gitignore'
 import * as tsjest from 'ts-jest'
 
···
   const __dirname = path.dirname(__filename)
   const ignorefile = path.resolve(__dirname, '.gitignore')
 
-  const { patterns } = gitignore(ignorefile)
-  return patterns
-    .map(p => globToRegexp(p, { globstar: true }).source)
+  const {patterns} = gitignore(ignorefile)
+  return patterns.map((p) => globToRegexp(p, {globstar: true}).source)
 }
 
 export default {
   testMatch: ['<rootDir>/src/**/*.spec.{ts,tsx}'],
-  testPathIgnorePatterns: [
-    ...gitignorePatterns(),
-  ],
+  testPathIgnorePatterns: [...gitignorePatterns()],
 
   cache: true,
   cacheDirectory: path.join(import.meta.dirname, '.jestcache'),
···
 
   // use ts-jest preset for esm support
   // but we have to tell it to look at jsx files too, not just tsx
-  ...(
-    tsjest.createJsWithTsEsmPreset()
-  ),
+  ...tsjest.createJsWithTsEsmPreset(),
 
   // if node_modules are ESM, we need to _include_ them from
-  transformIgnorePatterns: [
-    'node_modules/(?!(nanoid|jose|preact|@preact)/)',
-  ],
+  transformIgnorePatterns: ['node_modules/(?!(nanoid|jose|preact|@preact)/)'],
 
-  collectCoverageFrom: [
-    'src/**/*.{ts,tsx}',
-    '!src/**/*.spec.{ts,tsx}',
-    '!src/**/node_modules/**',
-  ],
+  collectCoverageFrom: ['src/**/*.{ts,tsx}', '!src/**/*.spec.{ts,tsx}', '!src/**/node_modules/**'],
 }

jest.setup.js

···
-import { expect } from '@jest/globals'
+import {expect} from '@jest/globals'
 
 // jest-dom matchers for better DOM assertions
 import '@testing-library/jest-dom'

jsdoc.json

···
     "dictionaries": ["jsdoc"]
   },
   "source": {
-    "include": [
-      "src"
-    ],
+    "include": ["src"],
     "includePattern": ".+\\.js(doc)?$",
     "excludePattern": "(^|\\/|\\\\)_"
   },
···
     "destination": "./docs/",
     "recurse": true
   },
-  "plugins": [
-    "plugins/markdown"
-  ],
+  "plugins": ["plugins/markdown"],
   "templates": {
     "referenceTitle": "skypod",
     "cleverLinks": true,

package-lock.json

···
         "@types/ws": "^8.18.1",
         "confusing-browser-globals": "^1.0.11",
         "eslint": "^9.28.0",
+        "eslint-config-prettier": "^10.1.5",
+        "eslint-plugin-prettier": "^5.5.0",
         "eslint-plugin-react": "^7.37.5",
         "eslint-plugin-react-hooks": "^5.2.0",
         "eslint-plugin-tsdoc": "^0.4.0",
···
         "jest-fixed-jsdom": "^0.0.9",
         "jsdom": "^26.1.0",
         "parse-gitignore": "^2.0.0",
+        "prettier": "^3.5.3",
+        "prettier-plugin-organize-imports": "^4.1.0",
         "tidy-jsdoc-fork": "github:lygaret/tidy-jsdoc",
         "ts-jest": "^29.4.0",
         "typescript": "^5.8.3",
···
         }
       }
     },
+    "node_modules/eslint-config-prettier": {
+      "version": "10.1.5",
+      "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.5.tgz",
+      "integrity": "sha512-zc1UmCpNltmVY34vuLRV61r1K27sWuX39E+uyUnY8xS2Bex88VV9cugG+UZbRSRGtGyFboj+D8JODyme1plMpw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "eslint-config-prettier": "bin/cli.js"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-config-prettier"
+      },
+      "peerDependencies": {
+        "eslint": ">=7.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-prettier": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.0.tgz",
+      "integrity": "sha512-8qsOYwkkGrahrgoUv76NZi23koqXOGiiEzXMrT8Q7VcYaUISR+5MorIUxfWqYXN0fN/31WbSrxCxFkVQ43wwrA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prettier-linter-helpers": "^1.0.0",
+        "synckit": "^0.11.7"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-plugin-prettier"
+      },
+      "peerDependencies": {
+        "@types/eslint": ">=8.0.0",
+        "eslint": ">=8.0.0",
+        "eslint-config-prettier": ">= 7.0.0 <10.0.0 || >=10.1.0",
+        "prettier": ">=3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/eslint": {
+          "optional": true
+        },
+        "eslint-config-prettier": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/eslint-plugin-react": {
       "version": "7.37.5",
       "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.37.5.tgz",
···
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
       "dev": true,
       "license": "MIT"
+    },
+    "node_modules/fast-diff": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz",
+      "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==",
+      "dev": true,
+      "license": "Apache-2.0"
     },
     "node_modules/fast-fifo": {
       "version": "1.3.2",
···
       "license": "MIT",
       "engines": {
         "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/prettier": {
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.3.tgz",
+      "integrity": "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/prettier-linter-helpers": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz",
+      "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-diff": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/prettier-plugin-organize-imports": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/prettier-plugin-organize-imports/-/prettier-plugin-organize-imports-4.1.0.tgz",
+      "integrity": "sha512-5aWRdCgv645xaa58X8lOxzZoiHAldAPChljr/MT0crXVOWTZ+Svl4hIWlz+niYSlO6ikE5UXkN1JrRvIP2ut0A==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "prettier": ">=2.0",
+        "typescript": ">=2.9",
+        "vue-tsc": "^2.1.0"
+      },
+      "peerDependenciesMeta": {
+        "vue-tsc": {
+          "optional": true
+        }
       }
     },
     "node_modules/pretty-format": {

package.json

···
     "@types/ws": "^8.18.1",
     "confusing-browser-globals": "^1.0.11",
     "eslint": "^9.28.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.5.0",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-tsdoc": "^0.4.0",
···
     "jest-fixed-jsdom": "^0.0.9",
     "jsdom": "^26.1.0",
     "parse-gitignore": "^2.0.0",
+    "prettier": "^3.5.3",
+    "prettier-plugin-organize-imports": "^4.1.0",
     "tidy-jsdoc-fork": "github:lygaret/tidy-jsdoc",
     "ts-jest": "^29.4.0",
     "typescript": "^5.8.3",

prettier.config.js

···
+/**
+ * @see https://prettier.io/docs/configuration
+ * @type {import("prettier").Config}
+ */
+export default {
+  printWidth: 100,
+  tabWidth: 2,
+  semi: false,
+  singleQuote: true,
+  trailingComma: 'all',
+  bracketSpacing: false,
+
+  plugins: ['prettier-plugin-organize-imports'],
+}

src/client/components/messenger.tsx

···
-import { RealmConnection } from '#client/realm/connection.js'
-import { IdentID } from '#common/protocol'
-import { useState, useEffect, useCallback } from 'preact/hooks'
+import {RealmConnection} from '#client/realm/connection.js'
+import {IdentID} from '#common/protocol'
+import {useCallback, useEffect, useState} from 'preact/hooks'
 
 export type MessengerProps = {
   realmConnection: RealmConnection
 }
 
-export const Messenger: preact.FunctionComponent<{ webrtcManager: RealmConnection }> = (props) => {
-  const { webrtcManager } = props
+export const Messenger: preact.FunctionComponent<{webrtcManager: RealmConnection}> = (props) => {
+  const {webrtcManager} = props
   const [messages, setMessages] = useState<[IdentID, string][]>([])
 
-  const peerdata = useCallback((event: CustomEvent<{ remoteId: IdentID, data: unknown }>) => {
-    setMessages([...messages, [event.detail.remoteId, `${event.detail.data}`]])
-  }, [messages])
+  const peerdata = useCallback(
+    (event: CustomEvent<{remoteId: IdentID; data: unknown}>) => {
+      setMessages([...messages, [event.detail.remoteId, `${event.detail.data}`]])
+    },
+    [messages],
+  )
 
   const sendMessage = useCallback(() => {
-    webrtcManager.broadcast('what\'s up friends?')
+    webrtcManager.broadcast("what's up friends?")
   }, [webrtcManager])
 
   useEffect(() => {
     if (!webrtcManager) return
 
-    webrtcManager.addEventListener('peerdata', peerdata as ((event: Event) => void))
+    webrtcManager.addEventListener('peerdata', peerdata as (event: Event) => void)
     return () => {
-      webrtcManager.removeEventListener('peerdata', peerdata as ((event: Event) => void))
+      webrtcManager.removeEventListener('peerdata', peerdata as (event: Event) => void)
     }
   }, [webrtcManager, peerdata])
 
   return (
     <div className="messages-list">
       <h3>Realm Messages</h3>
-      <pre>
-        { JSON.stringify(messages, null, 2) }
-      </pre>
+      <pre>{JSON.stringify(messages, null, 2)}</pre>
       <div>
         <textarea />
         <button onClick={sendMessage}>Send</button>

src/client/components/peer-list.tsx

···
-import { useState, useEffect } from 'preact/hooks'
+import {useEffect, useState} from 'preact/hooks'
 
-import { PeerState, RealmConnection } from '#client/realm/connection'
-import { IdentID } from '#common/protocol'
+import {PeerState, RealmConnection} from '#client/realm/connection'
+import {IdentID} from '#common/protocol'
 
-export const PeerList: preact.FunctionComponent<{ webrtcManager: RealmConnection }> = (props) => {
-  const { webrtcManager } = props
+export const PeerList: preact.FunctionComponent<{webrtcManager: RealmConnection}> = (props) => {
+  const {webrtcManager} = props
   const [peers, setPeers] = useState<Record<IdentID, PeerState>>({})
 
   useEffect(() => {
···
   return (
     <div className="peer-list">
       <h3>Realm Members</h3>
-      {
-        Object.keys(peers).length === 0
-          ? <p>No other peers connected</p>
-          : (
-              <ul>
-                {Object.entries(peers).map(([peerId, state]) => (
-                  <li key={peerId} className={`peer-item`}>
-                    <span className="peer-id">{peerId}</span>
-                    <ConnectionStatus state={state} />
-                  </li>
-                ))}
-              </ul>
-            )
-      }
+      {Object.keys(peers).length === 0 ? (
+        <p>No other peers connected</p>
+      ) : (
+        <ul>
+          {Object.entries(peers).map(([peerId, state]) => (
+            <li key={peerId} className={`peer-item`}>
+              <span className="peer-id">{peerId}</span>
+              <ConnectionStatus state={state} />
+            </li>
+          ))}
+        </ul>
+      )}
     </div>
   )
 }
 
-function ConnectionStatus({ state }: { state: PeerState }): preact.JSX.Element {
+function ConnectionStatus({state}: {state: PeerState}): preact.JSX.Element {
   const getStatusIcon = () => {
     if (state.connected) return '🟢'
     if (state.destroyed) return '🔴'
···
     <div className="connection-status">
       <span className="status-icon">{getStatusIcon()}</span>
       <code className="initiator">
-        {state.address.family}
-        -
-        {state.address.address}
-        :
-        {state.address.port}
+        {state.address.family}-{state.address.address}:{state.address.port}
       </code>
     </div>
   )

src/client/index.tsx

···
-import { render } from 'preact'
+import {render} from 'preact'
 
-import { App } from './page-app'
 import './index.css'
+import {App} from './page-app'
 
 const root = document.getElementById('app')
-if (root == null)
-  throw new TypeError('root isn\'t present?')
+if (root == null) throw new TypeError("root isn't present?")
 
 render(<App />, root)

src/client/page-app.tsx

···
-import { RealmConnectionProvider } from './realm/context'
-import { WebRTCDemo } from './webrtc-demo'
+import {RealmConnectionProvider} from './realm/context'
+import {WebRTCDemo} from './webrtc-demo'
 
 export const App: preact.FunctionComponent = () => {
   return (

src/client/realm/connection.ts

···
-import { nanoid } from 'nanoid'
-import SimplePeer from 'simple-peer'
 import WebSocket from 'isomorphic-ws'
-import { z } from 'zod/v4'
+import {nanoid} from 'nanoid'
+import SimplePeer from 'simple-peer'
+import {z} from 'zod/v4'
 
-import { generateSignableJwt, jwkExport } from '#common/crypto/jwks'
-import { normalizeError, normalizeProtocolError, ProtocolError } from '#common/errors'
-import { IdentID, parseJson, PreauthRegisterMessage, RealmBroadcastMessage, realmFromServerMessageSchema, RealmID, RealmRtcPeerWelcomeMessage, realmRtcPeerWelcomeMessageSchema, RealmRtcSignalMessage } from '#common/protocol'
-import { sendSocket, streamSocketJson, takeSocketJson } from '#common/socket'
+import {generateSignableJwt, jwkExport} from '#common/crypto/jwks'
+import {normalizeError, normalizeProtocolError, ProtocolError} from '#common/errors'
+import {
+  IdentID,
+  parseJson,
+  PreauthRegisterMessage,
+  RealmBroadcastMessage,
+  realmFromServerMessageSchema,
+  RealmID,
+  RealmRtcPeerWelcomeMessage,
+  realmRtcPeerWelcomeMessageSchema,
+  RealmRtcSignalMessage,
+} from '#common/protocol'
+import {sendSocket, streamSocketJson, takeSocketJson} from '#common/socket'
 
 /** the state of a specific peer */
 export interface PeerState {
-
   /** true if the peer connection is active */
   connected: boolean
 
···
 
   /** the peer's address */
   address: ReturnType<SimplePeer.Instance['address']>
-
 }
 
 export interface RealmIdentity {
···
 
 /** A connection manager */
 export class RealmConnection extends EventTarget {
-
   #url: string
   #identity: RealmIdentity
 
···
   }
 
   #handleSocketOpen: WebSocket['onopen'] = async () => {
-    if (this.#socket == undefined)
-      throw new Error('socket open handler called with no socket?')
+    if (this.#socket == undefined) throw new Error('socket open handler called with no socket?')
 
     try {
       console.debug('realm connection, socket loop open')
···
 
       const pubkey = await jwkExport.parseAsync(this.#identity.keypair.publicKey)
       this.#socket.send(
-        await this.#signJwt({ msg: 'preauth.register', pubkey } as PreauthRegisterMessage),
+        await this.#signJwt({msg: 'preauth.register', pubkey} as PreauthRegisterMessage),
       )
 
       // the next message should be a welcome message
···
       let welcome: RealmRtcPeerWelcomeMessage
       try {
         welcome = await takeSocketJson(this.#socket, realmRtcPeerWelcomeMessageSchema)
-      }
-      catch (exc) {
+      } catch (exc) {
         const err = normalizeError(exc)
-        throw new ProtocolError('failure on authentication', 401, { cause: err })
+        throw new ProtocolError('failure on authentication', 401, {cause: err})
       }
 
-      this.#dispatchCustomEvent('wsauth', { welcome })
+      this.#dispatchCustomEvent('wsauth', {welcome})
 
       // we initiate connections outbound when starting up
       // we never initiate connections to other peers otherwise
···
 
         // not a known rtc specific message, so we don't capture it
         if (!parse.success) {
-          this.#dispatchCustomEvent('wsdata', { data })
+          this.#dispatchCustomEvent('wsdata', {data})
           continue
         }
 
···
         switch (parse.data.msg) {
           case 'realm.rtc.peer-joined':
             // new peers connect to us, we don't connect to them
-            this.#dispatchCustomEvent('peerjoined', { identid: parse.data.identid })
+            this.#dispatchCustomEvent('peerjoined', {identid: parse.data.identid})
             continue
 
           case 'realm.rtc.peer-left':
             // peer is gone, disconnect
             this.disconnectPeer(parse.data.identid)
-            this.#dispatchCustomEvent('peerleft', { identid: parse.data.identid })
+            this.#dispatchCustomEvent('peerleft', {identid: parse.data.identid})
             continue
 
           case 'realm.rtc.signal': {
···
           }
         }
       }
-    }
-    catch (exc) {
+    } catch (exc) {
       const err = normalizeProtocolError(exc)
 
       console.error('realm connection, socket loop error', err)
-      this.#dispatchCustomEvent('wserror', { error: err })
-    }
-    finally {
+      this.#dispatchCustomEvent('wserror', {error: err})
+    } finally {
       console.debug('realm connection, socket loop ended')
       this.destroy()
     }
   }
 
   #handleSocketError: WebSocket['onerror'] = (exc) => {
-    this.#dispatchCustomEvent('wserror', { error: normalizeProtocolError(exc) })
+    this.#dispatchCustomEvent('wserror', {error: normalizeProtocolError(exc)})
     this.destroy()
   }
 
···
   destroy() {
     console.debug('realm connection #destroy!')
 
-    if (this.connected)
-      this.#socket.close()
+    if (this.connected) this.#socket.close()
 
-    for (const peer of this.#peers.values())
-      peer.destroy()
+    for (const peer of this.#peers.values()) peer.destroy()
 
     this.#peers.clear()
     this.#nonces.clear()
   }
 
   #dispatchCustomEvent(type: string, detail?: object) {
-    this.dispatchEvent(new CustomEvent(type, { detail }))
+    this.dispatchEvent(new CustomEvent(type, {detail}))
   }
 
   /** generates and signs a JWT scoped to this identity/realm containing the given payload */
···
       return peer
     }
 
-    peer = new RealmConnectionPeer(
-      this,
-      nanoid(),
-      this.#identity.identid,
-      remoteid,
-      initiator,
-    )
+    peer = new RealmConnectionPeer(this, nanoid(), this.#identity.identid, remoteid, initiator)
 
     peer.on('connect', () => {
       console.log(`connected to ${remoteid}`)
 
-      this.#dispatchCustomEvent('peeropen', { remoteid })
+      this.#dispatchCustomEvent('peeropen', {remoteid})
     })
 
     peer.on('close', () => {
···
 
       this.#peers.delete(remoteid)
       this.#nonces.delete(remoteid)
-      this.#dispatchCustomEvent('peerclose', { remoteid })
+      this.#dispatchCustomEvent('peerclose', {remoteid})
     })
 
     peer.on('error', (err) => {
       console.error(`Error with peer ${remoteid}:`, err)
 
-      this.#dispatchCustomEvent('peererror', { remoteid, error: err })
+      this.#dispatchCustomEvent('peererror', {remoteid, error: err})
     })
 
     peer.on('message', (data: unknown) => {
-      this.#dispatchCustomEvent('peerdata', { remoteid, data })
+      this.#dispatchCustomEvent('peerdata', {remoteid, data})
     })
 
     this.#peers.set(remoteid, peer)
···
     const peer = this.#peers.get(identid)
     if (peer && peer.connected) {
       peer.send(JSON.stringify(data))
-    }
-    else {
+    } else {
       throw new Error(`Not connected to peer: ${identid}`)
     }
   }
···
 
     return states
   }
-
 }
 
-const peerPingSchema = z.object({ type: z.literal('ping'), timestamp: z.number() })
+const peerPingSchema = z.object({type: z.literal('ping'), timestamp: z.number()})
 
 /**
  * a peer belonging to the connection manager
  */
 export class RealmConnectionPeer extends SimplePeer {
-
   #connection: RealmConnection
 
   initiator: boolean
···
   remoteid: IdentID
   nonce: string
 
-  constructor(connection: RealmConnection, nonce: string, localid: IdentID, remoteid: IdentID, initiator: boolean) {
+  constructor(
+    connection: RealmConnection,
+    nonce: string,
+    localid: IdentID,
+    remoteid: IdentID,
+    initiator: boolean,
+  ) {
     super({
       initiator,
       config: {
         iceServers: [
-          { urls: 'stun:stun.l.google.com:19302' },
-          { urls: 'stun:stun1.l.google.com:19302' },
+          {urls: 'stun:stun.l.google.com:19302'},
+          {urls: 'stun:stun1.l.google.com:19302'},
         ],
       },
     })
···
   }
 
   #handlePeerSignal = (e: SimplePeer.SignalData) => {
-    this.#connection.sendToServer(
-      {
-        msg: 'realm.rtc.signal',
-        initiator: this.initiator,
-        sender: this.localid,
-        recipient: this.remoteid,
-        payload: JSON.stringify(e),
-      } satisfies RealmRtcSignalMessage,
-    )
+    this.#connection.sendToServer({
+      msg: 'realm.rtc.signal',
+      initiator: this.initiator,
+      sender: this.localid,
+      recipient: this.remoteid,
+      payload: JSON.stringify(e),
+    } satisfies RealmRtcSignalMessage)
   }
 
   #handlePeerData = (chunk: string) => {
     try {
       const ping = parseJson.pipe(peerPingSchema).safeParse(chunk)
       if (ping.success) {
-        this.send(
-          JSON.stringify({ type: 'pong', timestamp: ping.data.timestamp }),
-        )
-      }
-      else {
+        this.send(JSON.stringify({type: 'pong', timestamp: ping.data.timestamp}))
+      } else {
         this.emit('message', chunk)
       }
-    }
-    catch (err) {
+    } catch (err) {
       console.error('Failed to parse message:', err)
     }
   }
-
 }

src/client/realm/context.tsx

···
-import { createContext } from 'preact'
-import { useCallback, useEffect, useState } from 'preact/hooks'
+import {createContext} from 'preact'
+import {useCallback, useEffect, useState} from 'preact/hooks'
 
-import { RealmConnection, RealmIdentity } from '#client/realm/connection.js'
+import {RealmConnection, RealmIdentity} from '#client/realm/connection.js'
 
 interface RealmConnectionContext {
   realm?: RealmConnection
···
   url: string
   children: preact.ComponentChildren
 }> = (props) => {
-
-  const [identity$, setIdentity$]     = useState<RealmIdentity>()
+  const [identity$, setIdentity$] = useState<RealmIdentity>()
   const [connection$, setConnection$] = useState<RealmConnection>()
 
   const connect = useCallback(() => {
     if (connection$) return
     if (!identity$) return
 
-    setConnection$(
-      new RealmConnection(props.url, identity$)
-    )
+    setConnection$(new RealmConnection(props.url, identity$))
   }, [connection$, identity$, props.url])
 
   const disconnect = useCallback(() => {

src/client/webrtc-demo.css

···
 .system-message .from {
   font-weight: bold;
   margin: 0 5px;
-}
+}

src/client/webrtc-demo.tsx

···
-import { useEffect, useContext, useCallback } from 'preact/hooks'
+import {useCallback, useContext, useEffect} from 'preact/hooks'
 
-import { RealmConnectionContext } from '#client/realm/context'
-import { PeerList } from '#client/components/peer-list'
+import {Messenger} from '#client/components/messenger'
+import {PeerList} from '#client/components/peer-list'
+import {RealmConnectionContext} from '#client/realm/context'
 
+import {generateSigningJwkPair} from '#common/crypto/jwks'
 import * as protocol from '#common/protocol'
-import { generateSigningJwkPair } from '#common/crypto/jwks'
-import { Messenger } from './components/messenger'
-import { Callback } from '#common/types.js'
+import {Callback} from '#common/types.js'
 
-function attachEventListener<CB extends Callback>(target: EventTarget, name: string, listener: CB): CB {
+function attachEventListener<CB extends Callback>(
+  target: EventTarget,
+  name: string,
+  listener: CB,
+): CB {
   target.addEventListener(name, listener)
   return listener
 }
 
 export const WebRTCDemo: preact.FunctionComponent = () => {
   const context = useContext(RealmConnectionContext)
-  if (!context)
-    throw new Error('expected to be called inside realm connection context!')
+  if (!context) throw new Error('expected to be called inside realm connection context!')
 
   useEffect(() => {
     if (!context.realm) return
···
       const identid = protocol.IdentBrand.generate()
       const keypair = await generateSigningJwkPair()
 
-      context.setIdentity({ realmid, identid, keypair })
+      context.setIdentity({realmid, identid, keypair})
     }
 
     go().catch((e: unknown) => {
···
     <div className="webrtc-demo">
       <h1>WebRTC Demo</h1>
 
-      <button onClick={connect}>
-        Connect
-      </button>
+      <button onClick={connect}>Connect</button>
 
       <div>
         Identity:
-        <pre>{ JSON.stringify(context.identity, null, 2) }</pre>
+        <pre>{JSON.stringify(context.identity, null, 2)}</pre>
       </div>
 
       <div className="connection-info">
···
           {context.realm?.connected ? '🟢 Connected' : '🔴 Disconnected'}
         </p>
         <pre>
-          <code>
-            { JSON.stringify(context.realm, null, 2) }
-          </code>
+          <code>{JSON.stringify(context.realm, null, 2)}</code>
         </pre>
       </div>
 
-      { context.realm && (
+      {context.realm && (
         <div className="demo-layout">
           <div className="demo-section">
             <PeerList webrtcManager={context.realm} />

src/cmd/register-ident.ts

···
 #!/usr/bin/env node
 
-import { generateSignableJwt, generateSigningJwkPair, jwkExport } from '#common/crypto/jwks'
-import { IdentBrand, RealmBrand } from '#common/protocol'
+import {generateSignableJwt, generateSigningJwkPair, jwkExport} from '#common/crypto/jwks'
+import {IdentBrand, RealmBrand} from '#common/protocol'
 
 async function generateRegistrationJWT(realm?: string) {
   const keypair = await generateSigningJwkPair()

src/cmd/server.ts

···
-import { dirname, join } from 'path'
-import { fileURLToPath } from 'url'
-import { parseArgs } from 'util'
+import {dirname, join} from 'path'
+import {fileURLToPath} from 'url'
+import {parseArgs} from 'util'
 
-import { buildServer } from '#server/index'
+import {buildServer} from '#server/index'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
···
 const args = parseArgs({
   args: process.argv.slice(2),
   options: {
-    port: { type: 'string', default: '3001' },
-    host: { type: 'string', default: '127.0.0.1' },
+    port: {type: 'string', default: '3001'},
+    host: {type: 'string', default: '127.0.0.1'},
   },
 })
 

src/common/async/aborts.ts

···
   }
 
   controller.signal.addEventListener('abort', cancel)
-  return { signal: controller.signal, cancel }
+  return {signal: controller.signal, cancel}
 }
 
 /**
···
     }
 
     signal.addEventListener('abort', handler)
-    cleanups.push(() => { signal.removeEventListener('abort', handler); })
+    cleanups.push(() => {
+      signal.removeEventListener('abort', handler)
+    })
   }
 
   controller.signal.addEventListener('abort', () => {
-    cleanups.forEach(cb => { cb(); })
+    cleanups.forEach((cb) => {
+      cb()
+    })
   })
 
   return controller.signal

src/common/async/blocking-atom.ts

···
-import { Semaphore } from './semaphore.js'
+import {Semaphore} from './semaphore.js'
 
 /**
  * simple blocking atom, for waiting for a value.
  * cribbed mostly from {@link https://github.com/ComFreek/async-playground}
  */
 export class BlockingAtom<T> {
-
   #item: T | undefined
   #sema: Semaphore
 
···
 
     signal?.throwIfAborted()
   }
-
 }

src/common/async/blocking-queue.ts

···
-import { Semaphore } from './semaphore.js'
+import {Semaphore} from './semaphore.js'
 
 /**
  * simple blocking queue, for turning streams into async pulls.
  * cribbed mostly from {@link https://github.com/ComFreek/async-playground}
  */
 export class BlockingQueue<T> {
-
   #sema: Semaphore
   #maxsize?: number
   #items: T[]
···
 
   #poll() {
     const item = this.#items.length > 0 && this.#items.shift()
-    if (item)
-      return item
+    if (item) return item
 
     throw Error('no elements')
   }
-
 }

src/common/async/semaphore.ts

···
  * cribbed mostly from {@link https://github.com/ComFreek/async-playground}
  */
 export class Semaphore {
-
   #counter: number = 0
-  #resolvers: Array<((taken: boolean) => void)> = []
+  #resolvers: Array<(taken: boolean) => void> = []
 
   constructor(count = 0) {
     this.#counter = count
···
    */
   take(signal?: AbortSignal): Promise<boolean> {
     return new Promise((resolve) => {
-      if (signal?.aborted) { resolve(false); return; }
+      if (signal?.aborted) {
+        resolve(false)
+        return
+      }
 
       // if there's resources available, use them
 
       this.#counter--
-      if (this.#counter >= 0) { resolve(true); return; }
+      if (this.#counter >= 0) {
+        resolve(true)
+        return
+      }
 
       // otherwise add to pending
       // and explicitly remove the resolver from the list on abort
···
     if (this.#resolvers.length > 0) {
       const resolver = this.#resolvers.shift()
       if (resolver)
-        queueMicrotask(() => { resolver(true); })
+        queueMicrotask(() => {
+          resolver(true)
+        })
     }
   }
-
 }

src/common/async/sleep.ts

···
 
   // not sure why this error is coming up
   // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  const { resolve, reject, promise } = Promise.withResolvers<void>()
+  const {resolve, reject, promise} = Promise.withResolvers<void>()
   const timeout = setTimeout(resolve, ms)
 
-  if (!signal)
-    return promise
+  if (!signal) return promise
 
   const abortHandler = () => {
     clearTimeout(timeout)

src/common/breaker.ts

···
-import { Callback } from "#common/types"
+import {Callback} from '#common/types'
 
 /**
  * A Breaker, which allows creating wrapped functions which will only be executed before
···
  * ```
  */
 export class Breaker {
-
   #tripped: boolean
   #onTripped?: () => void
 
···
       }
     }) as CB
   }
-
 }

src/common/crypto/cipher.ts

···
-import { base64url } from 'jose'
-import { nanoid } from 'nanoid'
+import {base64url} from 'jose'
+import {nanoid} from 'nanoid'
 
-const encrAlgo = { name: 'AES-GCM', length: 256 }
-const deriveAlgo = { name: 'PBKDF2', hash: 'SHA-256' }
+const encrAlgo = {name: 'AES-GCM', length: 256}
+const deriveAlgo = {name: 'PBKDF2', hash: 'SHA-256'}
 
 function orRandom(s: string): string {
   return s ?? nanoid(10)
···
 function asUint8Array(s: string | Uint8Array): Uint8Array {
   if (s instanceof Uint8Array) {
     return s
-  }
-  else if (typeof s === 'string') {
+  } else if (typeof s === 'string') {
     return new TextEncoder().encode(s)
   }
 
···
  * @param iterations - number of iterations for pbkdf
  * @returns the derived crypto key
  */
-async function deriveKey(passwordStr: string, saltStr: string, nonceStr: string, iterations: number = 100000): Promise<CryptoKey> {
+async function deriveKey(
+  passwordStr: string,
+  saltStr: string,
+  nonceStr: string,
+  iterations: number = 100000,
+): Promise<CryptoKey> {
   const encoder = new TextEncoder()
 
   const password = encoder.encode(`${passwordStr}-pass-cryptosystem`)
···
   const derivedsalt = new Uint8Array([...salt, ...nonce])
 
   return await crypto.subtle.deriveKey(
-    { ...deriveAlgo, salt: derivedsalt, iterations },
+    {...deriveAlgo, salt: derivedsalt, iterations},
     derivedkey,
     encrAlgo,
     false,
···
  * another HMAC.
  */
 export class Cipher {
-
   /**
    * creates a cipher with key derivation.
    *
···
    * @param data - the data to encrypte
    * @returns a url-safe base64 encoded encrypted string.
    */
-  async encrypt(data: (string | Uint8Array)): Promise<string> {
+  async encrypt(data: string | Uint8Array): Promise<string> {
     const iv = crypto.getRandomValues(new Uint8Array(12))
     const encoded = asUint8Array(data)
-    const encrypted = await crypto.subtle.encrypt({ ...encrAlgo, iv }, this.#cryptokey, encoded)
+    const encrypted = await crypto.subtle.encrypt({...encrAlgo, iv}, this.#cryptokey, encoded)
 
     // output = [iv + encrypted] which gives us the auth tag
 
···
     // Extract IV and encrypted data (which includes auth tag)
     const iv = combined.slice(0, 12)
     const encrypted = combined.slice(12)
-    return await crypto.subtle.decrypt({ ...encrAlgo, iv }, this.#cryptokey, encrypted)
+    return await crypto.subtle.decrypt({...encrAlgo, iv}, this.#cryptokey, encrypted)
   }
-
 }

src/common/crypto/errors.ts

···
-import { BaseError, BaseErrorOpts } from '#common/errors.js'
+import {BaseError, BaseErrorOpts} from '#common/errors.js'
 
 /** Common base class for errors in the crypto module */
 export class CryptoError extends BaseError {}
 
 /** Thrown when failing to verify a JWT signature */
 export class JWTBadSignatureError extends CryptoError {
-
   constructor(options?: BaseErrorOpts) {
     super('could not verify token signature', options)
   }
-
 }

src/common/crypto/jwks.ts

···
 import * as jose from 'jose'
-import { z } from 'zod/v4'
-import { CryptoError } from './errors.js'
+import {z} from 'zod/v4'
+import {CryptoError} from './errors.js'
 
-const subtleSignAlgo = { name: 'ECDSA', namedCurve: 'P-256' }
-const joseSignAlgo = { name: 'ES256' }
+const subtleSignAlgo = {name: 'ECDSA', namedCurve: 'P-256'}
+const joseSignAlgo = {name: 'ES256'}
 
 const jwkEcPublicSchema = z.object({
   kty: z.literal('EC'),
···
  * @see https://www.rfc-editor.org/rfc/rfc7517
  * @see https://github.com/panva/jose/blob/main/src/types.d.ts#L2
  */
-export const jwkSchema: z.ZodType<jose.JWK> = z.union([
-  jwkEcPublicSchema,
-  jwkEcPrivateSchema,
-])
+export const jwkSchema: z.ZodType<jose.JWK> = z.union([jwkEcPublicSchema, jwkEcPrivateSchema])
 
 /**
  * zod transform from JWK to CryptoKey
···
         message: 'symmetric keys unsupported',
         input: val,
       })
-    }
-    else {
+    } else {
       ctx.issues.push({
         code: 'custom',
         message: 'not a valid JWK object',
         input: val,
       })
     }
-  }
-  catch (e) {
+  } catch (e) {
     ctx.issues.push({
       code: 'custom',
       message: `could not import JWK object: ${e}`,
···
       message: 'non-extractable key!',
       input: val,
     })
-  }
-  catch (e) {
+  } catch (e) {
     ctx.issues.push({
       code: 'custom',
       message: `could not export JWK object: ${e}`,
···
  */
 export async function generateSigningJwkPair(): Promise<CryptoKeyPair> {
   const pair = await crypto.subtle.generateKey(subtleSignAlgo, true, ['sign', 'verify'])
-  if (!('publicKey' in pair))
-    throw new CryptoError('keypair returned a single key!?')
+  if (!('publicKey' in pair)) throw new CryptoError('keypair returned a single key!?')
 
   return pair
 }
···
  * @returns a properly configured jwt signer, with the payload provided
  */
 export function generateSignableJwt(payload: jose.JWTPayload): jose.SignJWT {
-  return new jose.SignJWT(payload)
-    .setProtectedHeader({ alg: joseSignAlgo.name })
+  return new jose.SignJWT(payload).setProtectedHeader({alg: joseSignAlgo.name})
 }

src/common/crypto/jwts.ts

···
+import {JWTBadSignatureError} from '#common/crypto/errors'
+import {normalizeError} from '#common/errors'
 import * as jose from 'jose'
-import { z } from 'zod/v4'
-import { JWTBadSignatureError } from '#common/crypto/errors'
-import { normalizeError } from '#common/errors'
+import {z} from 'zod/v4'
 
-const signAlgo = { name: 'ES256' }
+const signAlgo = {name: 'ES256'}
 
 interface JWTToken {
   token: string
···
  * schema describing a decoded JWT.
  * **important** - this does no claims validation, only decoding from string to JWT!
  */
-export const jwtSchema: z.ZodType<JWTToken, string> = z.jwt({ abort: true }).transform((token, ctx) => {
-  try {
-    const claims = jose.decodeJwt(token)
-    return { claims, token }
-  }
-  catch (e) {
-    ctx.issues.push({
-      code: 'custom',
-      message: `error while decoding token: ${e}`,
-      input: token,
-    })
+export const jwtSchema: z.ZodType<JWTToken, string> = z
+  .jwt({abort: true})
+  .transform((token, ctx) => {
+    try {
+      const claims = jose.decodeJwt(token)
+      return {claims, token}
+    } catch (e) {
+      ctx.issues.push({
+        code: 'custom',
+        message: `error while decoding token: ${e}`,
+        input: token,
+      })
 
-    return z.NEVER
-  }
-})
+      return z.NEVER
+    }
+  })
 
 /**
  * schema describing a verified payload in a JWT.
  * **important** - this does no claims validation, only decoding from string to JWT!
  */
 export const jwtPayload = <T>(schema: z.ZodType<T>): z.ZodType<JWTTokenPayload<T>> => {
-  const parser = z.looseObject({ payload: schema })
+  const parser = z.looseObject({payload: schema})
 
   return jwtSchema.transform(async (payload, ctx) => {
     const result = await parser.safeParseAsync(payload.claims)
-    if (result.success)
-      return { ...payload, payload: result.data.payload }
+    if (result.success) return {...payload, payload: result.data.payload}
 
     result.error.issues.forEach((iss) => {
       ctx.issues.push(iss)
···
  * @returns a verified payload
  * @throws if the signature is not valid
  */
-export async function verifyJwtToken(jwt: string, pubkey: CryptoKey, options: VerifyOpts = {}): Promise<jose.JWTPayload> {
+export async function verifyJwtToken(
+  jwt: string,
+  pubkey: CryptoKey,
+  options: VerifyOpts = {},
+): Promise<jose.JWTPayload> {
   try {
     const result = await jose.jwtVerify(jwt, pubkey, {
       algorithms: [signAlgo.name],
···
     })
 
     return result.payload
-  }
-  catch (exc) {
+  } catch (exc) {
     const err = normalizeError(exc)
-    throw new JWTBadSignatureError({ cause: err })
+    throw new JWTBadSignatureError({cause: err})
   }
 }
 

src/common/errors.spec.ts

···
-import { describe, it, expect } from '@jest/globals'
+import {describe, expect, it} from '@jest/globals'
 
-import {
-  ProtocolError,
-  isProtocolError,
-  normalizeProtocolError,
-} from '#common/errors'
+import {ProtocolError, isProtocolError, normalizeProtocolError} from '#common/errors'
 
 describe('isProtocolError', () => {
   it('identifies protocol errors', () => {

src/common/errors.ts

···
-import { prettifyError, ZodError } from 'zod/v4'
+import {prettifyError, ZodError} from 'zod/v4'
 
 const StatusCodes: Record<number, string> = {
   400: 'Bad Request',
···
  * only difference is that we explicitly type cause to be Error
  */
 export class BaseError extends Error {
-
   /** the cause of the error */
   declare cause?: Error
 
   constructor(message: string, options?: BaseErrorOpts) {
     super(message, options)
-    if (options?.cause)
-      this.cause = normalizeError(options.cause)
+    if (options?.cause) this.cause = normalizeError(options.cause)
   }
-
 }
 
 /** Common base class for Websocket Errors */
 export class ProtocolError extends BaseError {
-
   /** the HTTP status code representing this error */
   status: number
 
···
     this.name = this.constructor.name
     this.status = status
   }
-
 }
 
 /** Check if an error is a protocol error with optional status check */
 export function isProtocolError(e: Error, status?: number): e is ProtocolError {
-  return (e instanceof ProtocolError && (status === undefined || e.status == status))
+  return e instanceof ProtocolError && (status === undefined || e.status == status)
 }
 
 /**
···
  * passes through input that is already protocol errors.
  */
 export function normalizeProtocolError(cause: unknown): ProtocolError {
-  if (cause instanceof ProtocolError)
-    return cause
+  if (cause instanceof ProtocolError) return cause
 
-  if (cause instanceof ZodError)
-    return new ProtocolError(prettifyError(cause), 400, { cause })
+  if (cause instanceof ZodError) return new ProtocolError(prettifyError(cause), 400, {cause})
 
   if (cause instanceof Error || cause instanceof DOMException) {
-    if (cause.name === 'TimeoutError')
-      return new ProtocolError('operation timed out', 408, { cause })
+    if (cause.name === 'TimeoutError') return new ProtocolError('operation timed out', 408, {cause})
 
-    if (cause.name === 'AbortError')
-      return new ProtocolError('operation was aborted', 499, { cause })
+    if (cause.name === 'AbortError') return new ProtocolError('operation was aborted', 499, {cause})
 
-    return new ProtocolError(cause.message, 500, { cause })
+    return new ProtocolError(cause.message, 500, {cause})
   }
 
   // fallback, unknown
-  const options = cause == undefined ? undefined : { cause: normalizeError(cause) }
+  const options = cause == undefined ? undefined : {cause: normalizeError(cause)}
   return new ProtocolError(`Error! ${cause}`, 500, options)
 }
 
···
  * passes through input that is already an Error object.
  */
 export function normalizeError(failure: unknown): Error {
-  if (failure instanceof Error)
-    return failure
+  if (failure instanceof Error) return failure
 
   return new NormalizedError(`unnormalized failure ${failure}`)
 }

src/common/protocol.ts

···
 export * from './protocol/messages-preauth'
 export * from './protocol/messages-realm'
 
-import { z } from 'zod/v4'
+import {z} from 'zod/v4'
 
 /** A zod transformer for parsing json */
-export const parseJson: z.ZodTransform<unknown, string> = z.transform(
-  (input, ctx) => {
-    try {
-      return JSON.parse(input) as unknown
-    }
-    catch {
-      ctx.issues.push({
-        code: 'custom',
-        input,
-        message: 'input could not be parsed as JSON',
-      })
+export const parseJson: z.ZodTransform<unknown, string> = z.transform((input, ctx) => {
+  try {
+    return JSON.parse(input) as unknown
+  } catch {
+    ctx.issues.push({
+      code: 'custom',
+      input,
+      message: 'input could not be parsed as JSON',
+    })
 
-      return z.NEVER
-    }
+    return z.NEVER
   }
-)
+})

src/common/protocol/brands.ts

···
-import { Brand } from '#common/schema/brand'
+import {Brand} from '#common/schema/brand'
 
 const ident = Symbol('ident')
 export const IdentBrand = new Brand<typeof ident>(ident, 'ident')

src/common/protocol/messages-preauth.ts

···
-import { z } from 'zod/v4'
-import { jwkSchema } from '#common/crypto/jwks'
+import {jwkSchema} from '#common/crypto/jwks'
+import {z} from 'zod/v4'
 
 /** zod schema for `preauth.authn` message */
 export const preauthRegisterMessageSchema = z.object({

src/common/protocol/messages-realm.ts

···
-import { z } from 'zod/v4'
+import {z} from 'zod/v4'
 
-import { IdentBrand } from './brands'
-import { responseOkSchema } from './messages'
+import {IdentBrand} from './brands'
+import {responseOkSchema} from './messages'
 
 /**
  * zod schema for `realm.broadcast` message
···
 export const realmBroadcastMessageSchema = z.object({
   msg: z.literal('realm.broadcast'),
   payload: z.any(),
-  recipients: z.union([
-    z.boolean(),
-    z.array(IdentBrand.schema),
-  ]).default(false),
+  recipients: z.union([z.boolean(), z.array(IdentBrand.schema)]).default(false),
 })
 
 export type RealmBroadcastMessage = z.infer<typeof realmBroadcastMessageSchema>

src/common/protocol/messages.ts

···
-import { z } from 'zod/v4'
+import {z} from 'zod/v4'
 
 /** zod schema for `ok` message */
 export const responseOkSchema = z.object({

src/common/schema/brand.ts

···
-import { nanoid } from 'nanoid'
-import { z } from 'zod/v4'
+import {nanoid} from 'nanoid'
+import {z} from 'zod/v4'
 
-export type Branded<T, B> = T & { __brand: B }
+export type Branded<T, B> = T & {__brand: B}
 
 /**
  * A brand creates identifiers that are typesafe by construction,
  * and shouldn't be able to be passed to the wrong resource type.
  */
 export class Brand<B extends symbol> {
-
   #prefix: string
   #length: number
   #schema
···
   }
 
   /** @returns a boolean if the string is valid */
-  validate(input: string): input is Branded<string, B>  {
+  validate(input: string): input is Branded<string, B> {
     return input != null && typeof input === 'string' && this.#schema.safeParse(input).success
   }
-
 }

src/common/socket.ts

···
-import WebSocket, { ErrorEvent, MessageEvent } from 'isomorphic-ws'
+import WebSocket, {ErrorEvent, MessageEvent} from 'isomorphic-ws'
 
-import { combineSignals } from '#common/async/aborts'
-import { BlockingAtom } from '#common/async/blocking-atom'
-import { BlockingQueue } from '#common/async/blocking-queue'
-import { Breaker } from '#common/breaker'
-import { normalizeError, ProtocolError } from '#common/errors'
-import { z } from 'zod/v4'
+import {combineSignals} from '#common/async/aborts'
+import {BlockingAtom} from '#common/async/blocking-atom'
+import {BlockingQueue} from '#common/async/blocking-queue'
+import {Breaker} from '#common/breaker'
+import {normalizeError, ProtocolError} from '#common/errors'
+import {z} from 'zod/v4'
 
-import { parseJson } from './protocol.js'
+import {parseJson} from './protocol.js'
 
 /** Send some data in JSON format down the wire. */
 export function sendSocket(ws: WebSocket, data: unknown): void {
···
   const error = new AbortController()
   const multisignal = combineSignals(error.signal, signal)
 
-  const onMessage = breaker.tripThen((m: MessageEvent) => { atom.set(m.data); })
-  const onError = breaker.tripThen((e: unknown) => { error.abort(e); })
-  const onClose = breaker.tripThen(() => { error.abort('closed'); })
+  const onMessage = breaker.tripThen((m: MessageEvent) => {
+    atom.set(m.data)
+  })
+  const onError = breaker.tripThen((e: unknown) => {
+    error.abort(e)
+  })
+  const onClose = breaker.tripThen(() => {
+    error.abort('closed')
+  })
 
   try {
     ws.addEventListener('message', onMessage)
···
     const data = await atom.get(multisignal)
     if (!data) {
       const cause = normalizeError(multisignal.reason)
-      throw new ProtocolError('socket read aborted', 408, { cause })
+      throw new ProtocolError('socket read aborted', 408, {cause})
     }
 
     return data
-  }
-  finally {
+  } finally {
     ws.removeEventListener('message', onMessage)
     ws.removeEventListener('error', onError)
     ws.removeEventListener('close', onClose)
···
  * @param signal - an abort signal to cancel the block
  * @returns the message off the socket
  */
-export async function takeSocketJson<T>(ws: WebSocket, schema: z.ZodType<T>, signal?: AbortSignal): Promise<T> {
+export async function takeSocketJson<T>(
+  ws: WebSocket,
+  schema: z.ZodType<T>,
+  signal?: AbortSignal,
+): Promise<T> {
   const data = await takeSocket(ws, signal)
   return parseJson.pipe(schema).parseAsync(data)
 }
···
 /** stream configuration options */
 
 interface ConfigProps {
-    maxDepth: number
-    signal?: AbortSignal
+  maxDepth: number
+  signal?: AbortSignal
 }
 
 export const STREAM_CONFIG_DEFAULT: ConfigProps = {
-  maxDepth: 1000
+  maxDepth: 1000,
 }
 
 // symbols for iteration protocol
 
 const yield$ = Symbol('yield$')
 const error$ = Symbol('error$')
-const end$   = Symbol('end$')
+const end$ = Symbol('end$')
 
-type StreamYield =
-  | [typeof yield$, unknown]
-  | [typeof error$, Error]
-  | [typeof end$]
+type StreamYield = [typeof yield$, unknown] | [typeof error$, Error] | [typeof end$]
 
 /**
  * Given a websocket, stream messages off the socket as an async generator.
···
  * ```
  */
 export async function* streamSocket(ws: WebSocket, config_?: Partial<ConfigProps>) {
-  const { signal, ...config } = { ...STREAM_CONFIG_DEFAULT, ...(config_ || {}) }
+  const {signal, ...config} = {...STREAM_CONFIG_DEFAULT, ...(config_ || {})}
   signal?.throwIfAborted()
 
   // await incoming messages without blocking
···
           return
       }
     }
-  }
-  finally {
+  } finally {
     ws.removeEventListener('message', onMessage)
     ws.removeEventListener('error', onError)
     ws.removeEventListener('close', onClose)
···
  * exactly stream socket, but will additionally apply a json decoding
  * messages not validating will end the stream with an error
  */
-export async function* streamSocketJson(ws: WebSocket, config?: Partial<ConfigProps>): AsyncGenerator {
+export async function* streamSocketJson(
+  ws: WebSocket,
+  config?: Partial<ConfigProps>,
+): AsyncGenerator {
   for await (const message of streamSocket(ws, config)) {
     yield parseJson.parseAsync(message)
   }

src/common/strict-map.ts

···
 /** A map with methods to ensure key presence and safe update. */
 export class StrictMap<K, V> extends Map<K, V> {
-
   /**
    * Get a value from the map, throwing if missing
    * @throws Error if the key is not present in the map
···
 
     if (next === undefined) {
       this.delete(key)
-    }
-    else {
+    } else {
       this.set(key, next)
     }
   }
-
 }

src/common/types.ts

···
-import { NEVER } from 'zod/v4'
+import {NEVER} from 'zod/v4'
 
 /** A callback function, with arbitrary arguments; use `Parameters` to extract them. */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

src/server/index.ts

···
 import express from 'express'
 import * as http from 'http'
 
-import { WebSocketServer } from 'ws'
+import {WebSocketServer} from 'ws'
 
-import { apiRouter } from './routes-api/middleware'
-import { socketHandler } from './routes-socket/handler'
-import { makeStaticMiddleware, makeSpaMiddleware } from './routes-static'
-import { notFoundHandler } from './routes-error'
+import {apiRouter} from './routes-api/middleware'
+import {notFoundHandler} from './routes-error'
+import {socketHandler} from './routes-socket/handler'
+import {makeSpaMiddleware, makeStaticMiddleware} from './routes-static'
 
 /**
  * configures an http server which hosts the SPA and websocket endpoint
···
   app.use('/api', apiRouter)
 
   // Static file serving
-  app.use(makeStaticMiddleware({ root, index: 'index.html' }))
-  app.use(makeSpaMiddleware({ root, index: 'index.html' }))
+  app.use(makeStaticMiddleware({root, index: 'index.html'}))
+  app.use(makeSpaMiddleware({root, index: 'index.html'}))
 
   // 404 handler
   app.use(notFoundHandler)
 
   // WebSocket handling
-  const wss = new WebSocketServer({ server, path: '/stream' })
+  const wss = new WebSocketServer({server, path: '/stream'})
   wss.on('connection', (ws) => {
     socketHandler(ws)
-      .catch((e: unknown) => { console.error('uncaught error from websocket', e) })
-      .finally(() => { console.log('socket handler complete') })
+      .catch((e: unknown) => {
+        console.error('uncaught error from websocket', e)
+      })
+      .finally(() => {
+        console.log('socket handler complete')
+      })
   })
 
   return server

src/server/routes-api/middleware.ts

···
-import { Router } from 'express'
+import {Router} from 'express'
 
 export const apiRouter = Router()
 

src/server/routes-socket/handler-preauth.ts

···
 import WebSocket from 'isomorphic-ws'
 
-import { combineSignals, timeoutSignal } from '#common/async/aborts'
-import { jwkImport } from '#common/crypto/jwks'
-import { jwtPayload, verifyJwtToken } from '#common/crypto/jwts'
-import { normalizeError, ProtocolError } from '#common/errors'
-import { IdentBrand, IdentID, preauthMessageSchema, RealmBrand, RealmID } from '#common/protocol'
-import { takeSocket } from '#common/socket'
+import {combineSignals, timeoutSignal} from '#common/async/aborts'
+import {jwkImport} from '#common/crypto/jwks'
+import {jwtPayload, verifyJwtToken} from '#common/crypto/jwts'
+import {normalizeError, ProtocolError} from '#common/errors'
+import {IdentBrand, IdentID, preauthMessageSchema, RealmBrand, RealmID} from '#common/protocol'
+import {takeSocket} from '#common/socket'
 
 import * as realms from './state'
 
···
  * - if the realm does not exist (by realm id), we create a new one, and add the identity (success).
  * - if the realm /does/ exist, we verify the message is a signed JWT our already registered pubkey.
  */
-export async function preauthHandler(ws: WebSocket, signal?: AbortSignal): Promise<realms.AuthenticatedIdentity> {
+export async function preauthHandler(
+  ws: WebSocket,
+  signal?: AbortSignal,
+): Promise<realms.AuthenticatedIdentity> {
   const timeout = timeoutSignal(3000)
   const combinedSignal = combineSignals(signal, timeout.signal)
 
···
     }
 
     return await authenticatePreauth(realmid, identid, jwt.token)
-  }
-  finally {
+  } finally {
     timeout.cancel()
   }
 }
 
-async function authenticatePreauth(realmid: RealmID, identid: IdentID, token: string): Promise<realms.AuthenticatedIdentity> {
+async function authenticatePreauth(
+  realmid: RealmID,
+  identid: IdentID,
+  token: string,
+): Promise<realms.AuthenticatedIdentity> {
   try {
     const realm = realms.realmMap.require(realmid)
     const pubkey = realm.identities.require(identid)
···
     // at this point we no langer care about the payload
     // but this throws as a side-effect if the token is invalid
     await verifyJwtToken(token, pubkey)
-    return { realmid, realm, identid, pubkey }
-  }
-  catch (exc) {
+    return {realmid, realm, identid, pubkey}
+  } catch (exc) {
     const err = normalizeError(exc)
-    throw new ProtocolError('jwt verification failed', 401, { cause: err })
+    throw new ProtocolError('jwt verification failed', 401, {cause: err})
   }
 }

src/server/routes-socket/handler-realm.ts

···
-import { WebSocket } from 'isomorphic-ws'
+import {WebSocket} from 'isomorphic-ws'
 
-import { normalizeProtocolError, ProtocolError } from '#common/errors'
-import { sendSocket, streamSocket } from '#common/socket.js'
+import {normalizeProtocolError, ProtocolError} from '#common/errors'
 import * as protocol from '#common/protocol'
+import {sendSocket, streamSocket} from '#common/socket.js'
 import * as realm from '#server/routes-socket/state'
 
 /**
  * ance we've retrieved authentication details, we go into the main realm loop.
  * read messages as they come in and dispatch actions.
  */
-export async function realmHandler(ws: WebSocket, auth: realm.AuthenticatedIdentity, signal?: AbortSignal) {
+export async function realmHandler(
+  ws: WebSocket,
+  auth: realm.AuthenticatedIdentity,
+  signal?: AbortSignal,
+) {
   realmBroadcast(auth, buildRtcPeerJoined(auth))
   sendSocket(ws, buildRtcPeerWelcome(auth))
 
-  const parser = protocol.parseJson
-    .pipe(protocol.realmToServerMessageSchema)
+  const parser = protocol.parseJson.pipe(protocol.realmToServerMessageSchema)
 
   try {
-    for await (const data of streamSocket(ws, { signal })) {
+    for await (const data of streamSocket(ws, {signal})) {
       try {
         const msg = await parser.parseAsync(data)
         switch (msg.msg) {
···
             console.error('unknown message!', msg)
             throw new ProtocolError(`unknown message type!`, 400)
         }
-      }
-      catch (exc) {
+      } catch (exc) {
         const error = normalizeProtocolError(exc)
-        if (error.status >= 500)
-          throw error
+        if (error.status >= 500) throw error
 
         if (ws.readyState === ws.OPEN) {
           sendSocket(ws, buildRealmError(error))
         }
       }
     }
-  }
-  finally {
+  } finally {
     console.log('client left!', auth)
     realmBroadcast(auth, buildRtcPeerLeft(auth))
   }
 }
 
-function buildRtcPeerWelcome(auth: realm.AuthenticatedIdentity): protocol.RealmRtcPeerWelcomeMessage {
+function buildRtcPeerWelcome(
+  auth: realm.AuthenticatedIdentity,
+): protocol.RealmRtcPeerWelcomeMessage {
   return {
     ok: true,
     msg: 'realm.rtc.peer-welcome',
···
  *   when false, send to the whole realm, excluding self
  *   when an array of recipients, send to those recipients explicitly
  */
-function realmBroadcast(auth: realm.AuthenticatedIdentity, payload: unknown, recipients: protocol.IdentID[] | boolean = false) {
+function realmBroadcast(
+  auth: realm.AuthenticatedIdentity,
+  payload: unknown,
+  recipients: protocol.IdentID[] | boolean = false,
+) {
   const echo = recipients === true || Array.isArray(recipients)
   const recips = Array.isArray(recipients) ? recipients : Array.from(auth.realm.identities.keys())
 

src/server/routes-socket/handler.ts

···
-import { format } from 'node:util'
 import WebSocket from 'isomorphic-ws'
+import {format} from 'node:util'
 
-import { normalizeError, normalizeProtocolError } from '#common/errors'
+import {normalizeError, normalizeProtocolError} from '#common/errors'
 
-import { preauthHandler } from './handler-preauth'
-import { realmHandler } from './handler-realm'
-import { attachSocket, detachSocket } from './state'
+import {preauthHandler} from './handler-preauth'
+import {realmHandler} from './handler-realm'
+import {attachSocket, detachSocket} from './state'
 
 /** when the socket connects, we drive our protocol through handlers. */
 export async function socketHandler(ws: WebSocket) {
···
     try {
       attachSocket(auth.realm, auth.identid, ws)
       await realmHandler(ws, auth)
-    }
-    finally {
+    } finally {
       detachSocket(auth.realm, auth.identid, ws)
     }
-  }
-  catch (exc) {
+  } catch (exc) {
     const error = normalizeError(exc)
     const failure = normalizeProtocolError(error)
 
     if (failure.status >= 500) {
       console.error('fatal:', error)
-      if (error.cause)
-        console.error('cause:', error.cause)
+      if (error.cause) console.error('cause:', error.cause)
     }
 
     const message = format('Error: %s', failure.message)
-    if (ws.readyState === ws.OPEN)
-      ws.send(message)
-  }
-  finally {
+    if (ws.readyState === ws.OPEN) ws.send(message)
+  } finally {
     if (ws.readyState !== ws.CLOSED) {
       ws.send(`kthxbye\n`)
       ws.close()

src/server/routes-socket/state.ts

···
 import WebSocket from 'isomorphic-ws'
 
-import { IdentID, RealmID } from '#common/protocol.js'
-import { StrictMap } from '#common/strict-map'
+import {IdentID, RealmID} from '#common/protocol.js'
+import {StrictMap} from '#common/strict-map'
 
 /** An authenticated identity; only handed out in response to successful authentication. */
 export interface AuthenticatedIdentity {
···
  * @param registrantkey - the public key of the registrant
  * @returns a registered realm, possibly newly created with the registrant
  */
-export function ensureRegisteredRealm(realmid: RealmID, registrantid: IdentID, registrantkey: CryptoKey): Realm {
+export function ensureRegisteredRealm(
+  realmid: RealmID,
+  registrantid: IdentID,
+  registrantkey: CryptoKey,
+): Realm {
   const realm = realmMap.ensure(realmid, () => ({
     realmid,
     sockets: new StrictMap(),
···
 }
 
 export function attachSocket(realm: Realm, ident: IdentID, socket: WebSocket) {
-  realm.sockets.update(ident, ss => (ss ? [...ss, socket] : [socket]))
+  realm.sockets.update(ident, (ss) => (ss ? [...ss, socket] : [socket]))
 }
 
 export function detachSocket(realm: Realm, ident: IdentID, socket: WebSocket) {
   realm.sockets.update(ident, (sockets) => {
-    const next = sockets?.filter(s => s !== socket)
+    const next = sockets?.filter((s) => s !== socket)
     return next?.length ? next : undefined
   })
 }

src/server/routes-static.ts

···
 import express from 'express'
-import { join } from 'path'
+import {join} from 'path'
 
 interface StaticOpts {
   root: string
···
  * @returns a new middleware
  */
 export function makeStaticMiddleware(opts: StaticOpts): express.RequestHandler {
-  return express.static(opts.root, { index: opts.index })
+  return express.static(opts.root, {index: opts.index})
 }
 
 /**
···
 export function makeSpaMiddleware(opts: StaticOpts): express.RequestHandler {
   return (req, res, next) => {
     if (req.method === 'GET' && req.accepts('text/html')) {
-      res.sendFile(join(opts.root, opts.index)); return;
+      res.sendFile(join(opts.root, opts.index))
+      return
     }
 
     next() // otherwise

tsconfig.json

···
     "types": ["node"],
     "lib": ["es2024", "DOM", "DOM.Iterable", "DOM.AsyncIterable"]
   },
-  "include": [
-    "src/**/*",
-    "vite.config.js",
-    "eslint.config.js"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "tmp"
-  ]
+  "include": ["src/**/*", "vite.config.js", "eslint.config.js"],
+  "exclude": ["node_modules", "dist", "tmp"]
 }

vite.config.js

···
 import preact from '@preact/preset-vite'
-import { resolve } from 'node:path'
-import { defineConfig } from 'vite'
-import { nodePolyfills } from 'vite-plugin-node-polyfills'
+import {resolve} from 'node:path'
+import {defineConfig} from 'vite'
+import {nodePolyfills} from 'vite-plugin-node-polyfills'
 // import checker from 'vite-plugin-checker'
 
 // https://vite.dev/config/