@weft-js/start 0.1.0 → 0.1.2

package/src/link/election.ts

@@ -0,0 +1,178 @@
+/** Bump when a message here changes shape: tabs of two shapes share nothing, and each is its own client. */
+const WIRE = 1
+export const NAME = `weft:link:${WIRE}`
+export const BEAT = 5000
+const PONG = 1500
+// getRandomValues, not randomUUID: a page on plain http (a LAN address) has no randomUUID, and this runs on import.
+export const tab =
+  typeof crypto === 'undefined' ? '' : crypto.getRandomValues(new Uint32Array(1))[0]!.toString(36)
+const locks = (): LockManager | undefined =>
+  typeof navigator !== 'undefined' ? navigator.locks : undefined
+export const shareable = () => !!locks() && typeof BroadcastChannel !== 'undefined'
+
+// ---- a lock, a queue and a ping ---------------------------------------------------------------------------------------
+
+export interface Campaign {
+  probe(): void
+  stop(): void
+  leading(): boolean
+  pinged?: () => void
+}
+
+/** `lead` when this tab takes the lock; `lose` when another tab takes it from under this one. */
+export function campaign(
+  name: string,
+  won: () => void,
+  lose: () => void,
+  stolen?: () => void,
+): Campaign {
+  const l = locks()
+  const lockName = `${name}:leader`
+  const state: ElectionState = { on: true, leads: false, waiting: undefined }
+  const hold = () => {
+    state.leads = true
+    clearTimeout(state.waiting) // a ping that went out before there was anyone to answer it
+    state.waiting = undefined
+    won()
+  }
+  if (!l || typeof BroadcastChannel === 'undefined') {
+    queueMicrotask(() => {
+      if (state.on) hold()
+    })
+    return {
+      probe() {},
+      leading: () => state.leads,
+      stop() {
+        state.on = state.leads = false
+      },
+    }
+  }
+  return queuedCampaign(name, lockName, l, state, { hold, lose, stolen })
+}
+
+interface ElectionState {
+  on: boolean
+  leads: boolean
+  waiting: ReturnType<typeof setTimeout> | undefined
+}
+
+function queuedCampaign(
+  name: string,
+  lockName: string,
+  l: LockManager,
+  state: ElectionState,
+  on: { hold: () => void; lose: () => void; stolen?: (() => void) | undefined },
+): Campaign {
+  const { hold, lose, stolen } = on
+  let release: (() => void) | undefined
+  let abort: AbortController | undefined
+  let pongAt = 0
+  const bc = new BroadcastChannel(`${name}:e`)
+  const me: Campaign = {
+    leading: () => state.leads,
+    probe() {
+      // Each hover asks, so a recent answer has to do: one message a second, not one a move.
+      if (state.leads || state.waiting !== undefined || !state.on || Date.now() - pongAt < 1000)
+        return
+      bc.postMessage({ ping: tab })
+      const asked = Date.now()
+      state.waiting = setTimeout(() => {
+        state.waiting = undefined
+        // Late means this tab was frozen, and the answer is queued behind this timer: ask again.
+        if (Date.now() - asked > PONG * 1.5) return me.probe()
+        stolen?.()
+        const queued = abort
+        elect(true)
+        queued?.abort()
+      }, PONG)
+    },
+    stop() {
+      state.on = false
+      state.leads = false
+      clearTimeout(state.waiting)
+      clearInterval(timer)
+      abort?.abort()
+      release?.()
+      bc.close()
+    },
+  }
+  bc.onmessage = ({ data }) => {
+    if (data.ping && state.leads) {
+      bc.postMessage({ pong: data.ping })
+      me.pinged?.()
+    } else if (data.pong === tab) {
+      pongAt = Date.now()
+      clearTimeout(state.waiting)
+      state.waiting = undefined
+    }
+  }
+  function elect(steal = false) {
+    const ctl = new AbortController()
+    abort = ctl
+    l.request(
+      lockName,
+      steal ? { steal: true } : { signal: ctl.signal },
+      // A grant that comes after stop() (a steal can't be aborted) is handed straight back.
+      () =>
+        state.on
+          ? new Promise<void>((ok) => {
+              release = ok
+              hold()
+            })
+          : undefined,
+    ).catch(() => {
+      if (!state.on || abort !== ctl) return // this tab left the queue on purpose
+      if (state.leads) {
+        state.leads = false
+        lose()
+      }
+      elect()
+    })
+  }
+  const timer = setInterval(() => me.probe(), BEAT)
+  elect()
+  return me
+}
+
+// ---- this tab's own lock ----------------------------------------------------------------------------------------------
+
+let tabHeld = false
+let tabFree: (() => void) | undefined
+/** Bumped by freeTab(): a grant for an earlier turn is handed straight back. */
+let tabTurn = 0
+const whenHeld: (() => void)[] = []
+
+/** Held before the tab says anything, so a sibling that queues on it can't read a live tab as dead. */
+export function holdTab(then: () => void) {
+  if (tabHeld || !locks()) return then()
+  whenHeld.push(then)
+  if (whenHeld.length > 1) return
+  const turn = tabTurn
+  locks()!
+    .request(`${NAME}:tab:${tab}`, () => {
+      if (turn !== tabTurn) return undefined // freed while it was asked for
+      return new Promise<void>((ok) => {
+        tabFree = ok
+        tabHeld = true
+        for (const f of whenHeld.splice(0)) f()
+      })
+    })
+    // No lock after all: go on without one rather than leave the callers (and every later one) waiting.
+    .catch(() => {
+      for (const f of whenHeld.splice(0)) f()
+    })
+}
+
+/** Comes through when that tab is gone, crash included. */
+export function freeTab() {
+  tabTurn++
+  tabHeld = false
+  whenHeld.length = 0
+  tabFree?.()
+  tabFree = undefined
+}
+
+export const whenGone = (t: string, fn: () => void) =>
+  void locks()
+    ?.request(`${NAME}:tab:${t}`, () => fn())
+    .catch(() => {})

package/src/link/lines.ts

@@ -0,0 +1,27 @@
+export interface Mine {
+  id: string
+  hello: string
+  frame(text: string): void
+  closed(code: number, reason?: string): void
+}
+
+export const lines = new Map<string, Mine>()
+
+export function end(l: Mine, code: number, reason?: string) {
+  lines.delete(l.id)
+  l.closed(code, reason)
+}
+export const endAll = (code: number) => {
+  for (const l of Array.from(lines.values())) end(l, code)
+}
+
+export function arrive(text: string) {
+  const at = text.indexOf(':', 2)
+  const l = lines.get(text.slice(2, at))
+  if (!l) return
+  if (text[0] === 'x') {
+    const split = text.indexOf(':', at + 1)
+    return end(l, +text.slice(at + 1, split), text.slice(split + 1))
+  }
+  l.frame(text.slice(at + 1))
+}

package/src/link.ts

@@ -12,168 +12,70 @@
 //
 // Without Web Locks every tab leads itself: its own socket, which is what every tab used to have.
 
-/** Bump when a message here changes shape: tabs of two shapes share nothing, and each is its own client. */
-const WIRE = 1
-const NAME = `weft:link:${WIRE}`
-const PING = 20_000, DEAD = 45_000, BASE = 200, CAP = 30_000, IDLE = 1000
-export const BEAT = 5000
-const PONG = 1500
+import {
+  NAME,
+  campaign,
+  freeTab,
+  holdTab,
+  shareable,
+  tab,
+  whenGone,
+  type Campaign,
+} from './link/election'
+import { arrive, end, endAll, lines, type Mine } from './link/lines'
+export {
+  BEAT,
+  campaign,
+  freeTab,
+  holdTab,
+  shareable,
+  tab,
+  whenGone,
+  type Campaign,
+} from './link/election'
+
+const PING = 20_000,
+  DEAD = 45_000,
+  BASE = 200,
+  CAP = 30_000,
+  IDLE = 1000
 /** The line went because the leader did: not the network's fault, so reopen at once. */
 export const HANDOVER = 4900
 
-// getRandomValues, not randomUUID: a page on plain http (a LAN address) has no randomUUID, and this runs on import.
-export const tab = typeof crypto === 'undefined' ? '' : crypto.getRandomValues(new Uint32Array(1))[0]!.toString(36)
-const locks = (): LockManager | undefined => (typeof navigator !== 'undefined' ? navigator.locks : undefined)
-export const shareable = () => !!locks() && typeof BroadcastChannel !== 'undefined'
-
 /** What a test reads. */
 export const linkStats = { role: 'none' as 'none' | 'leader' | 'follower', steals: 0, dials: 0 }
 
-// ---- a lock, a queue and a ping ---------------------------------------------------------------------------------------
-
-export interface Campaign { probe(): void; stop(): void; leading(): boolean; pinged?: () => void }
-
-/** `lead` when this tab takes the lock; `lose` when another tab takes it from under this one. */
-export function campaign(name: string, won: () => void, lose: () => void, stolen?: () => void): Campaign {
-  const l = locks()
-  const lockName = `${name}:leader`
-  let on = true, leads = false
-  let release: (() => void) | undefined
-  let abort: AbortController | undefined
-  let waiting: ReturnType<typeof setTimeout> | undefined
-  let pongAt = 0
-  const hold = () => {
-    leads = true
-    clearTimeout(waiting) // a ping that went out before there was anyone to answer it
-    waiting = undefined
-    won()
-  }
-  if (!l || typeof BroadcastChannel === 'undefined') {
-    queueMicrotask(() => { if (on) hold() })
-    return { probe() {}, leading: () => leads, stop() { on = leads = false } }
-  }
-  const bc = new BroadcastChannel(`${name}:e`)
-  const me: Campaign = {
-    leading: () => leads,
-    probe() {
-      // Each hover asks, so a recent answer has to do: one message a second, not one a move.
-      if (leads || waiting !== undefined || !on || Date.now() - pongAt < 1000) return
-      bc.postMessage({ ping: tab })
-      const asked = Date.now()
-      waiting = setTimeout(() => {
-        waiting = undefined
-        // Late means this tab was the frozen one, and the answer is queued behind this timer: ask again.
-        if (Date.now() - asked > PONG * 1.5) return me.probe()
-        stolen?.()
-        const queued = abort
-        elect(true)
-        queued?.abort()
-      }, PONG)
-    },
-    stop() {
-      on = false
-      leads = false
-      clearTimeout(waiting)
-      clearInterval(timer)
-      abort?.abort()
-      release?.()
-      bc.close()
-    },
-  }
-  bc.onmessage = ({ data }) => {
-    if (data.ping && leads) {
-      bc.postMessage({ pong: data.ping })
-      me.pinged?.()
-    } else if (data.pong === tab) {
-      pongAt = Date.now()
-      clearTimeout(waiting)
-      waiting = undefined
-    }
-  }
-  function elect(steal = false) {
-    const ctl = new AbortController()
-    abort = ctl
-    l!.request(lockName, steal ? { steal: true } : { signal: ctl.signal }, () => new Promise<void>(ok => {
-      release = ok
-      hold()
-    })).catch(() => {
-      if (!on || abort !== ctl) return // this tab left the queue on purpose
-      if (leads) {
-        leads = false
-        lose()
-      }
-      elect()
-    })
-  }
-  const timer = setInterval(() => me.probe(), BEAT)
-  elect()
-  return me
-}
-
-// ---- this tab's own lock ----------------------------------------------------------------------------------------------
-
-let tabHeld = false
-let tabFree: (() => void) | undefined
-const whenHeld: (() => void)[] = []
-
-/** Held before the tab says anything, so a sibling that queues on it can't read a live tab as dead. */
-export function holdTab(then: () => void) {
-  if (tabHeld || !locks()) return then()
-  whenHeld.push(then)
-  if (whenHeld.length > 1) return
-  locks()!.request(`${NAME}:tab:${tab}`, () => new Promise<void>(ok => {
-    tabFree = ok
-    tabHeld = true
-    for (const f of whenHeld.splice(0)) f()
-  })).catch(() => {})
-}
-
-/** Comes through when that tab is gone, crash included. */
-export function freeTab() {
-  tabHeld = false
-  tabFree?.()
-  tabFree = undefined
-}
-
-export const whenGone = (t: string, fn: () => void) => void locks()?.request(`${NAME}:tab:${t}`, () => fn()).catch(() => {})
-
 // ---- lines, as a tab sees them ----------------------------------------------------------------------------------------
 
-export interface Line { send(text: string): void; close(): void }
-interface Mine { id: string; hello: string; frame(text: string): void; closed(code: number, reason?: string): void }
+export interface Line {
+  send(text: string): void
+  close(): void
+}
 
-const lines = new Map<string, Mine>()
 let nth = 0
 
+declare const __WEFT_SOCKETS__: boolean | undefined
+/** Whether this deploy can hold a socket. `weft build` says no for a function host (Netlify, Vercel, Lambda…). */
+export const SOCKETS = typeof __WEFT_SOCKETS__ === 'undefined' || __WEFT_SOCKETS__
+
 /** Sockets that never said hello in a row: the page's way to learn this host has none. */
 export let socketFailures = 0
-/** The one who asked goes round SSE once, and the socket gets another chance after. */
+/** The one who asked goes round SSE once, and the socket gets another chance after. Where the build said none, always. */
 export const noSockets = () => {
+  if (!SOCKETS) return true
   const none = socketFailures >= 2
   if (none) socketFailures = 0
   return none
 }
 export const probeLink = () => election?.probe()
 
-function end(l: Mine, code: number, reason?: string) {
-  lines.delete(l.id)
-  l.closed(code, reason)
-}
-const endAll = (code: number) => { for (const l of Array.from(lines.values())) end(l, code) }
-
-function arrive(text: string) {
-  const at = text.indexOf(':', 2)
-  const l = lines.get(text.slice(2, at))
-  if (!l) return
-  if (text[0] === 'x') {
-    const split = text.indexOf(':', at + 1)
-    return end(l, +text.slice(at + 1, split), text.slice(split + 1))
-  }
-  l.frame(text.slice(at + 1))
-}
-
 /** `c`: a socket's frames (socket.ts). `r`: realtime events, opened with a `/_weft/rt` body (hub.ts). */
-export function openLine(kind: 'c' | 'r', hello: string, frame: (text: string) => void, closed: (code: number, reason?: string) => void): Line {
+export function openLine(
+  kind: 'c' | 'r',
+  hello: string,
+  frame: (text: string) => void,
+  closed: (code: number, reason?: string) => void,
+): Line {
   start()
   const id = `${tab}.${++nth}`
   const l: Mine = { id, hello: `o:${id}:${kind}:${hello}`, frame, closed }
@@ -181,7 +83,9 @@ export function openLine(kind: 'c' | 'r', hello: string, frame: (text: string) =
   say(id, 'o', l.hello)
   if (!election?.leading()) election?.probe()
   return {
-    send(text) { if (lines.has(id)) say(id, 'f', `f:${id}:${text}`) },
+    send(text) {
+      if (lines.has(id)) say(id, 'f', `f:${id}:${text}`)
+    },
     close() {
       if (!lines.has(id)) return
       say(id, 'x', `x:${id}:`)
@@ -194,7 +98,11 @@ export function openLine(kind: 'c' | 'r', hello: string, frame: (text: string) =
 
 type Up = { tab: string; id: string; k: 'o' | 'x' | 'f'; l: string }
 type Note =
-  | { t: 'lead' } | { t: 'lost'; code: number; never: boolean } | { t: 'who'; tab: string } | { t: 'you'; to: string; u?: string } | { t: 'redial' }
+  | { t: 'lead' }
+  | { t: 'lost'; code: number; never: boolean }
+  | { t: 'who'; tab: string }
+  | { t: 'you'; to: string; u?: string }
+  | { t: 'redial' }
   | { t: 'bye'; tab: string }
 
 let running = false
@@ -218,13 +126,18 @@ function start() {
   running = true
   if (shareable()) {
     notes = new BroadcastChannel(NAME)
-    notes.onmessage = e => note(e.data)
+    notes.onmessage = (e) => note(e.data)
     down = new BroadcastChannel(`${NAME}:down:${tab}`)
-    down.onmessage = e => arrive(e.data)
+    down.onmessage = (e) => arrive(e.data)
     upTo = new BroadcastChannel(`${NAME}:up`)
   }
   listen()
-  election = campaign(NAME, lead, () => hangUp(HANDOVER), () => void linkStats.steals++)
+  election = campaign(
+    NAME,
+    lead,
+    () => hangUp(HANDOVER),
+    () => void linkStats.steals++,
+  )
   linkStats.role = 'follower'
   if (!shareable() || session) return
   gate = []
@@ -239,11 +152,12 @@ function note(m: Note) {
     if (election?.leading()) return
     if (m.never) socketFailures++
     endAll(m.code)
-  }
-  else if (m.t === 'who') { if (election?.leading()) notes!.postMessage({ t: 'you', to: m.tab, u: open ? user : undefined }) }
-  else if (m.t === 'you' && m.to === tab) theirs?.(m.u)
-  else if (m.t === 'redial') { if (election?.leading() && ws) lost(ws, HANDOVER, true) }
-  else if (m.t === 'bye') dropTab(m.tab)
+  } else if (m.t === 'who') {
+    if (election?.leading()) notes!.postMessage({ t: 'you', to: m.tab, u: open ? user : undefined })
+  } else if (m.t === 'you' && m.to === tab) theirs?.(m.u)
+  else if (m.t === 'redial') {
+    if (election?.leading() && ws) lost(ws, HANDOVER, true)
+  } else if (m.t === 'bye') dropTab(m.tab)
 }
 
 let session: Promise<void> | undefined
@@ -251,8 +165,15 @@ let theirs: ((u: string | undefined) => void) | undefined
 
 /** One round trip, once, the first time a tab that didn't dial opens a line: a new socket used to cost the same. */
 function checkSession() {
-  const mine = fetch('/_weft/rt', { method: 'POST', headers: { 'content-type': 'application/json', 'x-weft': '1' }, body: '{"w":1}' }).then(r => (r.ok ? r.json() : undefined)).then(r => r?.u as string | undefined).catch(() => undefined)
-  const leader = new Promise<string | undefined>(ok => {
+  const mine = fetch('/_weft/rt', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', 'x-weft': '1' },
+    body: '{"w":1}',
+  })
+    .then((r) => (r.ok ? r.json() : undefined))
+    .then((r) => r?.u as string | undefined)
+    .catch(() => undefined)
+  const leader = new Promise<string | undefined>((ok) => {
     theirs = ok
     notes!.postMessage({ t: 'who', tab })
     setTimeout(ok, 1000)
@@ -283,7 +204,7 @@ const opened = new Map<string, Set<string>>()
 const ears = new Map<string, BroadcastChannel>()
 let upFrom: BroadcastChannel | undefined
 
-const offline = () => ! navigator.onLine
+const offline = () => !navigator.onLine
 const send = (line: string) => {
   if (open) ws!.send(line)
   else {
@@ -305,13 +226,14 @@ function take(m: Up) {
   } else if (m.k === 'x') set?.delete(m.id)
   // A line that closed before the socket came never has to be opened.
   if (m.k === 'x' && !open) {
-    const hello = queue.findIndex(q => q.startsWith(`o:${m.id}:`))
+    const hello = queue.findIndex((q) => q.startsWith(`o:${m.id}:`))
     if (hello >= 0) queue.splice(hello, 1)
   } else send(m.l)
-  if (![...opened.values()].some(s => s.size)) idle ??= setTimeout(() => {
-    idle = undefined
-    if (ws && ![...opened.values()].some(s => s.size)) lost(ws, 1000)
-  }, IDLE)
+  if (![...opened.values()].some((s) => s.size))
+    idle ??= setTimeout(() => {
+      idle = undefined
+      if (ws && ![...opened.values()].some((s) => s.size)) lost(ws, 1000)
+    }, IDLE)
 }
 
 function dropTab(t: string) {
@@ -351,22 +273,29 @@ function forward(owner: string, text: string) {
 }
 
 function wantSocket() {
-  if (ws || retry !== undefined || !election?.leading() || offline()) return
+  if (!SOCKETS || ws || retry !== undefined || !election?.leading() || offline()) return
   if (!attempt) return dial()
-  retry = setTimeout(() => {
-    retry = undefined
-    dial()
-  }, Math.random() * Math.min(CAP, BASE * 2 ** attempt))
+  retry = setTimeout(
+    () => {
+      retry = undefined
+      dial()
+    },
+    Math.random() * Math.min(CAP, BASE * 2 ** attempt),
+  )
 }
 
 function dial() {
   if (ws || !election?.leading()) return
   linkStats.dials++
-  const s = new WebSocket(`${location.protocol === 'https:' ? 'wss' : 'ws'}://${location.host}/_weft/ws?mux=1`)
+  const s = new WebSocket(
+    `${location.protocol === 'https:' ? 'wss' : 'ws'}://${location.host}/_weft/ws?mux=1`,
+  )
   ws = s
-  s.onmessage = e => arriveFrom(e.data)
+  s.onmessage = (e) => arriveFrom(e.data)
   s.onclose = () => lost(s, 1006)
-  ping = setInterval(() => { if (open) s.send('p') }, PING)
+  ping = setInterval(() => {
+    if (open) s.send('p')
+  }, PING)
   dead = setTimeout(() => lost(s, 1006), DEAD)
 }
 
@@ -413,7 +342,7 @@ function lead() {
   linkStats.role = 'leader'
   if (shareable()) {
     upFrom = new BroadcastChannel(`${NAME}:up`)
-    upFrom.onmessage = e => take(e.data)
+    upFrom.onmessage = (e) => take(e.data)
     notes!.postMessage({ t: 'lead' })
   }
   // What this tab held for the session check goes straight out, and its lines were waiting on nobody.