@weft-js/start 0.1.1 → 0.1.3

package/src/verify/live.ts

@@ -0,0 +1,63 @@
+import type { VerifyOptions } from '../data'
+import type { Link } from '../verify'
+import { Broke, read, type subscribe } from './support'
+import type { openApp } from './app'
+
+type Timed = <T>(link: Link, run: () => Promise<T>) => Promise<T>
+type Live = Awaited<ReturnType<typeof openApp>>
+type Denied = Awaited<ReturnType<typeof subscribe>> | undefined
+
+export async function checkLive(o: {
+  live: Live
+  denied: Denied
+  timed: Timed
+  skip: (links: Link[], why: string) => void
+  url: string
+  id: string
+  input: unknown
+  cookie: string | undefined
+  other: string | undefined
+  marker: string
+  timeout: number
+  options: VerifyOptions
+}) {
+  const { live, denied, timed, skip, url, id, input, cookie, other, marker, timeout, options } = o
+  await timed('poke', async () => {
+    const p = await live.until(
+      (f) => f[0] === 'p' && (f[1] as { t: string[] }).t.some((t) => live.tags.includes(t)),
+      timeout,
+    )
+    if (!p)
+      throw new Broke(
+        'poke',
+        `the database notified, and the app never poked this subscription within ${timeout} ms: its listener, or a tag the query doesn't declare`,
+      )
+  })
+  await timed('refetch', async () => {
+    const end = Date.now() + timeout
+    for (;;) {
+      const res = await read(url, id, input, cookie)
+      if (res.ok && (await res.text()).includes(marker)) return
+      if (Date.now() > end)
+        throw new Broke(
+          'refetch',
+          `poked, and the query didn't return the row within ${timeout} ms${options.row ? '' : ': if it filters by user, say whose it is in `verify.row`'}`,
+        )
+      await new Promise((ok) => {
+        setTimeout(ok, 50)
+      })
+    }
+  })
+  if (denied)
+    await timed('denied', async () => {
+      const res = await read(url, id, input, other)
+      const text = await res.text()
+      if (text.includes(marker) || denied.frames.some((f) => JSON.stringify(f[1]).includes(marker)))
+        throw new Broke('denied', `${other ? 'the other user' : 'a signed-out client'} got the row`)
+    })
+  else
+    skip(
+      ['denied'],
+      'a query with no `auth` and no other user to compare: set `WEFT_STAGING_OTHER_COOKIE`',
+    )
+}

package/src/verify/notify.ts

@@ -0,0 +1,35 @@
+import { CHANNEL } from '../changes-sql.mjs'
+import { Broke } from './support'
+
+export async function waitNotice(
+  heard: string[],
+  table: string,
+  id: string,
+  timeout: number,
+  setHearing: (fn: () => void) => void,
+) {
+  const seen = () =>
+    heard.some((h) => {
+      try {
+        const m = JSON.parse(h)
+        return m.t === table && (!m.i || m.i.includes(id))
+      } catch {
+        return false
+      }
+    })
+  if (!seen())
+    await new Promise<void>((ok) => {
+      const t = setTimeout(ok, timeout)
+      setHearing(() => {
+        if (seen()) {
+          clearTimeout(t)
+          ok()
+        }
+      })
+    })
+  if (!seen())
+    throw new Broke(
+      'notify',
+      `the trigger on \`${table}\` sent nothing on \`${CHANNEL}\` within ${timeout} ms`,
+    )
+}

package/src/verify/skip.ts

@@ -0,0 +1,19 @@
+import type { Link, VerifyResult } from '../verify'
+
+export function skipper(untested: VerifyResult['untested']) {
+  return (links: Link[], why: string) => {
+    for (const link of links) untested.push({ link, why })
+  }
+}
+
+export function skipWithoutUrl(
+  url: string | undefined,
+  sql: unknown,
+  skip: (links: Link[], why: string) => void,
+) {
+  if (!url)
+    skip(
+      sql ? ['app', 'poke', 'refetch', 'denied'] : ['app'],
+      'no URL target: the database half was tested, not the running app. Set `WEFT_STAGING_URL` or `verify.url`',
+    )
+}

package/src/verify/support.ts

@@ -0,0 +1,149 @@
+import type postgres from 'postgres'
+import type { Link } from '../verify'
+
+export class Broke extends Error {
+  constructor(
+    public link: Link,
+    why: string,
+  ) {
+    super(why)
+  }
+}
+
+export const clean = (s: unknown) =>
+  String((s as Error | null | undefined)?.message ?? s).replace(/\/\/[^@/\s]*@/g, '//…@')
+
+/** A value for a required column nobody named. Foreign keys can't be guessed: `row` is for those. */
+function made(type: string, marker: string): unknown {
+  if (/uuid/.test(type)) return crypto.randomUUID()
+  if (/int|serial/.test(type)) return Math.floor(Math.random() * 2_000_000_000)
+  if (/numeric|double|real|money/.test(type)) return 0
+  if (/bool/.test(type)) return false
+  if (/timestamp|date/.test(type)) return new Date().toISOString()
+  if (/time/.test(type)) return '00:00:00'
+  if (/json/.test(type)) return JSON.stringify({ marker })
+  return marker
+}
+
+export async function insert(
+  sql: postgres.Sql,
+  table: string,
+  marker: string,
+  row: Record<string, unknown>,
+  pk: string[],
+) {
+  const cols =
+    await sql`select column_name, data_type, is_nullable, column_default, is_identity, is_generated from information_schema.columns where table_schema = current_schema() and table_name = ${table} order by ordinal_position`
+  if (!cols.length) throw new Broke('write', `no table \`${table}\` in this database`)
+  const values: Record<string, unknown> = { ...row }
+  let marked = false
+  for (const c of cols) {
+    const name = c.column_name as string
+    if (name in values) continue
+    if (/char|text/.test(c.data_type) && !marked) {
+      values[name] = marker
+      marked = true
+    } else if (
+      c.is_nullable === 'NO' &&
+      c.column_default === null &&
+      c.is_identity === 'NO' &&
+      c.is_generated === 'NEVER'
+    )
+      values[name] = made(c.data_type, marker)
+  }
+  if (!marked)
+    throw new Broke(
+      'write',
+      `\`${table}\` has no free text column to mark a row with: name one less in \`row\``,
+    )
+  const names = Object.keys(values)
+  const quoted = (n: string) => `"${n.replaceAll('"', '""')}"`
+  const key = pk.length ? pk : names.slice(0, 1)
+  const [got] = await sql.unsafe(
+    `insert into ${quoted(table)} (${names.map(quoted).join(', ')}) values (${names.map((_, i) => `$${i + 1}`).join(', ')}) returning ${key.map(quoted).join(', ')}`,
+    names.map((n) => values[n]) as never[],
+  )
+  if (!got) throw new Broke('write', `\`${table}\` took the row and returned nothing`)
+  const where = key.map((k, i) => `${quoted(k)} = $${i + 1}`).join(' and ')
+  return {
+    id: key.map((k) => String(got[k])).join(':'),
+    remove: () =>
+      sql.unsafe(
+        `delete from ${quoted(table)} where ${where}`,
+        key.map((k) => got[k]),
+      ),
+  }
+}
+
+export async function primaryKey(sql: postgres.Sql, table: string): Promise<string[]> {
+  const rows =
+    await sql`select a.attname from pg_index i join pg_class c on c.oid = i.indrelid join pg_attribute a on a.attrelid = c.oid and a.attnum = any(i.indkey) where c.relname = ${table} and i.indisprimary`
+  return rows.map((r) => r.attname as string)
+}
+
+/** One SSE connection to the app, by the protocol a browser's tab speaks. */
+type Frame = [event: string, data: unknown]
+export type Hello = { l?: { m?: string; d?: unknown } }
+
+export async function subscribe(
+  url: string,
+  id: string,
+  input: unknown,
+  cookie: string | undefined,
+  signal: AbortSignal,
+) {
+  const res = await fetch(`${url}/_weft/rt`, {
+    method: 'POST',
+    signal,
+    headers: {
+      'content-type': 'application/json',
+      'x-weft': '1',
+      accept: 'text/event-stream',
+      origin: url,
+      ...(cookie && { cookie }),
+    },
+    body: JSON.stringify({ s: [[1, 'q', id, input]] }),
+  })
+  if (!res.ok) throw new Error(`\`/_weft/rt\` answered ${res.status}`)
+  const frames: Frame[] = []
+  const waiting = new Set<() => void>()
+  void (async () => {
+    const dec = new TextDecoder()
+    let buf = ''
+    try {
+      for await (const chunk of res.body as unknown as AsyncIterable<Uint8Array>) {
+        buf += dec.decode(chunk, { stream: true })
+        for (let i; (i = buf.indexOf('\n\n')) >= 0; buf = buf.slice(i + 2)) {
+          if (buf[0] === ':') continue
+          const line = buf.indexOf('\n')
+          frames.push([buf.slice(7, line), JSON.parse(buf.slice(line + 7, i))])
+          for (const w of waiting) w()
+        }
+      }
+    } catch {}
+  })()
+  const until = async (test: (f: Frame) => boolean, ms: number) => {
+    const end = Date.now() + ms
+    for (;;) {
+      const hit = frames.find(test)
+      if (hit) return hit
+      const left = end - Date.now()
+      if (left <= 0) return undefined
+      await new Promise<void>((ok) => {
+        const t = setTimeout(ok, left)
+        waiting.add(() => {
+          clearTimeout(t)
+          ok()
+        })
+      })
+      waiting.clear()
+    }
+  }
+  return { frames, until }
+}
+
+export const read = (url: string, id: string, input: unknown, cookie?: string) =>
+  fetch(
+    `${url}/_weft/fn/${id}${input == null ? '' : `?i=${encodeURIComponent(JSON.stringify(input))}`}`,
+    { headers: { accept: 'application/json', ...(cookie && { cookie }) } },
+  )

package/src/verify/timing.ts

@@ -0,0 +1,15 @@
+import type { Link, VerifyResult } from '../verify'
+import { Broke, clean } from './support'
+
+export function timer(ms: VerifyResult['ms']) {
+  return async <T>(link: Link, run: () => Promise<T>): Promise<T> => {
+    const t = performance.now()
+    try {
+      return await run()
+    } catch (e) {
+      throw e instanceof Broke ? e : new Broke(link, clean(e))
+    } finally {
+      ms[link] = Math.round(performance.now() - t)
+    }
+  }
+}

package/src/verify/trigger.ts

@@ -0,0 +1,14 @@
+import type postgres from 'postgres'
+import { Broke } from './support'
+
+export async function checkTrigger(sql: postgres.Sql, table: string) {
+  const [t] =
+    await sql`select t.tgenabled from pg_trigger t join pg_class c on c.oid = t.tgrelid where t.tgname = 'weft_changes_ins' and c.relname = ${table}`
+  if (!t)
+    throw new Broke(
+      'trigger',
+      `\`${table}\` has no change trigger: run \`weft db live\`, and apply the migration there`,
+    )
+  if (t.tgenabled === 'D')
+    throw new Broke('trigger', `the change trigger on \`${table}\` is disabled`)
+}

package/src/verify.ts

@@ -7,15 +7,32 @@
 // A database target tests the first half and a URL target the app's half; with both, the whole chain. Whatever wasn't
 // tested is reported, by name. `live-target.mjs` decides whether a target may be touched at all.
 
-import postgres from 'postgres'
 import { CHANNEL } from './changes-sql.mjs'
 import type { Context, Fn, VerifyOptions } from './data'
 import type { Source } from './changes'
+import { Broke, clean, insert, primaryKey, subscribe } from './verify/support'
+import { waitNotice } from './verify/notify'
+import { database } from './verify/database'
+import { skipper, skipWithoutUrl } from './verify/skip'
+import { cleanup } from './verify/cleanup'
+import { timer } from './verify/timing'
+import { checkTrigger } from './verify/trigger'
+import { checkLive } from './verify/live'
+import { openApp } from './verify/app'
 
 export type { VerifyOptions }
 
 /** Each step of the round trip, in order. */
-export const LINKS = ['trigger', 'write', 'notify', 'app', 'poke', 'refetch', 'denied', 'cleanup'] as const
+export const LINKS = [
+  'trigger',
+  'write',
+  'notify',
+  'app',
+  'poke',
+  'refetch',
+  'denied',
+  'cleanup',
+] as const
 /** One step of the round trip. */
 export type Link = (typeof LINKS)[number]
 
@@ -28,96 +45,6 @@ export interface VerifyResult {
   untested: { link: Link; why: string }[]
 }
 
-class Broke extends Error {
-  constructor(public link: Link, why: string) { super(why) }
-}
-
-const clean = (s: unknown) => String((s as Error | null | undefined)?.message ?? s).replace(/\/\/[^@/\s]*@/g, '//…@')
-
-/** A value for a required column nobody named. Foreign keys can't be guessed: `row` is for those. */
-function made(type: string, marker: string): unknown {
-  if (/uuid/.test(type)) return crypto.randomUUID()
-  if (/int|serial/.test(type)) return Math.floor(Math.random() * 2_000_000_000)
-  if (/numeric|double|real|money/.test(type)) return 0
-  if (/bool/.test(type)) return false
-  if (/timestamp|date/.test(type)) return new Date().toISOString()
-  if (/time/.test(type)) return '00:00:00'
-  if (/json/.test(type)) return JSON.stringify({ marker })
-  return marker
-}
-
-async function insert(sql: postgres.Sql, table: string, marker: string, row: Record<string, unknown>, pk: string[]) {
-  const cols = await sql`select column_name, data_type, is_nullable, column_default, is_identity, is_generated from information_schema.columns where table_schema = current_schema() and table_name = ${table} order by ordinal_position`
-  if (!cols.length) throw new Broke('write', `no table \`${table}\` in this database`)
-  const values: Record<string, unknown> = { ...row }
-  let marked = false
-  for (const c of cols) {
-    const name = c.column_name as string
-    if (name in values) continue
-    if (/char|text/.test(c.data_type) && !marked) {
-      values[name] = marker
-      marked = true
-    } else if (c.is_nullable === 'NO' && c.column_default === null && c.is_identity === 'NO' && c.is_generated === 'NEVER') values[name] = made(c.data_type, marker)
-  }
-  if (!marked) throw new Broke('write', `\`${table}\` has no free text column to mark a row with: name one less in \`row\``)
-  const names = Object.keys(values)
-  const quoted = (n: string) => `"${n.replaceAll('"', '""')}"`
-  const key = pk.length ? pk : names.slice(0, 1)
-  const [got] = await sql.unsafe(`insert into ${quoted(table)} (${names.map(quoted).join(', ')}) values (${names.map((_, i) => `$${i + 1}`).join(', ')}) returning ${key.map(quoted).join(', ')}`, names.map(n => values[n]) as never[])
-  if (!got) throw new Broke('write', `\`${table}\` took the row and returned nothing`)
-  const where = key.map((k, i) => `${quoted(k)} = $${i + 1}`).join(' and ')
-  return { id: key.map(k => String(got[k])).join(':'), remove: () => sql.unsafe(`delete from ${quoted(table)} where ${where}`, key.map(k => got[k])) }
-}
-
-async function primaryKey(sql: postgres.Sql, table: string): Promise<string[]> {
-  const rows = await sql`select a.attname from pg_index i join pg_class c on c.oid = i.indrelid join pg_attribute a on a.attrelid = c.oid and a.attnum = any(i.indkey) where c.relname = ${table} and i.indisprimary`
-  return rows.map(r => r.attname as string)
-}
-
-/** One SSE connection to the app, by the protocol a browser's tab speaks. */
-type Frame = [event: string, data: unknown]
-type Hello = { l?: { m?: string; d?: unknown } }
-
-async function subscribe(url: string, id: string, input: unknown, cookie: string | undefined, signal: AbortSignal) {
-  const res = await fetch(`${url}/_weft/rt`, { method: 'POST', signal, headers: { 'content-type': 'application/json', 'x-weft': '1', accept: 'text/event-stream', origin: url, ...(cookie && { cookie }) }, body: JSON.stringify({ s: [[1, 'q', id, input]] }) })
-  if (!res.ok) throw new Error(`\`/_weft/rt\` answered ${res.status}`)
-  const frames: Frame[] = []
-  const waiting = new Set<() => void>()
-  void (async () => {
-    const dec = new TextDecoder()
-    let buf = ''
-    try {
-      for await (const chunk of res.body as unknown as AsyncIterable<Uint8Array>) {
-        buf += dec.decode(chunk, { stream: true })
-        for (let i; (i = buf.indexOf('\n\n')) >= 0; buf = buf.slice(i + 2)) {
-          if (buf[0] === ':') continue
-          const line = buf.indexOf('\n')
-          frames.push([buf.slice(7, line), JSON.parse(buf.slice(line + 7, i))])
-          for (const w of waiting) w()
-        }
-      }
-    } catch {}
-  })()
-  const until = async (test: (f: Frame) => boolean, ms: number) => {
-    const end = Date.now() + ms
-    for (;;) {
-      const hit = frames.find(test)
-      if (hit) return hit
-      const left = end - Date.now()
-      if (left <= 0) return undefined
-      await new Promise<void>(ok => {
-        const t = setTimeout(ok, left)
-        waiting.add(() => { clearTimeout(t); ok() })
-      })
-      waiting.clear()
-    }
-  }
-  return { frames, until }
-}
-
-const read = (url: string, id: string, input: unknown, cookie?: string) =>
-  fetch(`${url}/_weft/fn/${id}${input == null ? '' : `?i=${encodeURIComponent(JSON.stringify(input))}`}`, { headers: { accept: 'application/json', ...(cookie && { cookie }) } })
-
 /** What `roundTrip` needs: the query, the feed, and where the app is. */
 export interface RoundTrip {
   fn: Fn
@@ -132,120 +59,94 @@ export interface RoundTrip {
 function tableOf(fn: Fn, source: Source | undefined, input: unknown): string | undefined {
   const any = new Proxy({}, { get: (_, k) => (k === Symbol.toPrimitive ? () => '*' : '*') })
   let tags: readonly string[] = []
-  try { tags = typeof fn.def.tags === 'function' ? fn.def.tags(input ?? any, any as Context) : fn.def.tags ?? [] } catch {}
-  const names = tags.map(t => t.split(':')[0])
-  return names.find(t => t !== undefined && source?.tables.includes(t)) ?? names[0]
+  try {
+    tags =
+      typeof fn.def.tags === 'function'
+        ? fn.def.tags(input ?? any, any as Context)
+        : (fn.def.tags ?? [])
+  } catch {}
+  const names = tags.map((t) => t.split(':')[0])
+  return names.find((t) => t !== undefined && source?.tables.includes(t)) ?? names[0]
 }
 
 /** Writes a real row and follows it to a live client, naming the first link that breaks. */
-export async function roundTrip({ fn, source, url, db, options, env }: RoundTrip): Promise<VerifyResult> {
-  const timeout = options.timeout ?? 5000
+export async function roundTrip({
+  fn,
+  source,
+  url,
+  db,
+  options,
+  env,
+}: RoundTrip): Promise<VerifyResult> {
+  const { input, timeout = 5000 } = options
   const marker = `weft-verify-${crypto.randomUUID()}` // concurrent builds never touch each other's row
   const ms: VerifyResult['ms'] = {}
   const untested: VerifyResult['untested'] = []
-  const input = options.input
   const cookie = env[options.cookie ?? 'WEFT_STAGING_COOKIE']
   const other = env[options.otherCookie ?? 'WEFT_STAGING_OTHER_COOKIE']
-  const timed = async <T,>(link: Link, run: () => Promise<T>): Promise<T> => {
-    const t = performance.now()
-    try {
-      return await run()
-    } catch (e) {
-      throw e instanceof Broke ? e : new Broke(link, clean(e))
-    } finally {
-      ms[link] = Math.round(performance.now() - t)
-    }
-  }
-  const skip = (links: Link[], why: string) => { for (const link of links) untested.push({ link, why }) }
-  const sql = db ? postgres(db, { max: 3, idle_timeout: 2, connect_timeout: 5, onnotice: () => {} }) : undefined
-  const listener = db ? postgres(db, { max: 1, idle_timeout: 2, connect_timeout: 5, onnotice: () => {} }) : undefined
+  const timed = timer(ms)
+  const skip = skipper(untested)
+  const { sql, listener } = database(db)
   const ac = new AbortController()
   let row: Awaited<ReturnType<typeof insert>> | undefined
-  let cleaning: unknown
   try {
     const table = tableOf(fn, source, input)
     if (!table) throw new Broke('trigger', `\`${fn.$id}\` has no tag naming a table`)
     const heard: string[] = []
     let hearing: (() => void) | undefined
     if (sql) {
-      await timed('trigger', async () => {
-        const [t] = await sql`select t.tgenabled from pg_trigger t join pg_class c on c.oid = t.tgrelid where t.tgname = 'weft_changes_ins' and c.relname = ${table}`
-        if (!t) throw new Broke('trigger', `\`${table}\` has no change trigger: run \`weft db live\`, and apply the migration there`)
-        if (t.tgenabled === 'D') throw new Broke('trigger', `the change trigger on \`${table}\` is disabled`)
+      await timed('trigger', () => checkTrigger(sql, table))
+      await listener!.listen(CHANNEL, (p) => {
+        heard.push(p)
+        hearing?.()
       })
-      await listener!.listen(CHANNEL, p => { heard.push(p); hearing?.() })
-    } else skip(['trigger', 'write', 'notify', 'poke', 'refetch', 'denied', 'cleanup'], 'no database target: nothing wrote a row, so only the app and its feed were checked. Set `STAGING_DATABASE_URL` or `verify.db`')
-
-    const live = url ? await timed('app', async () => {
-      const a = await subscribe(url, fn.$id, input, cookie, ac.signal)
-      const hi = await a.until(f => f[0] === 'h', timeout)
-      if (!hi) throw new Broke('app', 'the app accepted the connection and said nothing')
-      const said = (hi[1] as Hello).l
-      if (said?.m !== 'feed' && said?.m !== 'external') throw new Broke('app', `the app's live mode is \`${said?.m ?? 'app'}\`, not a feed: its log says why`)
-      if (said?.d) throw new Broke('app', 'the app\'s change feed is down')
-      const ack = await a.until(f => (f[0] === 'a' || f[0] === 'e') && (f[1] as unknown[])[0] === 1, timeout)
-      if (!ack) throw new Broke('app', 'no answer to the subscription')
-      const answer = (ack[1] as [number, unknown])[1]
-      const failed = answer as { code?: string; message?: string }
-      if (ack[0] === 'e') throw new Broke('app', failed.code === 'Q009' ? `the app doesn't know \`${fn.$id}\`: it runs another build` : failed.code === 'A002' ? `\`${fn.$id}\` needs a signed-in user: set \`WEFT_STAGING_COOKIE\`` : `the subscription failed: ${failed.message}`)
-      return { ...a, tags: answer as string[] }
-    }) : undefined
-    if (!url) skip(sql ? ['app', 'poke', 'refetch', 'denied'] : ['app'], 'no URL target: the database half was tested, not the running app. Set `WEFT_STAGING_URL` or `verify.url`')
+    } else
+      skip(
+        ['trigger', 'write', 'notify', 'poke', 'refetch', 'denied', 'cleanup'],
+        'no database target: nothing wrote a row, so only the app and its feed were checked. Set `STAGING_DATABASE_URL` or `verify.db`',
+      )
+
+    const live = url
+      ? await timed('app', () =>
+          openApp({ url, id: fn.$id, input, cookie, signal: ac.signal, timeout }),
+        )
+      : undefined
+    skipWithoutUrl(url, sql, skip)
 
     if (!sql) {
       if (live) ac.abort()
       return { ok: true, ms, untested }
     }
-    const denied = url && !(cookie && !other && !fn.def.auth) ? await subscribe(url, fn.$id, input, other, ac.signal).catch(() => undefined) : undefined
+    const denied =
+      url && !(cookie && !other && !fn.def.auth)
+        ? await subscribe(url, fn.$id, input, other, ac.signal).catch(() => undefined)
+        : undefined
 
     const pk = await primaryKey(sql, table)
     row = await timed('write', () => insert(sql, table, marker, options.row ?? {}, pk))
-    await timed('notify', async () => {
-      const seen = () => heard.some(h => { try { const m = JSON.parse(h); return m.t === table && (!m.i || m.i.includes(row!.id)) } catch { return false } })
-      if (!seen()) await new Promise<void>(ok => {
-        const t = setTimeout(ok, timeout)
-        hearing = () => { if (seen()) { clearTimeout(t); ok() } }
-      })
-      if (!seen()) throw new Broke('notify', `the trigger on \`${table}\` sent nothing on \`${CHANNEL}\` within ${timeout} ms`)
-    })
-    if (live) {
-      await timed('poke', async () => {
-        const p = await live.until(f => f[0] === 'p' && (f[1] as { t: string[] }).t.some(t => live.tags.includes(t)), timeout)
-        if (!p) throw new Broke('poke', `the database notified, and the app never poked this subscription within ${timeout} ms: its listener, or a tag the query doesn't declare`)
-      })
-      await timed('refetch', async () => {
-        const end = Date.now() + timeout
-        for (;;) {
-          const res = await read(url!, fn.$id, input, cookie)
-          if (res.ok && (await res.text()).includes(marker)) return
-          if (Date.now() > end) throw new Broke('refetch', `poked, and the query didn't return the row within ${timeout} ms${options.row ? '' : ': if it filters by user, say whose it is in `verify.row`'}`)
-          await new Promise(ok => { setTimeout(ok, 50) })
-        }
+    await timed('notify', () =>
+      waitNotice(heard, table, row!.id, timeout, (wake) => (hearing = wake)),
+    )
+    if (live)
+      await checkLive({
+        live,
+        denied,
+        timed,
+        skip,
+        url: url!,
+        id: fn.$id,
+        input,
+        cookie,
+        other,
+        marker,
+        timeout,
+        options,
       })
-      if (denied) await timed('denied', async () => {
-        const res = await read(url!, fn.$id, input, other)
-        const text = await res.text()
-        if (text.includes(marker) || denied.frames.some(f => JSON.stringify(f[1]).includes(marker))) throw new Broke('denied', `${other ? 'the other user' : 'a signed-out client'} got the row`)
-      })
-      else skip(['denied'], 'a query with no `auth` and no other user to compare: set `WEFT_STAGING_OTHER_COOKIE`')
-    }
     return { ok: true, ms, untested }
   } catch (e) {
     const b = e instanceof Broke ? e : new Broke('trigger', clean(e))
     return { ok: false, broke: { link: b.link, why: clean(b.message) }, ms, untested }
   } finally {
-    ac.abort()
-    if (row) {
-      const t = performance.now()
-      try {
-        await row.remove()
-        ms.cleanup = Math.round(performance.now() - t)
-      } catch (e) {
-        cleaning = e
-      }
-    }
-    await Promise.all([sql?.end({ timeout: 1 }), listener?.end({ timeout: 1 })]).catch(() => {})
-    // oxlint-disable-next-line no-unsafe-finally -- a row left in a real database outranks whatever the run concluded
-    if (cleaning) throw new Broke('cleanup', `row \`${marker}\` is still there: ${clean(cleaning)}`)
+    await cleanup({ ac, row, ms, sql, listener, marker })
   }
 }