@lincyaw/cli 1.0.0-rc.0 → 1.0.0-rc.1

package/README.md

@@ -2,20 +2,20 @@
 
 The `presmium` command: `new`, `check`, `ir`, `build`, `dev` and `serve` for Presmium documents and workspaces.
 
-Part of [Presmium](https://github.com/Lincyaw/presmium), which turns lectures written in MyST Markdown into web pages, slides, Jupyter notebooks and narrated lectures.
+Part of [Presmium](https://github.com/Lincyaw/presmium), which turns structured teaching documents into web pages, slides, Jupyter notebooks and narrated lectures.
 
 ## Install
 
 Most people install the `presmium` package, which brings this command with the renderers and the official plugins:
 
 ```sh
-pnpm add -g presmium
+pnpm add -g @lincyaw/presmium
 ```
 
 In a project that picks its own renderers and plugins, install the CLI with them (Node.js 22.19 or later):
 
 ```sh
-pnpm add -D @lincyaw/cli @lincyaw/web @lincyaw/render-slides @lincyaw/render-notebook @lincyaw/slidev-addon-core
+pnpm add -D @lincyaw/cli @lincyaw/web @lincyaw/render-slides @lincyaw/render-notebook
 ```
 
 ## Commands
@@ -30,7 +30,7 @@ pnpm add -D @lincyaw/cli @lincyaw/web @lincyaw/render-slides @lincyaw/render-not
 | `presmium serve [dir]` | The workspace service, on this machine: the documents and their sites, compiled on demand (`--port`, `--host`, `--operator-dir`, `--preview-origin`) |
 | `presmium studio [dir]` | The workbench (experimental), from `@lincyaw/studio` installed in the project (`--port`, `--host`); installed globally, it is `presmium-studio` |
 
-`[deck]` is a directory with `lecture.md` or an entry file, by default the current directory. Exit codes: 0 no errors, 1 error findings, 2 usage or internal error. `presmium --help` lists every option.
+`[deck]` is a directory with `lecture.json` or an entry file, by default the current directory. Exit codes: 0 no errors, 1 error findings, 2 usage or internal error. `presmium --help` lists every option.
 
 ## Testing plugins
 
@@ -44,8 +44,8 @@ const { code, stdout } = await presmium(dir, ['build', '--to', 'web'])
 
 ## Documentation
 
-- [Author guide](https://github.com/Lincyaw/presmium/blob/main/site/guide/lecture.en.md)
-- [Plugin guide](https://github.com/Lincyaw/presmium/blob/main/site/plugins/lecture.en.md)
+- [Author guide](https://github.com/Lincyaw/presmium/blob/main/site/guide/locales/en/lecture.json)
+- [Plugin guide](https://github.com/Lincyaw/presmium/blob/main/site/plugins/locales/en/lecture.json)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lincyaw/cli",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.1",
   "description": "The presmium command: build, dev, ir, check and serve for Presmium documents",
   "license": "Apache-2.0",
   "repository": {
@@ -36,9 +36,10 @@
   ],
   "dependencies": {
     "jiti": "^2.7.0",
-    "@lincyaw/kernel": "1.0.0-rc.0",
-    "@lincyaw/workspace": "1.0.0-rc.0",
-    "@lincyaw/server": "1.0.0-rc.0",
-    "@lincyaw/compiler": "1.0.0-rc.0"
+    "@lincyaw/kernel": "1.0.0-rc.1",
+    "@lincyaw/compiler": "1.0.0-rc.1",
+    "@lincyaw/server": "1.0.0-rc.1",
+    "@lincyaw/workspace": "1.0.0-rc.1",
+    "@lincyaw/skills": "1.0.0-rc.1"
   }
 }

package/src/check.ts

@@ -2,7 +2,7 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { ANCHOR_LOCK_PATH, errorMessage } from '@lincyaw/kernel'
 import type { AnchorString, Finding } from '@lincyaw/kernel'
-import { checkContext, Compiler, frontmatterLine, sortFindings } from '@lincyaw/compiler'
+import { checkContext, Compiler, sortFindings } from '@lincyaw/compiler'
 import type { Compilation, CompilerOptions } from '@lincyaw/compiler'
 
 export interface CheckOptions {
@@ -35,7 +35,7 @@ export async function runCheck(options: CheckOptions): Promise<CheckResult> {
 
   let lock: LockUpdate | undefined
   if (options.updateLock) {
-    lock = await updateLock(compilation, (name, error) => fail(`plugin "${name}" failed to list anchors: ${errorMessage(error)}`, frontmatterLine(entryText, name)))
+    lock = await updateLock(compilation, (name, error) => fail(`plugin "${name}" failed to list anchors: ${errorMessage(error)}`, jsonLine(entryText, name)))
     compilation = await compiler.compile()
   }
 
@@ -54,7 +54,7 @@ export async function probeEnvironments(compilation: Compilation, text: string):
     } catch (error) {
       reason = errorMessage(error)
     }
-    if (reason) findings.push({ checkId: 'presmium.execute', severity: 'error', message: `environment "${name}" (${spec.kind}) is not reachable: ${reason}`, source: { file: compilation.entry, line: frontmatterLine(text, `${name}:`) } })
+    if (reason) findings.push({ checkId: 'presmium.execute', severity: 'error', message: `environment "${name}" (${spec.kind}) is not reachable: ${reason}`, source: { file: compilation.entry, line: jsonLine(text, name) } })
   }
   return findings
 }
@@ -83,3 +83,9 @@ async function updateLock(compilation: Compilation, onError: (plugin: string, er
   }
   return { file, anchors: lock.size, changed: text !== before }
 }
+
+/** JSON property locations are diagnostic hints; entity paths are supplied by document validation. */
+function jsonLine(text: string, property: string): number {
+  const index = text.indexOf(JSON.stringify(property))
+  return index < 0 ? 1 : text.slice(0, index).split("\n").length
+}

package/src/cli.ts

@@ -5,92 +5,42 @@ import { dirname, join, relative, resolve } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { parseArgs } from 'node:util'
 import { createJiti } from 'jiti'
-import { errorMessage } from '@lincyaw/kernel'
+import { APPROVAL_KINDS, errorMessage } from '@lincyaw/kernel'
+import { bracketIPv6, ffmpegInstallCommand, findFfmpeg, irRevision, lanAddresses } from '@lincyaw/kernel/node'
 import type { ApprovalKind, Finding, Severity } from '@lincyaw/kernel'
 import { build, Compiler, dev, resolveEntry } from '@lincyaw/compiler'
 import type { BuildReport, Compilation, RunStats } from '@lincyaw/compiler'
-import { anyAddress, isLoopback, networkAddresses, servedDocument, startServer } from '@lincyaw/server'
+import { isAnyAddress, isLoopback, serverConfigKey, servedDocument, startServer } from '@lincyaw/server'
 import type { ApprovalPolicy } from '@lincyaw/server'
 import { buildWorkspace, isWorkspaceRoot, serveWorkspace } from '@lincyaw/workspace'
 import type { WorkspaceBuild } from '@lincyaw/workspace'
 import { runCheck } from './check.ts'
 import type { CheckResult } from './check.ts'
-import { devHost } from './host.ts'
+import { devHost } from './dev-host.ts'
+import { CLI_MESSAGES, systemLocale } from './messages.ts'
 
-export const BUNDLED = fileURLToPath(new URL('..', import.meta.url))
+const BUNDLED = fileURLToPath(new URL('..', import.meta.url))
+const PRESMIUM_BIN = fileURLToPath(new URL('../bin/presmium.mjs', import.meta.url))
 
 export interface MainOptions {
+  /** The package whose dependencies hold the renderers and plugins a document does not install itself. */
   bundled?: string
+  /** The presmium command that presmium studio starts. */
   bin?: string
 }
 
-let bundled = BUNDLED
-let presmiumBin = fileURLToPath(new URL('../bin/presmium.mjs', import.meta.url))
-
-const USAGE = `Usage: presmium <command> [deck] [options]
-
-The deck is a directory holding lecture.md, or an entry file (default: .).
-
-Commands:
-  new     a new project in the directory (default: asks), from create-presmium
-          --type <kind>   lecture, workspace or plugin (default: asks)
-          --title <text>  the lecture's or the workspace's title
-          --name <name>   the plugin's package name
-          --no-git        do not run git init
-  build   compile and render; writes <out>/ir.json and <out>/<renderer>/; at a workspace root
-          (presmium.workspace.yaml) builds the workspace site into <out>/web/
-          --to <ids>      renderers to run, comma-separated (default: the deck's renderers)
-          --out <dir>     output directory (default: <deck>/dist)
-          --audience <name>  only the content for this audience (e.g. student); then every file
-                          written is scanned for the sentences of the content left out
-  dev     compile, start the Presmium server and the renderers' dev servers, recompile on save
-          --to <ids>      renderers to run, comma-separated
-          --out <dir>     working directory (default: <deck>/.presmium/dev)
-          --server-port <n>  port of the Presmium server (default: a free port)
-          --allow <kinds>    approvals given without asking: operate, spend, write, agent
-  ir      print the IR as JSON
-          --out <file>    write it to a file instead
-  check   compile and run the plugins' checks
-          --json          print the result as JSON
-          --update-lock   re-resolve anchors and rewrite .presmium/anchors.lock.json
-          --env           also connect to the environments of execute.environments
-          --audience <name>  check the deck as compiled for this audience
-          --external-links   also check the external links, with lychee when it is installed
-  serve   the workspace service for you on this machine (the argument is the workspace root, or
-          a deck): the workspace site, the documents and their history, the reviews, the plugins'
-          routes, the classroom sync; without --host it listens on this machine only
-          --port <n>      port (default: 4310)
-          --host <addr>   address to listen on (default: 127.0.0.1); 0.0.0.0 or an address on the
-                          local network opens it to your other devices there, with no login:
-                          whoever reaches the port works as you
-          --operator-dir <dir>  the operator directory (default: the user's state directory)
-          --preview-origin <origin>  (repeatable) the origin of a workbench whose pages embed the
-                          previews, e.g. http://127.0.0.1:4320; with PRESMIUM_SERVICE_TOKEN set, the
-                          workspace's routes ask for it (Authorization: Bearer)
-  studio  the workbench (experimental): DeepSeek Harness with Presmium's bundle and the workspace
-          service of the directory (the workspace root, or a deck); prints the one address to open.
-          It is the package @lincyaw/studio (with DeepSeek Harness, about 865 MB), installed beside
-          this one
-          --port <n>      the workbench's port (default: 4320, or a free one when that is in use)
-          --host <addr>   listen on this address of the machine on the local network instead of
-                          127.0.0.1, with no login: whoever reaches the port works as you
-
-  -h, --help   show this help
-
-Exit codes: 0 no errors, 1 error findings, 2 usage or internal error.`
+const t = CLI_MESSAGES[systemLocale()]
 
 const OPTIONS = {
   'build': ['to', 'out', 'audience'],
   'dev': ['to', 'out', 'server-port', 'allow'],
   'ir': ['out'],
   'check': ['json', 'update-lock', 'env', 'audience', 'external-links'],
-  'serve': ['port', 'host', 'operator-dir', 'preview-origin'],
+  'serve': ['port', 'host', 'operator-dir', 'preview-origin', 'public-url'],
 } as const
 
 type Name = keyof typeof OPTIONS
 
-const KINDS: readonly ApprovalKind[] = ['operate', 'spend', 'write', 'agent']
-
 interface Command {
   name: Name
   entry: string
@@ -106,33 +56,34 @@ interface Command {
   allow: ApprovalKind[]
   operatorDir?: string
   port?: number
-  host?: string
+  listenAddress?: string
   previewOrigins: string[]
+  publicUrl?: string
 }
 
 export async function main(argv: string[], options: MainOptions = {}): Promise<number> {
-  bundled = options.bundled ?? BUNDLED
-  if (options.bin) presmiumBin = options.bin
-  if (argv[0] === 'new') return create(argv.slice(1))
-  if (argv[0] === 'studio') return studio(argv.slice(1))
+  const bundled = options.bundled ?? BUNDLED
+  if (argv[0] === 'new') return runNewCommand(argv.slice(1), bundled)
+  if (argv[0] === 'skills') return (await import('@lincyaw/skills')).main(argv.slice(1))
+  if (argv[0] === 'studio') return runStudioCommand(argv.slice(1), bundled, options.bin ?? PRESMIUM_BIN)
   let command: Command | 'help'
   try {
     command = parseCommand(argv)
   } catch (error) {
-    process.stderr.write(`presmium: ${errorMessage(error)}\n\n${USAGE}\n`)
+    process.stderr.write(`presmium: ${errorMessage(error)}\n\n${t.usage}\n`)
     return 2
   }
   if (command === 'help') {
-    process.stdout.write(`${USAGE}\n`)
+    process.stdout.write(`${t.usage}\n`)
     return 0
   }
   try {
     switch (command.name) {
-      case 'check': return await check(command)
-      case 'ir': return await ir(command)
-      case 'build': return await buildDeck(command)
-      case 'dev': return await devDeck(command)
-      case 'serve': return await serve(command)
+      case 'check': return await runCheckCommand(command, bundled)
+      case 'ir': return await runIrCommand(command, bundled)
+      case 'build': return await runBuildCommand(command, bundled)
+      case 'dev': return await runDevCommand(command, bundled)
+      case 'serve': return await runServeCommand(command, bundled)
     }
   } catch (error) {
     process.stderr.write(`presmium: ${errorMessage(error)}\n`)
@@ -158,34 +109,37 @@ function parseCommand(argv: string[]): Command | 'help' {
       'port': { type: 'string' },
       'host': { type: 'string' },
       'preview-origin': { type: 'string', multiple: true },
+      'public-url': { type: 'string' },
       'help': { type: 'boolean', short: 'h', default: false },
     },
   })
   if (values.help) return 'help'
   const [name, deck = '.', ...extra] = positionals
-  if (!name) throw new Error('missing command')
-  if (!(name in OPTIONS)) throw new Error(`unknown command "${name}"`)
+  if (!name) throw new Error(t.missingCommand)
+  if (!(name in OPTIONS)) throw new Error(t.unknownCommand(name))
   const allowed: readonly string[] = OPTIONS[name as Name]
   const given = Object.entries(values).filter(([key, value]) => key !== 'help' && value !== undefined && value !== false)
   const wrong = given.find(([key]) => !allowed.includes(key))
-  if (wrong) throw new Error(`option --${wrong[0]} does not apply to ${name}`)
-  if (extra.length > 0) throw new Error(`unexpected argument "${extra[0]}"`)
+  if (wrong) throw new Error(t.optionNotFor(wrong[0], name))
+  if (extra.length > 0) throw new Error(t.unexpectedArgument(extra[0]!))
   const workspace = name === 'build' && existsSync(deck) && statSync(deck).isDirectory() && isWorkspaceRoot(resolve(deck)) ? resolve(deck) : undefined
-  if (workspace && values.to) throw new Error('--to does not apply to a workspace: its site is the web form')
-  if (workspace && values.audience !== undefined) throw new Error('--audience does not apply to a workspace yet: build each document for its audience')
+  if (workspace && values.to) throw new Error(t.toNotForWorkspace)
+  if (workspace && values.audience !== undefined) throw new Error(t.audienceNotForWorkspace)
   const audience = values.audience?.trim()
-  if (values.audience !== undefined && !/^[\w.-]+$/.test(audience ?? '')) throw new Error(`--audience takes the name of an audience, e.g. student, not "${values.audience}"`)
+  if (values.audience !== undefined && !/^[\w.-]+$/.test(audience ?? '')) throw new Error(t.badAudience(values.audience))
   const directory = name === 'serve'
   const entry = directory || workspace ? resolve(deck) : resolveEntry(deck)
-  if (!existsSync(entry) || (directory && !statSync(entry).isDirectory())) throw new Error(`${entry} not found`)
+  if (!existsSync(entry) || (directory && !statSync(entry).isDirectory())) throw new Error(t.notFound(entry))
   const to = values.to?.split(',').map(id => id.trim()).filter(Boolean)
-  if (to?.length === 0) throw new Error('--to needs at least one renderer id')
+  if (to?.length === 0) throw new Error(t.emptyTo)
   const allow = values.allow?.split(',').map(kind => kind.trim()).filter(Boolean) ?? []
-  const unknown = allow.find(kind => !(KINDS as string[]).includes(kind))
-  if (unknown) throw new Error(`--allow takes ${KINDS.join(', ')}, not "${unknown}"`)
+  const unknown = allow.find(kind => !(APPROVAL_KINDS as readonly string[]).includes(kind))
+  if (unknown) throw new Error(t.badAllow(APPROVAL_KINDS, unknown))
   const previewOrigins = values['preview-origin'] ?? []
   const notOrigin = previewOrigins.find(origin => !isOrigin(origin))
-  if (notOrigin !== undefined) throw new Error(`--preview-origin takes an origin such as http://127.0.0.1:4320, not "${notOrigin}"`)
+  if (notOrigin !== undefined) throw new Error(t.badPreviewOrigin(notOrigin))
+  const publicUrl = values['public-url']
+  if (publicUrl !== undefined && !isPublicUrl(publicUrl)) throw new Error(t.badPublicUrl(publicUrl))
   return {
     name: name as Name,
     entry,
@@ -197,12 +151,23 @@ function parseCommand(argv: string[]): Command | 'help' {
     env: values.env,
     ...audience ? { audience } : {},
     externalLinks: values['external-links'],
-    serverPort: port(values['server-port'], '--server-port'),
+    serverPort: parsePort(values['server-port'], '--server-port'),
     allow: allow as ApprovalKind[],
     operatorDir: values['operator-dir'],
-    port: port(values.port, '--port'),
-    host: values.host,
+    port: parsePort(values.port, '--port'),
+    listenAddress: values.host,
     previewOrigins,
+    ...publicUrl ? { publicUrl } : {},
+  }
+}
+
+/** An http(s) address, optionally with the path a proxy forwards; no credentials, query or fragment. */
+function isPublicUrl(value: string): boolean {
+  try {
+    const url = new URL(value)
+    return /^https?:$/.test(url.protocol) && !url.username && !url.password && !url.search && !url.hash
+  } catch {
+    return false
   }
 }
 
@@ -215,14 +180,14 @@ function isOrigin(value: string): boolean {
   }
 }
 
-function port(value: string | undefined, option: string): number | undefined {
+function parsePort(value: string | undefined, option: string): number | undefined {
   if (value === undefined) return undefined
   const n = Number(value)
-  if (!Number.isInteger(n) || n < 0 || n > 65535) throw new Error(`${option} takes a port number, not "${value}"`)
+  if (!Number.isInteger(n) || n < 0 || n > 65535) throw new Error(t.badPort(option, value))
   return n
 }
 
-async function check(command: Command): Promise<number> {
+async function runCheckCommand(command: Command, bundled: string): Promise<number> {
   const result = await runCheck({
     deck: command.entry,
     updateLock: command.updateLock,
@@ -234,7 +199,7 @@ async function check(command: Command): Promise<number> {
   return exitCode(result.findings)
 }
 
-async function ir(command: Command): Promise<number> {
+async function runIrCommand(command: Command, bundled: string): Promise<number> {
   const { doc } = await new Compiler(command.entry, { bundled }).compile()
   const json = `${JSON.stringify(doc, null, 2)}\n`
   if (command.out) {
@@ -248,7 +213,7 @@ async function ir(command: Command): Promise<number> {
   return exitCode(doc.diagnostics)
 }
 
-async function buildDeck(command: Command): Promise<number> {
+async function runBuildCommand(command: Command, bundled: string): Promise<number> {
   if (command.workspace) {
     const report = await buildWorkspace(command.workspace, { outDir: command.out, bundled })
     process.stdout.write(workspaceText(report))
@@ -257,11 +222,11 @@ async function buildDeck(command: Command): Promise<number> {
   const compilation = await new Compiler(command.entry, { bundled, ...command.audience ? { audience: command.audience } : {} }).compile({ pruneCache: true })
   const outDir = resolve(command.out ?? join(compilation.deckDir, 'dist'))
   const report = await build(compilation, { outDir, to: command.to })
-  process.stdout.write(buildText(report, compilation.runs, compilation.audience?.name))
+  process.stdout.write(buildText(report, compilation.runStats, compilation.audience?.name))
   return exitCode(report.findings)
 }
 
-async function devDeck(command: Command): Promise<number> {
+async function runDevCommand(command: Command, bundled: string): Promise<number> {
   let latest: Compilation | undefined
   const deckDir = dirname(command.entry)
   const approvals: Partial<Record<ApprovalKind, ApprovalPolicy>> = Object.fromEntries(command.allow.map(kind => [kind, 'allow']))
@@ -274,20 +239,27 @@ async function devDeck(command: Command): Promise<number> {
     document: async dir => (dir === '' && latest ? servedDocument(latest) : undefined),
     stateFile: join(deckDir, '.presmium', 'server.json'),
   })
-  const compiler = new Compiler(command.entry, { bundled, services: server.services })
+  const compiler = new Compiler(command.entry, { bundled, priority: 'interactive', services: server.services })
   const outDir = resolve(command.out ?? join(compiler.deckDir, '.presmium', 'dev'))
   await mkdir(outDir, { recursive: true })
   await writeFile(join(outDir, '.gitignore'), '*\n')
-  let session
+  let devServers
   try {
-    session = await dev(compiler, {
+    devServers = await dev(compiler, {
       outDir,
       to: command.to,
       server: { url: server.url },
       onCompile(compilation, findings) {
+        const changed = latest && serverConfigKey(latest) !== serverConfigKey(compilation)
         latest = compilation
+        const revision = irRevision(compilation.doc)
+        server.diagnostics.compiled('', compilation.doc, compilation.workspaceRoot, revision)
+        server.diagnostics.replace({ document: '', origin: 'preview' }, findings.filter(finding => finding.checkId === 'presmium.render'), { root: compilation.workspaceRoot, irRevision: revision })
+        if (changed) void server.unmount('', { preserveFocus: true }).catch((error: unknown) => {
+          process.stderr.write(`${t.unmountFailed(errorMessage(error))}\n`)
+        })
         const lines = findingLines(findings)
-        lines.push(`compiled ${compilation.doc.sections.length} sections; ${summary(findings)}`)
+        lines.push(t.compiled(compilation.doc.sections.length, summary(findings)))
         process.stdout.write(`${lines.join('\n')}\n`)
       },
     })
@@ -295,32 +267,34 @@ async function devDeck(command: Command): Promise<number> {
     await server.close()
     throw error
   }
-  for (const { renderer, url } of session.servers) process.stdout.write(`${renderer}  ${url}\n`)
-  process.stdout.write(`server  ${server.url}\nmcp  ${server.url}/mcp (its token is in ${relative(process.cwd(), join(deckDir, '.presmium', 'server.json'))})\n`)
-  process.stdout.write(`watching; IR in ${relative(process.cwd(), session.ir)}\n`)
+  for (const { renderer, url } of devServers.servers) process.stdout.write(`${renderer}  ${url}\n`)
+  process.stdout.write(`server  ${server.url}\nmcp  ${server.url}/mcp${t.token(relative(process.cwd(), join(deckDir, '.presmium', 'server.json')))}\n`)
+  process.stdout.write(`${t.watching(relative(process.cwd(), devServers.ir))}\n`)
   await new Promise<void>((done) => {
     process.once('SIGINT', done)
     process.once('SIGTERM', done)
   })
-  await session.close()
+  await devServers.close()
   await server.close()
   return 0
 }
 
-async function serve(command: Command): Promise<number> {
+async function runServeCommand(command: Command, bundled: string): Promise<number> {
   const started = await serveWorkspace({
     dir: command.entry,
-    host: command.host,
+    listenAddress: command.listenAddress,
     port: command.port,
     ...command.operatorDir ? { operatorDir: resolve(command.operatorDir) } : {},
     bundled,
     check: compilation => compilation.check(),
     previewOrigins: command.previewOrigins,
+    ...command.publicUrl ? { publicUrl: command.publicUrl } : {},
   })
-  process.stdout.write(`serve  ${started.url}\n${networkLines(command.host, started.url)}workspace  ${started.root}\nmcp  ${started.mcp.url} (its token is in ${started.mcp.stateFile})\n`)
-  if (command.host && !isLoopback(command.host)) {
-    process.stderr.write(`presmium serve: listening on ${command.host}, on the local network, with no login: anyone who reaches port ${new URL(started.url).port} uses this workspace as you (edits, runs code, approves). Use it on a network you trust; without --host it listens on this machine only.\n`)
+  process.stdout.write(`serve  ${started.url}\n${networkLines(command.listenAddress, started.url)}workspace  ${started.root}\nmcp  ${started.mcp.url}${t.token(started.mcp.stateFile)}\n`)
+  if (command.listenAddress && !isLoopback(command.listenAddress)) {
+    process.stderr.write(`${t.serveOpen(command.listenAddress, new URL(started.url).port)}\n`)
   }
+  if (!findFfmpeg()) process.stderr.write(`${t.noFfmpeg(ffmpegInstallCommand())}\n`)
   await new Promise<void>((done) => {
     process.once('SIGINT', done)
     process.once('SIGTERM', done)
@@ -329,7 +303,7 @@ async function serve(command: Command): Promise<number> {
   return 0
 }
 
-function installed(name: string): string | undefined {
+function resolveInstalled(name: string, bundled: string): string | undefined {
   for (const from of [pathToFileURL(join(bundled, 'package.json')).href, import.meta.url, pathToFileURL(join(process.cwd(), 'package.json')).href]) {
     try {
       return createRequire(from).resolve(name)
@@ -339,30 +313,30 @@ function installed(name: string): string | undefined {
   return undefined
 }
 
-async function create(argv: string[]): Promise<number> {
-  const entry = installed('create-presmium')
+async function runNewCommand(argv: string[], bundled: string): Promise<number> {
+  const entry = resolveInstalled('create-presmium', bundled)
   if (!entry) {
-    process.stderr.write('presmium new: create-presmium is not installed; it comes with the presmium package: pnpm add -g presmium\n')
+    process.stderr.write(`${t.newMissing}\n`)
     return 2
   }
   const { main: createMain } = await createJiti(import.meta.url).import<{ main(argv: string[]): Promise<number> }>(entry)
   return createMain(argv)
 }
 
-async function studio(argv: string[]): Promise<number> {
-  const entry = installed('@lincyaw/studio')
+async function runStudioCommand(argv: string[], bundled: string, presmiumBin: string): Promise<number> {
+  const entry = resolveInstalled('@lincyaw/studio', bundled)
   if (!entry) {
-    process.stderr.write('presmium studio: the workbench is not installed here. It is the package @lincyaw/studio (experimental; with DeepSeek Harness, about 865 MB): pnpm add -g @lincyaw/studio, then run presmium-studio; or pnpm add -D @lincyaw/studio in this project.\n')
+    process.stderr.write(`${t.studioMissing}\n`)
     return 2
   }
   const { main: studioMain } = await createJiti(import.meta.url).import<{ main(argv: string[], options: { presmium: string }): Promise<number> }>(entry)
   return studioMain(argv, { presmium: presmiumBin })
 }
 
-function networkLines(host: string | undefined, url: string): string {
-  if (!host || isLoopback(host)) return ''
+function networkLines(listenAddress: string | undefined, url: string): string {
+  if (!listenAddress || isLoopback(listenAddress)) return ''
   const { port } = new URL(url)
-  const addresses = anyAddress(host) ? networkAddresses() : [host.includes(':') && !host.startsWith('[') ? `[${host}]` : host]
+  const addresses = isAnyAddress(listenAddress) ? lanAddresses() : [bracketIPv6(listenAddress)]
   return addresses.map(address => `network  http://${address}:${port}/\n`).join('')
 }
 
@@ -378,13 +352,13 @@ function counts(findings: Finding[]): Record<Severity, number> {
 
 function summary(findings: Finding[]): string {
   const n = counts(findings)
-  return findings.length === 0 ? 'no problems' : `${n.error} errors, ${n.warning} warnings, ${n.info} infos`
+  return findings.length === 0 ? t.noProblems : t.counts(n.error, n.warning, n.info)
 }
 
 function findingLines(findings: Finding[], cwd = process.cwd()): string[] {
   return findings.flatMap((f) => {
     const where = f.source ? `${relative(cwd, f.source.file)}${f.source.line ? `:${f.source.line}` : ''}` : ''
-    return [`${where}  ${f.severity}  ${f.message}  (${f.checkId})`, ...f.hint ? [`    hint: ${f.hint}`] : []]
+    return [`${where}  ${t.severity[f.severity]}  ${f.message}  (${f.checkId})`, ...f.hint ? [t.hint(f.hint)] : []]
   })
 }
 
@@ -395,8 +369,7 @@ function checkJson(result: CheckResult) {
 function checkText(result: CheckResult, cwd = process.cwd()): string {
   const out = findingLines(result.findings, cwd)
   if (result.lock) {
-    const state = result.lock.changed ? 'updated' : 'unchanged'
-    out.push(`${relative(cwd, result.lock.file)} ${state} (${result.lock.anchors} anchors)`)
+    out.push(t.lock(relative(cwd, result.lock.file), result.lock.changed, result.lock.anchors))
   }
   out.push(summary(result.findings))
   return `${out.join('\n')}\n`
@@ -405,7 +378,7 @@ function checkText(result: CheckResult, cwd = process.cwd()): string {
 function workspaceText(report: WorkspaceBuild, cwd = process.cwd()): string {
   const out = findingLines(report.findings, cwd)
   for (const { dir, title, runs } of report.documents) {
-    out.push(`document  ${dir || '.'}  ${title}${runs.executed + runs.cached > 0 ? `  (code runs: ${runs.executed} executed, ${runs.cached} from cache)` : ''}`)
+    out.push(`document  ${dir || '.'}  ${title}${runs.executed + runs.cached > 0 ? t.documentRuns(runs.executed, runs.cached) : ''}`)
   }
   out.push(`web  ${relative(cwd, report.outDir)}`)
   out.push(summary(report.findings))
@@ -417,10 +390,10 @@ function buildText(report: BuildReport, runs: RunStats, audience?: string, cwd =
   if (audience) out.push(`audience  ${audience}`)
   out.push(`ir  ${relative(cwd, report.ir)}`)
   for (const { renderer, outDir, skipped } of report.outputs) {
-    out.push(`${renderer}  ${relative(cwd, outDir)}${skipped.length ? `  (${skipped.length} blocks not rendered)` : ''}`)
+    out.push(`${renderer}  ${relative(cwd, outDir)}${skipped.length ? t.notRendered(skipped.length) : ''}`)
     for (const s of skipped) out.push(`    ${s.section}#${s.block}: ${s.reason}`)
   }
-  if (runs.executed + runs.cached > 0) out.push(`code runs: ${runs.executed} executed, ${runs.cached} from cache${runs.sandbox && runs.executed > 0 ? `, isolated by ${runs.sandbox}` : ''}`)
+  if (runs.executed + runs.cached > 0) out.push(t.codeRuns(runs.executed, runs.cached, runs.sandbox && runs.executed > 0 ? runs.sandbox : undefined))
   out.push(summary(report.findings))
   return `${out.join('\n')}\n`
 }

package/src/{host.ts → dev-host.ts}

@@ -1,4 +1,4 @@
-import { buildView, runBlock } from '@lincyaw/compiler'
+import { buildSummary, buildToDist, runBlock } from '@lincyaw/compiler'
 import type { Compilation } from '@lincyaw/compiler'
 import type { ServerHost } from '@lincyaw/server'
 
@@ -9,6 +9,7 @@ export function devHost(latest: () => Compilation | undefined): ServerHost {
     return compilation
   }
   return {
+    get workspaceRoot() { return latest()?.workspaceRoot },
     async documents() {
       const compilation = latest()
       return compilation ? [{ dir: '', title: compilation.doc.meta.title, lang: compilation.doc.meta.lang }] : []
@@ -22,8 +23,7 @@ export function devHost(latest: () => Compilation | undefined): ServerHost {
       return [...compilation.doc.diagnostics, ...await compilation.check()]
     },
     async build(document, options = {}) {
-      const report = await buildView(current(document), options)
-      return { outputs: report.outputs.map(({ renderer, outDir }) => ({ renderer, outDir })), findings: report.findings }
+      return buildSummary(await buildToDist(current(document), options))
     },
     run: async (document, target, signal) => runBlock(current(document), target, signal),
   }

package/src/index.ts

@@ -1,3 +1,2 @@
-export { runCheck } from './check.ts'
-export type { CheckOptions, CheckResult, LockUpdate } from './check.ts'
 export { main } from './cli.ts'
+export type { MainOptions } from './cli.ts'

package/src/messages.ts

@@ -0,0 +1,219 @@
+export { systemLocale } from '@lincyaw/kernel/node'
+import { DOCUMENT_ENTRY } from '@lincyaw/kernel'
+import type { Locale } from '@lincyaw/kernel'
+
+// The lines that start with a key and two spaces (`serve  <url>`, `workspace  <root>`, `mcp  <url>`, `<renderer>  <url>`)
+// are read by programs (`@lincyaw/dsh/launch`, the tests): their keys, URLs and paths stay the same in both languages.
+export interface CliMessages {
+  usage: string
+  missingCommand: string
+  unknownCommand(name: string): string
+  optionNotFor(option: string, command: string): string
+  unexpectedArgument(argument: string): string
+  toNotForWorkspace: string
+  audienceNotForWorkspace: string
+  badAudience(value: string): string
+  notFound(entry: string): string
+  emptyTo: string
+  badAllow(kinds: readonly string[], value: string): string
+  badPreviewOrigin(value: string): string
+  badPublicUrl(value: string): string
+  badPort(option: string, value: string): string
+  unmountFailed(error: string): string
+  compiled(sections: number, summary: string): string
+  token(file: string): string
+  watching(ir: string): string
+  serveOpen(address: string, port: string): string
+  noFfmpeg(command: string): string
+  newMissing: string
+  studioMissing: string
+  noProblems: string
+  counts(errors: number, warnings: number, infos: number): string
+  severity: Record<'error' | 'warning' | 'info', string>
+  hint(text: string): string
+  lock(file: string, changed: boolean, anchors: number): string
+  documentRuns(executed: number, cached: number): string
+  notRendered(blocks: number): string
+  codeRuns(executed: number, cached: number, sandbox?: string): string
+}
+
+export const CLI_MESSAGES: Record<Locale, CliMessages> = {
+  'zh-CN': {
+    usage: `用法：presmium <命令> [<文稿>] [<选项>]
+
+<文稿> 是含有 ${DOCUMENT_ENTRY} 的目录，或这个文件本身（默认为 .）。
+
+命令：
+  new     在目录中新建项目（没有给出时逐项询问），由 create-presmium 完成
+          --type <种类>   lecture、workspace、site 或 plugin（默认询问）
+          --theme <主题>  site 的主题：course、docs 或 showcase（默认 course）
+          --title <标题>  讲义、工作区或网站的标题
+          --name <包名>   插件的包名
+          --no-git        不运行 git init
+  skills  安装内置技能（与 MCP 和可视化编辑器共用）
+          install <目录> [--json]  安装缺少的 .agents/skills，保留已有技能
+          --name <技能>   只安装指定技能，可重复
+          --json          以 JSON 打印安装结果
+  build   导出文稿：写出 <输出>/ir.json 与 <输出>/<形态>/；在工作区的根目录
+          （有 presmium.workspace.yaml）把整个工作区导出为网站，写到 <输出>/web/
+          --to <形态>     要导出的形态，以逗号分隔（默认为文稿声明的形态）
+          --out <目录>    输出目录（默认为 <文稿>/dist）
+          --audience <名称>  只导出面向这类读者的内容（例如 student），并在写出的每个
+                          文件中查找被略去内容的句子
+  dev     实时预览：启动 Presmium 服务与各形态的预览服务器，保存后自动更新
+          --to <形态>     要预览的形态，以逗号分隔
+          --out <目录>    工作目录（默认为 <文稿>/.presmium/dev）
+          --server-port <端口>  Presmium 服务的端口（默认为空闲端口）
+          --allow <种类>  无需询问即允许的操作：operate、spend、write、agent
+  ir      以 JSON 打印文稿的运行快照
+          --out <文件>    写入文件，而不是打印
+  check   检查文稿并运行插件的检查
+          --json          以 JSON 打印结果
+          --update-lock   重新定位代码锚点，并重写 .presmium/anchors.lock.json
+          --env           同时连接 execute.environments 中的运行环境
+          --audience <名称>  按面向这类读者的内容检查
+          --external-links   同时检查外部链接（装有 lychee 时用它）
+  serve   在本机提供工作区服务（参数是工作区的根目录或一份文稿）：工作区网站、
+          各文稿与其版本历史、审阅、插件的服务端路由与课堂同步；不加 --host 时
+          只在本机监听
+          --port <端口>   端口（默认为 4310）
+          --host <地址>   监听的地址（默认为 127.0.0.1）；0.0.0.0 或局域网中的地址
+                          让同一网络中的其他设备也能使用，且没有登录：任何能访问
+                          这个端口的人都以你的身份操作
+          --operator-dir <目录>  运营者目录（默认为用户的状态目录）
+          --preview-origin <来源>  （可重复）嵌入预览的 Presmium Studio 页面的来源，
+                          例如 http://127.0.0.1:4320；设置 PRESMIUM_SERVICE_TOKEN 时，
+                          工作区的路由要求它（Authorization: Bearer）
+          --public-url <网址>  反向代理在前面时浏览器使用的地址：信任它的主机，预览与产物
+                          的地址用它给出；带路径时代理原样转发该路径，服务的全部内容都在它下面
+  studio  启动 Presmium Studio（实验性）：浏览器中的编辑应用与这个目录（工作区的
+          根目录或一份文稿）的工作区服务，只打印一个要打开的网址。需要另外安装
+          @lincyaw/studio（约 865 MB）
+          --port <端口>   Presmium Studio 的端口（默认为 4320，被占用时取空闲端口）
+          --host <地址>   改为监听本机在局域网中的这个地址，而不是 127.0.0.1，且没有
+                          登录：任何能访问这个端口的人都以你的身份操作
+
+  -h, --help   显示本说明
+
+退出码：0 没有错误，1 有错误级别的问题，2 用法错误或内部错误。`,
+    missingCommand: '缺少命令。请在 presmium 之后给出命令，例如 presmium build。',
+    unknownCommand: name => `没有命令“${name}”。可用的命令见 presmium --help。`,
+    optionNotFor: (option, command) => `选项 --${option} 不能用于 presmium ${command}。可用的选项见 presmium --help。`,
+    unexpectedArgument: argument => `多余的参数“${argument}”。每个命令只接受一个文稿或目录。`,
+    toNotForWorkspace: '--to 不能用于工作区：工作区总是导出为网站。',
+    audienceNotForWorkspace: '--audience 暂不能用于工作区。请分别为每份文稿加 --audience 导出。',
+    badAudience: value => `“${value}”不是读者类别的名称。请给出字母、数字、.、_ 或 - 组成的名称，例如 student。`,
+    notFound: entry => `找不到 ${entry}。请检查路径，或用 presmium new 新建文稿。`,
+    emptyTo: '--to 至少需要一个形态，例如 --to web。',
+    badAllow: (kinds, value) => `--allow 不接受“${value}”。可用的种类：${kinds.join('、')}。`,
+    badPreviewOrigin: value => `“${value}”不是来源。请给出协议、主机与端口，例如 http://127.0.0.1:4320。`,
+    badPublicUrl: value => `“${value}”不是可用的网址。请给出浏览器访问的地址，例如 https://preview.example.com 或 https://example.com/user/a/preview/。`,
+    badPort: (option, value) => `${option} 需要 0 到 65535 之间的端口号，而不是“${value}”。`,
+    unmountFailed: error => `presmium: 无法关闭上一次加载的服务端扩展：${error}`,
+    compiled: (sections, summary) => `已更新 ${sections} 个页面；${summary}`,
+    token: file => ` （访问令牌在 ${file} 中）`,
+    watching: ir => `正在监视修改；运行快照在 ${ir}`,
+    noFfmpeg: command => `presmium serve: 没有找到 FFmpeg，讲授视频只能由浏览器导出为 WebM，画质较低。安装后可导出清晰的 MP4：${command}`,
+    serveOpen: (address, port) => `presmium serve: 正在 ${address} 上监听，局域网中的设备可以访问，且没有登录：任何能访问端口 ${port} 的人都以你的身份使用这个工作区（编辑、运行代码、允许操作）。请只在可信的网络中使用；不加 --host 时只在本机监听。`,
+    newMissing: 'presmium new: 没有安装 create-presmium。它随 presmium 一起安装，请运行 pnpm add -g @lincyaw/presmium。',
+    studioMissing: 'presmium studio: 这里没有安装 Presmium Studio（实验性，约 865 MB）。请运行 pnpm add -g @lincyaw/studio 后使用 presmium-studio，或在本项目中运行 pnpm add -D @lincyaw/studio。',
+    noProblems: '没有问题',
+    counts: (errors, warnings, infos) => `${errors} 个错误，${warnings} 个警告，${infos} 条信息`,
+    severity: { error: '错误', warning: '警告', info: '信息' },
+    hint: text => `    建议：${text}`,
+    lock: (file, changed, anchors) => `${file} ${changed ? '已更新' : '没有变化'}（${anchors} 个锚点）`,
+    documentRuns: (executed, cached) => `  （代码运行：执行 ${executed} 个，取自缓存 ${cached} 个）`,
+    notRendered: blocks => `  （${blocks} 个内容块未显示）`,
+    codeRuns: (executed, cached, sandbox) => `代码运行：执行 ${executed} 个，取自缓存 ${cached} 个${sandbox ? `，隔离方式为 ${sandbox}` : ''}`,
+  },
+  'en': {
+    usage: `Usage: presmium <command> [deck] [options]
+
+The deck is a directory holding ${DOCUMENT_ENTRY}, or that entry file (default: .).
+
+Commands:
+  new     a new project in the directory (default: asks), from create-presmium
+          --type <kind>   lecture, workspace, site, or plugin (default: asks)
+          --theme <name>  site theme: course, docs, or showcase (default: course)
+          --title <text>  the lecture, workspace, or site title
+          --name <name>   the plugin’s package name
+          --no-git        do not run git init
+  skills  install bundled skills, shared with MCP and the visual editor
+          install <dir> [--json]  install missing .agents/skills; keep existing skills
+          --name <skill>  install only the named skill; repeat for more
+          --json          print the installation result as JSON
+  build   export the deck: writes <out>/ir.json and <out>/<renderer>/; at a workspace root
+          (presmium.workspace.yaml) exports the workspace as a website into <out>/web/
+          --to <ids>      forms to export, comma-separated (default: the deck’s renderers)
+          --out <dir>     output directory (default: <deck>/dist)
+          --audience <name>  only the content for this audience (e.g. student); then every file
+                          written is scanned for the sentences of the content left out
+  dev     live preview: starts the Presmium server and the renderers’ dev servers, updates on save
+          --to <ids>      forms to preview, comma-separated
+          --out <dir>     working directory (default: <deck>/.presmium/dev)
+          --server-port <n>  port of the Presmium server (default: a free port)
+          --allow <kinds>    approvals given without asking: operate, spend, write, agent
+  ir      print the runtime snapshot as JSON
+          --out <file>    write it to a file instead
+  check   check the deck and run the plugins’ checks
+          --json          print the result as JSON
+          --update-lock   re-resolve anchors and rewrite .presmium/anchors.lock.json
+          --env           also connect to the environments of execute.environments
+          --audience <name>  check the content for this audience
+          --external-links   also check the external links, with lychee when it is installed
+  serve   the workspace service for you on this machine (the argument is the workspace root, or
+          a deck): the workspace site, the documents and their history, the reviews, the plugins’
+          routes, and the classroom sync; without --host it listens on this machine only
+          --port <n>      port (default: 4310)
+          --host <addr>   address to listen on (default: 127.0.0.1); 0.0.0.0 or an address on the
+                          local network opens it to your other devices there, with no login:
+                          whoever reaches the port works as you
+          --operator-dir <dir>  the operator directory (default: the user’s state directory)
+          --preview-origin <origin>  (repeatable) the origin of a Presmium Studio whose pages embed
+                          the previews, e.g. http://127.0.0.1:4320; with PRESMIUM_SERVICE_TOKEN set,
+                          the workspace’s routes ask for it (Authorization: Bearer)
+          --public-url <url>  the address browsers use when a reverse proxy fronts the service: its
+                          host is trusted, and previews and outputs are linked under it; with a path, the
+                          proxy forwards that path unchanged and everything the service serves is below it
+  studio  Presmium Studio (experimental): the editing app in the browser and the workspace service
+          of the directory (the workspace root, or a deck); prints the one address to open. It is
+          the package @lincyaw/studio (about 865 MB), installed beside this one
+          --port <n>      Presmium Studio’s port (default: 4320, or a free one when that is in use)
+          --host <addr>   listen on this address of the machine on the local network instead of
+                          127.0.0.1, with no login: whoever reaches the port works as you
+
+  -h, --help   show this help
+
+Exit Codes: 0 no errors, 1 error findings, 2 usage or internal error.`,
+    missingCommand: 'No command given. Put a command after presmium, for example presmium build.',
+    unknownCommand: name => `There is no command “${name}”. See presmium --help for the commands.`,
+    optionNotFor: (option, command) => `The option --${option} does not apply to presmium ${command}. See presmium --help for its options.`,
+    unexpectedArgument: argument => `Unexpected argument “${argument}”. Each command takes one deck or directory.`,
+    toNotForWorkspace: '--to does not apply to a workspace: its site is the web form.',
+    audienceNotForWorkspace: '--audience does not apply to a workspace yet. Export each document with --audience instead.',
+    badAudience: value => `“${value}” is not the name of an audience. Give a name of letters, digits, ., _, or -, such as student.`,
+    notFound: entry => `Couldn’t find ${entry}. Check the path, or make a document with presmium new.`,
+    emptyTo: '--to needs at least one renderer, such as --to web.',
+    badAllow: (kinds, value) => `--allow does not take “${value}”. The kinds are ${kinds.join(', ')}.`,
+    badPreviewOrigin: value => `“${value}” is not an origin. Give a scheme, host, and port, such as http://127.0.0.1:4320.`,
+    badPublicUrl: value => `“${value}” is not a usable address. Give the address browsers use, such as https://preview.example.com or https://example.com/user/a/preview/.`,
+    badPort: (option, value) => `${option} takes a port number from 0 to 65535, not “${value}”.`,
+    unmountFailed: error => `presmium: couldn’t close the previous server contributions: ${error}`,
+    compiled: (sections, summary) => `compiled ${sections} sections; ${summary}`,
+    token: file => ` (its token is in ${file})`,
+    watching: ir => `watching; runtime snapshot in ${ir}`,
+    noFfmpeg: command => `presmium serve: FFmpeg was not found, so lecture videos export from the browser as WebM, at a lower quality. Install it for sharp MP4 videos: ${command}`,
+    serveOpen: (address, port) => `presmium serve: listening on ${address}, on the local network, with no login: anyone who reaches port ${port} uses this workspace as you (edits, runs code, approves). Use it on a network you trust; without --host it listens on this machine only.`,
+    newMissing: 'presmium new: create-presmium is not installed. It comes with the presmium package: run pnpm add -g @lincyaw/presmium.',
+    studioMissing: 'presmium studio: Presmium Studio is not installed here (experimental, about 865 MB). Run pnpm add -g @lincyaw/studio, then presmium-studio; or run pnpm add -D @lincyaw/studio in this project.',
+    noProblems: 'no problems',
+    counts: (errors, warnings, infos) => `${errors} errors, ${warnings} warnings, ${infos} infos`,
+    severity: { error: 'error', warning: 'warning', info: 'info' },
+    hint: text => `    hint: ${text}`,
+    lock: (file, changed, anchors) => `${file} ${changed ? 'updated' : 'unchanged'} (${anchors} anchors)`,
+    documentRuns: (executed, cached) => `  (code runs: ${executed} executed, ${cached} from cache)`,
+    notRendered: blocks => `  (${blocks} blocks not rendered)`,
+    codeRuns: (executed, cached, sandbox) => `code runs: ${executed} executed, ${cached} from cache${sandbox ? `, isolated by ${sandbox}` : ''}`,
+  },
+}
+

package/src/testing.ts

@@ -22,5 +22,3 @@ export function presmium(cwd: string, args: string[], env: Record<string, string
   return run(process.execPath, [PRESMIUM_BIN, ...args], { cwd, env: { ...inherited, ...env } })
 }
 
-export { fakeModel, recordingProxy } from './fake-model.ts'
-export type { FakeModel, Received, Step } from './fake-model.ts'

package/src/fake-model.ts

@@ -1,101 +0,0 @@
-import { createServer } from 'node:http'
-import type { IncomingHttpHeaders } from 'node:http'
-import type { AddressInfo } from 'node:net'
-
-export type Step = { text: string } | { tool: string, input: Record<string, unknown> }
-
-export interface Received {
-  path: string
-  headers: IncomingHttpHeaders
-  body: Record<string, any>
-}
-
-export interface FakeModel {
-  url: string
-  received: Received[]
-  hold(): void
-  release(): void
-  close(): Promise<void>
-}
-
-const event = (name: string, data: unknown) => `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`
-
-function stream(step: Step, n: number): string {
-  const start = { type: 'message_start', message: { id: `msg_${n}`, type: 'message', role: 'assistant', model: 'fake-model', content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 10, output_tokens: 0 } } }
-  const block = 'text' in step
-    ? [event('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }), event('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: step.text } })]
-    : [event('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'tool_use', id: `toolu_${n}`, name: step.tool, input: {} } }), event('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'input_json_delta', partial_json: JSON.stringify(step.input) } })]
-  return [
-    event('message_start', start),
-    ...block,
-    event('content_block_stop', { type: 'content_block_stop', index: 0 }),
-    event('message_delta', { type: 'message_delta', delta: { stop_reason: 'text' in step ? 'end_turn' : 'tool_use', stop_sequence: null }, usage: { output_tokens: 5 } }),
-    event('message_stop', { type: 'message_stop' }),
-  ].join('')
-}
-
-export async function fakeModel(script: Step[]): Promise<FakeModel> {
-  const received: Received[] = []
-  let held: Promise<void> | undefined
-  let release = () => {}
-  const server = createServer((req, res) => {
-    let body = ''
-    req.setEncoding('utf8').on('data', (chunk: string) => body += chunk)
-    req.on('end', async () => {
-      let parsed: Record<string, any> = {}
-      try {
-        parsed = JSON.parse(body) as Record<string, any>
-      } catch {
-      }
-      const record: Received = { path: req.url ?? '', headers: req.headers, body: parsed }
-      received.push(record)
-      if (req.method !== 'POST' || !(req.url ?? '').endsWith('/v1/messages')) {
-        res.writeHead(404).end()
-        return
-      }
-      await held
-      const turn = (r: Received) => r.path.endsWith('/v1/messages') && Array.isArray(r.body.tools) && r.body.tools.length > 0
-      const n = received.filter(r => r.path.endsWith('/v1/messages')).length
-      const step = turn(record) ? script[received.filter(turn).indexOf(record)] ?? { text: '完毕。' } : { text: 'Presmium' }
-      res.writeHead(200, { 'Content-Type': 'text/event-stream' }).end(stream(step, n))
-    })
-  })
-  const port = await new Promise<number>(done => server.listen(0, '127.0.0.1', () => done((server.address() as AddressInfo).port)))
-  return {
-    url: `http://127.0.0.1:${port}`,
-    received,
-    hold() {
-      held = new Promise(done => release = done)
-    },
-    release() {
-      release()
-      held = undefined
-    },
-    close: () => new Promise<void>((done) => {
-      release()
-      server.close(() => done())
-      server.closeAllConnections()
-    }),
-  }
-}
-
-export async function recordingProxy(): Promise<{ url: string, attempts: string[], close(): Promise<void> }> {
-  const attempts: string[] = []
-  const server = createServer((req, res) => {
-    attempts.push(`${req.method} ${req.url}`)
-    res.writeHead(502).end()
-  })
-  server.on('connect', (req, socket) => {
-    attempts.push(`CONNECT ${req.url}`)
-    socket.end('HTTP/1.1 502 Bad Gateway\r\n\r\n')
-  })
-  const port = await new Promise<number>(done => server.listen(0, '127.0.0.1', () => done((server.address() as AddressInfo).port)))
-  return {
-    url: `http://127.0.0.1:${port}`,
-    attempts,
-    close: () => new Promise<void>((done) => {
-      server.close(() => done())
-      server.closeAllConnections()
-    }),
-  }
-}