@lincyaw/workspace 1.0.0-rc.0 → 1.0.0-rc.2

package/src/node/serve.ts

@@ -1,38 +1,54 @@
+import { createProjectAuthoring } from './projects.ts'
+import { createDocumentHistory } from './document-history.ts'
+import { createAuthoringClients } from './authoring-clients.ts'
 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 { join, relative } from 'node:path'
+import { Compiler, operatorDir as resolveOperatorDir, 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 { CHANGE_REVIEW, DOCUMENT_FILES, DOCUMENT_LOCKS, DOCUMENT_VOICE_TASKS, errorMessage, PRODUCTION_AUDIO_AUTHORING, REVISIONS, SPEECH, VOICEOVER, VOICEOVER_EXECUTION } from '@lincyaw/kernel'
+import { irRevision, operatorSpeechSecrets } from '@lincyaw/kernel/node'
+import { speechSettingsRoute } from './speech-settings.ts'
+import type { CanonicalSource, ChangeReviewService, Finding, IRDocument, Logger, ProductionAudioAuthoring, ServiceToken, SiteSpec, SpeechService } from '@lincyaw/kernel'
+import { serverConfigKey, servedDocument, startServer } from '@lincyaw/server'
+import type { DiagnosticStore, PresmiumServer, ServedDocument, ServedPlugin, ServerHost } from '@lincyaw/server'
+import { CompileSession } from './compile-session.ts'
+import { documentSummaries, listDocuments, readWorkspaceConfig } from './config.ts'
+import { DocumentOperations, documentsDiff } from './document-operations.ts'
+import type { DocumentsChange } from './document-operations.ts'
+import { RequestError } from './errors.ts'
 import { Git } from './git.ts'
+import { createJobs, OUTPUTS_PATH } from './jobs.ts'
 import { DocumentLocks } from './locks.ts'
-import { Reviews } from './review/reviews.ts'
+import { AgentSessionReviews } from './review/agent-session-reviews.ts'
+import { createTaskReviewService } from './review/task-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'
+import { WORKSPACE_ID, authorizeWorkspaceRoutes, workspaceRoutes, workspaceRoutesPlugin } from './routes.ts'
+import { refreshDocumentVitePlugins, siteContext, siteDocument, siteDocumentIR, siteSpec, untranslatedFindings, webRenderer } from './site.ts'
+import { SourceEditor } from './source-editor.ts'
+import { createDocumentEditor } from './document-editor.ts'
+import type { DocumentEditor } from './document-editor.ts'
+import { createDocumentTranscriptions } from './document-transcription.ts'
+import { createTranscriptionAdoption } from './document-transcription-adoption.ts'
+import { createDocumentAudioAuthoring } from './document-audio.ts'
+import { createDocumentImageAuthoring } from './document-images.ts'
+import { createDocumentVoiceAuthoring } from './document-voice.ts'
+import type { DocumentVoiceServices } from './document-voice.ts'
+import { createWorkbenchBackend } from './workbench-api.ts'
+import type { WorkbenchBackend } from './workbench-api.ts'
+import { localWriter } from './writer.ts'
 
 export interface ServeOptions {
   dir: string
-  host?: string
+  listenAddress?: string
   port?: number
   operatorDir?: string
   bundled?: string
   check?(compilation: Compilation): Promise<Finding[]>
   previewOrigins?: string[]
+  /** The address browsers use when a reverse proxy fronts the service (see `ServerOptions.publicUrl`). */
+  publicUrl?: string
   env?: NodeJS.ProcessEnv
   approvalTimeoutMs?: number
   log?: Logger
@@ -45,9 +61,21 @@ export interface WorkspaceServer {
   close(): Promise<void>
 }
 
+/** What the workspace keeps when it is a git repository: its revisions, the document operations and the reviews. */
+interface WorkspaceHistory {
+  git: Git
+  revisions: Revisions
+  operations: DocumentOperations
+  agentSessionReviews: AgentSessionReviews
+  taskReviews: ChangeReviewService
+}
+
+interface AuthoringServices extends DocumentVoiceServices { audio?: ProductionAudioAuthoring }
+interface NodeServiceLoad { key: string, promise: Promise<AuthoringServices>, controller: AbortController }
+
 const DISK_LOOK_MS = 1000
 
-function stateDir(root: string, env: NodeJS.ProcessEnv): string {
+function makeStateDir(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 })
@@ -57,194 +85,355 @@ function stateDir(root: string, env: NodeJS.ProcessEnv): string {
 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 config = readWorkspaceConfig(options.dir)
   const { root } = config
+  const operatorDirectory = resolveOperatorDir(root, options.operatorDir ?? env.PRESMIUM_OPERATOR_DIR)
+  const stateDir = makeStateDir(root, env)
   const docs = () => listDocuments(config)
-  const sessions = new Map<string, DocumentSession>()
+  const compileSessions = new Map<string, CompileSession>()
+  const agentToolListeners = new Set<(document: string) => void>()
   const locks = new DocumentLocks()
+  const writer = localWriter(config)
+  const editor = new SourceEditor({ config, writer, locks })
   const check = options.check ?? (compilation => compilation.check())
-  const token = env.PRESMIUM_SERVICE_TOKEN || undefined
+  const launcherToken = env.PRESMIUM_SERVICE_TOKEN || undefined
   const preview = { origins: options.previewOrigins ?? [] }
+  // Behind a proxy that forwards a path (`--public-url https://host/user/a/preview/`), the site, the jobs' files and the
+  // previews' links are all below that path; the server finds its own routes below it too.
+  const basePath = options.publicUrl ? `${new URL(options.publicUrl).pathname.replace(/\/+$/, '')}/` : '/'
+  const outputsPath = `${basePath}${OUTPUTS_PATH.slice(1)}`
+  const publicOrigin = () => options.publicUrl ? new URL(options.publicUrl).origin : server?.url ?? ''
 
-  let services: [ServiceToken<unknown>, unknown][] = []
-  let hostServices: [ServiceToken<unknown>, unknown][] = []
-  let site: SiteBackend | undefined
+  let serverServices: [ServiceToken<unknown>, unknown][] = []
+  let workspaceServices: [ServiceToken<unknown>, unknown][] = []
+  let site: WorkspaceSite | undefined
   let server: PresmiumServer | undefined
-  let service: Service | undefined
+  let workbench: WorkbenchBackend | undefined
+  let history: WorkspaceHistory | undefined
+  let documentEditor: DocumentEditor | undefined
+  let documentHistory: ReturnType<typeof createDocumentHistory> | undefined
+  let projectAuthoring: ReturnType<typeof createProjectAuthoring> | undefined
+  let authoringClients: ReturnType<typeof createAuthoringClients> | undefined
+  let transcriptions: ReturnType<typeof createDocumentTranscriptions> | undefined
+  let transcriptionAdoption: ReturnType<typeof createTranscriptionAdoption> | undefined
+  let audioAuthoring: ReturnType<typeof createDocumentAudioAuthoring> | undefined
+  let imageAuthoring: ReturnType<typeof createDocumentImageAuthoring> | undefined
+  let voiceAuthoring: ReturnType<typeof createDocumentVoiceAuthoring> | undefined
+  let workspaceRoutesOwner: ReturnType<typeof workspaceRoutes> | undefined
+  let routesPlugin: ServedPlugin | undefined
+  // The builds and exports, as jobs the workbench and the AI start and follow.
+  const jobs = createJobs({
+    stateDir,
+    url: publicOrigin,
+    outputsPath,
+    compilation: (dir, fresh) => fresh ? compileSessionOf(dir).recompile() : compileSessionOf(dir).ready(),
+    revision: compilation => irRevision(compilation.doc),
+    origins: preview.origins,
+    log,
+  })
 
-  const sessionOf = (dir: string): DocumentSession => {
-    const known = sessions.get(dir)
+  const compileSessionOf = (dir: string): CompileSession => {
+    const known = compileSessions.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)
+    const session = new CompileSession(dir, new Compiler(join(root, document.entry), { ...compilerOptions(), priority: 'interactive', execution: { env: 'serve' } }), log)
+    let configKey: string | undefined
     session.onCompile(async (compilation) => {
-      for (const finding of untranslated(compilation, root)) {
+      const next = serverConfigKey(compilation)
+      if (configKey !== undefined && configKey !== next) void server?.unmount(dir, { preserveFocus: true }).catch((error: unknown) => {
+        log.error(`the previous server contributions of ${dir || '.'} did not close: ${errorMessage(error)}`)
+      })
+      configKey = next
+      for (const finding of untranslatedFindings(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)}`))
+      server?.diagnostics.compiled(dir, compilation.doc, root, irRevision(compilation.doc))
+      workbench?.compiled(dir, compilation, changed)
+      for (const listener of agentToolListeners) listener(dir)
+      void site?.update(dir, compilation).catch((error: unknown) => log.warn(`the site did not take ${dir}: ${errorMessage(error)}`))
     })
-    sessions.set(dir, session)
+    session.onFailure(error => server?.diagnostics.failed(dir, errorMessage(error), { file: relative(root, session.compiler.entry).replace(/\\/g, '/') }))
+    compileSessions.set(dir, session)
     return session
   }
 
-  const pluginOptions = (): CompilerOptions => ({
+  const compilerOptions = (): CompilerOptions => ({
     workspaceRoot: root,
     settings: config.settings,
-    services: [...services, ...hostServices],
+    services: [...serverServices, ...workspaceServices],
     bundled: options.bundled,
-    ...options.operatorDir ? { operatorDir: options.operatorDir } : {},
-    secret: name => env[name],
+    operatorDir: operatorDirectory,
+    secret: operatorSpeechSecrets(operatorDirectory, name => env[name]),
   })
 
+  // Coalesce only in-flight discovery. A later read reassembles actual services and problems;
+  // source edits or a repaired plugin cannot be hidden behind a retained capability cache.
+  const nodeServiceLoads = new Map<string, NodeServiceLoad>()
+  const nodeServicePending = new Set<NodeServiceLoad>()
+  let authoringServicesClosed = false
+  const authoringServices = (document: string, source: CanonicalSource): Promise<AuthoringServices> => {
+    if (authoringServicesClosed) throw new RequestError(503, 'document-services-unavailable')
+    const key = JSON.stringify(source), known = nodeServiceLoads.get(document)
+    if (known?.key === key) return known.promise
+    const selected = docs().find(doc => doc.dir === document)
+    if (!selected) throw new RequestError(404, 'authoring-document-missing')
+    const controller = new AbortController()
+    const promise: Promise<AuthoringServices> = new Compiler(join(root, selected.entry), compilerOptions()).nodeServices({ signal: controller.signal }).then(loaded => {
+      if (loaded.source.documentId !== source.documentId || loaded.source.version !== source.version || loaded.source.fingerprint !== source.fingerprint) throw new RequestError(409, 'document-version-changed')
+      return { audio: loaded.service(PRODUCTION_AUDIO_AUTHORING), speech: loaded.service(SPEECH), voiceover: loaded.service(VOICEOVER), voiceoverExecution: loaded.service(VOICEOVER_EXECUTION), findings: loaded.findings }
+    }).finally(() => { if (nodeServiceLoads.get(document) === load) nodeServiceLoads.delete(document); nodeServicePending.delete(load) })
+    const load: NodeServiceLoad = { key, promise, controller }
+    nodeServiceLoads.set(document, load)
+    nodeServicePending.add(load)
+    return promise
+  }
+  const closeAuthoring = async () => {
+    authoringServicesClosed = true
+    transcriptionAdoption?.close()
+    for (const load of nodeServicePending) load.controller.abort()
+    await Promise.all([projectAuthoring?.close(), transcriptions?.close(), audioAuthoring?.close(), voiceAuthoring?.close(), documentHistory?.close(), authoringClients?.close(), workspaceRoutesOwner?.close?.()])
+    await Promise.allSettled([...nodeServicePending].map(load => load.promise))
+    nodeServiceLoads.clear()
+  }
+
   const spec: SiteSpec = siteSpec(config, docs().map(doc => siteDocument(doc)))
   const refreshSpec = (): DocumentsChange => {
+    const retained = new Map(spec.documents.map(doc => [doc.dir, doc]))
+    const before = [...retained.keys()]
     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 listed = now.map(doc => {
+      const summary = siteDocument(doc)
+      const known = retained.get(doc.dir)
+      if (!known) return summary
+      // Undoing prose also refreshes the list: retain compiled document modules and translations.
+      delete known.lang
+      delete known.tags
+      return Object.assign(known, summary)
+    })
+    spec.documents.splice(0, spec.documents.length, ...listed)
+    return documentsDiff(before, now.map(doc => doc.dir))
   }
 
   const documentsChanged = async (change: DocumentsChange): Promise<void> => {
     for (const dir of change.removed) {
-      sessions.get(dir)?.close()
-      sessions.delete(dir)
+      server?.diagnostics.forget(dir)
+      compileSessions.get(dir)?.close()
+      compileSessions.delete(dir)
+      for (const listener of agentToolListeners) listener(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)
+    await workbench?.documentsRemoved(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)) }
+    const change = documentsDiff(spec.documents.map(doc => doc.dir), docs().map(doc => doc.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: {} } }
+  const openHistory = (): WorkspaceHistory | undefined => {
+    if (!Git.isRepository(root)) {
+      log.warn(`${root} is not a git repository: editing, the document operations and the history are not available (run git init)`)
+      return undefined
+    }
+    const git = new Git(root)
+    const revisions = new Revisions(git, { config, writer })
+    return {
+      revisions,
+      operations: new DocumentOperations({ config, git, revisions, writer, changed: documentsChanged, locks }),
+      git,
+      agentSessionReviews: new AgentSessionReviews({ config, revisions, locks, files: writer, log }),
+      taskReviews: createTaskReviewService({ config, locks, files: writer, log }),
+    }
   }
-  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 = {
+    workspaceRoot: root,
+    get authoring() { return documentEditor },
+    get documentHistory() { return documentHistory?.service },
+    get projectAuthoring() { return projectAuthoring?.service },
+    get authoringClients() { return authoringClients?.service },
+    get audioAuthoring() { return audioAuthoring?.service },
+    get imageAuthoring() { return imageAuthoring?.service },
+    get voiceAuthoring() { return voiceAuthoring?.service },
+    get transcriptions() { return transcriptions },
+    get transcriptionAdoption() { return transcriptionAdoption?.service },
+    get routes() { return workspaceRoutesOwner?.routes ? { [WORKSPACE_ID]: workspaceRoutesOwner.routes, ...voiceAuthoring ? { 'presmium.lecture': authorizeWorkspaceRoutes(voiceAuthoring.routes, launcherToken) } : {} } : undefined },
+    agentTools(document) {
+      const compiled = (document === undefined ? [...compileSessions.values()] : [compileSessions.get(document)]).flatMap(session => session?.latest ? [session.latest] : [])
+      const tools = new Map(compiled.flatMap(compilation => compilation.plugins.flatMap(loaded => loaded.plugin?.tools ?? [])).map(tool => [tool.name, tool]))
+      return { tools: [...tools.values()], service: <T>(token: ServiceToken<T>) => compiled[0]?.service(token) }
+    },
+    watchAgentTools(listener) { agentToolListeners.add(listener); return () => { agentToolListeners.delete(listener) } },
+    async readSource(path, member) {
+      await ready
+      return editor.read(editor.scope(''), path, member)
+    },
     async documents() {
-      return docs().map(({ entry: _entry, ...doc }) => doc)
+      return documentSummaries(config)
     },
     async compile(document) {
       await ready
-      const { doc } = await sessionOf(document).ready()
+      const { doc } = await compileSessionOf(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)]
+      const session = compileSessionOf(document)
+      const compilation = await session.ready()
+      const findings = await check(compilation)
+      if (session.latest === compilation) server?.diagnostics.replace({ document, origin: 'check' }, findings, { root, irRevision: irRevision(compilation.doc) })
+      return [...compilation.doc.diagnostics, ...findings]
     },
     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 }
+      // As jobs, which the workbench shows: one a renderer, waited for.
+      const targets = buildOptions.to ?? (await jobs.targets(document)).filter(target => target.kind === 'render').map(target => target.id)
+      const ended = await Promise.all((await Promise.all(targets.map(target => jobs.start(document, target)))).map(job => jobs.wait(job.id)))
+      const outputs = ended.filter(job => job.state === 'done').map(job => ({ renderer: job.target, outDir: jobs.directory(job) }))
+      const findings: Finding[] = ended.flatMap(job => [
+        ...job.state === 'failed' ? [{ checkId: 'presmium.render', severity: 'error' as const, message: `${job.target}: ${job.error ?? job.state}` }] : [],
+        ...job.warnings.map(message => ({ checkId: 'presmium.render', severity: 'warning' as const, message })),
+      ])
+      return { outputs, findings }
     },
+    jobs,
     async run(document, target, signal) {
       await ready
-      return runBlock(await sessionOf(document).ready(), target, signal)
+      return runBlock(await compileSessionOf(document).ready(), target, signal)
     },
   }
 
   let operators: ReturnType<typeof workspacePlugins> | undefined
   let home: string | undefined
-  const operatorsOf = async () => {
+  const loadOperatorPlugins = async () => {
     await ready
     home ??= mkdtempSync(join(tmpdir(), 'presmium-home-'))
-    return operators ??= workspacePlugins(root, pluginOptions())
+    return operators ??= workspacePlugins(root, compilerOptions())
   }
   const homeDocument = async (): Promise<ServedDocument> => {
-    const loaded = await operatorsOf()
+    const loaded = await loadOperatorPlugins()
     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]
+    const own = (token: ServiceToken<unknown>) => [...serverServices, ...workspaceServices].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: {} }] : []))],
+      plugins: [routesPlugin!, ...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 } : {},
+      operatorDir: operatorDirectory,
       home: true,
     }
   }
 
-  const stateFile = join(stateDir(root, env), 'server.json')
+  const stateFile = join(stateDir, 'server.json')
   server = await startServer({
     mode: 'serve',
-    host: options.host,
+    listenAddress: options.listenAddress,
     port: options.port,
+    ...options.publicUrl ? { publicUrl: options.publicUrl } : {},
     stateFile,
-    forward: () => {
+    forward: async (path) => {
       lookAtDisk()
-      return site?.forward()
+      if (path.startsWith(outputsPath)) return await jobs.origin()
+      if (!site) return undefined
+      // Straight to the dev server of the path's document, not through the site's router: one hop less per module.
+      try {
+        return await site.target(path)
+      } catch {
+        return site.forward()
+      }
     },
     settings: config.settings,
     approvals: config.approvals,
-    ...options.operatorDir ? { operatorDir: options.operatorDir } : {},
+    operatorDir: operatorDirectory,
     serverHost,
     env,
     ...options.approvalTimeoutMs ? { approvalTimeoutMs: options.approvalTimeoutMs } : {},
     log,
     async document(dir) {
       await ready
-      if (dir === '' && !config.single) return await homeDocument()
+      if (dir === '' && !config.singleDeck) return await homeDocument()
       if (!docs().some(doc => doc.dir === dir)) return undefined
-      const compilation = await sessionOf(dir).ready()
+      const compilation = await compileSessionOf(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 taskReviews = history?.taskReviews
+      const service = <T>(token: ServiceToken<T>) => served.service(token) ?? (taskReviews && token.id === CHANGE_REVIEW.id ? taskReviews as T : undefined)
+      return { ...served, service, plugins: [routesPlugin!, ...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],
+  serverServices = running.services
+  voiceAuthoring = createDocumentVoiceAuthoring({ editor, services: authoringServices, revision: document => { const latest = compileSessions.get(document)?.latest; return latest ? irRevision(latest.doc) : undefined } })
+  workbench = createWorkbenchBackend({ root, compileSessionOf, serverHost, voices: voiceAuthoring.service, diagnostics: running.diagnostics, url: () => options.publicUrl ? new URL(options.publicUrl).origin : running.url, basePath, preview, log, warmSite: dir => site?.warm(dir) ?? Promise.resolve(), viewerPage: (dir, wait) => site?.app(dir, wait) ?? Promise.resolve(undefined) })
+  history = openHistory()
+  documentEditor = createDocumentEditor({ productionPlan: async (document, source) => { const audio = (await authoringServices(document, source)).audio; if (!audio) throw new RequestError(503, 'caption-production-unavailable'); return audio.readPlan({ source }) }, editor, revisions: history?.revisions, reviewRequired: config.settings['presmium.assistant']?.review === 'required' })
+  projectAuthoring = createProjectAuthoring({ config, documentEditor, operations: history?.operations, revisions: history?.revisions, git: history?.git })
+  authoringClients = createAuthoringClients(editor)
+  documentHistory = createDocumentHistory({ config, editor, locks, revisions: history?.revisions, reviewRequired: config.settings['presmium.assistant']?.review === 'required', changed: (before, after) => documentsChanged(documentsDiff(before, after)), reverted: (target, revision) => history?.agentSessionReviews.reverted(target, revision) })
+  transcriptions = createDocumentTranscriptions({ root, editor, services: authoringServices })
+  transcriptionAdoption = createTranscriptionAdoption({ documentEditor, transcriptions })
+  audioAuthoring = createDocumentAudioAuthoring({ root, editor, revisions: history?.revisions, services: authoringServices, reviewRequired: config.settings['presmium.assistant']?.review === 'required' })
+  imageAuthoring = createDocumentImageAuthoring({ root, editor, revisions: history?.revisions, reviewRequired: config.settings['presmium.assistant']?.review === 'required' })
+  const routeOptions = {
+      speechSettings: speechSettingsRoute(operatorDirectory, name => env[name]),
+      config,
+      editor,
+      documentEditor,
+      transcriptions,
+      transcriptionAdoptionRoutes: transcriptionAdoption.routes,
+      audioAuthoringRoutes: audioAuthoring.routes,
+      imageAuthoringRoutes: imageAuthoring.routes,
+      historyRoutes: documentHistory.routes,
+      authoringClientRoutes: authoringClients.routes,
+      projectRoutes: projectAuthoring.routes,
+      locks,
+      ...history ? { revisions: history.revisions, operations: history.operations, reviews: history.agentSessionReviews } : {},
+      documentsChanged,
+      workbench,
+      jobs,
+      ...launcherToken ? { launcherToken } : {},
+  }
+  workspaceRoutesOwner = workspaceRoutes(routeOptions)
+  routesPlugin = { id: WORKSPACE_ID, plugin: workspaceRoutesPlugin(routeOptions, workspaceRoutesOwner.routes), config: {} }
+  workspaceServices = [
+    ...history ? [[REVISIONS, history.revisions] as [ServiceToken<unknown>, unknown]] : [],
+    [DOCUMENT_FILES, writer],
     [DOCUMENT_LOCKS, locks],
+    [DOCUMENT_VOICE_TASKS, voiceAuthoring.service],
   ]
-  await workspace.reviews?.recover(docs().map(doc => doc.dir))
+  try {
+    await history?.agentSessionReviews.recover(docs().map(doc => doc.dir))
+  } catch (error) {
+    history?.agentSessionReviews.close()
+    await closeAuthoring()
+    await workbench.close()
+    await running.close()
+    throw error
+  }
 
   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))
+  const compileForSite = async (dir: string): Promise<IRDocument> => {
+    const compilation = await compileSessionOf(dir).ready()
+    refreshDocumentVitePlugins(spec, dir, compilation)
+    return workbench!.stampPreviewRevision(compilation, siteDocumentIR(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 })
+    site = await startWorkspaceSite({ root, spec, basePath, bundled: options.bundled, stateDir, compile: compileForSite, stampPreviewRevision: (compilation, doc) => workbench!.stampPreviewRevision(compilation, doc), diagnostics: running.diagnostics, preview, log })
   } catch (error) {
-    await service?.close()
+    await closeAuthoring()
+    await workbench.close()
     await running.close()
     if (home) rmSync(home, { recursive: true, force: true })
     throw error
@@ -255,9 +444,11 @@ export async function serveWorkspace(options: ServeOptions): Promise<WorkspaceSe
     root,
     mcp: { url: `${running.url}/mcp`, stateFile },
     async close() {
-      workspace?.reviews?.close()
-      for (const session of sessions.values()) session.close()
-      await service?.close()
+      history?.agentSessionReviews.close()
+      await closeAuthoring()
+      for (const session of compileSessions.values()) session.close()
+      await jobs.close()
+      await workbench?.close()
       await site?.close()
       await running.close()
       if (home) rmSync(home, { recursive: true, force: true })
@@ -265,38 +456,48 @@ export async function serveWorkspace(options: ServeOptions): Promise<WorkspaceSe
   }
 }
 
-interface SiteBackend {
-  forward(): string | undefined
-  update(dir: string, compilation: Compilation): Promise<void> | void
-  documentsChanged(removed: string[]): Promise<void>
-  close(): Promise<void>
-}
-
-interface LocalSiteOptions {
+interface WorkspaceSiteOptions {
   root: string
+  basePath: string
   spec: SiteSpec
   bundled?: string
-  state: string
+  stateDir: string
   compile(dir: string): Promise<IRDocument>
-  siteDoc(compilation: Compilation, doc: IRDocument): IRDocument
+  stampPreviewRevision(compilation: Compilation, doc: IRDocument): IRDocument
   preview: { origins: string[] }
   log: Logger
+  diagnostics: DiagnosticStore
 }
 
-async function localSite(options: LocalSiteOptions): Promise<SiteBackend> {
+type WorkspaceSite = Awaited<ReturnType<typeof startWorkspaceSite>>
+
+/** The workspace site's dev router in this process, which serve forwards the site's paths to. */
+async function startWorkspaceSite(options: WorkspaceSiteOptions) {
   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 })
+  const work = join(options.stateDir, 'site', 'full')
+  const ctx = siteContext({ root, outDir: work, workDir: work, base: options.basePath, 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(),
+    forward: (): string => origin,
+    target: (path: string): Promise<string> => dev.target?.(path) ?? Promise.resolve(origin),
+    update: (dir: string, compilation: Compilation): Promise<void> => {
+      refreshDocumentVitePlugins(spec, dir, compilation)
+      const revision = irRevision(compilation.doc)
+      return dev.update(dir, options.stampPreviewRevision(compilation, siteDocumentIR(compilation))).then(() => {
+        if (options.diagnostics.irRevision(dir) === revision) options.diagnostics.clear(dir, 'preview', 'web')
+      }, (error: unknown) => {
+        const message = `the site did not take ${dir}: ${errorMessage(error)}`
+        if (options.diagnostics.irRevision(dir) === revision) options.diagnostics.replace({ document: dir, origin: 'preview', renderer: 'web' }, [{ checkId: 'presmium.preview', severity: 'error', message }], { irRevision: revision })
+        log.warn(message)
+      })
+    },
+    warm: (dir: string): Promise<void> => dev.warm?.(dir) ?? Promise.resolve(),
+    app: (dir: string, wait: boolean): Promise<string | undefined> => dev.app?.(dir, wait) ?? Promise.resolve(undefined),
+    close: (): Promise<void> => dev.close(),
   }
 }