@lincyaw/workspace 0.0.0-stage → 1.0.0-rc.0

package/src/node/serve.ts

@@ -0,0 +1,302 @@
+import { createHash } from 'node:crypto'
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs'
+import { homedir, tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { buildView, Compiler, pluginLogger, runBlock, workspacePlugins } from '@lincyaw/compiler'
+import type { Compilation, CompilerOptions } from '@lincyaw/compiler'
+import { CHANGE_REVIEW, DOCUMENT_FILES, DOCUMENT_LOCKS, errorMessage, REVISIONS } from '@lincyaw/kernel'
+import type { Finding, IRDocument, Logger, ServiceToken, SiteSpec } from '@lincyaw/kernel'
+import { servedDocument, startServer } from '@lincyaw/server'
+import type { PresmiumServer, ServedDocument, ServedPlugin, ServerHost } from '@lincyaw/server'
+import { WORKSPACE_ID } from '../domain/api.ts'
+import { listDocuments, readWorkspace } from './config.ts'
+import { workspaceService } from './service.ts'
+import type { Service } from './service.ts'
+import { Documents, RequestError } from './documents.ts'
+import type { DocumentsChange } from './documents.ts'
+import { localWriter } from './files.ts'
+import type { DocumentWriter } from './files.ts'
+import { Git } from './git.ts'
+import { DocumentLocks } from './locks.ts'
+import { Reviews } from './review/reviews.ts'
+import { Revisions } from './revisions.ts'
+import { workspacePlugin } from './routes.ts'
+import type { WorkspaceRoutes } from './routes.ts'
+import { DocumentSession } from './session.ts'
+import { siteContext, siteDocument, siteIR, siteSpec, untranslated, webRenderer } from './site.ts'
+
+export interface ServeOptions {
+  dir: string
+  host?: string
+  port?: number
+  operatorDir?: string
+  bundled?: string
+  check?(compilation: Compilation): Promise<Finding[]>
+  previewOrigins?: string[]
+  env?: NodeJS.ProcessEnv
+  approvalTimeoutMs?: number
+  log?: Logger
+}
+
+export interface WorkspaceServer {
+  url: string
+  root: string
+  mcp: { url: string, stateFile: string }
+  close(): Promise<void>
+}
+
+const DISK_LOOK_MS = 1000
+
+function stateDir(root: string, env: NodeJS.ProcessEnv): string {
+  const base = env.XDG_CACHE_HOME || join(homedir(), '.cache')
+  const dir = join(base, 'presmium', 'serve', createHash('sha256').update(root).digest('hex').slice(0, 16))
+  mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+export async function serveWorkspace(options: ServeOptions): Promise<WorkspaceServer> {
+  const env = options.env ?? process.env
+  const log = options.log ?? pluginLogger('presmium serve')
+  const config = readWorkspace(options.dir)
+  const { root } = config
+  const docs = () => listDocuments(config)
+  const sessions = new Map<string, DocumentSession>()
+  const locks = new DocumentLocks()
+  const check = options.check ?? (compilation => compilation.check())
+  const token = env.PRESMIUM_SERVICE_TOKEN || undefined
+  const preview = { origins: options.previewOrigins ?? [] }
+
+  let services: [ServiceToken<unknown>, unknown][] = []
+  let hostServices: [ServiceToken<unknown>, unknown][] = []
+  let site: SiteBackend | undefined
+  let server: PresmiumServer | undefined
+  let service: Service | undefined
+
+  const sessionOf = (dir: string): DocumentSession => {
+    const known = sessions.get(dir)
+    if (known) return known
+    const document = docs().find(doc => doc.dir === dir)
+    if (!document) throw new RequestError(404, `no document ${JSON.stringify(dir)}`)
+    const session = new DocumentSession(dir, new Compiler(join(root, document.entry), { ...pluginOptions(), execution: { env: 'serve' } }), log)
+    session.onCompile(async (compilation) => {
+      for (const finding of untranslated(compilation, root)) {
+        if (!compilation.doc.diagnostics.some(f => f.message === finding.message)) compilation.doc.diagnostics.push(finding)
+      }
+    })
+    session.onCompile((compilation, changed) => {
+      service?.compiled(dir, compilation, changed)
+      void Promise.resolve(site?.update(dir, compilation)).catch((error: unknown) => log.warn(`the site did not take ${dir}: ${errorMessage(error)}`))
+    })
+    sessions.set(dir, session)
+    return session
+  }
+
+  const pluginOptions = (): CompilerOptions => ({
+    workspaceRoot: root,
+    settings: config.settings,
+    services: [...services, ...hostServices],
+    bundled: options.bundled,
+    ...options.operatorDir ? { operatorDir: options.operatorDir } : {},
+    secret: name => env[name],
+  })
+
+  const spec: SiteSpec = siteSpec(config, docs().map(doc => siteDocument(doc)))
+  const refreshSpec = (): DocumentsChange => {
+    const now = docs()
+    const before = spec.documents.map(doc => doc.dir)
+    spec.documents.splice(0, spec.documents.length, ...now.map(doc => siteDocument(doc)))
+    return { removed: before.filter(dir => !now.some(doc => doc.dir === dir)), added: now.map(doc => doc.dir).filter(dir => !before.includes(dir)) }
+  }
+
+  const documentsChanged = async (change: DocumentsChange): Promise<void> => {
+    for (const dir of change.removed) {
+      sessions.get(dir)?.close()
+      sessions.delete(dir)
+    }
+    const listed = refreshSpec()
+    const removed = [...new Set([...change.removed, ...listed.removed])]
+    for (const dir of new Set([...removed, ...change.added, ...listed.added])) await server?.unmount(dir)
+    await site?.documentsChanged(removed)
+    await service?.removed(removed)
+  }
+
+  let lookedAt = 0
+  const lookAtDisk = (): void => {
+    if (Date.now() - lookedAt < DISK_LOOK_MS) return
+    lookedAt = Date.now()
+    const now = docs().map(doc => doc.dir)
+    const known = spec.documents.map(doc => doc.dir)
+    const change = { removed: known.filter(dir => !now.includes(dir)), added: now.filter(dir => !known.includes(dir)) }
+    if (change.removed.length || change.added.length) void documentsChanged(change).catch((error: unknown) => log.warn(`the documents on disk changed, but the site did not follow: ${errorMessage(error)}`))
+  }
+
+  const workspaceOf = (): { revisions?: Revisions, reviews?: Reviews, writer: DocumentWriter, plugin: ServedPlugin } => {
+    const writer = localWriter(config)
+    const git = Git.isRepository(root) ? new Git(root) : undefined
+    if (!git) log.warn(`${root} is not a git repository: editing, the document operations and the history are not available (run git init)`)
+    const revisions = git ? new Revisions(git, { config, writer }) : undefined
+    const reviews = revisions ? new Reviews({ config, revisions, locks, files: writer, log }) : undefined
+    const documents = new Documents({ config, git: git!, revisions: revisions!, writer, changed: documentsChanged, locks })
+    const routes: WorkspaceRoutes = { documents, ...revisions ? { revisions } : {}, locks, documentsChanged, ...service ? { service } : {}, ...token ? { token } : {}, ...reviews ? { reviews } : {} }
+    return { ...revisions ? { revisions } : {}, ...reviews ? { reviews } : {}, writer, plugin: { id: WORKSPACE_ID, plugin: workspacePlugin(routes), config: {} } }
+  }
+  let workspace: ReturnType<typeof workspaceOf> | undefined
+  const plugin = (): ServedPlugin => workspace!.plugin
+
+  let started!: () => void
+  const ready = new Promise<void>(resolve => started = resolve)
+
+  const serverHost: ServerHost = {
+    async documents() {
+      return docs().map(({ entry: _entry, ...doc }) => doc)
+    },
+    async compile(document) {
+      await ready
+      const { doc } = await sessionOf(document).ready()
+      return { doc, diagnostics: doc.diagnostics }
+    },
+    async check(document) {
+      await ready
+      const compilation = await sessionOf(document).ready()
+      return [...compilation.doc.diagnostics, ...await check(compilation)]
+    },
+    async build(document, buildOptions = {}) {
+      await ready
+      const compilation = await sessionOf(document).ready()
+      const outDir = join(stateDir(root, env), 'builds', encodeURIComponent(document) || '_')
+      const report = await buildView(compilation, { to: buildOptions.to, outDir })
+      return { outputs: report.outputs.map(({ renderer, outDir: written }) => ({ renderer, outDir: written })), findings: report.findings }
+    },
+    async run(document, target, signal) {
+      await ready
+      return runBlock(await sessionOf(document).ready(), target, signal)
+    },
+  }
+
+  let operators: ReturnType<typeof workspacePlugins> | undefined
+  let home: string | undefined
+  const operatorsOf = async () => {
+    await ready
+    home ??= mkdtempSync(join(tmpdir(), 'presmium-home-'))
+    return operators ??= workspacePlugins(root, pluginOptions())
+  }
+  const homeDocument = async (): Promise<ServedDocument> => {
+    const loaded = await operatorsOf()
+    for (const problem of loaded.problems) log.warn(`the home page: ${problem.message}`)
+    const own = (token: ServiceToken<unknown>) => [...services, ...hostServices].find(([known]) => known.id === token.id)?.[1]
+    return {
+      deckDir: home!,
+      workspaceRoot: home!,
+      plugins: [plugin(), ...loaded.plugins.flatMap(({ plugin: node }) => (node ? [{ id: node.id, plugin: node, config: {} }] : []))],
+      service: <T>(token: ServiceToken<T>) => (own(token) ?? loaded.service(token)) as T | undefined,
+      settings: config.settings,
+      ...options.operatorDir ? { operatorDir: options.operatorDir } : {},
+      home: true,
+    }
+  }
+
+  const stateFile = join(stateDir(root, env), 'server.json')
+  server = await startServer({
+    mode: 'serve',
+    host: options.host,
+    port: options.port,
+    stateFile,
+    forward: () => {
+      lookAtDisk()
+      return site?.forward()
+    },
+    settings: config.settings,
+    approvals: config.approvals,
+    ...options.operatorDir ? { operatorDir: options.operatorDir } : {},
+    serverHost,
+    env,
+    ...options.approvalTimeoutMs ? { approvalTimeoutMs: options.approvalTimeoutMs } : {},
+    log,
+    async document(dir) {
+      await ready
+      if (dir === '' && !config.single) return await homeDocument()
+      if (!docs().some(doc => doc.dir === dir)) return undefined
+      const compilation = await sessionOf(dir).ready()
+      const served = servedDocument(compilation)
+      const reviews = workspace?.reviews
+      const service = <T>(token: ServiceToken<T>) => served.service(token) ?? (reviews && token.id === CHANGE_REVIEW.id ? reviews.service as T : undefined)
+      return { ...served, service, plugins: [plugin(), ...served.plugins] }
+    },
+  })
+  const running = server
+  services = running.services
+  service = workspaceService({ root, sessionOf, serverHost, url: () => running.url, preview, stateDir: stateDir(root, env), log })
+  workspace = workspaceOf()
+  hostServices = [
+    ...workspace.revisions ? [[REVISIONS, workspace.revisions] as [ServiceToken<unknown>, unknown]] : [],
+    [DOCUMENT_FILES, workspace.writer],
+    [DOCUMENT_LOCKS, locks],
+  ]
+  await workspace.reviews?.recover(docs().map(doc => doc.dir))
+
+  started()
+  if (config.single) for (const { dir } of docs()) void sessionOf(dir).ready().catch(() => undefined)
+
+  const compileFull = async (dir: string): Promise<IRDocument> => {
+    const compilation = await sessionOf(dir).ready()
+    return service!.siteDoc(compilation, siteIR(compilation))
+  }
+  try {
+    site = await localSite({ root, spec, bundled: options.bundled, state: stateDir(root, env), compile: compileFull, siteDoc: (compilation, doc) => service!.siteDoc(compilation, doc), preview, log })
+  } catch (error) {
+    await service?.close()
+    await running.close()
+    if (home) rmSync(home, { recursive: true, force: true })
+    throw error
+  }
+
+  return {
+    url: running.url,
+    root,
+    mcp: { url: `${running.url}/mcp`, stateFile },
+    async close() {
+      workspace?.reviews?.close()
+      for (const session of sessions.values()) session.close()
+      await service?.close()
+      await site?.close()
+      await running.close()
+      if (home) rmSync(home, { recursive: true, force: true })
+    },
+  }
+}
+
+interface SiteBackend {
+  forward(): string | undefined
+  update(dir: string, compilation: Compilation): Promise<void> | void
+  documentsChanged(removed: string[]): Promise<void>
+  close(): Promise<void>
+}
+
+interface LocalSiteOptions {
+  root: string
+  spec: SiteSpec
+  bundled?: string
+  state: string
+  compile(dir: string): Promise<IRDocument>
+  siteDoc(compilation: Compilation, doc: IRDocument): IRDocument
+  preview: { origins: string[] }
+  log: Logger
+}
+
+async function localSite(options: LocalSiteOptions): Promise<SiteBackend> {
+  const { root, spec, log } = options
+  const renderer = await webRenderer(root, options.bundled)
+  const findings: Finding[] = []
+  const work = join(options.state, 'site', 'full')
+  const ctx = siteContext({ root, outDir: work, workDir: work, findings })
+  ctx.preview = options.preview
+  const dev = await renderer.devSite!(spec, ctx, options.compile)
+  const origin = new URL(dev.url).origin
+  log.info(`the workspace site's dev router is at ${origin} (this machine only; pages reach it through serve)`)
+  return {
+    forward: () => origin,
+    update: (dir, compilation) => dev.update(dir, options.siteDoc(compilation, siteIR(compilation))).catch((error: unknown) => log.warn(`the site did not take ${dir}: ${errorMessage(error)}`)),
+    documentsChanged: async () => {},
+    close: () => dev.close(),
+  }
+}

package/src/node/service.ts

@@ -0,0 +1,237 @@
+import { createHash } from 'node:crypto'
+import { createServer } from 'node:net'
+import type { AddressInfo } from 'node:net'
+import { join, relative, sep } from 'node:path'
+import { dev, relativeIR } from '@lincyaw/compiler'
+import type { Compilation } from '@lincyaw/compiler'
+import { errorMessage, PREVIEW_REVISION } from '@lincyaw/kernel'
+import type { Finding, IRDocument, Logger, ProxySpec } from '@lincyaw/kernel'
+import type { ServerHost } from '@lincyaw/server'
+import { WORKSPACE_ID } from '../domain/api.ts'
+import type { DocumentSession } from './session.ts'
+
+export interface IrAnswer {
+  document: string
+  revision: string
+  doc: IRDocument
+  diagnostics: Finding[]
+}
+
+export interface IrEvent {
+  document: string
+  revision: string
+  diagnostics: { errors: number, warnings: number }
+  files: string[]
+}
+
+export interface PreviewAnswer {
+  document: string
+  web: string
+  slides?: string
+}
+
+export interface BuildAnswer {
+  outputs: { renderer: string, outDir: string }[]
+  findings: Finding[]
+}
+
+export interface CheckAnswer {
+  findings: Finding[]
+}
+
+export interface WorkspaceService {
+  ir(document: string): Promise<IrAnswer>
+  events(document: string, signal: AbortSignal): AsyncIterable<{ event: string, data: IrEvent }>
+  preview(document: string): Promise<PreviewAnswer>
+  build(document: string, to?: string[]): Promise<BuildAnswer>
+  check(document: string): Promise<CheckAnswer>
+  proxies: ProxySpec[]
+}
+
+export function irRevision(doc: IRDocument): string {
+  return createHash('sha256').update(JSON.stringify(doc)).digest('hex').slice(0, 16)
+}
+
+export function withRevision(doc: IRDocument, revision: string): IRDocument {
+  return { ...doc, meta: { ...doc.meta, [PREVIEW_REVISION]: revision } }
+}
+
+function workspacePath(root: string, file: string): string {
+  return relative(root, file).split(sep).join('/')
+}
+
+function freePort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer()
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address() as AddressInfo
+      server.close(() => resolve(port))
+    })
+  })
+}
+
+function urlPath(dir: string): string {
+  return dir.split('/').map(encodeURIComponent).join('/')
+}
+
+function slidesPath(dir: string): string {
+  return `slides/${dir ? `${urlPath(dir)}/` : ''}`
+}
+
+export interface ServiceOptions {
+  root: string
+  sessionOf(dir: string): DocumentSession
+  serverHost: ServerHost
+  url(): string
+  preview?: { origins: string[] }
+  stateDir: string
+  log: Logger
+}
+
+export interface Service extends WorkspaceService {
+  compiled(dir: string, compilation: Compilation, changed: string[]): void
+  siteDoc(compilation: Compilation, doc: IRDocument): IRDocument
+  removed(dirs: string[]): Promise<void>
+  close(): Promise<void>
+}
+
+export function workspaceService(options: ServiceOptions): Service {
+  const { root, log } = options
+  const revisions = new WeakMap<Compilation, string>()
+  const revisionOf = (compilation: Compilation) => {
+    let known = revisions.get(compilation)
+    if (!known) revisions.set(compilation, known = irRevision(compilation.doc))
+    return known
+  }
+  const listeners = new Map<string, Set<(event: IrEvent) => void>>()
+  const slides = new Map<string, Promise<{ update(compilation: Compilation): Promise<void>, close(): Promise<void> } | undefined>>()
+  const proxies: ProxySpec[] = []
+  let closed = false
+
+  const eventOf = (dir: string, compilation: Compilation, changed: string[]): IrEvent => {
+    const count = (severity: Finding['severity']) => compilation.doc.diagnostics.filter(finding => finding.severity === severity).length
+    return { document: dir, revision: revisionOf(compilation), diagnostics: { errors: count('error'), warnings: count('warning') }, files: changed.map(file => workspacePath(root, file)) }
+  }
+  const stamped = (compilation: Compilation): Compilation => (options.preview ? { ...compilation, doc: withRevision(compilation.doc, revisionOf(compilation)) } : compilation)
+
+  const slidesOf = (dir: string) => {
+    let known = slides.get(dir)
+    if (!known) {
+      known = (async () => {
+        const session = options.sessionOf(dir)
+        const compilation = await session.ready()
+        const configured = Object.keys(compilation.doc.config.renderers)
+        if (configured.length > 0 && !configured.includes('slides')) return undefined
+        const path = slidesPath(dir)
+        const started = await dev(session.compiler, {
+          outDir: join(options.stateDir, 'preview', encodeURIComponent(dir) || '_'),
+          to: ['slides'],
+          compilation: stamped(compilation),
+          base: `/__presmium/${WORKSPACE_ID}/${path}`,
+          port: await freePort(),
+          ...options.preview ? { preview: { origins: options.preview.origins } } : {},
+          onCompile(_compilation, findings) {
+            for (const finding of findings.filter(f => f.checkId === 'presmium.render')) log.warn(`the slides' preview of ${dir || '.'}: ${finding.message}`)
+          },
+        })
+        const server = started.servers[0]
+        if (!server || closed) {
+          await started.close()
+          return undefined
+        }
+        const target = new URL(server.url)
+        proxies.push({ path: path.replace(/\/$/, ''), target: `${target.origin}${target.pathname.replace(/\/$/, '')}` })
+        proxies.sort((a, b) => b.path.length - a.path.length)
+        return started
+      })()
+      known.catch((error: unknown) => {
+        log.warn(`the slides' preview of ${dir || '.'} did not start: ${errorMessage(error)}`)
+        slides.delete(dir)
+      })
+      slides.set(dir, known)
+    }
+    return known
+  }
+
+  const stop = async (dir: string) => {
+    const known = slides.get(dir)
+    slides.delete(dir)
+    const path = slidesPath(dir).replace(/\/$/, '')
+    const at = proxies.findIndex(proxy => proxy.path === path)
+    if (at >= 0) proxies.splice(at, 1)
+    await (await known?.catch(() => undefined))?.close()
+  }
+
+  return {
+    proxies,
+    async ir(document) {
+      const compilation = await options.sessionOf(document).ready()
+      const doc = relativeIR(compilation.doc, root, root)
+      return { document, revision: revisionOf(compilation), doc, diagnostics: doc.diagnostics }
+    },
+    events(document, signal) {
+      const waiting: IrEvent[] = []
+      let wake: (() => void) | undefined
+      const listener = (event: IrEvent) => {
+        waiting.push(event)
+        wake?.()
+      }
+      const own = listeners.get(document) ?? new Set()
+      listeners.set(document, own.add(listener))
+      const done = () => own.delete(listener)
+      signal.addEventListener('abort', () => {
+        done()
+        wake?.()
+      }, { once: true })
+      const session = options.sessionOf(document)
+      if (session.latest) waiting.push(eventOf(document, session.latest, []))
+      else void session.ready().catch(() => undefined)
+      return {
+        async* [Symbol.asyncIterator]() {
+          try {
+            while (!signal.aborted) {
+              const next = waiting.shift()
+              if (next) {
+                yield { event: 'revision', data: next }
+                continue
+              }
+              await new Promise<void>(resolve => wake = resolve)
+              wake = undefined
+            }
+          } finally {
+            done()
+          }
+        },
+      }
+    },
+    async preview(document) {
+      const base = options.url()
+      const web = `${base}/${document ? `${urlPath(document)}/` : ''}`
+      const own = await slidesOf(document).catch(() => undefined)
+      return { document, web, ...own ? { slides: `${base}/__presmium/${WORKSPACE_ID}/${slidesPath(document)}` } : {} }
+    },
+    async build(document, to) {
+      return await options.serverHost.build(document, to ? { to } : {})
+    },
+    async check(document) {
+      return { findings: await options.serverHost.check(document) }
+    },
+    compiled(dir, compilation, changed) {
+      const event = eventOf(dir, compilation, changed)
+      for (const listener of listeners.get(dir) ?? []) listener(event)
+      const known = slides.get(dir)
+      if (known) void known.then(started => started?.update(stamped(compilation))).catch((error: unknown) => log.warn(`the slides' preview of ${dir || '.'} did not update: ${errorMessage(error)}`))
+    },
+    siteDoc(compilation, doc) {
+      return options.preview ? withRevision(doc, revisionOf(compilation)) : doc
+    },
+    async removed(dirs) {
+      for (const dir of dirs) await stop(dir)
+    },
+    async close() {
+      closed = true
+      for (const dir of [...slides.keys()]) await stop(dir)
+    },
+  }
+}

package/src/node/session.ts

@@ -0,0 +1,123 @@
+import { existsSync, statSync, watch } from 'node:fs'
+import type { FSWatcher } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import type { Compilation, Compiler } from '@lincyaw/compiler'
+import { errorMessage } from '@lincyaw/kernel'
+import type { Logger } from '@lincyaw/kernel'
+
+export class DocumentSession {
+  readonly dir: string
+  readonly compiler: Compiler
+  #latest?: Compilation
+  #first?: Promise<Compilation>
+  #running: Promise<unknown> = Promise.resolve()
+  #queued?: Promise<Compilation>
+  readonly #listeners = new Set<(compilation: Compilation, changed: string[]) => void | Promise<void>>()
+  #changedFiles = new Set<string>()
+  readonly #watchers = new Map<string, FSWatcher>()
+  #relevant = new Map<string, Set<string>>()
+  #timer?: NodeJS.Timeout
+  #closed = false
+  readonly #log: Logger
+
+  constructor(dir: string, compiler: Compiler, log: Logger) {
+    this.dir = dir
+    this.compiler = compiler
+    this.#log = log
+  }
+
+  ready(): Promise<Compilation> {
+    if (this.#latest) return Promise.resolve(this.#latest)
+    if (!this.#first) {
+      const first = this.recompile()
+      first.catch(() => {
+        if (this.#first === first) this.#first = undefined
+      })
+      this.#first = first
+    }
+    return this.#first
+  }
+
+  get latest(): Compilation | undefined {
+    return this.#latest
+  }
+
+  onCompile(listener: (compilation: Compilation, changed: string[]) => void | Promise<void>): () => void {
+    this.#listeners.add(listener)
+    return () => this.#listeners.delete(listener)
+  }
+
+  recompile(): Promise<Compilation> {
+    if (this.#queued) return this.#queued
+    const next = this.#running.then(async () => {
+      this.#queued = undefined
+      const started = Date.now()
+      const changed = [...this.#changedFiles]
+      this.#changedFiles.clear()
+      const compilation = await this.compiler.compile()
+      this.#latest = compilation
+      for (const listener of this.#listeners) {
+        try {
+          await listener(compilation, changed)
+        } catch (error) {
+          this.#log.error(`after compiling ${this.dir || '.'}: ${errorMessage(error)}`)
+        }
+      }
+      this.#watch(compilation, started)
+      return compilation
+    })
+    this.#queued = next
+    this.#running = next.catch((error: unknown) => this.#log.error(`compiling ${this.dir || '.'} failed: ${errorMessage(error)}`))
+    return next
+  }
+
+  close(): void {
+    this.#closed = true
+    clearTimeout(this.#timer)
+    for (const watcher of this.#watchers.values()) watcher.close()
+    this.#watchers.clear()
+    this.#listeners.clear()
+  }
+
+  #watch(compilation: Compilation, started: number): void {
+    if (this.#closed) return
+    const files = new Set([...compilation.files, ...compilation.dependencies.files])
+    const next = new Map<string, Set<string>>()
+    for (const file of files) {
+      let dir = dirname(file)
+      let name = basename(file)
+      while (!existsSync(dir) && dirname(dir) !== dir) {
+        name = basename(dir)
+        dir = dirname(dir)
+      }
+      next.set(dir, (next.get(dir) ?? new Set<string>()).add(name))
+    }
+    this.#relevant = next
+    for (const [dir, watcher] of this.#watchers) {
+      if (next.has(dir)) continue
+      watcher.close()
+      this.#watchers.delete(dir)
+    }
+    for (const dir of next.keys()) {
+      if (this.#watchers.has(dir)) continue
+      try {
+        this.#watchers.set(dir, watch(dir, (_event, name) => {
+          if (name && this.#relevant.get(dir)?.has(basename(name))) this.#changed(join(dir, name))
+        }))
+      } catch {
+      }
+    }
+    const modified = [...files].filter((file) => {
+      const time = statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? 0
+      return time >= started - 20 && time <= Date.now()
+    })
+    for (const file of modified) this.#changed(file)
+  }
+
+  #changed(file: string): void {
+    if (this.#closed) return
+    this.#changedFiles.add(file)
+    clearTimeout(this.#timer)
+    this.#timer = setTimeout(() => void this.recompile().catch(() => undefined), 50)
+  }
+}