@weft-js/start 0.1.0 → 0.1.2

package/src/shape.mjs

@@ -12,7 +12,20 @@ export function toJson(schema, side) {
 }
 
 /** Typical lengths by field name, for strings with no hint (research 11 §7.1). */
-const NAMES = { title: 40, name: 16, label: 16, email: 22, body: 200, content: 200, text: 120, description: 120, summary: 120, slug: 24, url: 40, id: 8 }
+const NAMES = {
+  title: 40,
+  name: 16,
+  label: 16,
+  email: 22,
+  body: 200,
+  content: 200,
+  text: 120,
+  description: 120,
+  summary: 120,
+  slug: 24,
+  url: 40,
+  id: 8,
+}
 const FORMATS = { email: 22, uuid: 36, url: 40, uri: 40, 'date-time': 24, date: 10, time: 8 }
 /** A string with no hint: X036 if a skeleton shows one. */
 const UNHINTED = 16
@@ -35,7 +48,7 @@ export function schemaTree(s, name = '') {
   if (s.enum) return s.enum[0]
   const union = s.anyOf ?? s.oneOf
   if (union) {
-    const some = union.filter(x => x.type !== 'null')
+    const some = union.filter((x) => x.type !== 'null')
     return some.length < union.length && !(s.probability >= 0.5) ? null : schemaTree(some[0], name)
   }
   switch (s.type) {
@@ -47,10 +60,14 @@ export function schemaTree(s, name = '') {
     case 'boolean':
       return false
     case 'array':
-      return { ...(s.maxItems !== undefined ? { $a: s.maxItems } : {}), $of: schemaTree(s.items, name) }
+      return {
+        ...(s.maxItems !== undefined ? { $a: s.maxItems } : {}),
+        $of: schemaTree(s.items, name),
+      }
     case 'object': {
       const out = {}
-      for (const [k, v] of Object.entries(s.properties ?? {})) if (s.required?.includes(k) || v.probability >= 0.5) out[k] = schemaTree(v, k)
+      for (const [k, v] of Object.entries(s.properties ?? {}))
+        if (s.required?.includes(k) || v.probability >= 0.5) out[k] = schemaTree(v, k)
       return out
     }
   }
@@ -60,8 +77,15 @@ export function schemaTree(s, name = '') {
 /** `example` (a declared `shape`) over `tree`. */
 function merge(tree, example) {
   if (example === undefined) return tree
-  if (Array.isArray(example)) return example.length > 1 || !tree?.$of ? example : { ...tree, $of: merge(tree.$of, example[0]) }
-  if (example && typeof example === 'object') return Object.fromEntries([...Object.entries(tree ?? {}), ...Object.entries(example).map(([k, v]) => [k, merge(tree?.[k], v)])])
+  if (Array.isArray(example))
+    return example.length > 1 || !tree?.$of
+      ? example
+      : { ...tree, $of: merge(tree.$of, example[0]) }
+  if (example && typeof example === 'object')
+    return Object.fromEntries([
+      ...Object.entries(tree ?? {}),
+      ...Object.entries(example).map(([k, v]) => [k, merge(tree?.[k], v)]),
+    ])
   return example
 }
 

package/src/share/display.ts

@@ -0,0 +1,50 @@
+import { NONE } from '@weft-js/core/interaction'
+import { tab } from '../link'
+import { clients, lines, shown, siblings, tabs, type Client, type Triple } from './state'
+
+export function render(key: string) {
+  const heard = lines.get(key)
+  if (!heard) return
+  let hover = 0,
+    focus = 0,
+    pressed = 0
+  const add = (bits: number) => {
+    if (bits & 1) hover++
+    if (bits & 2) focus++
+    if (bits & 4) pressed++
+  }
+  for (const [t, keys] of tabs) if (t !== tab) add(keys.get(key) ?? 0)
+  for (const e of clients.get(key)?.values() ?? []) add(e.bits)
+  const was = shown.get(key) ?? NONE
+  if (was.hover === hover && was.focus === focus && was.pressed === pressed) return
+  const now = hover || focus || pressed ? { hover, focus, pressed } : NONE
+  shown.set(key, now)
+  heard(now)
+}
+export const renderAll = () => {
+  for (const k of lines.keys()) render(k)
+}
+
+export function hear(s: Triple[], leading: boolean) {
+  const at = Date.now(),
+    touched = new Set<string>()
+  for (const [id, key, bits] of s) {
+    if (siblings.has(id) || (!leading && !lines.has(key))) continue
+    let held = clients.get(key)
+    if (bits) {
+      if (!held) clients.set(key, (held = new Map()))
+      held.set(id, { bits, at })
+    } else if (!held?.delete(id)) continue
+    touched.add(key)
+  }
+  for (const k of touched) render(k)
+}
+
+export function dropClients(which: (e: Client, id: string) => boolean) {
+  for (const [key, held] of clients) {
+    let changed = false
+    for (const [id, e] of held) if (which(e, id)) changed = held.delete(id)
+    if (!held.size) clients.delete(key)
+    if (changed) render(key)
+  }
+}

package/src/share/network.ts

@@ -0,0 +1,119 @@
+import type { connectBuiltIn } from '../channel'
+import type { shareStats as ShareStats } from '../share'
+import { mine, tabs, type Pair } from './state'
+
+type Conn = ReturnType<typeof connectBuiltIn>
+
+function changedPairs(o: {
+  dirtyNet: Set<string>
+  sent: Map<string, number>
+  refused: Set<string>
+  upstream: (key: string) => number
+  BATCH: number
+}) {
+  const { dirtyNet, sent, refused, upstream, BATCH } = o
+  const e: Pair[] = []
+  for (const key of dirtyNet) {
+    if (e.length === BATCH) break
+    dirtyNet.delete(key)
+    if (!sent.has(key) || refused.has(key)) continue
+    const bits = upstream(key)
+    // Off and on again inside the gap: nothing to say. The latest value is all that's kept.
+    if (bits !== sent.get(key)) {
+      sent.set(key, bits)
+      e.push([key, bits])
+    }
+  }
+  return e
+}
+
+export function network({
+  connection,
+  isOpen,
+  sent,
+  refused,
+  dirtyNet,
+  toAdd,
+  toDrop,
+  upstream,
+  shareStats,
+  GAP_NET,
+  BATCH,
+}: {
+  connection: () => Conn | undefined
+  isOpen: () => boolean
+  sent: Map<string, number>
+  refused: Set<string>
+  dirtyNet: Set<string>
+  toAdd: Set<string>
+  toDrop: Set<string>
+  upstream: (key: string) => number
+  shareStats: typeof ShareStats
+  GAP_NET: number
+  BATCH: number
+}) {
+  let netLast = 0
+  let netTimer: ReturnType<typeof setTimeout> | undefined
+  /** One frame per GAP_NET, `u` first: the bucket is 20 a second, and a frame carries every key that's waiting. */
+  function netTick() {
+    netTimer = undefined
+    const conn = connection()
+    if (!conn || !isOpen()) return
+    let name: 'u' | 'set' | undefined,
+      msg: unknown,
+      size = 0
+    if (toAdd.size || toDrop.size) {
+      const add = [...toAdd].slice(0, BATCH),
+        drop = [...toDrop].slice(0, BATCH - add.length)
+      for (const k of add) toAdd.delete(k)
+      for (const k of drop) toDrop.delete(k)
+      name = 'u'
+      msg = { add, drop }
+      size = add.length + drop.length
+    } else {
+      const e = changedPairs({ dirtyNet, sent, refused, upstream, BATCH })
+      if (e.length) {
+        name = 'set'
+        msg = { e }
+        size = e.length
+      }
+    }
+    if (name) {
+      netLast = performance.now()
+      shareStats.frames++
+      shareStats.keysSent += size
+      conn.send(name as never, msg as never).catch(() => {}) // a dropped link re-says everything
+    }
+    if (toAdd.size || toDrop.size || dirtyNet.size) netSoon()
+  }
+  /** Not a timer when the gap has passed: the leader is often a hidden tab, where a timer waits a second or more. */
+  function netSoon() {
+    const wait = GAP_NET - (performance.now() - netLast)
+    if (wait > 0) {
+      netTimer ??= setTimeout(netTick, wait)
+      return
+    }
+    clearTimeout(netTimer)
+    netTick()
+  }
+
+  const clear = () => {
+    clearTimeout(netTimer)
+    netTimer = undefined
+  }
+  return { netSoon, clear }
+}
+
+export const upstream = (key: string, locks: boolean) => {
+  if (!locks) return mine.get(key) ?? 0
+  let bits = 0
+  for (const keys of tabs.values()) bits |= keys.get(key) ?? 0
+  return bits
+}
+
+export function wanted(locks: boolean) {
+  if (!locks) return new Set(mine.keys())
+  const out = new Set<string>()
+  for (const keys of tabs.values()) for (const k of keys.keys()) out.add(k)
+  return out
+}

package/src/share/receive.ts

@@ -0,0 +1,70 @@
+import {
+  clients,
+  siblings,
+  tabAt,
+  tabs,
+  visible,
+  type Client,
+  type Msg,
+  type Triple,
+} from './state'
+import { hear, render, renderAll } from './display'
+
+export function receiver({
+  dropClients,
+  watch,
+  reconcile,
+  wakeIfLeading,
+  leading,
+  post,
+  announce,
+  dropTab,
+  link,
+}: {
+  dropClients: (test: (e: Client, id: string) => boolean) => void
+  watch: (tab: string) => void
+  reconcile: () => void
+  wakeIfLeading: () => void
+  leading: () => boolean
+  post: (msg: Msg) => void
+  announce: () => void
+  dropTab: (tab: string) => void
+  link: (up: boolean) => void
+}) {
+  return (m: Msg) => {
+    if (m.t === 'tab') {
+      tabs.set(m.tab, new Map(m.keys))
+      tabAt.set(m.tab, Date.now())
+      visible.set(m.tab, m.shown)
+      if (m.k && !siblings.has(m.k)) {
+        siblings.add(m.k)
+        dropClients((_, id) => id === m.k)
+      }
+      watch(m.tab)
+      renderAll()
+      reconcile()
+      if (m.shown) wakeIfLeading()
+      // A tab that arrived late has what the socket already heard.
+      if (leading()) {
+        const s: Triple[] = []
+        for (const [key] of m.keys)
+          for (const [id, e] of clients.get(key) ?? []) s.push([id, key, e.bits])
+        if (s.length) post({ t: 'net', s })
+      }
+    } else if (m.t === 'bits') {
+      const keys = tabs.get(m.tab) ?? new Map<string, number>()
+      tabs.set(m.tab, keys)
+      tabAt.set(m.tab, Date.now())
+      for (const [key, bits] of m.e) keys.set(key, bits)
+      watch(m.tab)
+      for (const [key] of m.e) render(key)
+      reconcile()
+    } else if (m.t === 'shown') {
+      visible.set(m.tab, m.shown)
+      if (m.shown) wakeIfLeading()
+    } else if (m.t === 'roll') announce()
+    else if (m.t === 'bye') dropTab(m.tab)
+    else if (m.t === 'net') hear(m.s, leading())
+    else if (m.t === 'link') link(m.up)
+  }
+}

package/src/share/state.ts

@@ -0,0 +1,30 @@
+import type { Counts } from '@weft-js/core/interaction'
+
+export type Pair = [key: string, bits: number]
+export type Triple = [id: string, key: string, bits: number]
+export type Msg =
+  | { t: 'tab'; tab: string; keys: Pair[]; shown: boolean; k?: string | undefined }
+  | { t: 'bits'; tab: string; e: Pair[] }
+  | { t: 'shown'; tab: string; shown: boolean }
+  | { t: 'net'; s: Triple[] }
+  | { t: 'link'; up: boolean }
+  | { t: 'roll' }
+  | { t: 'bye'; tab: string }
+
+export interface Client {
+  bits: number
+  at: number
+  stale?: boolean
+}
+
+export const lines = new Map<string, (c: Counts) => void>()
+export const shown = new Map<string, Counts>()
+/** key → bits, per tab, mine included. */
+export const tabs = new Map<string, Map<string, number>>()
+export const tabAt = new Map<string, number>()
+export const visible = new Map<string, boolean>()
+export const mine = new Map<string, number>()
+export const watched = new Set<string>()
+export const siblings = new Set<string>()
+/** key → other clients. Everything the leader joined; a follower keeps what its own lines want. */
+export const clients = new Map<string, Map<string, Client>>()

package/src/share/tab-queue.ts

@@ -0,0 +1,28 @@
+import type { Msg } from './state'
+
+export function tabQueue(
+  dirtyTab: Set<string>,
+  mine: Map<string, number>,
+  post: (msg: Msg) => void,
+  tab: string,
+  GAP_TAB: number,
+) {
+  let tabLast = 0
+  let tabTimer: ReturnType<typeof setTimeout> | undefined
+  function flushTab() {
+    tabTimer = undefined
+    tabLast = performance.now()
+    if (dirtyTab.size)
+      post({ t: 'bits', tab, e: [...dirtyTab].map((key) => [key, mine.get(key) ?? 0]) })
+    dirtyTab.clear()
+  }
+  function queueTab(key: string) {
+    dirtyTab.add(key)
+    if (tabTimer !== undefined) return
+    const wait = GAP_TAB - (performance.now() - tabLast)
+    if (wait <= 0) flushTab()
+    else tabTimer = setTimeout(flushTab, wait)
+  }
+
+  return queueTab
+}

package/src/share-server.ts

@@ -23,25 +23,55 @@ const SHARDS = 64
 /** One key at a time, or `{ keys }` to answer a whole join at once: a rule that reads a database runs once for it. */
 export type ShareRule =
   | ((args: { ctx: Context; key: string }) => boolean | Promise<boolean>)
-  | { keys: (args: { ctx: Context; keys: string[] }) => Iterable<string> | Promise<Iterable<string>> }
+  | {
+      keys: (args: { ctx: Context; keys: string[] }) => Iterable<string> | Promise<Iterable<string>>
+    }
 
 type Issue = { issues: { message: string }[] }
 type Sent = { add?: unknown; drop?: unknown; e?: unknown } | null | undefined
 const isIssue = (r: unknown): r is Issue => !!(r as Partial<Issue> | null | undefined)?.issues
-const schema = <T,>(validate: (v: Sent) => T | Issue): StandardSchemaV1<T, T> => ({ '~standard': { version: 1, vendor: 'weft', validate: (v: unknown) => { const r = validate(v as Sent); return isIssue(r) ? r : { value: r } } } })
+const schema = <T>(validate: (v: Sent) => T | Issue): StandardSchemaV1<T, T> => ({
+  '~standard': {
+    version: 1,
+    vendor: 'weft',
+    validate: (v: unknown) => {
+      const r = validate(v as Sent)
+      return isIssue(r) ? r : { value: r }
+    },
+  },
+})
 
 /** What a handler of the share channel is given. */
-interface Said<M = unknown> { msg: M; id: string; ctx: Context; reply: Client['reply'] }
+interface Said<M = unknown> {
+  msg: M
+  id: string
+  ctx: Context
+  reply: Client['reply']
+}
 const no = (message: string): Issue => ({ issues: [{ message }] })
-const isKey = (k: unknown): k is string => typeof k === 'string' && k.length > 0 && k.length <= MAX_KEY
+const isKey = (k: unknown): k is string =>
+  typeof k === 'string' && k.length > 0 && k.length <= MAX_KEY
 const isBits = (b: unknown) => Number.isInteger(b) && (b as number) >= 0 && (b as number) <= 7
-const anything = schema(v => v)
+const anything = schema((v) => v)
 
 /** Who has `k` in `s`: `[id, key, bits]`. */
 type Triple = [id: string, key: string, bits: number]
-interface Client { id: string; keys: Map<string, number>; reply(name: string, msg: unknown): void }
-interface Shard { name: string; refs: number; ch: ReturnType<Hub['channel']>; on: (ev: Ev | null) => void }
-interface Sharing { clients: Map<string, Client>; holders: Map<string, Set<Client>>; shards: Map<number, Shard> }
+interface Client {
+  id: string
+  keys: Map<string, number>
+  reply(name: string, msg: unknown): void
+}
+interface Shard {
+  name: string
+  refs: number
+  ch: ReturnType<Hub['channel']>
+  on: (ev: Ev | null) => void
+}
+interface Sharing {
+  clients: Map<string, Client>
+  holders: Map<string, Set<Client>>
+  shards: Map<number, Shard>
+}
 
 const states = new WeakMap<Hub, Sharing>()
 const stateOf = (h: Hub) => {
@@ -57,7 +87,7 @@ function shardOf(key: string) {
   return (x >>> 0) % SHARDS
 }
 
-const byShard = <T,>(items: T[], key: (item: T) => string) => {
+const byShard = <T>(items: T[], key: (item: T) => string) => {
   const out = new Map<number, T[]>()
   for (const item of items) {
     const s = shardOf(key(item))
@@ -68,29 +98,39 @@ const byShard = <T,>(items: T[], key: (item: T) => string) => {
   return out
 }
 
-const publish = (h: Hub, shard: number, body: object) => h.bus.publish(`weft:s:${shard}`, `{"v":1,${JSON.stringify(body).slice(1)}`)
+const publish = (h: Hub, shard: number, body: object) =>
+  h.bus.publish(`weft:s:${shard}`, `{"v":1,${JSON.stringify(body).slice(1)}`)
 
 function heard(h: Hub, st: Sharing, shard: number, ev: Ev | null) {
   if (!ev) return // the bus lost something: bits are re-said on a beat, and peers age out
-  const m = (ev.p ??= JSON.parse(ev.raw)) as { f?: string; e?: [string, number][]; a?: string; k?: string[]; t?: string; s?: Triple[] }
-  if (m.t) return  (m.s && st.clients.get(m.t)?.reply('b', { s: m.s }))
+  const m = (ev.p ??= JSON.parse(ev.raw)) as {
+    f?: string
+    e?: [string, number][]
+    a?: string
+    k?: string[]
+    t?: string
+    s?: Triple[]
+  }
+  if (m.t) return m.s && st.clients.get(m.t)?.reply('b', { s: m.s })
   if (m.a) {
     const s: Triple[] = []
-    for (const key of m.k ?? []) for (const c of st.holders.get(key) ?? []) {
-      const bits = c.keys.get(key)
-      if (bits && c.id !== m.a) s.push([c.id, key, bits])
-    }
+    for (const key of m.k ?? [])
+      for (const c of st.holders.get(key) ?? []) {
+        const bits = c.keys.get(key)
+        if (bits && c.id !== m.a) s.push([c.id, key, bits])
+      }
     if (s.length) void publish(h, shard, { t: m.a, s })
     return
   }
   // One frame per client per event, whatever it names.
   const each = new Map<Client, Triple[]>()
-  for (const [key, bits] of m.e ?? []) for (const c of st.holders.get(key) ?? []) {
-    if (c.id === m.f) continue
-    const list = each.get(c)
-    if (list) list.push([m.f!, key, bits])
-    else each.set(c, [[m.f!, key, bits]])
-  }
+  for (const [key, bits] of m.e ?? [])
+    for (const c of st.holders.get(key) ?? []) {
+      if (c.id === m.f) continue
+      const list = each.get(c)
+      if (list) list.push([m.f!, key, bits])
+      else each.set(c, [[m.f!, key, bits]])
+    }
   for (const [c, s] of each) c.reply('b', { s })
 }
 
@@ -103,7 +143,9 @@ function hold(h: Hub, st: Sharing, c: Client, key: string) {
   const n = shardOf(key)
   let shard = st.shards.get(n)
   if (!shard) {
-    const name = `weft:s:${n}`, ch = h.channel(name), on = (ev: Ev | null) => heard(h, st, n, ev)
+    const name = `weft:s:${n}`,
+      ch = h.channel(name),
+      on = (ev: Ev | null) => heard(h, st, n, ev)
     ch.listeners.add(on)
     st.shards.set(n, (shard = { name, refs: 0, ch, on }))
   }
@@ -116,7 +158,8 @@ function unhold(h: Hub, st: Sharing, c: Client, key: string) {
   const set = st.holders.get(key)!
   set.delete(c)
   if (!set.size) st.holders.delete(key)
-  const n = shardOf(key), shard = st.shards.get(n)!
+  const n = shardOf(key),
+    shard = st.shards.get(n)!
   if (--shard.refs) return
   st.shards.delete(n)
   h.unlisten(shard.ch, shard.on)
@@ -124,22 +167,57 @@ function unhold(h: Hub, st: Sharing, c: Client, key: string) {
 
 /** Say zero for what these keys held, then let go of them. */
 function release(h: Hub, st: Sharing, c: Client, keys: string[]) {
-  const held = keys.filter(k => c.keys.get(k))
+  const held = keys.filter((k) => c.keys.get(k))
   for (const k of keys) unhold(h, st, c, k)
-  return Promise.all([...byShard(held, k => k)].map(([n, list]) => publish(h, n, { f: c.id, e: list.map(k => [k, 0]) })))
+  return Promise.all(
+    [...byShard(held, (k) => k)].map(([n, list]) =>
+      publish(h, n, { f: c.id, e: list.map((k) => [k, 0]) }),
+    ),
+  )
 }
 
 async function allowedKeys(rule: ShareRule, ctx: Context, keys: string[]) {
   if (!keys.length) return keys
   if (typeof rule !== 'function') {
-    const yes = await Promise.resolve().then(() => rule.keys({ ctx, keys })).catch(() => [])
+    const yes = await Promise.resolve()
+      .then(() => rule.keys({ ctx, keys }))
+      .catch(() => [])
     const passed = new Set(yes)
-    return keys.filter(k => passed.has(k))
+    return keys.filter((k) => passed.has(k))
   }
-  const answers = await Promise.all(keys.map(key => Promise.resolve().then(() => rule({ ctx, key })).catch(() => false)))
+  const answers = await Promise.all(
+    keys.map((key) =>
+      Promise.resolve()
+        .then(() => rule({ ctx, key }))
+        .catch(() => false),
+    ),
+  )
   return keys.filter((_, i) => answers[i])
 }
 
+function clientMessages() {
+  return {
+    u: schema<{ add: string[]; drop: string[] }>((v) => {
+      const add = v?.add ?? [],
+        drop = v?.drop ?? []
+      return Array.isArray(add) &&
+        Array.isArray(drop) &&
+        add.length + drop.length <= MAX_BATCH &&
+        add.every(isKey) &&
+        drop.every(isKey)
+        ? { add, drop }
+        : no(`\`u\` takes up to ${MAX_BATCH} keys of 1 to ${MAX_KEY} characters`)
+    }),
+    set: schema<{ e: [string, number][] }>((v) =>
+      Array.isArray(v?.e) &&
+      v.e.length <= MAX_BATCH &&
+      v.e.every((x) => Array.isArray(x) && isKey(x[0]) && isBits(x[1]))
+        ? { e: v.e }
+        : no('`set` takes `[key, bits]` pairs, bits 0 to 7'),
+    ),
+  }
+}
+
 /** The `channel` behind `share`, made per hub. socket.ts takes it for `$share`, so every limit a channel has applies. */
 export function shareChannel(h: Hub): Fn {
   const rule = h.share
@@ -150,40 +228,47 @@ export function shareChannel(h: Hub): Fn {
     return c
   }
   return {
-    kind: 'channel', $id: SHARE,
+    kind: 'channel',
+    $id: SHARE,
     def: {
       authorize() {
         if (rule) return true
-        throw new StartError('R011', '`interaction({ share })` crossed to the socket, and nothing allows it', 'add `share: ({ ctx, key }) => …` to `realtime()`; `() => true` must be written out')
-      },
-      client: {
-        u: schema<{ add: string[]; drop: string[] }>(v => {
-          const add = v?.add ?? [], drop = v?.drop ?? []
-          return Array.isArray(add) && Array.isArray(drop) && add.length + drop.length <= MAX_BATCH && add.every(isKey) && drop.every(isKey) ? { add, drop } : no(`\`u\` takes up to ${MAX_BATCH} keys of 1 to ${MAX_KEY} characters`)
-        }),
-        set: schema<{ e: [string, number][] }>(v => (Array.isArray(v?.e) && v.e.length <= MAX_BATCH && v.e.every(x => Array.isArray(x) && isKey(x[0]) && isBits(x[1])) ? { e: v.e } : no('`set` takes `[key, bits]` pairs, bits 0 to 7'))),
+        throw new StartError(
+          'R011',
+          '`interaction({ share })` crossed to the socket, and nothing allows it',
+          'add `share: ({ ctx, key }) => …` to `realtime()`; `() => true` must be written out',
+        )
       },
+      client: clientMessages(),
       server: { ok: anything, b: anything },
       on: {
         async u({ msg, id, ctx, reply }: Said<{ add: string[]; drop: string[] }>) {
           const c = client(id, reply)
           await release(h, st, c, msg.drop)
           const room = Math.max(0, h.limits.shareKeys - c.keys.size)
-          const fresh = msg.add.filter(k => !c.keys.has(k))
+          const fresh = msg.add.filter((k) => !c.keys.has(k))
           const asked = fresh.slice(0, room)
           const ok = await allowedKeys(rule!, ctx, asked)
           if (!st.clients.has(id)) return // it left while the rule ran
           const passed = new Set(ok)
           for (const k of ok) hold(h, st, c, k)
-          await Promise.all(ok.length ? [...byShard<string>(ok, k => k)].map(([n, k]) => st.shards.get(n)!.ch.ready.then(() => publish(h, n, { a: id, k }))) : [])
-          reply('ok', { id, no: fresh.filter(k => !passed.has(k)) })
+          await Promise.all(
+            ok.length
+              ? [...byShard<string>(ok, (k) => k)].map(([n, k]) =>
+                  st.shards.get(n)!.ch.ready.then(() => publish(h, n, { a: id, k })),
+                )
+              : [],
+          )
+          reply('ok', { id, no: fresh.filter((k) => !passed.has(k)) })
         },
         set({ msg, id }: Said<{ e: [string, number][] }>) {
           const c = st.clients.get(id)
           if (!c) return
           const known = msg.e.filter(([k]) => c.keys.has(k))
           for (const [k, bits] of known) c.keys.set(k, bits)
-          return Promise.all([...byShard(known, e => e[0])].map(([n, e]) => publish(h, n, { f: id, e })))
+          return Promise.all(
+            [...byShard(known, (e) => e[0])].map(([n, e]) => publish(h, n, { f: id, e })),
+          )
         },
       },
       left({ id }: Pick<Said, 'id'>) {
@@ -198,7 +283,7 @@ export function shareChannel(h: Hub): Fn {
         if (!c || !rule) return
         const keys = [...c.keys.keys()]
         const passed = new Set(await allowedKeys(rule, ctx, keys))
-        const gone = keys.filter(k => !passed.has(k))
+        const gone = keys.filter((k) => !passed.has(k))
         if (!gone.length) return
         await release(h, st, c, gone)
         reply('ok', { id, no: gone })