updated max line length

eslint.config.js

···
 import react from 'eslint-plugin-react'
 import reactHooks from 'eslint-plugin-react-hooks'
 import tsdoc from 'eslint-plugin-tsdoc'
+import {defineConfig} from 'eslint/config'
 import globals from 'globals'
 import path from 'node:path'
 import tseslint from 'typescript-eslint'
 
 const gitignore = path.resolve(import.meta.dirname, '.gitignore')
 
-export default tseslint.config(
+export default defineConfig(
   includeIgnoreFile(gitignore, '.gitignore'),
 
   // all files by default get shared globals
···
       '@typescript-eslint/restrict-template-expressions': 'off',
 
       // I need to be able to do `while(true)`, come on yall...
-      '@typescript-eslint/no-unnecessary-condition': [
-        'warn',
-        {allowConstantLoopConditions: 'always'},
-      ],
+      '@typescript-eslint/no-unnecessary-condition': ['warn', {allowConstantLoopConditions: 'always'}],
 
       // this breaks when I want to use a type parameter to allow type checking inline arguments
       // it's "unnecessary type parameters" or an `as` declaration, which I don't like

prettier.config.js

···
  * @type {import("prettier").Config}
  */
 export default {
-  printWidth: 100,
+  printWidth: 120,
   tabWidth: 2,
   semi: false,
   singleQuote: true,

src/client/components/feed-import-nytimes.tsx

···
   return (
     <div className="feed-import-nytimes">
       <button type="button" onClick={importAll} disabled={importing$.value}>
-        {importing$.value
-          ? `Importing... (${imported$.value}/${NYTIMES_FEEDS.length})`
-          : 'Import All NY Times Feeds'}
+        {importing$.value ? `Importing... (${imported$.value}/${NYTIMES_FEEDS.length})` : 'Import All NY Times Feeds'}
       </button>
 
       {errors$.value.length > 0 && (

src/client/components/feed-import-podcasts.tsx

···
   return (
     <div className="feed-import-podcasts">
       <button type="button" onClick={importAll} disabled={importing$.value}>
-        {importing$.value
-          ? `Importing... (${imported$.value}/${PODCAST_FEEDS.length})`
-          : 'Import Podcast Feeds'}
+        {importing$.value ? `Importing... (${imported$.value}/${PODCAST_FEEDS.length})` : 'Import Podcast Feeds'}
       </button>
 
       {errors$.value.length > 0 && (

src/client/components/feed-import-tech.tsx

···
   return (
     <div className="feed-import-tech">
       <button type="button" onClick={importAll} disabled={importing$.value}>
-        {importing$.value
-          ? `Importing... (${imported$.value}/${TECH_FEEDS.length})`
-          : 'Import Tech Feeds'}
+        {importing$.value ? `Importing... (${imported$.value}/${TECH_FEEDS.length})` : 'Import Tech Feeds'}
       </button>
 
       {errors$.value.length > 0 && (

src/client/page-app.tsx

···
   const wsurl = `${wsproto}://${wshost}/stream`
 
   return (
-    <SkypodProvider
-      identityFallback={identityFallback}
-      connectionFallback={connectionFallback}
-      websocketUrl={wsurl}
-    >
+    <SkypodProvider identityFallback={identityFallback} connectionFallback={connectionFallback} websocketUrl={wsurl}>
       <RealmConnectionManager />
       <PeerList />
       <FeedImportNYTimes />

src/client/root/context-database.tsx

···
   useDbSignal: <T>(querier: DbQuerier<T>) => ReadonlySignal<T | undefined>
 }
 
-export const DatabaseProvider: preact.FunctionComponent<{children: preact.ComponentChildren}> = (
-  props,
-) => {
+export const DatabaseProvider: preact.FunctionComponent<{children: preact.ComponentChildren}> = (props) => {
   const db = useMemo(() => new Database(), [])
 
   function useDbSignal<T>(querier: DbQuerier<T>): ReadonlySignal<T | undefined> {
···
     return signal
   }
 
-  return (
-    <DatabaseContext.Provider value={{db, useDbSignal}}>{props.children}</DatabaseContext.Provider>
-  )
+  return <DatabaseContext.Provider value={{db, useDbSignal}}>{props.children}</DatabaseContext.Provider>
 }
 
 export function useDatabase() {

src/client/skypod/action-dispatch/context.tsx

···
 
 import {Action, ActionMap, ActionOpts} from '#skypod/actions'
 
-export type MiddlewareFn = (
-  this: undefined,
-  action: Action,
-) => void | Action[] | Promise<void | Action[]>
+export type MiddlewareFn = (this: undefined, action: Action) => void | Action[] | Promise<void | Action[]>
 
 export type MiddlewareRouterFn<K extends keyof ActionMap> = (
   this: undefined,
···
       }
     },
 
-    action: <N extends keyof ActionMap>(
-      msg: N,
-      dat: ActionMap[N]['dat'],
-      opt?: ActionOpts,
-    ): ActionMap[N] => {
+    action: <N extends keyof ActionMap>(msg: N, dat: ActionMap[N]['dat'], opt?: ActionOpts): ActionMap[N] => {
       const clk = identity.clock.now()
       return {typ: 'act', clk, msg, dat, opt} as ActionMap[N]
     },
···
     },
   })
 
-  return (
-    <ActionDispatchContext.Provider value={context.current}>
-      {props.children}
-    </ActionDispatchContext.Provider>
-  )
+  return <ActionDispatchContext.Provider value={context.current}>{props.children}</ActionDispatchContext.Provider>
 }
 
 export function useActionDispatch() {

src/client/skypod/feed-processor/worker.ts

···
 
   async processPending() {
     const pendingFeeds = this.#db.feeds.where('lastRefresh.status').equals('pending')
-    return await this.#db.withLock(
-      'feeds',
-      pendingFeeds,
-      this.#clock,
-      this.#owner,
-      this.#processLocked,
-    )
+    return await this.#db.withLock('feeds', pendingFeeds, this.#clock, this.#owner, this.#processLocked)
   }
 
   async processUrls(urls: string[]) {
     const requestedFeeds = this.#db.feeds.where('url').anyOf(urls)
-    return await this.#db.withLock(
-      'feeds',
-      requestedFeeds,
-      this.#clock,
-      this.#owner,
-      this.#processLocked,
-    )
+    return await this.#db.withLock('feeds', requestedFeeds, this.#clock, this.#owner, this.#processLocked)
   }
 
   #poll = () => {

src/cmd/register-ident.ts

···
     pubkey: await jwkExport.parseAsync(keypair.publicKey),
   }
 
-  const jwt = await generateSignableJwt(payload)
-    .setIssuedAt()
-    .setExpirationTime('1m')
-    .sign(keypair.privateKey)
+  const jwt = await generateSignableJwt(payload).setIssuedAt().setExpirationTime('1m').sign(keypair.privateKey)
 
   console.log('Generated Preauth JWT:')
   console.log(jwt)

src/common/crypto/cipher.ts

···
   const nonce = encoder.encode(`${nonceStr}-nonce-cryptosystem`)
   const derivedsalt = new Uint8Array([...salt, ...nonce])
 
-  return await crypto.subtle.deriveKey(
-    {...deriveAlgo, salt: derivedsalt, iterations},
-    derivedkey,
-    encrAlgo,
-    false,
-    ['encrypt', 'decrypt'],
-  )
+  return await crypto.subtle.deriveKey({...deriveAlgo, salt: derivedsalt, iterations}, derivedkey, encrAlgo, false, [
+    'encrypt',
+    'decrypt',
+  ])
 }
 
 /**
···
   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 as BufferSource,
-    )
+    const encrypted = await crypto.subtle.encrypt({...encrAlgo, iv}, this.#cryptokey, encoded as BufferSource)
 
     // output = [iv + encrypted] which gives us the auth tag
 

src/common/crypto/jwts.ts

···
  * 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.

src/common/socket.ts

···
 }
 
 /** exactly take socket, but will additionally apply a json decoding */
-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)
 }
···
  * 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/realm/client/components/connection-manager.tsx

···
       </p>
       <p>
         Exchange an invite:
-        <textarea
-          value={invitation.value}
-          onInput={(e) => (invitation.value = e.currentTarget.value)}
-        />
+        <textarea value={invitation.value} onInput={(e) => (invitation.value = e.currentTarget.value)} />
         <button type="button" onClick={exchange}>
           Exchange
         </button>

src/realm/client/context-identity.tsx

···
   }, [store, value$, error$])
 
   return value$.value ? (
-    <RealmIdentityContext.Provider value={value$.value}>
-      {props.children}
-    </RealmIdentityContext.Provider>
+    <RealmIdentityContext.Provider value={value$.value}>{props.children}</RealmIdentityContext.Provider>
   ) : (
     props.fallback({loading: !error$.value, error: error$.value})
   )

src/realm/client/service-connection-peer.ts

···
     super({
       initiator,
       config: {
-        iceServers: [
-          {urls: 'stun:stun.l.google.com:19302'},
-          {urls: 'stun:stun1.l.google.com:19302'},
-        ],
+        iceServers: [{urls: 'stun:stun.l.google.com:19302'}, {urls: 'stun:stun1.l.google.com:19302'}],
       },
     })
 

src/realm/client/service-connection.ts

···
 
     switch (parse.data.msg) {
       case 'realm.rtc.signal': {
-        const jwt = await jwtPayload(protocol.realmRtcSignalPayloadSchema).parseAsync(
-          parse.data.dat.signed,
-        )
+        const jwt = await jwtPayload(protocol.realmRtcSignalPayloadSchema).parseAsync(parse.data.dat.signed)
 
         // backwards from our perspective
         const remoteid = parse.data.dat.localid

src/realm/protocol/index.ts

···
 export * from './brands'
 export * from './messages'
 
-export function makeError(
-  error: ProtocolError,
-  detail: string,
-  seq?: number,
-): z.infer<typeof errorMessageSchema> {
+export function makeError(error: ProtocolError, detail: string, seq?: number): z.infer<typeof errorMessageSchema> {
   return {
     typ: 'err',
     msg: error.message,

src/realm/protocol/messages.ts

···
 import {IdentBrand} from './brands'
 import {deviceCapsSchema, deviceInfoSchema} from './device'
 import {LogicalClock} from './logical-clock'
-import {
-  makeEmptyRequestSchema,
-  makeEventSchema,
-  makeRequestSchema,
-  makeResponseSchema,
-} from './schema'
+import {makeEmptyRequestSchema, makeEventSchema, makeRequestSchema, makeResponseSchema} from './schema'
 
 export const serverPeerIdSchema = z.literal('server')
 export type ServerPeerId = z.infer<typeof serverPeerIdSchema>
···
 
 /// preauth
 
-export const preauthRegisterReqSchema = makeRequestSchema(
-  'preauth.register',
-  z.object({pubkey: jwkSchema}),
-)
+export const preauthRegisterReqSchema = makeRequestSchema('preauth.register', z.object({pubkey: jwkSchema}))
 
 export const preauthAuthnReqSchema = makeEmptyRequestSchema('preauth.authn')
 
···
   }),
 )
 
-export const realmRtcPongResponseSchema = makeResponseSchema(
-  'realm.rtc.pong',
-  z.object({peerClocks: peerClocksSchema}),
-)
+export const realmRtcPongResponseSchema = makeResponseSchema('realm.rtc.pong', z.object({peerClocks: peerClocksSchema}))
 
 export const realmRtcAnnounceRequestSchema = makeRequestSchema(
   'realm.rtc.announce',

src/realm/server/handler-preauth.ts

···
 import {jwtPayload, jwtSchema, JWTToken, verifyJwtToken} from '#common/crypto/jwts'
 import {normalizeError, ProtocolError} from '#common/errors'
 import {takeSocket} from '#common/socket'
-import {
-  IdentBrand,
-  IdentID,
-  preauthReqSchema,
-  PreauthResponse,
-  RealmBrand,
-  RealmID,
-} from '#realm/protocol/index'
+import {IdentBrand, IdentID, preauthReqSchema, PreauthResponse, RealmBrand, RealmID} from '#realm/protocol/index'
 
 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)
 
···
     const realm = realmMap.require(realmid)
 
     if (!invitation.claims.jti) throw new Error('invitation requires nonce!')
-    if (!(await realms.validateNonce(realmid, invitation.claims.jti)))
-      throw new Error('invitation already used!')
+    if (!(await realms.validateNonce(realmid, invitation.claims.jti))) throw new Error('invitation already used!')
 
     const inviterid = IdentBrand.parse(invitation.claims.iss)
     const inviterkey = realm.storage.identities.require(inviterid)
···
   }
 }
 
-async function preauthResponse(
-  auth: realms.AuthenticatedIdentity,
-  seq?: number,
-): Promise<PreauthResponse> {
+async function preauthResponse(auth: realms.AuthenticatedIdentity, seq?: number): Promise<PreauthResponse> {
   const peers: Array<IdentID | 'server'> = Array.from(auth.realm.sockets.keys())
   peers.unshift('server')
 

src/realm/server/handler-realm.ts

···
  * 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, await buildRtcPeerJoined(auth))
 
   try {
···
   }
 }
 
-async function buildRtcPeerJoined(
-  auth: realm.AuthenticatedIdentity,
-): Promise<protocol.RealmRtcPeerJoinedEvent> {
+async function buildRtcPeerJoined(auth: realm.AuthenticatedIdentity): Promise<protocol.RealmRtcPeerJoinedEvent> {
   return {
     typ: 'evt',
     msg: 'realm.rtc.peer-joined',
···
   recipients: protocol.IdentID[] | boolean = false,
 ) {
   const echo = recipients === true || Array.isArray(recipients)
-  const recips = Array.isArray(recipients)
-    ? recipients
-    : Array.from(auth.realm.storage.identities.keys())
+  const recips = Array.isArray(recipients) ? recipients : Array.from(auth.realm.storage.identities.keys())
   const json = JSON.stringify(payload)
 
   for (const recip of recips) {
···
   }
 }
 
-async function socketPeerPing(
-  ws: WebSocket,
-  auth: realm.AuthenticatedIdentity,
-  ping: protocol.RealmRtcPingRequest,
-) {
+async function socketPeerPing(ws: WebSocket, auth: realm.AuthenticatedIdentity, ping: protocol.RealmRtcPingRequest) {
   console.debug('ping from', auth.identid, ping.dat)
 
   const peerClocks = await auth.realm.storage.buildSyncState()

src/realm/server/state-storage.ts

···
     return new RealmStorage(realmid, identities, db, metapath)
   }
 
-  static async ensure(
-    realmid: RealmID,
-    registrantid: IdentID,
-    registrantkey: CryptoKey,
-  ): Promise<RealmStorage> {
+  static async ensure(realmid: RealmID, registrantid: IdentID, registrantkey: CryptoKey): Promise<RealmStorage> {
     try {
       return await this.open(realmid)
     } catch {
···
   #db: Level
   #metadataPath: string
 
-  private constructor(
-    realmid: RealmID,
-    identities: StrictMap<IdentID, CryptoKey>,
-    db: Level,
-    metadataPath: string,
-  ) {
+  private constructor(realmid: RealmID, identities: StrictMap<IdentID, CryptoKey>, db: Level, metadataPath: string) {
     this.realmid = realmid
     this.identities = identities
 

src/skypod/actions.ts

···
 export type ActionOpts = z.infer<typeof actionOptionsSchema>
 export type ActionMap = {[K in Action as K['msg']]: K}
 
-export function makeAction<N extends Action['msg']>(
-  msg: N,
-  clk: LCTimestamp,
-  dat: ActionMap[N]['dat'],
-): ActionMap[N] {
+export function makeAction<N extends Action['msg']>(msg: N, clk: LCTimestamp, dat: ActionMap[N]['dat']): ActionMap[N] {
   return {typ: 'act', clk, msg, dat} as ActionMap[N]
 }