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

package/README.md

@@ -1,8 +1,8 @@
 # @lincyaw/compiler
 
-Presmium's compiler: MyST source to the IR, plugin loading, compile-time execution and its cache, checks and publication checks, translations and the students' version, and running the renderers.
+Presmium's compiler validates the canonical `lecture.json` teaching document and lowers it to a runtime snapshot. Plugin loading, execution, checks and renderers consume that derived snapshot.
 
-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 publishes structured teaching documents as web pages, slides, Jupyter notebooks and narrated lectures.
 
 ## Install
 
@@ -13,17 +13,21 @@ It comes with `@lincyaw/cli`. Plugins that use its helpers declare it as a peer
 ```ts
 import { build, Compiler } from '@lincyaw/compiler'
 
-const compilation = await new Compiler('lecture.md').compile()
+const compilation = await new Compiler('lecture.json').compile()
 console.log(compilation.doc.sections.map(section => section.title))
 const findings = await compilation.check()
 await build(compilation, { outDir: 'dist', to: ['web'] })
 ```
 
+`lecture.json` is the only runtime authoring entry. The compiler uses the same `validateDocument` contract as UI and agent changes. MyST files require a one-time offline migration; they are not an alternate entry. Rich text lowers directly from its typed tree, without a Markdown round trip.
+
+Stable authoring step IDs and complete visual states are retained in the derived IR. A JSON pointer in diagnostics identifies the source entity; it is not a mutable source-line binding.
+
 `Compiler`, `Compilation`, `build`, `dev` and the options are public; the other exports serve Presmium's own packages.
 
 ## Documentation
 
-- [Plugin guide](https://github.com/Lincyaw/presmium/blob/main/site/plugins/lecture.en.md)
+- [Plugin guide](https://github.com/Lincyaw/presmium/blob/main/site/plugins/locales/en/lecture.json)
 
 ## License
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lincyaw/compiler",
-  "version": "1.0.0-rc.0",
-  "description": "Presmium's compiler: MyST source to the IR, plugin loading, compile-time execution and its cache, checks and the renderers",
+  "version": "1.0.0-rc.2",
+  "description": "Presmium's compiler: structured JSON documents to runtime IR, plugin loading, compile-time execution and its cache, checks and the renderers",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -12,7 +12,7 @@
   "bugs": "https://github.com/Lincyaw/presmium/issues",
   "keywords": [
     "presmium",
-    "myst",
+    "json",
     "compiler"
   ],
   "type": "module",
@@ -29,22 +29,21 @@
     "src"
   ],
   "dependencies": {
-    "html-tag-names": "2.1.0",
+    "content-disposition": "1.0.0",
+    "cors": "2.8.5",
     "jiti": "^2.7.0",
-    "mathml-tag-names": "4.0.0",
     "myst-common": "1.10.1",
-    "myst-ext-button": "0.0.2",
-    "myst-ext-card": "1.0.9",
-    "myst-ext-grid": "1.1.1",
-    "myst-ext-tabs": "1.0.10",
-    "myst-parser": "^1.7.4",
     "myst-transforms": "1.3.51",
+    "resolve.exports": "2.0.4",
     "semver": "^7.8.5",
-    "svg-tag-names": "3.0.1",
+    "send": "1.2.1",
     "yaml": "^2.9.1",
-    "@lincyaw/kernel": "1.0.0-rc.0"
+    "@lincyaw/kernel": "1.0.0-rc.2"
   },
   "devDependencies": {
-    "@types/semver": "^7.8.0"
+    "@types/content-disposition": "^0.5.9",
+    "@types/cors": "^2.8.19",
+    "@types/semver": "^7.8.0",
+    "@types/send": "^1.2.1"
   }
 }

package/src/assets.ts

@@ -0,0 +1,163 @@
+import { createHash } from 'node:crypto'
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { basename, dirname, join, relative, resolve, sep } from 'node:path'
+import { deckLocale, escapeHtml, NON_FILE_URL } from '@lincyaw/kernel'
+import type { DocumentLink, Finding, LocalAsset, SourcePos } from '@lincyaw/kernel'
+import { fileVersion, isInside } from '@lincyaw/kernel/node'
+import type { Compilation } from './compiler.ts'
+import { DECK_ENTRY, WORK_DIR } from './paths.ts'
+import { lineContaining } from './source-lines.ts'
+
+const hashes = new Map<string, { stamp: string, hash: string }>()
+
+const RACY_MS = 2000
+
+export function fileHash(file: string): string {
+  const stat = statSync(file, { bigint: true })
+  const stamp = fileVersion(stat)
+  const known = hashes.get(file)
+  if (known?.stamp === stamp) return known.hash
+  const hash = createHash('sha256').update(readFileSync(file)).digest('hex')
+  if (Date.now() - Number(stat.ctimeMs) > RACY_MS && Date.now() - Number(stat.mtimeMs) > RACY_MS) hashes.set(file, { stamp, hash })
+  else hashes.delete(file)
+  return hash
+}
+
+function unpublished(name: string): boolean {
+  return name.startsWith('.') || name === 'node_modules'
+}
+
+function directoryFiles(dir: string, prefix = ''): string[] {
+  return readdirSync(join(dir, prefix), { withFileTypes: true })
+    .filter(entry => !unpublished(entry.name))
+    .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+    .flatMap((entry) => {
+      const path = prefix ? `${prefix}/${entry.name}` : entry.name
+      if (entry.isDirectory()) return existsSync(join(dir, path, DECK_ENTRY)) ? [] : directoryFiles(dir, path)
+      return entry.isFile() ? [path] : []
+    })
+}
+
+const LISTING = {
+  'zh-CN': { count: (n: number) => `${n} 个文件，点击下载`, files: '文件' },
+  'en': { count: (n: number) => `${n} file${n === 1 ? '' : 's'}; select one to download it`, files: 'Files' },
+}
+
+function publishedDirectory(dir: string, stage: string, lang?: string): { file: string, name: string } {
+  const files = directoryFiles(dir)
+  const hash = createHash('sha256')
+  for (const file of files) hash.update(file).update('\0').update(fileHash(join(dir, file))).update('\0')
+  const name = `${hash.digest('hex').slice(0, 8)}-${basename(dir)}`
+  const target = join(stage, name)
+  if (existsSync(target)) return { file: target, name }
+  const partial = `${target}.${process.pid}`
+  rmSync(partial, { recursive: true, force: true })
+  mkdirSync(partial, { recursive: true })
+  for (const file of files) cpSync(join(dir, file), join(partial, file))
+  if (!files.includes('index.html')) {
+    const t = LISTING[deckLocale(lang)]
+    const href = (file: string) => file.split('/').map(encodeURIComponent).join('/')
+    const items = files.map(file => `<li><a href="${escapeHtml(href(file))}" download>${escapeHtml(file)}</a> <small>${statSync(join(dir, file)).size} B</small></li>`)
+    writeFileSync(join(partial, 'index.html'), `<!doctype html>
+<html lang="${escapeHtml(lang ?? 'zh-CN')}">
+<head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${escapeHtml(basename(dir))}</title>
+<style>body{font:16px/1.6 system-ui,sans-serif;max-width:48rem;margin:2rem auto;padding:0 1rem}small{color:#666}</style></head>
+<body><h1>${escapeHtml(basename(dir))}/</h1><p>${escapeHtml(t.count(files.length))}</p>
+<ul aria-label="${escapeHtml(t.files)}">
+${items.join('\n')}
+</ul></body></html>
+`)
+  }
+  try {
+    renameSync(partial, target)
+  } catch {
+    rmSync(partial, { recursive: true, force: true })
+  }
+  return { file: target, name }
+}
+
+export function publishesDirectory(target: string, deckDir: string): boolean {
+  return Boolean(lstatSync(target, { throwIfNoEntry: false })?.isDirectory()) && target !== deckDir && isInside(target, deckDir) && !existsSync(join(target, DECK_ENTRY))
+}
+
+export function unpublishedDirectory(target: string, deckDir: string): string | undefined {
+  return relative(deckDir, target).split(sep).some(unpublished) ? 'hidden directories and node_modules are not published' : undefined
+}
+
+export function directoryAsset(target: string, deckDir: string, stage: string, lang: string | undefined, warn: (message: string) => void): { file: string, name: string } | undefined {
+  const refused = unpublishedDirectory(target, deckDir)
+  if (refused) {
+    warn(refused)
+    return undefined
+  }
+  return publishedDirectory(target, stage, lang)
+}
+
+const FILES_DIR = 'files'
+
+export function localAsset(deckDir: string, source: SourcePos, url: string): { file: string, name: string } | undefined {
+  if (NON_FILE_URL.test(url)) return undefined
+  const path = url.replace(/[?#].*$/s, '')
+  if (!path) return undefined
+  let name = path
+  try {
+    name = decodeURIComponent(path)
+  } catch {
+  }
+  const file = name.startsWith('/') ? join(deckDir, 'public', name) : resolve(dirname(source.file), name)
+  if (!existsSync(file) || !statSync(file).isFile()) return undefined
+  return { file, name: `${fileHash(file).slice(0, 8)}-${basename(file)}` }
+}
+
+function localTarget(source: SourcePos, url: string): string | undefined {
+  if (NON_FILE_URL.test(url)) return undefined
+  const path = url.replace(/[?#].*$/s, '')
+  if (!path || path.startsWith('/')) return undefined
+  let name = path
+  try {
+    name = decodeURIComponent(path)
+  } catch {
+  }
+  return resolve(dirname(source.file), name)
+}
+
+export function documentLink(compilation: Compilation, source: SourcePos, url: string): DocumentLink | undefined {
+  const target = localTarget(source, url)
+  if (!target) return undefined
+  const dir = basename(target) === DECK_ENTRY && statSync(target, { throwIfNoEntry: false })?.isFile() ? dirname(target)
+    : statSync(target, { throwIfNoEntry: false })?.isDirectory() && existsSync(join(target, DECK_ENTRY)) ? target
+      : undefined
+  if (dir === undefined || !isInside(dir, compilation.workspaceRoot)) return undefined
+  const hash = url.indexOf('#')
+  let fragment = hash < 0 ? '' : url.slice(hash + 1)
+  try {
+    fragment = decodeURIComponent(fragment)
+  } catch {
+  }
+  return { dir: relative(compilation.workspaceRoot, dir).split(sep).join('/'), ...fragment ? { fragment } : {} }
+}
+
+export function publishedAsset(compilation: Compilation, source: SourcePos, url: string, report: (finding: Finding) => void): LocalAsset | undefined {
+  const { deckDir, workspaceRoot } = compilation
+  const warn = (message: string) => report({ checkId: 'presmium.links', severity: 'warning', message, source: { file: source.file, line: lineContaining(source, url) } })
+  const target = localTarget(source, url)
+  const found = localAsset(deckDir, source, url)
+  if (found && target && basename(realpathSync(found.file)) === DECK_ENTRY) {
+    const linked = documentLink(compilation, source, url)
+    warn(`${url} is not published: it is the source of ${linked?.dir ? `the document ${linked.dir}` : 'a document'}, which a workspace site links as its page; this build keeps the link as written`)
+    return undefined
+  }
+  if (found && !isInside(found.file, workspaceRoot) && existsSync(join(workspaceRoot, '.git'))) {
+    warn(`${url} is not published: the file lies outside the deck's repository`)
+    return undefined
+  }
+  if (found) return { ...found, directory: false }
+  if (!target) return undefined
+  if (!existsSync(target)) {
+    warn(`${url} is not published: there is no such file`)
+    return undefined
+  }
+  if (!publishesDirectory(target, deckDir)) return undefined
+  const directory = directoryAsset(target, deckDir, join(deckDir, WORK_DIR, FILES_DIR), compilation.doc.meta.lang, message => warn(`${url} is not published: ${message}`))
+  return directory && { ...directory, directory: true }
+}

package/src/audience.ts

@@ -1,10 +1,8 @@
 import { lstat, readdir, readFile } from 'node:fs/promises'
 import { basename, extname, join, relative } from 'node:path'
-import { irBlocks, isRecord, nodeMdast } from '@lincyaw/kernel'
+import { compactSteps, irBlocks, isRecord, nodeMdast, productionAssetIds, propText } from '@lincyaw/kernel'
 import type { Finding, IRBlock, IRDocument, IRNode, IRSection, MdastNode, SourcePos } from '@lincyaw/kernel'
 import { resolveReferences } from './references.ts'
-import { Parser, sourceOf } from './source.ts'
-import type { ParsedFile } from './source.ts'
 
 export interface Removed {
   source: SourcePos
@@ -25,172 +23,33 @@ export interface Withheld {
   sentences: string[]
 }
 
-export const AUDIENCE_SCOPE = 'presmiumAudience'
-
 const MIN_SENTENCE = 12
 
 const BINARY = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.avif', '.ico', '.bmp', '.mp3', '.mp4', '.m4a', '.webm', '.ogg', '.oga', '.wav', '.flac', '.woff', '.woff2', '.ttf', '.otf', '.eot', '.wasm', '.zip', '.gz', '.pdf'])
 
 const HTML_ENTITIES: Record<string, string> = { amp: '&', lt: '<', gt: '>', quot: '"', apos: '\'', nbsp: ' ' }
 
-export function forAudience(audience: string[] | undefined, name: string): boolean {
+export function includesAudience(audience: string[] | undefined, name: string): boolean {
   return !audience || audience.includes(name)
 }
 
-export function audienceList(text: string): string[] {
-  return [...new Set(text.split(/[\s,]+/).filter(Boolean))]
-}
-
-export function within(outer: string[] | undefined, inner: string[]): string[] {
-  return outer ? outer.filter(name => inner.includes(name)) : inner
-}
-
 export function markOf(node: unknown): string[] | undefined {
   const audience = isRecord(node) && isRecord(node.data) ? node.data.audience : undefined
   return Array.isArray(audience) ? audience as string[] : undefined
 }
 
-export function markAudience(nodes: MdastNode[], audience: string[]): MdastNode[] {
-  return nodes.map(node => ({ ...node, data: { ...isRecord(node.data) ? node.data : {}, audience: within(markOf(node), audience) } }))
-}
-
-export class AudienceParser extends Parser {
-  readonly #scoped = new WeakMap<ParsedFile, ParsedFile>()
-
-  override async read(file: string): Promise<ParsedFile | undefined> {
-    const parsed = await super.read(file)
-    if (!parsed) return undefined
-    let scoped = this.#scoped.get(parsed)
-    if (!scoped) this.#scoped.set(parsed, scoped = { ...parsed, children: scopeIncludes(parsed.children) })
-    return scoped
-  }
-}
-
-function scopeIncludes(nodes: MdastNode[]): MdastNode[] {
-  let changed = false
-  const result = nodes.map((node): MdastNode => {
-    const option = isRecord(node.options) ? node.options.audience : undefined
-    if (node.type === 'mystDirective' && node.name === 'include' && option !== undefined && !node.children?.some(c => c.type === 'include' && c.literal === true)) {
-      changed = true
-      return { type: AUDIENCE_SCOPE, audience: audienceList(typeof option === 'string' ? option : ''), position: node.position, children: [node] }
-    }
-    const children = node.children?.length ? scopeIncludes(node.children) : node.children
-    if (children === node.children) return node
-    changed = true
-    return { ...node, children }
-  })
-  return changed ? result : nodes
-}
-
-export function liftScopes(nodes: MdastNode[], sectionDepth: number, trailing?: (node: MdastNode, audience: string[]) => void): MdastNode[] {
-  if (!nodes.some(node => lifted(node, sectionDepth))) return nodes
-  const out: MdastNode[] = []
-  let section: string[] | undefined
-  for (const node of nodes) {
-    if (lifted(node, sectionDepth)) {
-      section = lift(node, node.audience as string[], sectionDepth, out, trailing)
-      continue
-    }
-    if (opens(node, sectionDepth)) section = undefined
-    else if (section && wider(node, undefined, section)) {
-      trailing?.(node, section)
-      section = undefined
-    }
-    out.push(node)
-  }
-  return out
-}
-
-function lifted(node: MdastNode, depth: number): boolean {
-  return node.type === AUDIENCE_SCOPE && (node.audience as string[]).length > 0 && holdsSection(node, depth)
-}
-
-function opens(node: MdastNode, depth: number): boolean {
-  return node.type === 'heading' && Number(node.depth) <= depth
-}
-
-function holdsSection(scope: MdastNode, depth: number): boolean {
-  return (scope.children ?? []).some(node => opens(node, depth) || (node.type === AUDIENCE_SCOPE && holdsSection(node, depth)))
-}
-
-const SETTINGS = new Set(['hints', 'config', 'audience'])
-
-function ownAudience(node: MdastNode): string[] | undefined {
-  if (node.type === AUDIENCE_SCOPE) return node.section ? undefined : node.audience as string[]
-  const option = node.type === 'mystDirective' && isRecord(node.options) ? node.options.audience : undefined
-  return option === undefined ? undefined : audienceList(typeof option === 'string' ? option : '')
-}
-
-function wider(node: MdastNode, own: string[] | undefined, section: string[]): boolean {
-  if (node.type === 'comment' || node.type === 'mystTarget' || (node.type === 'mystDirective' && SETTINGS.has(String(node.name)))) return false
-  const marked = ownAudience(node)
-  const audience = marked ? within(own, marked) : own
-  return !audience || audience.some(name => !section.includes(name))
-}
-
-export function audienceMarks(nodes: MdastNode[], entry: string, outer?: string[], marks: AudienceMark[] = []): AudienceMark[] {
-  for (const node of nodes) {
-    const own = ownAudience(node)
-    const audience = own ? within(outer, own) : outer
-    if (own && node.position) marks.push({ source: sourceOf(node, entry), audience: audience! })
-    if (node.children?.length) audienceMarks(node.children, entry, audience, marks)
-  }
-  return marks
-}
-
-export function markBlocks(sections: IRSection[], marks: AudienceMark[]): void {
-  if (marks.length === 0) return
-  for (const section of sections) {
-    for (const block of irBlocks(section.blocks)) {
-      const { file, line } = block.source
-      const end = block.source.endLine ?? line
-      for (const mark of marks) {
-        if (mark.source.file === file && mark.source.line <= line && end <= (mark.source.endLine ?? mark.source.line)) block.audience = within(block.audience, mark.audience)
-      }
-    }
-  }
-}
-
-function lift(scope: MdastNode, audience: string[], depth: number, out: MdastNode[], trailing?: (node: MdastNode, audience: string[]) => void): string[] {
-  const before: MdastNode[] = []
-  let opened = false
-  let last = audience
-  const open = () => {
-    if (!opened && before.length > 0) out.push(Object.assign(scope, { audience, children: before }))
-    opened = true
-  }
-  for (const node of scope.children ?? []) {
-    if (node.type === AUDIENCE_SCOPE && holdsSection(node, depth)) {
-      open()
-      last = lift(node, within(audience, node.audience as string[]), depth, out, trailing)
-    } else if (opens(node, depth)) {
-      const label = !opened && before.at(-1)?.type === 'mystTarget' ? before.pop() : undefined
-      open()
-      out.push(...label ? [label] : [], node, { type: AUDIENCE_SCOPE, audience, section: true })
-      last = audience
-    } else {
-      if (opened && last !== audience && wider(node, audience, last)) {
-        trailing?.(node, last)
-        last = audience
-      }
-      (opened ? out : before).push(node)
-    }
-  }
-  return last
-}
-
-export function audienceView(doc: IRDocument, name: string, marks: AudienceMark[] = []): { doc: IRDocument, removed: Removed[], keeps: (finding: Finding) => boolean } {
+/** Removes the sections and blocks not for the audience; `keeps` tells whether a finding lies in what is left. */
+export function filterForAudience(doc: IRDocument, name: string, marks: AudienceMark[] = []): { doc: IRDocument, removed: Removed[], keeps: (finding: Finding) => boolean } {
   const removed: Removed[] = []
   const sections: IRSection[] = []
-  const compacted = new Set<string>()
   for (const section of doc.sections) {
-    if (!forAudience(section.audience, name)) {
+    if (!includesAudience(section.audience, name)) {
       removed.push({ source: section.source, audience: section.audience!, title: section.title, blocks: section.blocks })
       continue
     }
     let dropped = false
     const keep = (blocks: IRBlock[]): IRBlock[] => blocks.flatMap((block) => {
-      if (!forAudience(block.audience, name)) {
+      if (!includesAudience(block.audience, name)) {
         dropped = true
         removed.push({ source: block.source, audience: block.audience!, blocks: [block] })
         return []
@@ -199,20 +58,20 @@ export function audienceView(doc: IRDocument, name: string, marks: AudienceMark[
       return [node === block.node ? block : { ...block, node }]
     })
     const blocks = keep(section.blocks)
-    if (dropped) compacted.add(section.id)
     sections.push(dropped ? compactSteps({ ...section, blocks }) : same(blocks, section.blocks) ? section : { ...section, blocks })
   }
-  const marked = marks.filter(mark => !forAudience(mark.audience, name)).map(mark => mark.source)
+  const marked = marks.filter(mark => !includesAudience(mark.audience, name)).map(mark => mark.source)
   if (removed.length === 0 && marked.length === 0) return { doc, removed, keeps: () => true }
-  const kept = new Set(sections.map(section => section.id))
-  sections.forEach((section, i) => sections[i] = withViewKeys(section, kept, compacted.has(section.id)))
   const spans = [...leftOut(doc, name, removed), ...marked]
   const keeps = ({ source: at }: Finding) => !at || !spans.some(span => at.file === span.file && (at.line ?? 0) >= span.line && (at.line ?? 0) <= (span.endLine ?? span.line))
+  const stepIds = new Set(sections.flatMap(section => section.stepIds ?? []))
+  const production = doc.production && { ...doc.production, ...doc.production.captionTimings ? { captionTimings: Object.fromEntries(Object.entries(doc.production.captionTimings).filter(([id]) => stepIds.has(id))) } : {}, mediaClips: doc.production.mediaClips.filter(clip => stepIds.has(clip.attachment.stepId)) }
   return {
     doc: {
       ...doc,
       sections: sections.map((section, i) => (section.index === i + 1 ? section : { ...section, index: i + 1 })),
       diagnostics: doc.diagnostics.filter(keeps),
+      ...production ? { production, productionAssets: Object.fromEntries(productionAssetIds(production, sections).flatMap(id => doc.productionAssets?.[id] ? [[id, doc.productionAssets[id]!]] : [])) } : {},
     },
     removed,
     keeps,
@@ -222,7 +81,7 @@ export function audienceView(doc: IRDocument, name: string, marks: AudienceMark[
 function leftOut(doc: IRDocument, name: string, removed: Removed[]): SourcePos[] {
   const spans: SourcePos[] = removed.filter(item => !item.nested && item.title === undefined).map(item => item.source)
   doc.sections.forEach((section, i) => {
-    if (forAudience(section.audience, name)) return
+    if (includesAudience(section.audience, name)) return
     const next = doc.sections.slice(i + 1).find(later => later.source.file === section.source.file)
     spans.push({ file: section.source.file, line: section.source.line, endLine: next ? next.source.line - 1 : Number.MAX_SAFE_INTEGER })
     for (const block of irBlocks(section.blocks)) if (block.source.file !== section.source.file) spans.push(block.source)
@@ -231,7 +90,7 @@ function leftOut(doc: IRDocument, name: string, removed: Removed[]): SourcePos[]
 }
 
 export function audienceDocument(doc: IRDocument, name: string, filled: WeakSet<object>, marks: AudienceMark[] = []): IRDocument {
-  const { doc: found, removed } = audienceView(doc, name, marks)
+  const { doc: found, removed } = filterForAudience(doc, name, marks)
   const view = { ...found, meta: { ...found.meta, audience: name } }
   if (removed.length === 0) return view
   const own = detached(view, filled)
@@ -252,7 +111,7 @@ export function emptyReferences(doc: IRDocument): WeakSet<object> {
 export function withheld(removed: Removed[], kept: IRDocument): Withheld[] {
   const shown = ownText(kept)
   return removed.map(({ source, audience, title, blocks }) => {
-    const texts = [...title ? [title] : [], ...blocks.flatMap(block => [...irBlocks([block])].flatMap(blockTexts))]
+    const texts = [...title ? [title] : [], ...blocks.flatMap(block => [...irBlocks([block])].flatMap(sentenceSources))]
     return { source, audience, sentences: [...new Set(texts.flatMap(sentences))].filter(sentence => !shown.includes(sentence)) }
   })
 }
@@ -263,7 +122,7 @@ export function unshown(left: Withheld[], docs: IRDocument[]): Withheld[] {
 }
 
 function ownText(doc: IRDocument): string {
-  return doc.sections.flatMap(section => [section.title, ...[...irBlocks(section.blocks)].flatMap(blockTexts)]).map(squash).join('\n')
+  return doc.sections.flatMap(section => [section.title, ...[...irBlocks(section.blocks)].flatMap(sentenceSources)]).map(squash).join('\n')
 }
 
 export async function scanOutputs(left: Withheld[], paths: string[], audience: string, base: string, quote = true): Promise<Finding[]> {
@@ -319,7 +178,7 @@ function prune<T>(value: T, name: string, left: MdastNode[]): T {
   if (Array.isArray(value)) {
     let changed = false
     const kept = value.flatMap((item: unknown) => {
-      if (!forAudience(markOf(item), name)) {
+      if (!includesAudience(markOf(item), name)) {
         left.push(item as MdastNode)
         changed = true
         return []
@@ -382,75 +241,21 @@ function withoutLeaks(view: IRDocument, removed: Removed[], name: string): IRDoc
   return findings.length === 0 ? view : { ...view, sections, diagnostics: [...view.diagnostics, ...findings] }
 }
 
-const STEPS_KEY = 'presmiumSteps'
-const BACK_KEY = 'presmiumBack'
-
-function withViewKeys(section: IRSection, sections: ReadonlySet<string>, compacted: boolean): IRSection {
-  const hints = section.hints.slides
-  const back = isRecord(hints) && typeof hints[BACK_KEY] === 'string' && !sections.has(hints[BACK_KEY])
-  if (!isRecord(hints) || (!(compacted && STEPS_KEY in hints) && !back)) return section
-  const paths = new Set<string>()
-  const visit = (blocks: readonly IRBlock[], prefix: string) => {
-    for (const block of blocks) {
-      paths.add(prefix + block.id)
-      if (block.node.type === 'component' && block.node.children) visit(block.node.children, `${prefix}${block.id}/`)
-    }
-  }
-  visit(section.blocks, '')
-  const has = (key: string) => paths.has(key) || paths.has(key.replace(/\+\d+$/, '')) || (key.endsWith('-') && paths.has(key.slice(0, -1)))
-  const own: Record<string, unknown> = { ...hints }
-  const steps = hints[STEPS_KEY]
-  if (compacted && Array.isArray(steps)) {
-    const left = steps.map(keys => (Array.isArray(keys) ? keys.filter(key => typeof key === 'string' && has(key)) : []))
-    const closed = left.filter((keys, i) => i === 0 || keys.length > 0)
-    if (closed.length > 1) own[STEPS_KEY] = closed
-    else delete own[STEPS_KEY]
-  }
-  if (back) delete own[BACK_KEY]
-  return { ...section, hints: { ...section.hints, slides: own } }
-}
-
-function compactSteps(section: IRSection): IRSection {
-  const used = new Set([0])
-  for (const block of irBlocks(section.blocks)) {
-    if (block.role !== 'visual') continue
-    for (let step = block.at; step <= block.at + (block.span ?? 0); step++) used.add(step)
-    if (block.until !== undefined) used.add(block.until)
-  }
-  if (used.size > section.steps) return section
-  const steps: number[] = []
-  for (let step = 0, n = -1; step <= section.steps; step++) steps.push(used.has(step) ? ++n : n)
-  const map = (step: number) => steps[Math.min(step, section.steps)]!
-  const renumber = (blocks: IRBlock[]): IRBlock[] => blocks.map(block => ({
-    ...block,
-    at: map(block.at),
-    ...block.until === undefined ? {} : { until: map(block.until) },
-    ...block.node.type === 'component' && block.node.children ? { node: { ...block.node, children: renumber(block.node.children) } } : {},
-  }))
-  return { ...section, steps: map(section.steps), blocks: renumber(section.blocks) }
-}
-
-function blockTexts(block: IRBlock): string[] {
+/** The texts of a block that the leak scan splits into sentences: its own source, without recorded output. */
+function sentenceSources(block: IRBlock): string[] {
   const { node } = block
   switch (node.type) {
-    case 'markdown': return mdastTexts(node.mdast)
+    case 'markdown': return mdastSentenceSources(node.mdast)
     case 'code': return [node.title ?? '', node.value, ...(node.variants ?? []).map(variant => variant.value)]
-    case 'component': return [...propTexts(node.props), ...node.fallback ? mdastTexts(node.fallback) : []]
+    case 'component': return [...propText(node.props), ...node.fallback ? mdastSentenceSources(node.fallback) : []]
   }
 }
 
-function mdastTexts(node: MdastNode): string[] {
+function mdastSentenceSources(node: MdastNode): string[] {
   const own: string[] = []
   if (typeof node.value === 'string') own.push(node.type === 'html' ? node.value.replace(/<[^<>]*>/g, ' ') : node.value)
   for (const key of ['alt', 'title'] as const) if (typeof node[key] === 'string') own.push(node[key] as string)
-  return [...own, ...(node.children ?? []).flatMap(mdastTexts)]
-}
-
-function propTexts(value: unknown): string[] {
-  if (typeof value === 'string') return [value]
-  if (Array.isArray(value)) return value.flatMap(propTexts)
-  if (value && typeof value === 'object') return Object.values(value).flatMap(propTexts)
-  return []
+  return [...own, ...(node.children ?? []).flatMap(mdastSentenceSources)]
 }
 
 function sentences(text: string): string[] {