@weft-js/start 0.1.1 → 0.1.3

package/src/sidecar.mjs

@@ -16,175 +16,32 @@
 // says which, so the next call loads it in place: an addon can't be unloaded, and needn't be. build: an addon and a
 // `.wasm` next to the server, in `.output/server/rust/`, so whatever moves the server moves them too.
 
-import { spawn } from 'node:child_process'
-import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:fs'
 import { createServer, request as httpRequest, Agent } from 'node:http'
 import { randomBytes } from 'node:crypto'
-import { basename, join, relative, resolve } from 'node:path'
-import { writeContract } from './contract.mjs'
-import { isServerModule } from './vite.mjs'
+import { join, resolve } from 'node:path'
+import { makeRefresh } from './sidecar/refresh.mjs'
+import { watchServices } from './sidecar/dev-watch.mjs'
+import { buildable, isNative } from './sidecar/common.mjs'
+import { publisher } from './sidecar/manifest.mjs'
+import { devBuilder } from './sidecar/dev-build.mjs'
+import { stop } from './sidecar/process.mjs'
 
 /** The app names a sidecar: a server module imports `remote`. Nothing else here runs for an app that doesn't. */
 export function usesRemote(root) {
   const src = join(root, 'src')
   if (!existsSync(src)) return false
-  return readdirSync(src, { recursive: true, withFileTypes: true }).some(f => f.isFile() && /\.[cm]?[jt]sx?$/.test(f.name) && /['"]@weft-js\/start\/rust['"]/.test(readFileSync(join(f.parentPath, f.name), 'utf8')))
+  return readdirSync(src, { recursive: true, withFileTypes: true }).some(
+    (f) =>
+      f.isFile() &&
+      /\.[cm]?[jt]sx?$/.test(f.name) &&
+      /['"]@weft-js\/start\/rust['"]/.test(readFileSync(join(f.parentPath, f.name), 'utf8')),
+  )
 }
 
-/** Same spelling as `urlVariable` in rust.ts, which can't share a module with this one: it ships in the server bundle. */
-export const urlVariable = service => `WEFT_RUST_${service.toUpperCase().replaceAll('-', '_')}_URL`
+export { crateDir, urlVariable } from './sidecar/common.mjs'
 
-const external = (rust, service) => rust?.services?.[service]?.external === true
-/** The crate folder of a service. */
-export const crateDir = (root, rust, service) => resolve(root, rust?.services?.[service]?.crate ?? `crates/${service}`)
-
-/** The services in a contract that have a crate here. */
-const buildable = (contract, rust) => Object.keys(contract.services ?? {}).filter(s => !external(rust, s))
-const isNative = (contract, service) => contract.services?.[service]?.kind === 'native'
-const WASM = 'wasm32-unknown-unknown'
-
-// ---- cargo --------------------------------------------------------------------------------------------------------
-
-function run(cmd, args, { cwd, env, onLine }) {
-  return new Promise(ok => {
-    let child
-    try {
-      child = spawn(cmd, args, { cwd, env: { ...process.env, ...env }, stdio: ['ignore', 'pipe', 'pipe'] })
-    } catch (e) {
-      ok({ code: 127, stdout: '', stderr: e.message, missing: true })
-      return
-    }
-    let stdout = '', stderr = ''
-    child.stdout.on('data', d => { stdout += d })
-    child.stderr.on('data', d => {
-      stderr += d
-      onLine?.(`${d}`)
-    })
-    child.on('error', e => ok({ code: 127, stdout, stderr: e.message, missing: e.code === 'ENOENT' }))
-    child.on('close', code => ok({ code, stdout, stderr }))
-  })
-}
-
-const pascal = name => name[0].toUpperCase() + name.slice(1)
-const snake = name => name.replace(/[A-Z]/g, (c, i) => `${i ? '_' : ''}${c.toLowerCase()}`)
-
-/**
- * cargo's JSON messages as diagnostics. An error that names a contract function's types or method is R103, with the
- * function's id, so it points at the TS edit that caused it (research 06 §7); any other is R109.
- */
-export function readCargo(stdout, { contract, service, root, dir }) {
-  const fns = (contract?.functions ?? []).filter(f => f.impl?.service === service)
-  const names = fns.map(f => ({ id: f.id, re: new RegExp(`\\b(${pascal(f.name)}\\w*|${snake(f.name)})\\b`) }))
-  const diagnostics = []
-  let exe, lib, ok = false
-  for (const line of stdout.split('\n')) {
-    if (!line.startsWith('{')) continue
-    let m
-    try { m = JSON.parse(line) } catch { continue }
-    if (m.reason === 'compiler-artifact' && m.executable && m.target?.kind?.includes('bin')) exe = m.executable
-    if (m.reason === 'compiler-artifact' && m.target?.kind?.includes('cdylib')) lib = m.filenames?.find(f => /\.(dylib|so|dll|wasm)$/.test(f))
-    if (m.reason === 'build-finished') ok = m.success
-    if (m.reason !== 'compiler-message' || m.message?.level !== 'error' || !m.message.code) continue
-    const text = m.message.rendered ?? m.message.message
-    const hit = names.find(n => n.re.test(text))
-    const at = m.message.spans?.find(s => s.is_primary) ?? m.message.spans?.[0]
-    const file = at && relative(root, resolve(dir, at.file_name)).replaceAll('\\', '/')
-    diagnostics.push({
-      code: hit ? 'R103' : 'R109', severity: 'error', ...(hit && { function: hit.id }), file: file ?? '.weft/contract.json',
-      span: at ? [at.line_start, at.column_start, at.line_end, at.column_end] : [1, 1, 1, 1],
-      why: hit ? `\`${hit.id}\`: the Rust no longer matches the contract: ${m.message.message}` : `\`${service}\` doesn't compile: ${m.message.message}`,
-      rendered: text,
-    })
-  }
-  return { ok, exe, lib, diagnostics }
-}
-
-/** `verb`: `build` or `check`. Failure names what to fix: a build script's panic is already R103 with the fix. */
-export async function cargo(verb, { root, dir, service, contract, release, target, onLine }) {
-  const args = [verb, '--message-format=json', ...(release ? ['--release'] : []), ...(target ? ['--target', target] : [])]
-  const env = { WEFT_CONTRACT: join(root, '.weft', 'contract.json'), ...(target === WASM && { CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS: '-C target-feature=+simd128' }) }
-  const r = await run('cargo', args, { cwd: dir, env, onLine })
-  if (r.missing) return { ok: false, diagnostics: [{ code: 'R109', severity: 'error', file: 'package.json', span: [1, 1, 1, 1], why: `\`${service}\` is Rust you opted into, so it needs \`cargo\`, and it isn't on PATH. Install it from rustup.rs, or set \`external: true\` for a sidecar built elsewhere. The rest of weft doesn't need Rust.` }] }
-  const read = readCargo(r.stdout, { contract, service, root, dir })
-  if (r.code === 0) return read
-  if (!read.diagnostics.length) {
-    const panic = /R103: ([^\n]+)/.exec(r.stderr)?.[1]
-    read.diagnostics.push({ code: panic ? 'R103' : 'R109', severity: 'error', file: relative(root, dir).replaceAll('\\', '/') + '/Cargo.toml', span: [1, 1, 1, 1], why: panic ?? `cargo ${verb} failed in \`${service}\`:\n${r.stderr.trim().split('\n').slice(-12).join('\n')}` })
-  }
-  return { ...read, ok: false }
-}
-
-/** R104 for a `.wasm` that won't build: a warning unless the build needs it. `error`: the preset has no other way to run. */
-export async function checkWasm({ root, dir, service, contract, preset, rust, build }) {
-  if (rust?.services?.[service]?.wasm === false) return { diagnostics: [] }
-  const r = await cargo(build ? 'build' : 'check', { root, dir, service, contract, target: WASM, release: build })
-  if (r.ok) return { lib: r.lib, diagnostics: [] }
-  const missing = r.diagnostics.find(d => /can't find crate for `(std|core)`|target may not be installed/.test(`${d.why}${d.rendered ?? ''}`))
-  const why = missing ? `\`rustup target add ${WASM}\`: this toolchain can't build \`${service}\`'s WASM fallback` : `\`${service}\` has no WASM fallback: ${r.diagnostics[0]?.why ?? 'the build failed'}`
-  const needed = preset && !/^(node|bun|deno[-_]server)/.test(preset)
-  return { diagnostics: [{ code: 'R104', severity: needed ? 'error' : 'warning', file: relative(root, dir).replaceAll('\\', '/') + '/Cargo.toml', span: [1, 1, 1, 1], why: `${why}. An addon loads on this machine, and nothing else can run it. Fix it, or set \`rust.services.${service}.wasm: false\` to say so` }] }
-}
-
-const stem = service => service.replaceAll('-', '_')
-
-/** Copy, then rename: macOS kills a process that loads a signed binary overwritten in place. */
-function place(from, to) {
-  copyFileSync(from, `${to}.tmp`)
-  renameSync(`${to}.tmp`, to)
-}
-
-// ---- children -----------------------------------------------------------------------------------------------------
-
-/** Start a binary and wait until it listens and its health check names `hash`. Rejects with why, and leaves nothing running. */
-function launch({ exe, service, hash, listen, secret, onExit, log }) {
-  return new Promise((ok, no) => {
-    const child = spawn(exe, [], { env: { ...process.env, WEFT_LISTEN: listen, WEFT_RUST_SECRET: secret }, stdio: ['ignore', 'pipe', 'inherit'] })
-    let out = '', ready = false
-    const failed = why => {
-      clearTimeout(timer)
-      child.kill('SIGKILL')
-      no(Object.assign(new Error(why), { code: 'R109' }))
-    }
-    const timer = setTimeout(() => failed(`\`${service}\` didn't listen within 30 s`), 30_000)
-    child.on('error', e => failed(`\`${service}\` didn't start: ${e.message}`))
-    child.on('exit', (code, signal) => {
-      if (!ready) return failed(`\`${service}\` exited before it listened (${signal ?? code})`)
-      onExit?.(code, signal)
-    })
-    child.stdout.on('data', d => void heard(d))
-    const heard = async d => {
-      if (ready) return void process.stdout.write(d)
-      out += d
-      const addr = /weft-listening (\S+)/.exec(out)?.[1]
-      if (!addr) return
-      ready = true
-      clearTimeout(timer)
-      const url = `http://${addr}`
-      try {
-        const health = await (await fetch(`${url}/_weft/health`)).json()
-        if (health.contract !== hash) {
-          ready = false
-          return failed(`R103: \`${service}\` was built from contract ${health.contract}, and this app's is ${hash}: rebuild it`)
-        }
-        log?.(`[weft] ${service}: listening on ${addr}`)
-        ok({ child, url, port: Number(addr.split(':').pop()), inflight: 0 })
-      } catch (e) {
-        ready = false
-        failed(`\`${service}\`'s health check failed: ${e.message}`)
-      }
-    }
-  })
-}
-
-/** SIGTERM, which the crate drains on; SIGKILL if that takes too long. */
-function stop(p, wait = 5_000) {
-  if (!p || p.child.exitCode !== null) return
-  p.stopped = true
-  p.child.kill('SIGTERM')
-  const t = setTimeout(() => p.child.kill('SIGKILL'), wait)
-  t.unref()
-  p.child.once('exit', () => clearTimeout(t))
-}
+export { cargo, checkWasm, readCargo } from './sidecar/cargo.mjs'
 
 // ---- dev ----------------------------------------------------------------------------------------------------------
 
@@ -196,18 +53,28 @@ function proxy(state) {
     if (!to) {
       if (!state.failure) return void res.destroy() // between crash and restart: `remote()` reports it, R107
       res.writeHead(422, { 'content-type': 'application/json' })
-      return res.end(JSON.stringify({ ok: false, error: { code: 'Drift', message: state.failure } }))
+      return res.end(
+        JSON.stringify({ ok: false, error: { code: 'Drift', message: state.failure } }),
+      )
     }
     to.inflight++
-    res.once('close', () => { if (--to.inflight === 0 && to.retired) stop(to) })
-    const up = httpRequest(`${to.url}${req.url}`, { method: req.method, headers: req.headers, agent }, answer => {
-      res.writeHead(answer.statusCode, answer.headers)
-      answer.pipe(res)
+    res.once('close', () => {
+      if (--to.inflight === 0 && to.retired) stop(to)
     })
+    const up = httpRequest(
+      `${to.url}${req.url}`,
+      { method: req.method, headers: req.headers, agent },
+      (answer) => {
+        res.writeHead(answer.statusCode, answer.headers)
+        answer.pipe(res)
+      },
+    )
     up.on('error', () => res.destroy())
     req.pipe(up)
   })
-  return new Promise(ok => { server.listen(0, '127.0.0.1', () => ok({ server, agent, port: server.address().port })) })
+  return new Promise((ok) => {
+    server.listen(0, '127.0.0.1', () => ok({ server, agent, port: server.address().port }))
+  })
 }
 
 /**
@@ -218,151 +85,53 @@ function proxy(state) {
 export async function devSidecars({ root, site, rust, log = console.log }) {
   root = resolve(root)
   const secret = (process.env.WEFT_RUST_SECRET ||= randomBytes(32).toString('hex'))
-  const say = d => log(`[weft] ${d.code} ${d.severity}: ${d.why}${d.rendered ? `\n${d.rendered}` : ''}`)
-  let vite, closed = false
-  const overlay = message => vite?.ws.send({ type: 'error', err: { message, stack: '', plugin: 'weft:sidecar' } })
-  const refresh = async () => {
-    const held = process.env.WEFT_BUILD
-    process.env.WEFT_BUILD = '1' // the same as a build: server modules load, and nothing connects
-    try {
-      const { contract, diagnostics } = await writeContract({ root, site, rust })
-      diagnostics.filter(d => d.code.startsWith('R1')).forEach(say)
-      return { contract, blocked: diagnostics.find(d => /^R10[12]$/.test(d.code) && d.severity === 'error') }
-    } finally {
-      if (held === undefined) delete process.env.WEFT_BUILD
-      else process.env.WEFT_BUILD = held
-    }
-  }
+  const say = (d) =>
+    log(`[weft] ${d.code} ${d.severity}: ${d.why}${d.rendered ? `\n${d.rendered}` : ''}`)
+  let vite,
+    closed = false
+  const overlay = (message) =>
+    vite?.ws.send({ type: 'error', err: { message, stack: '', plugin: 'weft:sidecar' } })
+  const refresh = makeRefresh(root, site, rust, say)
 
   const first = await refresh()
   let contract = first.contract
   const states = new Map()
   const nativeDir = join(root, '.weft', 'native')
-  /** What the server's `native()` reads on each call: one rename, so it never sees half of it. */
-  const publish = () => {
-    const manifest = Object.fromEntries([...states].filter(([k]) => isNative(contract, k)).map(([k, s]) => [k, s.loaded ?? { hash: '', failure: s.failure ?? `\`${k}\` hasn't built` }]))
-    writeFileSync(join(nativeDir, 'manifest.tmp'), JSON.stringify(manifest))
-    renameSync(join(nativeDir, 'manifest.tmp'), join(nativeDir, 'manifest.json'))
-  }
-  if (buildable(contract, rust).some(k => isNative(contract, k))) {
+  const publish = publisher(states, nativeDir, () => contract)
+  if (buildable(contract, rust).some((k) => isNative(contract, k))) {
     rmSync(nativeDir, { recursive: true, force: true })
     mkdirSync(nativeDir, { recursive: true })
     process.env.WEFT_NATIVE_DIR = nativeDir
   }
 
-  async function rebuild(service) {
-    const s = states.get(service)
-    if (s.building) return void (s.again = true)
-    s.building = true
-    try {
-      do {
-        s.again = false
-        await once(service, s)
-        // oxlint-disable-next-line no-unmodified-loop-condition -- `again` and `closed` are set by what arrives during the await
-      } while (s.again && !closed)
-    } finally {
-      s.building = false
-    }
-  }
-
-  async function once(service, s) {
-    const hash = contract.services?.[service]?.hash
-    if (!hash) return
-    const dir = crateDir(root, rust, service)
-    const t = performance.now()
-    const built = await cargo('build', { root, dir, service, contract })
-    if (!built.ok || !(built.exe || built.lib)) {
-      built.diagnostics.forEach(say)
-      s.failure = built.diagnostics.map(d => d.why).join('\n') || `\`${service}\` didn't build`
-      overlay(s.failure)
-      if (isNative(contract, service) && !s.loaded) publish()
-      return
-    }
-    log(`[weft] ${service}: built in ${Math.round(performance.now() - t)} ms`)
-    if (isNative(contract, service)) {
-      s.generation = (s.generation ?? 0) + 1
-      s.loaded = { hash, addon: `${stem(service)}-${s.generation}.node` }
-      s.failure = undefined
-      place(built.lib, join(nativeDir, s.loaded.addon))
-      return publish()
-    }
-    let next
-    try {
-      next = await launch({ exe: built.exe, service, hash, listen: '127.0.0.1:0', secret, log, onExit: (code, signal) => exited(service, s, next, code, signal) })
-    } catch (e) {
-      s.failure = e.message
-      log(`[weft] ${e.message}`)
-      return overlay(e.message)
-    }
-    // The swap: new calls go to `next` from here; the old child finishes what it has, then goes.
-    const old = s.current
-    s.current = next
-    s.failure = undefined
-    s.exe = built.exe
-    s.crashes = 0
-    if (old) {
-      old.retired = true
-      if (old.inflight === 0) stop(old)
-    }
-  }
-
-  function exited(service, s, child, code, signal) {
-    if (closed || !child || child.stopped || s.current !== child) return
-    s.current = undefined
-    const wait = Math.min(100 * 2 ** (s.crashes = (s.crashes ?? 0) + 1), 5_000)
-    log(`[weft] ${service} exited (${signal ?? code}): restarting in ${wait} ms`)
-    setTimeout(() => {
-      if (closed || s.current || s.building) return
-      void rebuild(service) // cargo finds nothing to do, and the binary starts again
-    }, wait).unref()
-  }
-
-  const watchers = []
-  const debounce = (fn, ms = 200) => {
-    let t
-    return () => { clearTimeout(t); t = setTimeout(() => fn(), ms) }
-  }
-
-  for (const service of buildable(contract, rust)) {
-    const dir = crateDir(root, rust, service)
-    const s = { current: undefined, failure: existsSync(dir) ? undefined : `\`crates/${service}\` doesn't exist`, building: false }
-    states.set(service, s)
-    if (!isNative(contract, service)) {
-      const p = await proxy(s)
-      s.proxy = p
-      process.env[urlVariable(service)] = `http://127.0.0.1:${p.port}`
-    }
-    if (!existsSync(dir)) {
-      log(`[weft] R109 error: ${s.failure}. Point \`rust.services.${service}.crate\` at it, or set \`external: true\``)
-      if (isNative(contract, service)) publish()
-      continue
-    }
-    if (!first.blocked) await rebuild(service)
-    const changed = debounce(() => rebuild(service))
-    watchers.push(watch(dir, { recursive: true }, (_, file) => {
-      if (file && !/^target([\\/]|$)/.test(file) && !file.endsWith('.lock')) changed()
-    }))
-  }
+  const rebuild = devBuilder({
+    root,
+    rust,
+    secret,
+    log,
+    say,
+    overlay,
+    states,
+    nativeDir,
+    publish,
+    contract: () => contract,
+    closed: () => closed,
+  })
 
-  // A server module's edit may change a schema: the contract is regenerated, and only a change to a service's hash
-  // rebuilds it. cargo then stops where the Rust no longer fits.
-  const src = join(root, 'src')
-  const contractChanged = debounce(async () => {
-    try {
-      const fresh = await refresh()
-      if (fresh.blocked) return overlay(fresh.blocked.why)
-      const before = contract
-      contract = fresh.contract
-      for (const service of buildable(contract, rust)) {
-        if (states.has(service) && before.services?.[service]?.hash !== contract.services[service].hash) void rebuild(service)
-      }
-    } catch (e) {
-      log(`[weft] the contract couldn't be regenerated: ${e.message.split('\n')[0]}`)
-    }
+  const watchers = await watchServices({
+    root,
+    rust,
+    contract: () => contract,
+    setContract: (next) => (contract = next),
+    first,
+    states,
+    proxy,
+    publish,
+    rebuild,
+    refresh,
+    overlay,
+    log,
   })
-  if (existsSync(src)) watchers.push(watch(src, { recursive: true }, (_, file) => {
-    if (file && isServerModule(`src/${file.replaceAll('\\', '/')}`)) contractChanged()
-  }))
 
   const killAll = () => {
     closed = true
@@ -371,7 +140,9 @@ export async function devSidecars({ root, site, rust, log = console.log }) {
   process.once('exit', killAll)
   return {
     ready: Object.fromEntries([...states].map(([k, s]) => [k, !!(s.current || s.loaded)])),
-    attach(server) { vite = server },
+    attach(server) {
+      vite = server
+    },
     async close() {
       process.removeListener('exit', killAll)
       killAll()
@@ -379,125 +150,13 @@ export async function devSidecars({ root, site, rust, log = console.log }) {
       for (const s of states.values()) {
         s.proxy?.agent.destroy()
         s.proxy?.server.closeAllConnections()
-        await new Promise(ok => { if (s.proxy) s.proxy.server.close(ok); else ok() })
+        await new Promise((ok) => {
+          if (s.proxy) s.proxy.server.close(ok)
+          else ok()
+        })
       }
     },
   }
 }
 
-// ---- build --------------------------------------------------------------------------------------------------------
-
-const BUILT = ['.weft', 'sidecars'] // a build empties `.output`, and these have to run during it
-const SHIPPED = ['.output', 'rust']
-const SHIPPED_NATIVE = ['.output', 'server', 'rust'] // with the server, so a host that moves it moves these
-
-/** Release binaries into `.weft/sidecars/`, and what `weft start` needs to run them. */
-export async function buildSidecars({ root, contract, rust, preset, log = () => {} }) {
-  root = resolve(root)
-  const out = join(root, ...BUILT)
-  const services = buildable(contract, rust)
-  rmSync(out, { recursive: true, force: true })
-  if (!services.length) return { services: [], diagnostics: [] }
-  mkdirSync(out, { recursive: true })
-  const manifest = {}
-  const diagnostics = []
-  for (const service of services) {
-    const dir = crateDir(root, rust, service)
-    if (!existsSync(dir)) {
-      diagnostics.push({ code: 'R109', severity: 'error', file: 'weft.config.ts', span: [1, 1, 1, 1], why: `\`rust://${service}\` has no crate at \`${relative(root, dir)}\`. Create it, point \`rust.services.${service}.crate\` at it, or set \`external: true\`.` })
-      continue
-    }
-    log(`building ${service}…`)
-    const built = await cargo('build', { root, dir, service, contract, release: true })
-    if (!built.ok || !(built.exe || built.lib)) {
-      diagnostics.push(...built.diagnostics)
-      continue
-    }
-    if (isNative(contract, service)) {
-      const addon = `${stem(service)}.${process.platform}-${process.arch}.node`
-      copyFileSync(built.lib, join(out, addon))
-      manifest[service] = { kind: 'native', addon, hash: contract.services[service].hash, bytes: statSync(built.lib).size }
-      const wasm = await checkWasm({ root, dir, service, contract, preset, rust, build: true })
-      diagnostics.push(...wasm.diagnostics)
-      if (wasm.lib) {
-        copyFileSync(wasm.lib, join(out, `${stem(service)}.wasm`))
-        Object.assign(manifest[service], { wasm: `${stem(service)}.wasm`, wasmBytes: statSync(wasm.lib).size })
-      }
-      continue
-    }
-    const bin = basename(built.exe)
-    copyFileSync(built.exe, join(out, bin))
-    manifest[service] = { bin, hash: contract.services[service].hash, bytes: statSync(built.exe).size }
-  }
-  writeFileSync(join(out, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n')
-  return { services: Object.keys(manifest), diagnostics }
-}
-
-/** Into the output, once the server is built. */
-export function shipSidecars(root) {
-  const from = join(resolve(root), ...BUILT)
-  if (!existsSync(from)) return
-  const manifest = JSON.parse(readFileSync(join(from, 'manifest.json'), 'utf8'))
-  const natives = Object.entries(manifest).filter(([, m]) => m.kind === 'native')
-  const sidecars = Object.entries(manifest).filter(([, m]) => m.kind !== 'native')
-  const copy = (list, to, names) => {
-    if (!list.length) return
-    mkdirSync(to, { recursive: true })
-    for (const [, m] of list) for (const f of names(m)) cpSync(join(from, f), join(to, f))
-    writeFileSync(join(to, 'manifest.json'), JSON.stringify(Object.fromEntries(list), null, 2) + '\n')
-  }
-  copy(sidecars, join(resolve(root), ...SHIPPED), m => [m.bin])
-  copy(natives, join(resolve(root), ...SHIPPED_NATIVE), m => [m.addon, m.wasm].filter(Boolean))
-}
-
-// ---- start --------------------------------------------------------------------------------------------------------
-
-/**
- * Run `.output/rust/`'s binaries for `weft start` (or `built`'s, while `weft build` prerenders). A service with `WEFT_RUST_<NAME>_URL` already set is someone else's.
- * Each keeps its port across restarts, so the server's address stays good.
- * @returns {Promise<{ env: Record<string, string>, close(): void }>} `env` for the server process
- */
-export async function startSidecars({ root, built = false, log = console.log }) {
-  const dir = join(resolve(root), ...(built ? BUILT : SHIPPED))
-  const file = join(dir, 'manifest.json')
-  if (!existsSync(file)) return { env: {}, close() {} }
-  const manifest = JSON.parse(readFileSync(file, 'utf8'))
-  const names = Object.keys(manifest).filter(s => manifest[s].kind !== 'native' && !process.env[urlVariable(s)])
-  // While a build prerenders, the libraries aren't next to a server yet.
-  const paths = built && Object.values(manifest).some(m => m.kind === 'native') ? { WEFT_NATIVE_DIR: dir } : {}
-  if (!names.length) return { env: paths, close() {} }
-  const secret = process.env.WEFT_RUST_SECRET || randomBytes(32).toString('hex')
-  const env = { ...paths, WEFT_RUST_SECRET: secret }
-  let closed = false
-  const live = new Map()
-
-  const supervise = service => {
-    const { bin, hash } = manifest[service]
-    let listen = '127.0.0.1:0', tries = 0, up
-    const begin = async () => {
-      up = Date.now()
-      const p = await launch({ exe: join(dir, bin), service, hash, listen, secret, log, onExit: (code, signal) => again(`exited (${signal ?? code})`) })
-      listen = `127.0.0.1:${p.port}` // restarts rebind what the first start got
-      live.set(service, p)
-      return p
-    }
-    const again = why => {
-      if (closed) return
-      // One that ran for a while starts over; one that dies at once backs off.
-      tries = Date.now() - up > 30_000 ? 1 : tries + 1
-      const wait = Math.min(100 * 2 ** tries, 5_000)
-      log(`[weft] ${service} ${why}: restarting in ${wait} ms`)
-      setTimeout(() => { if (!closed) begin().catch(e => again(e.message.split('\n')[0])) }, wait)
-    }
-    return begin()
-  }
-
-  for (const service of names) env[urlVariable(service)] = (await supervise(service)).url
-
-  const killAll = () => {
-    closed = true
-    for (const p of live.values()) stop(p, 1_000)
-  }
-  process.once('exit', killAll)
-  return { env, close: killAll }
-}
+export { buildSidecars, shipSidecars, startSidecars } from './sidecar/build.mjs'

package/src/socket/check.ts

@@ -0,0 +1,50 @@
+import { StartError, type Context, type Fn, type StandardSchemaV1 } from '../data'
+import type { Bucket } from './types'
+
+export function take(b: Bucket, perSecond: number, burst: number) {
+  const now = Date.now()
+  b.tokens = Math.min(burst, b.tokens + ((now - b.at) * perSecond) / 1000)
+  b.at = now
+  if (b.tokens < 1) return false
+  b.tokens--
+  return true
+}
+
+export async function check(schema: StandardSchemaV1 | undefined, value: unknown, what: string) {
+  if (!schema) return value
+  const r = await schema['~standard'].validate(value)
+  if (!r.issues) return r.value
+  throw new StartError(
+    'Q002',
+    `${what} was refused: ${r.issues.map((i) => i.message).join('; ')}`,
+    'send what the schema accepts',
+    {
+      status: 400,
+      issues: r.issues.map((i) => ({
+        message: i.message,
+        path: i.path?.map((p) => (typeof p === 'object' ? p.key : p)),
+      })),
+    },
+  )
+}
+
+type Authorize = ((args: { ctx: Context; params: unknown }) => unknown) &
+  Record<'read' | 'write', (args: { ctx: Context; key: unknown }) => unknown>
+export const allowed = async (
+  fn: Fn,
+  ctx: Context,
+  params: unknown,
+  write?: boolean,
+): Promise<boolean> => {
+  const a = fn.def.authorize as Authorize
+  return !!(await (fn.kind === 'shared'
+    ? a[write ? 'write' : 'read']({ ctx, key: params })
+    : a({ ctx, params })))
+}
+
+export const denied = (fn: Fn) =>
+  new StartError(
+    'R011',
+    `\`${fn.$id}\`: \`authorize\` refused this client`,
+    'sign in, or check `authorize`',
+  )

package/src/socket/deliver.ts

@@ -0,0 +1,16 @@
+import type { Hub, Ev } from '../hub'
+import type { Sock, Join } from './types'
+import { ASK } from './rooms'
+
+/** Fan-out of a room's messages to one join. */
+export function deliver(c: Sock, j: Join, h: Hub, ev: Ev, send: (c: Sock, out: unknown[]) => void) {
+  const m = (ev.p ??= JSON.parse(ev.raw)) as {
+    f?: string
+    x?: 1
+    t?: string
+    n: string
+    m: unknown
+  }
+  if (m.n === ASK || (m.x && m.f === c.k) || (m.t && m.t !== c.k)) return
+  send(c, ['m', j.n, h.cursorOf(ev.seq), m.n, m.m])
+}