@lincyaw/server 1.0.0-rc.0 → 1.0.0-rc.10

package/README.md

@@ -2,7 +2,7 @@
 
 The server of `presmium dev` and `presmium serve`: plugin routes and proxies under `/__presmium/`, approvals, the control channel and the MCP endpoint. It listens on this machine only unless `presmium serve --host` is given.
 
-Part of [Presmium](https://github.com/Lincyaw/presmium), which turns lectures written in MyST Markdown into web pages, slides, Jupyter notebooks and narrated lectures.
+Part of [Presmium](https://github.com/Lincyaw/presmium), which compiles canonical lecture.json teaching documents into web pages, slides, Jupyter notebooks and narrated playback.
 
 ## Install
 
@@ -10,7 +10,7 @@ It comes with `@lincyaw/cli`; you do not install it yourself. Its programming in
 
 ## Documentation
 
-- [Plugin guide](https://github.com/Lincyaw/presmium/blob/main/site/plugins/lecture.en.md): server routes
+- [Plugin guide](https://github.com/Lincyaw/presmium/blob/main/site/plugins/locales/en/lecture.json): server routes
 - [Security and the trust model](https://github.com/Lincyaw/presmium/blob/main/SECURITY.md)
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lincyaw/server",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.10",
   "description": "The server of presmium dev and presmium serve: plugin routes and proxies, approvals, the control channel and MCP",
   "license": "Apache-2.0",
   "repository": {
@@ -31,9 +31,9 @@
     "@hono/node-server": "2.1.3",
     "hono": "4.13.13",
     "http-proxy-3": "2.0.1",
-    "@lincyaw/compiler": "1.0.0-rc.0",
-    "@lincyaw/kernel": "1.0.0-rc.0",
-    "@lincyaw/mcp": "1.0.0-rc.0"
+    "@lincyaw/compiler": "1.0.0-rc.10",
+    "@lincyaw/kernel": "1.0.0-rc.10",
+    "@lincyaw/mcp": "1.0.0-rc.10"
   },
   "devDependencies": {
     "@modelcontextprotocol/client": "2.3.1"

package/src/auth.ts

@@ -1,9 +1,8 @@
 import type { IncomingMessage } from 'node:http'
-import { hostname as machineName, networkInterfaces } from 'node:os'
+import { hostname, networkInterfaces } from 'node:os'
+import { LOCAL_AUTHOR } from '@lincyaw/kernel'
 import type { Member } from '@lincyaw/kernel'
-import { header, hostname, isLoopback, originHost } from './http.ts'
-
-export const LOCAL_AUTHOR: Member = { id: 'local', name: 'local author', roles: ['owner'] }
+import { header, isLoopback, normalizeHostName, originHost } from './http.ts'
 
 export interface Refusal {
   status: number
@@ -12,21 +11,17 @@ export interface Refusal {
 
 export type MachineHosts = (host: string) => boolean
 
-export function anyAddress(host: string): boolean {
-  return ['0.0.0.0', '[::]'].includes(hostname(host))
-}
-
-export function networkAddresses(): string[] {
-  return Object.values(networkInterfaces()).flatMap(entries => entries ?? []).filter(entry => entry.family === 'IPv4' && !entry.internal).map(entry => entry.address)
+export function isAnyAddress(address: string): boolean {
+  return ['0.0.0.0', '[::]'].includes(normalizeHostName(address))
 }
 
-export function machineHosts(listen: string): MachineHosts {
-  const own = hostname(listen)
+export function machineHosts(listenAddress: string): MachineHosts {
+  const own = normalizeHostName(listenAddress)
   if (isLoopback(own)) return isLoopback
-  const addresses = anyAddress(own)
-    ? Object.values(networkInterfaces()).flatMap(entries => entries ?? []).map(entry => hostname(entry.address.replace(/%.*$/, '')))
+  const addresses = isAnyAddress(own)
+    ? Object.values(networkInterfaces()).flatMap(entries => entries ?? []).map(entry => normalizeHostName(entry.address.replace(/%.*$/, '')))
     : [own]
-  const name = machineName().toLowerCase()
+  const name = hostname().toLowerCase()
   const names = new Set([...addresses, name, `${name}.local`])
   return host => isLoopback(host) || names.has(host)
 }
@@ -34,7 +29,7 @@ export function machineHosts(listen: string): MachineHosts {
 export function authenticate(req: IncomingMessage, local: MachineHosts = isLoopback): Member | Refusal {
   const host = header(req.headers, 'host')
   const origin = originHost(header(req.headers, 'origin'))
-  if (!local(hostname(host))) return { status: 403, message: `Host ${host ?? '(none)'} is not this machine` }
+  if (!local(normalizeHostName(host))) return { status: 403, message: `Host ${host ?? '(none)'} is not this machine` }
   if (origin !== undefined && !local(origin)) return { status: 403, message: `Origin ${header(req.headers, 'origin')} is not this machine` }
   return LOCAL_AUTHOR
 }

package/src/control.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto'
-import type { ApprovalKind, ApprovalRequest, Approvals, Member, MemberRole } from '@lincyaw/kernel'
+import { hasRole, isPresentingRole, pushStream } from '@lincyaw/kernel'
+import type { ApprovalKind, ApprovalRequest, Approvals, Member, MemberRole, PushStream } from '@lincyaw/kernel'
 
 export type ApprovalPolicy = 'off' | 'ask' | 'allow'
 
@@ -20,10 +21,17 @@ export interface WindowReport {
   at: number
 }
 
+export interface WindowFilter {
+  member?: Member
+  document?: string
+}
+
 interface Window {
   id: string
   member: Member
   document: string
+  /** Hears approvals only: not a viewer, so it is never navigated, counted or asked to report. */
+  observer: boolean
   report?: WindowReport
   send(event: string, data: unknown): void
   close(): void
@@ -36,13 +44,8 @@ interface Pending {
   settle(allow: boolean): void
 }
 
-function presents(window: { report?: WindowReport }): boolean {
-  return window.report?.role === 'presenter' || window.report?.role === 'audience'
-}
-
-export function hasRole(member: Member, role: MemberRole): boolean {
-  const rank: Record<MemberRole, number> = { reader: 0, editor: 1, owner: 2 }
-  return member.roles.some(own => rank[own] >= rank[role])
+function isPresenting(window: Window): boolean {
+  return isPresentingRole(window.report?.role)
 }
 
 export interface ControlOptions {
@@ -50,7 +53,7 @@ export interface ControlOptions {
   timeoutMs?: number
 }
 
-export class Control {
+export class ControlChannel {
   readonly #windows = new Map<string, Window>()
   readonly #pending = new Map<string, Pending>()
   readonly #watchers = new Set<() => void>()
@@ -64,52 +67,26 @@ export class Control {
     request: (request, signal) => this.#request(request, signal),
   }
 
-  open(id: string, member: Member, document: string): AsyncIterable<{ event: string, data: unknown }> & { close(): void } {
+  open(id: string, member: Member, document: string, options: { observer?: boolean } = {}): PushStream<{ event: string, data: unknown }> {
     this.#windows.get(id)?.close()
-    const queue: { event: string, data: unknown }[] = []
-    let wake: (() => void) | undefined
-    let closed = false
-    const window: Window = {
-      id,
-      member,
-      document,
-      send(event, data) {
-        if (closed) return
-        queue.push({ event, data })
-        wake?.()
-      },
-      close: () => {
-        closed = true
+    let window!: Window
+    const stream = pushStream<{ event: string, data: unknown }>((push) => {
+      window = { id, member, document, observer: options.observer === true, send: (event, data) => push({ event, data }), close: () => stream.end() }
+      this.#windows.set(id, window)
+      return () => {
         if (this.#windows.get(id) === window) this.#windows.delete(id)
-        wake?.()
-      },
-    }
-    this.#windows.set(id, window)
+      }
+    })
     window.send('ready', { window: id })
     for (const pending of this.#pending.values()) {
       if (this.#eligible(member, pending.request)) window.send('approval', { id: pending.id, request: pending.request })
     }
-    const stream = {
-      close: window.close,
-      async* [Symbol.asyncIterator]() {
-        try {
-          while (!closed) {
-            while (queue.length > 0) yield queue.shift()!
-            if (closed) break
-            await new Promise<void>(resolve => wake = resolve)
-            wake = undefined
-          }
-        } finally {
-          window.close()
-        }
-      },
-    }
     return stream
   }
 
   report(id: string, member: Member, report: Omit<WindowReport, 'at'>): boolean {
     const window = this.#windows.get(id)
-    if (!window || window.member.id !== member.id) return false
+    if (!window || window.observer || window.member.id !== member.id) return false
     const moved = JSON.stringify(report.position) !== JSON.stringify(window.report?.position)
     window.report = { ...report, at: Date.now() }
     if (moved) for (const listener of [...this.#watchers]) listener()
@@ -133,24 +110,24 @@ export class Control {
     return 200
   }
 
-  positions(member?: Member, document?: string, viewer?: Member): { window: string, member: string, roles: MemberRole[], document: string, report: WindowReport }[] {
-    const all = [...this.#windows.values()].filter(w => w.report?.position && (!member || w.member.id === member.id) && (document === undefined || w.document === document))
-    const trusted = (w: Window) => hasRole(w.member, 'editor') || w.member.id === viewer?.id
-    const rank = (w: Window) => (!trusted(w) ? 2 : presents(w) ? 0 : 1)
+  positions(filter: WindowFilter & { viewer?: Member } = {}): { window: string, member: string, roles: MemberRole[], document: string, report: WindowReport }[] {
+    const all = this.#windowsOf(filter).filter(w => w.report?.position)
+    const trusted = (w: Window) => hasRole(w.member, 'editor') || w.member.id === filter.viewer?.id
+    const rank = (w: Window) => (!trusted(w) ? 2 : isPresenting(w) ? 0 : 1)
     return all.sort((a, b) => rank(a) - rank(b) || b.report!.at - a.report!.at)
       .map(w => ({ window: w.id, member: w.member.id, roles: w.member.roles, document: w.document, report: w.report! }))
   }
 
-  go(position: WindowPosition, member?: Member, document?: string): number {
-    const windows = [...this.#windows.values()].filter(w => (!member || w.member.id === member.id) && (document === undefined || w.document === document))
-    const presenting = windows.filter(w => w.report?.role === 'presenter' || w.report?.role === 'audience')
+  go(position: WindowPosition, filter: WindowFilter = {}): number {
+    const windows = this.#windowsOf(filter)
+    const presenting = windows.filter(isPresenting)
     const targets = presenting.length > 0 ? presenting : windows
     for (const window of targets) window.send('go', position)
     return targets.length
   }
 
-  session(action: 'start' | 'end', name?: string, document?: string, member?: Member): number {
-    const windows = [...this.#windows.values()].filter(w => (!member || w.member.id === member.id) && (document === undefined || w.document === document) && (w.report?.role === 'presenter' || w.report?.role === 'audience'))
+  setClassroom(action: 'start' | 'end', name: string | undefined, filter: WindowFilter = {}): number {
+    const windows = this.#windowsOf(filter).filter(isPresenting)
     for (const window of windows) window.send('session', { action, name })
     return windows.length
   }
@@ -165,6 +142,14 @@ export class Control {
     return out
   }
 
+  runtime(document: string): { window: string, report: WindowReport }[] {
+    return [...this.#windows.values()]
+      .filter(window => window.document === document && window.report?.status && hasRole(window.member, 'editor'))
+      .sort((a, b) => b.report!.at - a.report!.at)
+      .slice(0, 8)
+      .map(window => ({ window: window.id, report: window.report! }))
+  }
+
   close(): void {
     for (const pending of [...this.#pending.values()]) pending.settle(false)
     for (const window of [...this.#windows.values()]) window.close()
@@ -198,6 +183,10 @@ export class Control {
     })
   }
 
+  #windowsOf(filter: WindowFilter): Window[] {
+    return [...this.#windows.values()].filter(w => !w.observer && (!filter.member || w.member.id === filter.member.id) && (filter.document === undefined || w.document === filter.document))
+  }
+
   #eligible(member: Member, request: ApprovalRequest): boolean {
     if ((request.scope ?? 'workspace') === 'workspace') return hasRole(member, 'owner')
     return request.member ? member.id === request.member : hasRole(member, 'editor')

package/src/diagnostics.ts

@@ -0,0 +1,139 @@
+import { isAbsolute, relative } from 'node:path'
+import { diagnosticOf, pushStream } from '@lincyaw/kernel'
+import type { AuthoringDiagnostics, Diagnostic, DiagnosticOrigin, DiagnosticSnapshot, Finding, IRDocument, PreviewDiagnostics } from '@lincyaw/kernel'
+
+export interface DiagnosticSource {
+  document: string
+  origin: DiagnosticOrigin
+  renderer?: 'web' | 'slides'
+  instance?: string
+}
+
+interface Contribution {
+  source: DiagnosticSource
+  diagnostics: Diagnostic[]
+}
+
+export function workspaceFindings(findings: Finding[], root: string): Finding[] {
+  return findings.map(finding => ({
+    ...finding,
+    ...finding.source ? { source: { ...finding.source, file: (isAbsolute(finding.source.file) ? relative(root, finding.source.file) : finding.source.file).replace(/\\/g, '/') } } : {},
+  }))
+}
+
+/** Each producer replaces its current contribution. No diagnostic event history is kept. */
+export class DiagnosticStore {
+  readonly #contributions = new Map<string, Contribution>()
+  readonly #irRevisions = new Map<string, string | undefined>()
+  readonly #watchers = new Set<(document: string) => void>()
+  #version = 0
+
+  isObserved(document: string): boolean {
+    return this.#irRevisions.has(document)
+  }
+
+  irRevision(document: string): string | undefined {
+    return this.#irRevisions.get(document)
+  }
+
+  snapshot(document?: string): DiagnosticSnapshot {
+    const diagnostics = new Map<string, Diagnostic>()
+    for (const contribution of this.#contributions.values()) {
+      if (document !== undefined && contribution.source.document !== document) continue
+      for (const diagnostic of contribution.diagnostics) diagnostics.set(diagnostic.id, diagnostic)
+    }
+    return {
+      version: this.#version,
+      diagnostics: [...diagnostics.values()].map(diagnostic => ({ ...diagnostic, ...diagnostic.source ? { source: { ...diagnostic.source } } : {}, ...diagnostic.authoringSource ? { authoringSource: { ...diagnostic.authoringSource } } : {} })),
+    }
+  }
+
+  replace(source: DiagnosticSource, findings: Finding[], options: { irRevision?: string, root?: string } = {}): void {
+    const key = JSON.stringify([source.document, source.origin, source.renderer, source.instance])
+    const normalized = options.root ? workspaceFindings(findings, options.root) : findings
+    const diagnostics = normalized.map(finding => diagnosticOf(source.document, source.origin, finding, source.renderer, options.irRevision))
+    const previous = this.#contributions.get(key)
+    if (JSON.stringify(previous?.diagnostics ?? []) === JSON.stringify(diagnostics)) return
+    if (diagnostics.length) this.#contributions.set(key, { source, diagnostics })
+    else this.#contributions.delete(key)
+    this.#changed(source.document)
+  }
+
+  compiled(document: string, doc: IRDocument, root: string, irRevision?: string): void {
+    if (!this.#irRevisions.has(document) || this.#irRevisions.get(document) !== irRevision) {
+      this.#remove(document, source => source.origin === 'check' || source.origin === 'runtime')
+    }
+    this.#irRevisions.set(document, irRevision)
+    this.replace({ document, origin: 'compile' }, doc.diagnostics, { root, irRevision })
+  }
+
+  failed(document: string, message: string, source?: Finding['source']): void {
+    this.#irRevisions.set(document, undefined)
+    this.#remove(document, contribution => contribution.origin === 'check' || contribution.origin === 'runtime')
+    this.replace({ document, origin: 'compile' }, [{ checkId: 'presmium.compile', severity: 'error', message, ...source ? { source } : {} }])
+  }
+
+  report(report: PreviewDiagnostics): boolean {
+    const source: DiagnosticSource = { document: report.document, origin: 'runtime', renderer: report.renderer, instance: report.instance }
+    // A closing frame can always remove its own contribution, including after a new compile.
+    if (!report.findings.length) {
+      this.replace(source, [])
+      return true
+    }
+    if (!this.#irRevisions.has(report.document) || this.#irRevisions.get(report.document) !== report.revision) return false
+    this.replace(source, report.findings, { irRevision: report.revision })
+    return true
+  }
+
+  /** This producer describes authoring-window failures, independently of runtime compilation. */
+  reportAuthoring(report: AuthoringDiagnostics, member: string): void {
+    this.replace({ document: report.document, origin: 'authoring', instance: JSON.stringify([member, report.instance]) }, report.findings)
+  }
+
+  forget(document: string): void {
+    this.#irRevisions.delete(document)
+    this.#remove(document, () => true)
+  }
+
+  clear(document: string, origin: DiagnosticOrigin, renderer?: 'web' | 'slides'): void {
+    this.#remove(document, source => source.origin === origin && (renderer === undefined || source.renderer === renderer))
+  }
+
+  watch(listener: (document: string) => void): () => void {
+    this.#watchers.add(listener)
+    return () => { this.#watchers.delete(listener) }
+  }
+
+  events(document: string | undefined, signal: AbortSignal): AsyncIterable<{ event: string, data: DiagnosticSnapshot }> {
+    const store = this
+    return {
+      async* [Symbol.asyncIterator]() {
+        if (signal.aborted) return
+        const changes = pushStream<void>(push => store.watch((changed) => {
+          if (document === undefined || document === changed) push()
+        }), { signal, latestOnly: true })
+        try {
+          yield { event: 'diagnostics', data: store.snapshot(document) }
+          for await (const _change of changes) yield { event: 'diagnostics', data: store.snapshot(document) }
+        } finally {
+          changes.end()
+        }
+      },
+    }
+  }
+
+  #remove(document: string, matches: (source: DiagnosticSource) => boolean): void {
+    let changed = false
+    for (const [key, contribution] of this.#contributions) {
+      if (contribution.source.document !== document || !matches(contribution.source)) continue
+      this.#contributions.delete(key)
+      changed = true
+    }
+    if (changed) this.#changed(document)
+  }
+
+  #changed(document: string): void {
+    this.#version++
+    for (const watcher of this.#watchers) watcher(document)
+  }
+}

package/src/focus.ts

@@ -1,4 +1,4 @@
-import { focusReport, resolveFocus } from '@lincyaw/mcp'
+import { resolveFocus, toFocusReport } from '@lincyaw/mcp'
 import type { McpFocus } from '@lincyaw/mcp'
 import type { FocusReport, IRDocument } from '@lincyaw/kernel'
 
@@ -8,15 +8,15 @@ export class FocusStore {
   readonly #latest = new Map<string, McpFocus>()
   readonly #watchers = new Set<() => void>()
 
-  get(document?: string): McpFocus | undefined {
+  find(document?: string): McpFocus | undefined {
     if (document !== undefined) return this.#latest.get(document)
     let newest: McpFocus | undefined
     for (const found of this.#latest.values()) if (!newest || found.at >= newest.at) newest = found
     return newest
   }
 
-  report(document: string, doc: IRDocument, reports: FocusReport[]): McpFocus {
-    const record = { document, focus: reports.map(report => resolveFocus(doc, document, report)), at: Date.now() }
+  report(document: string, doc: IRDocument | undefined, reports: FocusReport[], readWorkspaceFile?: (file: string) => string): McpFocus {
+    const record = { document, focus: reports.map(report => resolveFocus(doc, document, report, undefined, readWorkspaceFile)), at: Date.now() }
     this.#latest.set(document, record)
     for (const watcher of this.#watchers) watcher()
     return record
@@ -32,14 +32,14 @@ export class FocusStore {
   }
 }
 
-export function focusBody(body: unknown): { document: string, focus: FocusReport[] } | string {
+export function toFocusRequest(body: unknown): { document: string, focus: FocusReport[] } | string {
   if (!body || typeof body !== 'object') return 'a JSON object { document, focus: [...] }'
   const { document, focus } = body as { document?: unknown, focus?: unknown }
   if (typeof document !== 'string') return 'the document directory (relative to the workspace root) as `document`'
   if (!Array.isArray(focus) || focus.length > MAX_FOCUS) return `focus is a list of at most ${MAX_FOCUS}`
   const reports: FocusReport[] = []
   for (const item of focus) {
-    const report = focusReport(item)
+    const report = toFocusReport(item)
     if (typeof report === 'string') return report
     reports.push(report)
   }

package/src/http.ts

@@ -1,14 +1,17 @@
-import { createServer } from 'node:http'
+import { timingSafeEqual } from 'node:crypto'
+import { Agent, createServer } from 'node:http'
+import { Agent as HttpsAgent } from 'node:https'
 import type { IncomingHttpHeaders, IncomingMessage, Server, ServerResponse } from 'node:http'
 import type { AddressInfo } from 'node:net'
 import type { Duplex } from 'node:stream'
 import { getRequestListener } from '@hono/node-server'
-import { json, problem } from '@lincyaw/kernel'
+import { jsonResponse } from '@lincyaw/kernel'
+import { bracketIPv6 } from '@lincyaw/kernel/node'
 import { createProxyServer } from 'http-proxy-3'
 
 const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]'])
 
-export function hostname(host: string | null | undefined): string {
+export function normalizeHostName(host: string | null | undefined): string {
   if (!host) return ''
   const value = host.trim().toLowerCase()
   if (value.startsWith('[')) return value.slice(0, value.indexOf(']') + 1)
@@ -17,13 +20,13 @@ export function hostname(host: string | null | undefined): string {
 }
 
 export function isLoopback(host: string | null | undefined): boolean {
-  return LOOPBACK.has(hostname(host))
+  return LOOPBACK.has(normalizeHostName(host))
 }
 
 export function originHost(origin: string | null | undefined): string | undefined {
   if (origin === null || origin === undefined) return undefined
   try {
-    return hostname(new URL(origin).host)
+    return normalizeHostName(new URL(origin).host)
   } catch {
     return ''
   }
@@ -34,10 +37,14 @@ export function bearer(value: string | null | undefined): string | undefined {
   return match?.[1]
 }
 
-export { json, problem }
+export function hasBearerToken(request: Request, accessToken: string): boolean {
+  const given = Buffer.from(bearer(request.headers.get('authorization')) ?? '')
+  const own = Buffer.from(accessToken)
+  return given.length === own.length && timingSafeEqual(given, own)
+}
 
 export async function limitBody(request: Request, limit: number): Promise<Request | Response> {
-  const tooLarge = () => json({ error: `the request body is larger than this route takes (${limit} bytes)` }, 413)
+  const tooLarge = () => jsonResponse({ error: `the request body is larger than this route takes (${limit} bytes)` }, 413)
   const declared = Number(request.headers.get('content-length') ?? Number.NaN)
   if (declared > limit) return tooLarge()
   if (!request.body) return request
@@ -90,6 +97,9 @@ export interface ProxyTarget {
 }
 
 export function createProxy() {
+  // A page loads hundreds of modules: the connections to the targets are kept and reused, not opened for each.
+  const agents = { http: new Agent({ keepAlive: true, maxSockets: 64 }), https: new HttpsAgent({ keepAlive: true, maxSockets: 64 }) }
+  const agentFor = (target: string) => (target.startsWith('https:') || target.startsWith('wss:') ? agents.https : agents.http)
   const proxy = createProxyServer({ ws: true, xfwd: false })
   proxy.on('error', (error: Error, _req: unknown, res: unknown) => {
     const response = res as ServerResponse | Duplex | undefined
@@ -103,13 +113,17 @@ export function createProxy() {
   return {
     web(req: IncomingMessage, res: ServerResponse, to: ProxyTarget): void {
       req.url = to.path
-      proxy.web(req, res, { target: to.target, headers: to.headers })
+      proxy.web(req, res, { target: to.target, headers: to.headers, agent: agentFor(to.target) })
     },
     ws(req: IncomingMessage, socket: Duplex, head: Buffer, to: ProxyTarget): void {
       req.url = to.path
-      proxy.ws(req, socket, head, { target: to.target, headers: to.headers })
+      proxy.ws(req, socket, head, { target: to.target, headers: to.headers, agent: agentFor(to.target) })
+    },
+    close: () => {
+      proxy.close()
+      agents.http.destroy()
+      agents.https.destroy()
     },
-    close: () => proxy.close(),
   }
 }
 
@@ -125,10 +139,12 @@ export function nodeServer(options: {
   decideUpgrade(req: IncomingMessage): Promise<{ to?: ProxyTarget, status?: number }>
   fetch(request: Request, req: IncomingMessage): Promise<Response>
   proxy: Proxy
-}): Server {
+}): { server: Server, close(): Promise<void> } {
   const listener = getRequestListener((request, env) => options.fetch(request, (env as { incoming: IncomingMessage }).incoming))
+  const upgrades = new Set<Duplex>()
   const server = createServer((req, res) => {
     void options.decide(req).then((decision) => {
+      if (res.destroyed) return
       if (decision.kind === 'fetch') return listener(req, res)
       if (decision.kind === 'proxy') return options.proxy.web(req, res, decision.to)
       return send(res, decision.response)
@@ -138,12 +154,22 @@ export function nodeServer(options: {
     })
   })
   server.on('upgrade', (req: IncomingMessage, socket: Duplex, head: Buffer) => {
+    upgrades.add(socket)
+    socket.once('close', () => upgrades.delete(socket))
     void options.decideUpgrade(req).then(({ to, status }) => {
+      if (socket.destroyed) return
       if (to) options.proxy.ws(req, socket, head, to)
       else refuseUpgrade(socket, status ?? 404)
     }, () => refuseUpgrade(socket, 500))
   })
-  return server
+  return {
+    server,
+    close: () => new Promise((resolve) => {
+      server.close(() => resolve())
+      server.closeAllConnections()
+      for (const socket of upgrades) socket.destroy()
+    }),
+  }
 }
 
 export function listen(server: Server, port: number, host: string): Promise<number> {
@@ -156,14 +182,7 @@ export function listen(server: Server, port: number, host: string): Promise<numb
   })
 }
 
-export function closeServer(server: Server): Promise<void> {
-  return new Promise((resolve) => {
-    server.close(() => resolve())
-    server.closeAllConnections()
-  })
-}
-
 export function urlHost(host: string): string {
   if (host === '0.0.0.0' || host === '::') return '127.0.0.1'
-  return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host
+  return bracketIPv6(host)
 }

package/src/index.ts

@@ -1,8 +1,8 @@
-export { APPROVAL_TIMEOUT_MS, Control } from './control.ts'
-export type { ApprovalPolicy, WindowPosition, WindowReport } from './control.ts'
-export { servedDocument } from './host.ts'
-export type { HostDocument, ServedDocument, ServedPlugin, ServerHost } from './host.ts'
-export { anyAddress, networkAddresses } from './auth.ts'
-export { bearer, isLoopback, json, limitBody, problem } from './http.ts'
-export { LOCAL_AUTHOR, SERVER_PATH, startServer } from './server.ts'
+export type { ApprovalPolicy } from './control.ts'
+export { DiagnosticStore } from './diagnostics.ts'
+export { serverConfigKey, servedDocument } from './server-host.ts'
+export type { ServedDocument, ServedPlugin, ServerHost } from './server-host.ts'
+export { isAnyAddress } from './auth.ts'
+export { hasBearerToken, isLoopback } from './http.ts'
+export { startServer } from './server.ts'
 export type { PresmiumServer, ServerOptions } from './server.ts'