@preventive/triage 1.0.0-alpha.4 → 1.0.0-alpha.40

package/server-managed/pretty-print.ts

@@ -0,0 +1,352 @@
+// Minified files pretty-printed for the Code tab (GET /api/bundles/:id/pretty
+// one file at a time, GET /api/npm/pretty all a version's at once), and the
+// files that changed between two bundles or versions for Compare (the same
+// with `other`, or `otherVersion`), named by path and content hash, formatted
+// with oxfmt once and kept Brotli-encoded by that hash: a bundle's in its
+// cache directory (so only made from, and read by readers of, that bundle), a
+// public npm version's under `cache/npm/`; a private version's are never
+// kept. Access is the caller's to check.
+import { Buffer } from 'node:buffer'
+import { Readable } from 'node:stream'
+import { promisify } from 'node:util'
+import { brotliDecompress } from 'node:zlib'
+import { format } from '@preventive/compare/pretty.js'
+import { computeFileHash } from '@preventive/report'
+import { FILE_HASH } from '../common/bundle-metadata.js'
+import { bundleCompareFiles } from '../common/bundle-compare-inputs.js'
+import { bundlePackageDirs, bundleSourcesAsMap } from '../common/bundle-sources.js'
+import { MAX_PRETTY_BYTES, needsPrettyPrint, prettyExtension } from '../common/pretty-print.js'
+import type { OpenedBlob } from './blob-store.ts'
+import { type BundleCacheStorage, readBundleDetails } from './bundle-cache.ts'
+import type { BundleStore } from './bundle-store.ts'
+import { encodeBrotli } from './brotli.ts'
+import { CacheMissError, type CacheStorage } from './cache-storage.ts'
+import type { ManagedBundle, ManagedDb } from './db.ts'
+import { loadNpmFiles } from './npm-loads.ts'
+import { type NpmVersionDocument, npmFileText } from './npm-packages.ts'
+
+// Part of every kept copy's name; bumped when what the formatter writes for
+// the same file changes, or what its check lets through, so copies written
+// before are no longer read.
+const PRETTY_VERSION = 3
+// Formats running at once per process, each holding its file's syntax tree,
+// and those waiting their turn past them (a version's files are formatted one
+// after another, beside other readers'), any more refused.
+const MAX_ACTIVE_FORMATS = 2
+const MAX_WAITING_FORMATS = 16
+
+export class PrettyError extends Error {
+  status: number
+  constructor(status: number, code: string) { super(code); this.status = status }
+}
+
+export interface PrettyRequest { path: string; hash: string; extension: string }
+
+// One of a version's files pretty-printed (npmAll), named by `source`, the
+// hash of the file it was formatted from: its copy's text, or why it has
+// none, as a PrettyError tells it.
+export type PrettyLine = { path: string; source: string; text: string } | { path: string; source: string; error: string; status: number }
+
+// Which of a comparison's two its files are of: the bundle or version asked
+// about, or the `other`.
+type Side = 'base' | 'other'
+
+// One of a comparison's changed files pretty-printed (compared), as a
+// version's is, with the side it is of.
+export type ComparedLine = PrettyLine & { side: Side }
+
+// A side of a comparison: its files that can be formatted, with their texts,
+// and every one of its files' hashes, by path; its packages' directories by
+// path, as a bundle records them (bundlePackageDirs), or null where it
+// records none; the copy kept for one, or null; and one made, kept where the
+// side keeps copies.
+export interface ComparedSide {
+  side: Side
+  files: Array<PrettyRequest & { text: string }>
+  hashes: Map<string, string>
+  packageDirs: Map<string, string> | null
+  kept(request: PrettyRequest): Promise<OpenedBlob | null>
+  made(request: PrettyRequest, text: string): Promise<OpenedBlob>
+}
+
+// The file a request's `path` and `hash` name, or null for one that can't be
+// formatted.
+export function prettyRequest(params: URLSearchParams): PrettyRequest | null {
+  const path = params.get('path') ?? ''
+  const extension = prettyExtension(path), hash = params.get('hash') ?? ''
+  return extension !== null && FILE_HASH.test(hash) ? { path, hash, extension } : null
+}
+
+// A copy's name: its file's hash in hex, with the extension it was parsed by.
+const prettyFile = ({ hash, extension }: PrettyRequest) =>
+  `pretty-v${PRETTY_VERSION}/${Buffer.from(hash.slice('sha512-'.length), 'base64').toString('hex')}.${extension}.br`
+
+let activeFormats = 0
+const waitingFormats: Array<() => void> = []
+
+// The text formatted and Brotli-encoded, where @preventive/compare's checks
+// find formatting changed only its layout: refused as `unsupported` where it
+// has no check for the kind of file, `unformattable` or `pretty-mismatch`.
+export async function prettyBody(text: string, extension: string): Promise<Buffer> {
+  if (Buffer.byteLength(text) > MAX_PRETTY_BYTES) throw new PrettyError(413, 'file-too-large')
+  if (activeFormats < MAX_ACTIVE_FORMATS) activeFormats++
+  else if (waitingFormats.length >= MAX_WAITING_FORMATS) throw new PrettyError(429, 'pretty-busy')
+  else await new Promise<void>(resolve => { waitingFormats.push(resolve) })
+  let result
+  try { result = await format(text, extension) }
+  finally {
+    const next = waitingFormats.shift()
+    if (next) next()
+    else activeFormats--
+  }
+  if ('error' in result) {
+    if (result.error === 'pretty-mismatch') console.warn(`managed: pretty-printing a .${extension} file changed more than its layout; not served`)
+    throw new PrettyError(422, result.error)
+  }
+  return encodeBrotli(Buffer.from(result.code))
+}
+
+const opened = (body: Buffer): OpenedBlob => ({ size: body.byteLength, stream: Readable.from([body]) })
+
+const decompress = promisify(brotliDecompress)
+
+// A pretty-printed copy's text, from its Brotli-encoded bytes.
+export async function prettyText(copy: OpenedBlob): Promise<string> {
+  const chunks: Buffer[] = []
+  for await (const chunk of copy.stream) chunks.push(chunk as Buffer)
+  return (await decompress(Buffer.concat(chunks))).toString()
+}
+
+// Every file of a version that needs pretty-printing (needsPrettyPrint), read
+// in one load of its files, in path order.
+async function npmPrintable(doc: NpmVersionDocument): Promise<Array<PrettyRequest & { text: string }>> {
+  const load = loadNpmFiles(doc)
+  const files: Array<PrettyRequest & { text: string }> = []
+  try {
+    for (const { path, bytes } of await load.result) {
+      const extension = prettyExtension(path)
+      if (extension === null || bytes.byteLength > MAX_PRETTY_BYTES) continue
+      const text = npmFileText(bytes)
+      if (text !== null && needsPrettyPrint(path, text)) files.push({ path, hash: await computeFileHash(bytes), extension, text })
+    }
+  } finally { load.release() }
+  return files.toSorted((a, b) => (a.path < b.path ? -1 : 1))
+}
+
+// A file's line (PrettyLine): the text of its copy, as `copy` has it, or why
+// it has none.
+async function prettyLine({ path, hash }: PrettyRequest, copy: () => Promise<OpenedBlob>): Promise<PrettyLine> {
+  try { return { path, source: hash, text: await prettyText(await copy()) } }
+  catch (err) {
+    if (!(err instanceof PrettyError)) throw err
+    return { path, source: hash, error: err.message, status: err.status }
+  }
+}
+
+// The files that changed between two sides, pretty-printed: each side's
+// formattable files the other has another text at the path of, or, where it
+// has none there, none of their text at a path of its own (a file renamed, or
+// moved with its tree, unchanged, has it there; a copy at a path both have is
+// not one), by the paths each side has them at. Those are both of the pairs
+// the viewer diffs but where it pairs files otherwise (among copies of one
+// text, across packages), whose copies it asks for alone. As they are
+// iterated, in path order, the base's first where both have one: those kept,
+// at once; then the rest, formatted one after another, the minified before
+// the others (needsPrettyPrint), as the viewer prints those unasked.
+export function compared(sides: readonly [ComparedSide, ComparedSide]): AsyncGenerator<ComparedLine> {
+  // Each side's texts at the paths the other hasn't: where a file moved has its own.
+  const moved = sides.map((own, i) => new Set([...own.hashes].filter(([path]) => !sides[1 - i]!.hashes.has(path)).map(([, hash]) => hash)))
+  const changed = sides.flatMap((own, i) => {
+    const other = sides[1 - i]!.hashes
+    return own.files.filter(({ path, hash }) => (other.has(path) ? other.get(path) !== hash : !moved[1 - i]!.has(hash))).map(file => ({ own, file }))
+  }).toSorted((a, b) => (a.file.path < b.file.path ? -1 : a.file.path > b.file.path ? 1 : 0))
+  return (async function* () {
+    const unkept: typeof changed = []
+    for (const { own, file } of changed) {
+      const copy = await own.kept(file)
+      if (copy) yield { side: own.side, ...await prettyLine(file, () => Promise.resolve(copy)) }
+      else unkept.push({ own, file })
+    }
+    const minified = new Map(unkept.map(({ file }) => [file, needsPrettyPrint(file.path, file.text)]))
+    for (const { own, file } of unkept.toSorted((a, b) => Number(minified.get(b.file)) - Number(minified.get(a.file)))) {
+      yield { side: own.side, ...await prettyLine(file, () => own.made(file, file.text)) }
+    }
+  })()
+}
+
+// Jobs by key, readers asking for one while it runs sharing it.
+function sharing<T>(): (key: string, make: () => Promise<T>) => Promise<T> {
+  const pending = new Map<string, Promise<T>>()
+  return (key, make) => {
+    let job = pending.get(key)
+    if (!job) pending.set(key, job = make().finally(() => pending.delete(key)))
+    return job
+  }
+}
+
+// Work done one job at a time, in the order asked.
+function serial(): <T>(work: () => Promise<T>) => Promise<T> {
+  let queue = Promise.resolve()
+  return work => {
+    const job = queue.then(work)
+    queue = job.then(() => undefined, () => undefined)
+    return job
+  }
+}
+
+async function keep(put: () => Promise<void>) {
+  try { await put() } catch (err) { console.warn('managed: pretty-print cache write failed:', err) }
+}
+
+// A copy kept, or null where none is.
+async function kept(open: () => Promise<OpenedBlob>): Promise<OpenedBlob | null> {
+  try { return await open() }
+  catch (err) { if (err instanceof CacheMissError) return null; throw err }
+}
+
+// A side's files that can be formatted, with their texts, and every one of
+// its files' hashes by path, from their paths and contents: texts, or bytes,
+// read as text where they are.
+async function sideFiles(entries: Iterable<[string, string | Uint8Array]>): Promise<Pick<ComparedSide, 'files' | 'hashes'>> {
+  const files: ComparedSide['files'] = [], hashes = new Map<string, string>()
+  for (const [path, content] of entries) {
+    const hash = await computeFileHash(content)
+    hashes.set(path, hash)
+    const extension = prettyExtension(path)
+    if (extension === null || (typeof content === 'string' ? Buffer.byteLength(content) : content.byteLength) > MAX_PRETTY_BYTES) continue
+    const text = typeof content === 'string' ? content : npmFileText(content)
+    if (text !== null) files.push({ path, hash, extension, text })
+  }
+  return { files, hashes }
+}
+
+// A bundle's side, from its details: its files, as sideFiles reads them,
+// within a reason `scope` as Compare reads them there (bundleCompareFiles),
+// and its packages' directories.
+async function bundleSide(details: Parameters<typeof bundlePackageDirs>[0], scope: string): Promise<Pick<ComparedSide, 'files' | 'hashes' | 'packageDirs'>> {
+  const scoped = scope ? new Set(bundleCompareFiles(details, scope).keys()) : null, sources = bundleSourcesAsMap(details)
+  return { ...await sideFiles(scoped ? [...sources].filter(([path]) => scoped.has(path)) : sources), packageDirs: bundlePackageDirs(details) }
+}
+
+// A version's files by path, from one load of them.
+async function npmFiles(doc: NpmVersionDocument): Promise<Array<[string, Uint8Array]>> {
+  const load = loadNpmFiles(doc)
+  try { return (await load.result).map(({ path, bytes }) => [path, bytes]) }
+  finally { load.release() }
+}
+
+// Removes the public npm copies of every version before PRETTY_VERSION, which
+// nothing reads any more, for maintenance: once a process, again where
+// removing them failed. A bundle's earlier copies go with the bundle.
+export function stalePrettyRemover(npm: CacheStorage): (signal?: AbortSignal) => Promise<void> {
+  let removed = false
+  return async signal => {
+    if (removed) return
+    for (let version = 1; version < PRETTY_VERSION; version++) {
+      if (signal?.aborted) return
+      await npm.delete(`pretty-v${version}`)
+    }
+    removed = true
+  }
+}
+
+export function createPrettyCache(bundles: BundleCacheStorage, npm: CacheStorage, db: Pick<ManagedDb, 'getBundle'>, store: BundleStore) {
+  // Copies being made; readers asking for one meanwhile share it.
+  const shared = sharing<Buffer>()
+  // Bundles are read one at a time: reading one decodes all of it.
+  const enqueue = serial()
+  function bundleDetails(record: ManagedBundle) {
+    return enqueue(async () => {
+      const details = await readBundleDetails(record, store)
+      if (!details) throw new PrettyError(422, 'bundle-unavailable')
+      return details
+    })
+  }
+  // A bundle's file pretty-printed from the text `read` reads, and kept in
+  // its cache.
+  function bundleCopy(record: ManagedBundle, request: PrettyRequest, read: () => Promise<string>): Promise<Buffer> {
+    const file = prettyFile(request)
+    return shared(`bundle ${record.id} ${file}`, async () => {
+      const body = await prettyBody(await read(), request.extension)
+      // As for its metadata (bundle-cache.ts): a bundle deleted meanwhile
+      // keeps no copy, nor does one deleted while it was written.
+      if (!await db.getBundle(record.id)) throw new PrettyError(404, 'no-bundle')
+      await keep(() => bundles.put(record.id, file, body))
+      if (!await db.getBundle(record.id)) {
+        await bundles.delete(record.id)
+        throw new PrettyError(404, 'no-bundle')
+      }
+      return body
+    })
+  }
+  // A version's file pretty-printed, `read` reading its text (and checking
+  // it is the file named): from the copy kept for a public version, else
+  // made, and kept for a public one.
+  async function npmCopy(doc: NpmVersionDocument, request: PrettyRequest, read: () => Promise<string>): Promise<OpenedBlob> {
+    const file = prettyFile(request)
+    if (!doc.private) {
+      try { return await npm.open(file) }
+      catch (err) { if (!(err instanceof CacheMissError)) throw err }
+    }
+    return opened(await shared(doc.private ? `npm ${doc.dist.integrity} ${file}` : `npm ${file}`, async () => {
+      const body = await prettyBody(await read(), request.extension)
+      if (!doc.private) await keep(() => npm.put(file, body))
+      return body
+    }))
+  }
+  return {
+    async bundle(record: ManagedBundle, request: PrettyRequest): Promise<OpenedBlob> {
+      const copy = await kept(() => bundles.open(record.id, prettyFile(request)))
+      if (copy) return copy
+      return opened(await bundleCopy(record, request, async () => {
+        const text = bundleSourcesAsMap(await bundleDetails(record)).get(request.path)
+        if (text === undefined) throw new PrettyError(404, 'no-file')
+        if (await computeFileHash(text) !== request.hash) throw new PrettyError(409, 'hash-mismatch')
+        return text
+      }))
+    },
+    // The version's file, from its files loaded as the viewer's are (and
+    // held to the same few loads at once).
+    npm(doc: NpmVersionDocument, request: PrettyRequest): Promise<OpenedBlob> {
+      return npmCopy(doc, request, async () => {
+        const load = loadNpmFiles(doc)
+        let text: string | null
+        try {
+          const bytes = (await load.result).find(entry => entry.path === request.path)?.bytes
+          if (!bytes) throw new PrettyError(404, 'no-file')
+          if (await computeFileHash(bytes) !== request.hash) throw new PrettyError(409, 'hash-mismatch')
+          text = npmFileText(bytes)
+        } finally { load.release() }
+        if (text === null) throw new PrettyError(422, 'unformattable')
+        return text
+      })
+    },
+    // Every file of the version that needs pretty-printing (npmPrintable),
+    // read before this resolves; then, as they are iterated, each
+    // pretty-printed as `npm` has it, one after another.
+    async npmAll(doc: NpmVersionDocument): Promise<AsyncGenerator<PrettyLine>> {
+      const files = await npmPrintable(doc)
+      return (async function* () {
+        for (const { text, ...request } of files) yield await prettyLine(request, () => npmCopy(doc, request, () => Promise.resolve(text)))
+      })()
+    },
+    // Two bundles' sides, or two versions', as a comparison reads them, read
+    // before this resolves: for the files that changed between them
+    // pretty-printed (compared), and their diffs with renamed names hidden
+    // (rename-diff.ts renamedPairs); a bundle's within a reason `scope`
+    // where one is asked for, as Compare reads it then.
+    async bundleSides(base: ManagedBundle, other: ManagedBundle, scope = ''): Promise<[ComparedSide, ComparedSide]> {
+      const sideOf = async (record: ManagedBundle, side: Side): Promise<ComparedSide> => ({ side, ...await bundleSide(await bundleDetails(record), scope),
+        kept: request => kept(() => bundles.open(record.id, prettyFile(request))),
+        made: async (request, text) => opened(await bundleCopy(record, request, () => Promise.resolve(text))) })
+      return [await sideOf(base, 'base'), await sideOf(other, 'other')]
+    },
+    async npmSides(base: NpmVersionDocument, other: NpmVersionDocument): Promise<[ComparedSide, ComparedSide]> {
+      const sideOf = async (doc: NpmVersionDocument, side: Side): Promise<ComparedSide> => ({ side, ...await sideFiles(await npmFiles(doc)), packageDirs: null,
+        kept: request => (doc.private ? Promise.resolve(null) : kept(() => npm.open(prettyFile(request)))),
+        made: (request, text) => npmCopy(doc, request, () => Promise.resolve(text)) })
+      return [await sideOf(base, 'base'), await sideOf(other, 'other')]
+    },
+  }
+}
+export type PrettyCache = ReturnType<typeof createPrettyCache>

package/server-managed/public-workspace.ts

@@ -0,0 +1,220 @@
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import { pipeline } from 'node:stream/promises'
+import { Buffer } from 'node:buffer'
+import type { ManagedHttpDeps } from './http.ts'
+import type { ManagedBundle } from './db.ts'
+import type { OpenedBlob } from './blob-store.ts'
+import type { WorkspaceShareSnapshot } from './workspace-shares.ts'
+import { sendJson, sendLines, writeResponse } from './http-response.ts'
+import { hashToken } from './crypto.ts'
+import { TeamReportsError, loadTeamAnnotations, loadTeamReportsResponse, teamReportVisibility } from './team-reports.ts'
+import { triageWireEntry } from './triage-response.ts'
+import { MAX_PACKAGE_INVENTORY_BYTES } from './bundle-cache.ts'
+import { backfillBundleSummaries, bundleSummaries } from './bundle-catalog.ts'
+import { ADVISORIES_TIMEOUT_MS, fetchBundleAdvisories } from './bundle-advisories.ts'
+import { auditCache, auditedRepos } from './upstream-cache.ts'
+import { serveTeamFeed } from './team-feed.ts'
+import { type ComparedSide, PrettyError, compared, prettyRequest, prettyText } from './pretty-print.ts'
+import { renameDiffOf, renameDiffRequest, renamedPairs } from './rename-diff.ts'
+import { typeOnlyFiles } from './type-only.ts'
+import { sharedTeamApp } from './team-app.ts'
+
+function json(res: ServerResponse, status: number, body: unknown): void {
+  sendJson(res, status, body, { 'cache-control': 'private, no-store', 'referrer-policy': 'no-referrer' })
+}
+
+// Called before ALL other routing, including OAuth, discovery, static and the
+// combined server fallback. A supplied capability never inherits cookie auth.
+export async function handlePublicWorkspace(req: IncomingMessage, res: ServerResponse, deps: ManagedHttpDeps, url: URL): Promise<void> {
+  const token = req.headers['x-deepview-share']
+  if (!deps.config.allowShare || typeof token !== 'string' || !/^[A-Za-z0-9_-]{43}$/u.test(token)) {
+    json(res, 401, { error: 'invalid-share' }); return
+  }
+  const method = req.method ?? 'GET'
+  if (method !== 'GET' && method !== 'HEAD') { json(res, 403, { error: 'share-read-only' }); return }
+  const shareRoute = /^\/api\/shares\/([A-Za-z0-9_-]+)\/workspace$/u.exec(url.pathname)
+  const teamRoute = /^\/api\/teams\/([^/]+)\/(shared|reports|feed|annotations)$/u.exec(url.pathname)
+  const reportRoute = /^\/api\/reports\/([^/]+)\/(triage|comments|sources)$/u.exec(url.pathname)
+  const bundleRoute = /^\/api\/bundles\/([^/]+)\/(metadata|contents|download|advisories|pretty|rename-diff|type-only)$/u.exec(url.pathname)
+  if (!shareRoute && !teamRoute && !reportRoute && !bundleRoute) { json(res, 403, { error: 'share-scope-required' }); return }
+  const tokenHash = hashToken(token)
+  const snapshot = await deps.db.getWorkspaceShare(tokenHash)
+  if (!snapshot) { json(res, 401, { error: 'invalid-share' }); return }
+  const recheck = async () => {
+    const current = deps.config.allowShare && await deps.db.getWorkspaceShare(tokenHash)
+    if (!current || JSON.stringify(current) !== JSON.stringify(snapshot)) throw new TeamReportsError(404, 'workspace-changed')
+  }
+  const send = async (body: unknown) => { await recheck(); json(res, 200, body) }
+  const sendTeam = async () => {
+    const [summaries, app] = await Promise.all([bundleSummaries(snapshot.team.bundles, deps.bundleCache), sharedTeamApp(deps.db, deps.reportStore, snapshot)])
+    await send({ user: snapshot.user, team: { ...snapshot.team, app,
+      bundles: snapshot.team.bundles.map(bundle => ({ ...bundle, ...(summaries.get(bundle.integrity) ?? { summary: null, summaryRetryAt: null }) })),
+    } })
+    await backfillBundleSummaries(snapshot.team.bundles, deps.bundleCache)
+  }
+  const stream = async (stored: OpenedBlob, encoding: string | null, contentType = 'application/json') => {
+    try { await recheck() } catch (error) { stored.stream.destroy(); throw error }
+    res.writeHead(200, { 'content-type': contentType, 'cache-control': 'private, no-store',
+      'x-content-type-options': 'nosniff', ...(encoding ? { 'content-encoding': encoding } : {}),
+      ...(stored.size == null ? {} : { 'content-length': String(stored.size) }),
+    })
+    if (method === 'HEAD') { stored.stream.destroy(); res.end(); return }
+    try { await pipeline(stored.stream, res) } catch { res.destroy() }
+  }
+  if (url.searchParams.has('team') && (url.searchParams.getAll('team').length !== 1 || url.searchParams.get('team') !== snapshot.teamId)) {
+    json(res, 404, { error: 'no-team' }); return
+  }
+  if (shareRoute) {
+    // The short hash is a recognizable link ID, never an access grant. Resolve
+    // with the full token so colliding IDs or slugs cannot broaden its scope.
+    // Existing links used the team ID as their fragment prefix.
+    if (shareRoute[1] !== tokenHash.slice(0, 8) && shareRoute[1] !== snapshot.teamId) {
+      json(res, 404, { error: 'no-share' }); return
+    }
+    await sendTeam(); return
+  }
+  if (teamRoute) {
+    if (teamRoute[1] !== snapshot.teamId) { json(res, 404, { error: 'no-team' }); return }
+    if (teamRoute[2] === 'feed') {
+      if (method !== 'GET') { json(res, 405, { error: 'method-not-allowed' }); return }
+      await serveTeamFeed(res, deps, snapshot, recheck, { readState: () => deps.db.getWorkspaceShareFeedState(tokenHash) }); return
+    }
+    if (teamRoute[2] === 'annotations') {
+      await send(await loadTeamAnnotations(deps.db, deps.reportStore, snapshot, url.searchParams.get('reportId'))); return
+    }
+    if (teamRoute[2] === 'shared') { await sendTeam(); return }
+    const body = await loadTeamReportsResponse(deps.db, deps.reportStore, snapshot)
+    await recheck()
+    res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'private, no-store', 'referrer-policy': 'no-referrer' })
+    writeResponse(res, body); return
+  }
+  if (reportRoute) {
+    const id = reportRoute[1]!, part = reportRoute[2]!
+    if (!snapshot.reports.some(report => report.id === id)) { json(res, 404, { error: 'no-report' }); return }
+    const visible = await teamReportVisibility(deps.db, deps.reportStore, snapshot, id)
+    await recheck()
+    if (part === 'sources') { await sources(res, deps, snapshot, id, visible.sourcePaths, recheck, stream); return }
+    if (part === 'comments') { await send({ comments: await deps.db.listComments([...visible.ids]) }); return }
+    const entries = Object.fromEntries((await deps.db.listTriage([...visible.ids])).map(row => [row.findingId, triageWireEntry(row)]))
+    await send({ entries }); return
+  }
+  const bundle = snapshot.bundles.find(item => item.id === bundleRoute![1])
+  if (!bundle) { json(res, 404, { error: 'no-bundle' }); return }
+  if (bundleRoute![2] === 'advisories' && !snapshot.permissions.security) { json(res, 403, { error: 'security-access-required' }); return }
+  if (bundleRoute![2] === 'rename-diff' || bundleRoute![2] === 'type-only' || (bundleRoute![2] === 'pretty' && url.searchParams.has('other'))) {
+    if (method !== 'GET') { json(res, 405, { error: 'method-not-allowed' }); return }
+    await serveCompared(res, deps, bundle, snapshot.bundles.find(item => item.id === url.searchParams.get('other')), bundleRoute![2], url, recheck, stream); return
+  }
+  await serveBundle(res, deps, bundle, bundleRoute![2]!, url, recheck, stream)
+}
+
+// What a bundle is compared with `other`, another of the link's bundles, by:
+// one of their JavaScript files diffed with renamed names hidden, or the
+// files that changed between them, or the pairs of those, or those that
+// changed in types alone, a line each.
+function serveCompared(res: ServerResponse, deps: ManagedHttpDeps, bundle: ManagedBundle, other: ManagedBundle | undefined, part: string, url: URL,
+  recheck: () => Promise<void>, stream: (stored: OpenedBlob, encoding: string | null, contentType?: string) => Promise<void>) {
+  if (part === 'rename-diff' && url.searchParams.has('path')) return serveRenameDiff(res, deps, bundle, other, url, stream)
+  return serveChanges(res, deps, bundle, other, recheck, part === 'pretty' ? compared : part === 'type-only' ? typeOnlyFiles : renamedPairs,
+    part === 'pretty' ? '' : url.searchParams.get('scope') ?? '')
+}
+
+// One of a bundle's JavaScript files diffed with one of `other`, another of
+// the link's bundles (rename-diff.ts).
+async function serveRenameDiff(res: ServerResponse, deps: ManagedHttpDeps, bundle: ManagedBundle, other: ManagedBundle | undefined, url: URL,
+  stream: (stored: OpenedBlob, encoding: string | null, contentType?: string) => Promise<void>) {
+  const request = renameDiffRequest(url.searchParams)
+  if (!request) { json(res, 400, { error: 'bad-file' }); return }
+  if (!other) { json(res, 404, { error: 'no-bundle' }); return }
+  const { prettyCache } = deps
+  if (!prettyCache) { json(res, 503, { error: 'unavailable' }); return }
+  let diff
+  try {
+    diff = await renameDiffOf(request, async () => [await prettyText(await prettyCache.bundle(bundle, request.base)),
+      await prettyText(await prettyCache.bundle(other, request.other))])
+  } catch (err) {
+    if (err instanceof PrettyError) { json(res, err.status, { error: err.message }); return }
+    throw err
+  }
+  await stream(diff, 'br')
+}
+
+// The files that changed between a bundle and `other`, another of the link's
+// bundles, both sides' pretty-printed (pretty-print.ts compared), or the pairs
+// of them its viewer diffs with renamed names hidden (rename-diff.ts
+// renamedPairs), those within a reason `scope` where given, the link checked
+// again before each line.
+async function serveChanges(res: ServerResponse, deps: ManagedHttpDeps, bundle: ManagedBundle, other: ManagedBundle | undefined, recheck: () => Promise<void>,
+  linesOf: (sides: [ComparedSide, ComparedSide]) => AsyncIterable<unknown>, scope: string) {
+  if (!other) { json(res, 404, { error: 'no-bundle' }); return }
+  if (!deps.prettyCache) { json(res, 503, { error: 'unavailable' }); return }
+  let lines
+  try { lines = linesOf(await deps.prettyCache.bundleSides(bundle, other, scope)) }
+  catch (err) {
+    if (err instanceof PrettyError) { json(res, err.status, { error: err.message }); return }
+    throw err
+  }
+  await recheck()
+  await sendLines(res, lines, () => recheck().then(() => true, () => false))
+}
+
+async function serveBundle(res: ServerResponse, deps: ManagedHttpDeps, bundle: ManagedBundle, part: string, url: URL,
+  recheck: () => Promise<void>, stream: (stored: OpenedBlob, encoding: string | null, contentType?: string) => Promise<void>) {
+  if (part === 'download') {
+    const stored = await deps.bundleStore.open(bundle.id, bundle.kind)
+    if (!stored) { json(res, 503, { error: 'unavailable' }); return }
+    await stream(stored, bundle.kind === 'sourcemap' ? 'br' : null, 'application/octet-stream'); return
+  }
+  if (part === 'pretty') {
+    const file = prettyRequest(url.searchParams)
+    if (!file) { json(res, 400, { error: 'bad-file' }); return }
+    if (!deps.prettyCache) { json(res, 503, { error: 'unavailable' }); return }
+    let pretty
+    try { pretty = await deps.prettyCache.bundle(bundle, file) }
+    catch (err) {
+      if (err instanceof PrettyError) { json(res, err.status, { error: err.message }); return }
+      throw err
+    }
+    await stream(pretty, 'br', 'text/plain; charset=utf-8'); return
+  }
+  if (!deps.bundleCache) { json(res, 503, { error: 'unavailable' }); return }
+  if (part === 'advisories') {
+    if (bundle.kind !== 'stasis') { json(res, 422, { error: 'unsupported-bundle' }); return }
+    const inventory = await deps.bundleCache.advisoryInventory(bundle, url.searchParams.get('reason') ?? '')
+    await recheck()
+    if (inventory === null) { json(res, 413, { error: 'payload-too-large' }); return }
+    if (inventory === undefined) { json(res, 400, { error: 'unknown-reason' }); return }
+    if (Buffer.byteLength(JSON.stringify(inventory)) > MAX_PACKAGE_INVENTORY_BYTES) { json(res, 413, { error: 'payload-too-large' }); return }
+    const signal = AbortSignal.timeout(ADVISORIES_TIMEOUT_MS)
+    const repoAdvisories = url.searchParams.get('repoAdvisories') === 'true'
+    const result = await fetchBundleAdvisories(inventory.packages, signal, {
+      debug: deps.config.debug, repoAdvisories, details: url.searchParams.get('details') === 'true',
+      cache: auditCache(deps.config.upstreamCacheDir, deps.db, signal, deps.config.debug, auditedRepos(inventory.packages, repoAdvisories)),
+    })
+    await recheck()
+    json(res, result.status, result.status === 200 ? { ...inventory, advisories: result.body } : result.body); return
+  }
+  let cached
+  try { cached = await deps.bundleCache.open(bundle, part as 'metadata' | 'contents') }
+  catch { json(res, 422, { error: 'bundle-unavailable' }); return }
+  await stream(cached, 'br')
+}
+
+async function sources(res: ServerResponse, deps: ManagedHttpDeps, snapshot: WorkspaceShareSnapshot,
+  id: string, paths: Set<string>, recheck: () => Promise<void>, stream: (stored: OpenedBlob, encoding: string | null) => Promise<void>) {
+  const report = await deps.db.getReport(id)
+  const bundle = report?.bundleId ? await deps.db.getBundle(report.bundleId) : null
+  const empty = async () => { await recheck(); res.writeHead(204, { 'cache-control': 'private, no-store' }); res.end() }
+  if (!report || !bundle || !['stasis', 'sourcemap'].includes(bundle.kind ?? '') || bundle.repoId !== report.repoId) { await empty(); return }
+  if (!deps.reportSourcesCache) { json(res, 503, { error: 'unavailable' }); return }
+  let cached
+  try { cached = await deps.reportSourcesCache.open(report, bundle, snapshot.permissions, paths) }
+  catch { await empty(); return }
+  if (!cached) { await empty(); return }
+  const current = await deps.db.getReport(id), currentBundle = await deps.db.getBundle(bundle.id)
+  if (JSON.stringify(current) !== JSON.stringify(report) || JSON.stringify(currentBundle) !== JSON.stringify(bundle)
+      || snapshot.reports.find(item => item.id === id)?.repo.github !== cached.repo.github) {
+    cached.stream.destroy(); throw new TeamReportsError(404, 'workspace-changed')
+  }
+  await stream(cached, 'gzip')
+}

package/server-managed/rename-diff-worker.js

@@ -0,0 +1,26 @@
+// Compare's diff with renamed names hidden (rename-diff.ts), worked out off the
+// server's event loop by @preventive/compare's renamedDiffs: the old side given
+// the new side's names, formatted again where that changes its layout alone,
+// diffed with whitespace changes shown and hidden, and the blocks checked to
+// take it to the new side. `{ before, blocks, reason, reads, marks,
+// ignoringWhitespace }`: the old side as diffed, the change blocks, why the
+// old side is as it was where its names could not be given safely, the
+// properties through which either side reads names (a view marks renamed
+// lines rather than hiding them where any are read, as a rename may then
+// change what the code does), and the blocks of the diff of the files as they
+// are that differ in renamed names alone; `ignoringWhitespace` the blocks and
+// those marked with whitespace changes hidden, as diff -b hides them. Blocks
+// that would not take the old side to the new are thrown, and so answer
+// nothing.
+import { parentPort, workerData } from 'node:worker_threads'
+import { renamedDiffs } from '@preventive/compare/names.js'
+
+const { before, after, extension, otherExtension } = workerData
+const diff = await renamedDiffs(before, after, { extension, otherExtension, whitespace: ['none', 'change'] })
+// A check that should never fail did, or a step gave way: told, the file shown with its names.
+for (const warning of diff.warnings) console.warn(`managed: rename diff: ${warning}`)
+const [shown, hidden] = diff.diffs
+const answer = { before: diff.before, blocks: shown.blocks, reason: diff.reason, reads: diff.reads, marks: shown.marks, ignoringWhitespace: { blocks: hidden.blocks, marks: hidden.marks } }
+// Node worker messages have no browser target origin.
+// oxlint-disable-next-line unicorn/require-post-message-target-origin
+parentPort.postMessage(answer)