[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_106":107,"_108":109},"routes/embed.x.$handle.$name.$",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":-5},"handle","mcpconformance","name","mcp-client-conformance","path","src/hosted/server.ts","project",{"_22":49,"_11":12,"_35":50,"_51":-5,"_52":44,"_53":54,"_55":54,"_56":-5,"_57":-5,"_58":59,"_60":61,"_62":34,"_63":-5,"_64":-5,"_65":66,"_67":68,"_69":-5,"_70":-5,"_71":-5,"_72":-5,"_73":74,"_75":74,"_76":77,"_78":77,"_79":77,"_80":74,"_81":74,"_82":83,"_84":85,"_86":87,"_88":44},"file",{"_22":23,"_11":24,"_25":26,"_27":28,"_29":30,"_31":32,"_33":34,"_35":36,"_37":38,"_39":40,"_41":42,"_43":44,"_45":-5,"_13":46},"permalink","https://www.val.town/x/mcpconformance/mcp-client-conformance/code/src/hosted/server.ts","extension","id","97b04a4b-cfdd-433a-a9e5-aa7f8335219e","server.ts","fileId","d2f92186-ad13-11f1-b27a-1607ee4eb77e","parentId","11abc952-e3be-41e6-ac33-6929c3af1284","branchId","fdc11199-683b-41f1-a3c5-d5ac53972f86","branchVersion",385,"latest",true,"createdAt",["D",1789379123067],"version",21,"fileType","script","content","/**\n * Hosted conformance server — direct-mount, no loopback proxy.\n *\n * One run exercises the whole matrix: every client scenario at every\n * specification revision that ships a requirement set (see ./matrix.ts).\n *\n * GET / Landing page: the static matrix\n * GET /scenarios JSON rows with per-revision cells\n * GET /s Mint a run id → 303 /s/\n * GET /s/ Config for every startable cell;\n * as HTML, the run page with each\n * URL's live status\n * GET /s//bulk Every client's config for every\n * cell, and the run's matrix\n * GET /s// … for one revision (a column)\n * GET /s/// … for one cell\n * ALL /s///[/]\n * The cell's server. Its MCP\n * endpoint is the cell URL plus\n * /mcp, whatever the scenario's\n * own mcpPath (see MCP_PATH).\n * GET /results/[/[/]]\n * Results, mirroring /s; a run or\n * column also as `?format=md`\n * POST /results//freeze Freeze the run's report → its\n * snapshot (303 for a browser)\n * GET /results//snapshot/ A frozen report (html/json/md)\n * DELETE /results/ Tear down every cell of the run,\n * and its snapshots\n *\n * Config and results answer HTML when the request prefers text/html and JSON\n * otherwise; `?format=html|json` overrides. At a cell URL a GET that accepts\n * text/html (and not text/event-stream) or carries `?format=` is a page\n * request; every other request is dispatched to the scenario.\n *\n * Scenarios are mounted via Scenario.handler() — the same RequestListener the\n * CLI runner wraps in http.createServer — so there is no loopback port and\n * this works on serverless hosts. Each cell gets a fresh Scenario instance,\n * created lazily on first hit, built for the column's wire version.\n */\n\nimport express, { Request, Response } from 'npm:express@^5.1.0';\nimport { timingSafeEqual } from 'node:crypto';\nimport {\n SessionManager,\n HostedRun,\n CellRef,\n RUN_ID_RE,\n UnknownScenarioError,\n NotHostableError,\n StoreUnavailableError,\n cellId,\n mintId,\n mintRunId,\n loadAllCells,\n loadCells,\n parseCellId\n} from './session.ts';\nimport {\n ROOT_PRM_PATH,\n ROOT_PRM_WINDOW_MS,\n rootPrmAmbiguousCheck,\n rootPrmAttributedCheck,\n rootPrmUnattributed,\n requesterHasher\n} from './root-prm.ts';\nimport {\n buildMatrix,\n MCP_PATH,\n type HostedMatrix,\n type MatrixCell\n} from './matrix.ts';\nimport {\n bodyFitsBuffer,\n declaresNoBody,\n onAnyBody,\n onBodySettled,\n tapJsonBody\n} from './body.ts';\nimport {\n capped,\n connectionOf,\n issuedBy,\n keptRequestHeaders,\n keptResponseHeaders,\n refusalBody,\n refusedCredential,\n rpcOf,\n redacted,\n connectionNumbers,\n jsonLine,\n type Exchange\n} from './traffic.ts';\n\n/** The response headers an exchange keeps (see keptResponseHeaders()). */\nconst RESPONSE_HEADERS = [\n 'content-type',\n 'www-authenticate',\n 'location',\n 'allow',\n 'mcp-session-id',\n 'mcp-protocol-version'\n];\nimport { identityFrom } from './identity.ts';\nimport { isStatefulVersion } from '../connection/versions.ts';\nimport {\n answeredVersion,\n authLayerStop,\n authStopCheck,\n describeRequest,\n discoverReply,\n asksForInput,\n getOnMcpCheck,\n GET_ON_MCP_REPLY,\n isAcceptedInitialize,\n isLegacyProbe,\n isLoneDiscover,\n isModernProbe,\n isUnparseable,\n legacyAnswer,\n legacyInitializeReply,\n legacyProbeCheck,\n modernProbeCheck,\n PARSE_ERROR_REPLY,\n pinInitializeVersion,\n refusalOf,\n reachedRevision,\n revisionReachedCheck,\n revisionSpokenCheck,\n spokeRevision,\n tapResponse,\n unparseableBodyCheck,\n versionAnswer,\n versionOfferedCheck,\n wireRejectedCheck,\n wireRejection,\n wrongRevision,\n wrongRevisionCheck,\n type CapturedResponse,\n type RequestInfo\n} from './wire.ts';\nimport type { CellPageData, EarlierSummary } from './cell-page.ts';\nimport { identitiesIn } from './identity.ts';\nimport { REACHED } from './markdown.ts';\nimport {\n buildReport,\n reportJson,\n summarize,\n viewCell,\n withNotTriedHints,\n type CellState,\n type ReportSources,\n type RunReport,\n type Verdict\n} from './report.ts';\nimport { runLive } from './run-status.ts';\nimport { parseComposite } from './composite.ts';\nimport { createCompositeRoute } from './composite-route.ts';\nimport { MemoryRunStore, type RunStore, type SnapshotInfo } from './store.ts';\nimport { reportMarkdown, reportText } from './markdown.ts';\nimport { jsonRows, type ShownCheck } from './shown.ts';\nimport { hostedScenarios } from './catalog.ts';\nimport { buildInfo, type BuildInfo } from './build.ts';\nimport { ConformanceCheck, AuxOriginRole, SpecVersion } from '../types.ts';\n\n/**\n * The page renderers, loaded with the first page anyone asks for. A client's\n * MCP request, a discover included, never renders one, and ./html brings the\n * step descriptions (and zod) with it.\n */\nconst pages = () => import('./html.ts');\nconst cellPages = () => import('./cell-page.ts');\n\n/** A cell's traffic as JSON lines, under its results path. */\nconst TRAFFIC_SUFFIX = '/traffic.jsonl';\n\n/** A reached cell's page as a frozen copy stores it. */\ntype FrozenCell = CellPageData & { frozenAt: string };\n\n/** The run page and the bulk page, loaded the same way (see pages). */\nconst runPages = () => import('./run-page.ts');\n\n/** `/s//bulk`: every client's config for every cell of the run. */\nconst BULK = 'bulk';\n\nexport interface HostedServerOptions {\n publicOrigin?: string;\n ttlMs?: number;\n /**\n * Public origins of the AS/IdP relay deployments. When set, scenarios that\n * implement `authHandlers()` become startable; their per-cell AS issuer is\n * `/r///`. See\n * examples/hosted/valtown-relay.ts.\n */\n auxOrigins?: Partial>;\n /**\n * Shared secret the relay sends in `x-relay-secret`. `/__aux/*` rejects\n * requests without it so the aux backchannel can't be hit directly. Set\n * the same value in the relay's env.\n */\n relaySecret?: string;\n /**\n * Persist runs so a deployment that load-balances one run's requests\n * across processes (serverless isolates) still serves complete results.\n * See ./store.ts. Omit for a single long-lived process.\n */\n store?: RunStore;\n /**\n * Scenarios this deployment refuses to mount, with the reason shown in\n * the matrix (e.g. scenarios that need one process's memory across\n * requests on a host that has none).\n */\n exclude?: Record;\n /**\n * The build to show on every page and record in each report. Defaults to\n * the deploy's stamp (./build-stamp.ts), else \"unknown\"; the local\n * `hosted` command passes the checkout's git commit.\n */\n build?: BuildInfo;\n /**\n * The clock a cell's quiet time is read by (ms since the epoch): a waiting\n * cell whose client has been silent for STOPPED_AFTER_MS reads stopped.\n * Defaults to Date.now; tests pass a fake one.\n */\n clock?: () => number;\n}\n\nconst AUX_ROLES: readonly AuxOriginRole[] = ['as', 'as2', 'idp'];\n\n/** Snapshot ids are minted like run ids (see mintId()), shorter. */\nconst SNAPSHOT_ID_RE = /^[0-9a-z]{1,32}$/;\n\n/** Cell config as served under /s/[/[/]]. */\nexport interface CellConfig {\n scenario: string;\n revision: SpecVersion;\n /** The MCP endpoint URL — what the client under test connects to. */\n url: string;\n resultsUrl: string;\n scoring: MatrixCell['scoring'];\n reason?: string;\n steps?: MatrixCell['steps'];\n env: {\n MCP_CONFORMANCE_SCENARIO: string;\n MCP_CONFORMANCE_PROTOCOL_VERSION: string;\n MCP_CONFORMANCE_CONTEXT?: string;\n };\n}\n\nexport interface RunConfig {\n runId: string;\n revision?: SpecVersion;\n scenario?: string;\n resultsUrl: string;\n mcpServers: Record;\n cells: CellConfig[];\n}\n\nexport function createHostedApp(opts: HostedServerOptions = {}): {\n app: express.Application;\n sessions: SessionManager;\n matrix: HostedMatrix;\n} {\n const auxOrigins = opts.auxOrigins ?? {};\n const build = opts.build ?? buildInfo();\n const clock = opts.clock ?? Date.now;\n const haveAux = AUX_ROLES.filter((r) => auxOrigins[r]);\n const sessions = new SessionManager({\n ttlMs: opts.ttlMs,\n auxOrigins,\n store: opts.store\n });\n const matrix = buildMatrix({ auxOrigins, exclude: opts.exclude });\n // Frozen reports live in the run store, so any isolate can serve a\n // permalink; a single process without one keeps them in memory.\n const snapshots: RunStore = opts.store ?? new MemoryRunStore();\n const revisions: readonly string[] = matrix.revisions;\n const app = express();\n // Copy JSON POST bodies as they flow so the report can name the client\n // (initialize params / per-request _meta) without consuming the stream\n // the scenario is about to read.\n app.use(tapJsonBody());\n\n // Who sent a request, for the origin-root metadata (./root-prm.ts): a\n // keyed hash of the client's address, the same in every process that\n // shares the relay secret.\n const requesterOf = requesterHasher(\n opts.relaySecret ?? process.env.CONFORMANCE_RELAY_SECRET\n );\n\n function origin(req: Request): string {\n if (opts.publicOrigin) return opts.publicOrigin;\n const proto = (req.header('x-forwarded-proto') ?? req.protocol) || 'http';\n const host = req.header('x-forwarded-host') ?? req.header('host');\n return `${proto}://${host}`;\n }\n\n const cellBaseUrl = (req: Request, ref: CellRef) =>\n `${origin(req)}/s/${cellId(ref)}`;\n const resultsUrlFor = (req: Request, ...parts: string[]) =>\n `${origin(req)}/results/${parts.join('/')}`;\n\n /**\n * Path segments of a captured route tail. A trailing slash (`/s//`,\n * `/results///`) is not a segment: without this it would read\n * as an empty revision or scenario name and 404.\n */\n function segmentsOf(tail: string): string[] {\n // A loop, not /\\/+$/: that regex backtracks polynomially on\n // request-controlled input (CodeQL js/polynomial-redos).\n while (tail.endsWith('/')) tail = tail.slice(0, -1);\n return tail.split('/');\n }\n\n /**\n * Longest registered scenario name that prefixes `segments` (names may\n * contain '/'), plus whatever follows it as a path suffix ('' if nothing).\n * Matches every registered client scenario, not only startable ones, so a\n * cell that cannot start still answers with its reason.\n */\n function resolveScenario(\n segments: string[]\n ): { scenarioName: string; suffix: string } | undefined {\n for (let i = segments.length; i >= 1; i--) {\n const candidate = segments.slice(0, i).join('/');\n if (hostedScenarios.has(candidate)) {\n return {\n scenarioName: candidate,\n suffix: i < segments.length ? '/' + segments.slice(i).join('/') : ''\n };\n }\n }\n return undefined;\n }\n\n interface ResolvedCell {\n ref: CellRef;\n cell: MatrixCell;\n suffix: string;\n }\n\n /**\n * Resolve `[, , , ]` to a startable\n * cell, or answer the request with why it isn't one and return undefined.\n */\n function resolveCell(\n segments: string[],\n res: Response\n ): ResolvedCell | undefined {\n const [runId, revision, ...rest] = segments;\n if (!RUN_ID_RE.test(runId ?? '')) {\n res.status(400).json({ error: 'invalid run-id' });\n return undefined;\n }\n if (!revisions.includes(revision ?? '')) {\n res\n .status(404)\n .json({ error: `unknown revision '${revision ?? ''}'`, revisions });\n return undefined;\n }\n const resolved = resolveScenario(rest);\n if (!resolved) {\n res.status(404).json({ error: `unknown scenario '${rest.join('/')}'` });\n return undefined;\n }\n const cell = matrix.cell(resolved.scenarioName, revision)!;\n if (!checkStartable(cell, res)) return undefined;\n return {\n ref: {\n runId,\n revision: revision as SpecVersion,\n scenarioName: resolved.scenarioName\n },\n cell,\n suffix: resolved.suffix\n };\n }\n\n /** 404 for n/a cells, 501 for cells this deployment cannot start. */\n function checkStartable(cell: MatrixCell, res: Response): boolean {\n if (cell.scoring === 'n/a') {\n res.status(404).json({\n error: `scenario '${cell.scenario}' does not apply to ${cell.revision}: ${cell.reason}`,\n scenario: cell.scenario,\n revision: cell.revision,\n scoring: cell.scoring,\n reason: cell.reason\n });\n return false;\n }\n if (!cell.startable) {\n res.status(501).json({\n error: `scenario '${cell.scenario}' at ${cell.revision} cannot be started here: ${cell.startReason}`,\n scenario: cell.scenario,\n revision: cell.revision,\n scoring: cell.scoring,\n reason: cell.startReason\n });\n return false;\n }\n return true;\n }\n\n /**\n * The cell, built on first reference but not yet seeded from the store;\n * or undefined, with the request answered, when it cannot be mounted.\n */\n function mountCell(\n req: Request,\n ref: CellRef,\n res: Response\n ): HostedRun | undefined {\n try {\n return sessions.getOrCreate(ref, (r) => cellBaseUrl(req, r));\n } catch (e) {\n if (e instanceof UnknownScenarioError) {\n res.status(404).json({ error: e.message });\n return undefined;\n }\n if (e instanceof NotHostableError) {\n res.status(501).json({ error: e.message });\n return undefined;\n }\n throw e;\n }\n }\n\n /**\n * The cell, hydrated from the store when this process has never seen it\n * (see SessionManager.acquire) — a request must not be dispatched before\n * the scenario knows the run's history.\n */\n async function createRun(\n req: Request,\n ref: CellRef,\n res: Response\n ): Promise {\n const run = mountCell(req, ref, res);\n if (run) await sessions.ready(run);\n return run;\n }\n\n /**\n * Make the cells ready for a request to their MCP endpoint (`mcp`) or\n * another path: seeded from the store, unless the request is a\n * `server/discover` whose answer no history can change. A client may give\n * discover a second before it falls back to an older handshake, so that\n * answer does not wait on the store; it is recorded all the same\n * (SessionManager.persist). Which discovers qualify: the hosted layer's\n * own refusal on a dated cell (discoverReply()), and on a stateless one\n * the scenario's, unless it reads its log to answer\n * (Scenario.discoverReadsHistory). Not an auth cell's, whose resource\n * server decides before it looks at the request.\n */\n async function prepare(\n runs: HostedRun[],\n req: Request,\n mcp: boolean\n ): Promise {\n const early =\n mcp &&\n req.method === 'POST' &&\n bodyFitsBuffer(req) &&\n runs.every(\n (run) =>\n !run.auxListeners &&\n (isStatefulVersion(run.revision) ||\n !run.scenario.discoverReadsHistory)\n ) &&\n (await new Promise((resolve) =>\n onBodySettled(req, (body) =>\n resolve(body !== undefined && isLoneDiscover(body))\n )\n ));\n if (!early) await Promise.all(runs.map((run) => sessions.ready(run)));\n }\n\n /**\n * The path the scenario sees for a request at ``: the\n * suffix, except that `/mcp` on a scenario serving MCP at its root is the\n * root — every cell is reachable at `/mcp` (see MCP_PATH).\n */\n function scenarioPath(run: HostedRun, suffix: string): string {\n if (suffix === MCP_PATH && !run.mcpPath) return '';\n return suffix;\n }\n\n /** Whether `rewrittenUrl` (path, maybe a query) is the cell's MCP endpoint. */\n function isMcpEndpoint(run: HostedRun, rewrittenUrl: string): boolean {\n const q = rewrittenUrl.indexOf('?');\n const path = q === -1 ? rewrittenUrl : rewrittenUrl.slice(0, q);\n return path === (run.mcpPath || '/');\n }\n\n /**\n * The probe notes this process has recorded per cell, keyed by kind and\n * the revision probed for, and whether each already carries the cell's\n * version answer. Only a note's wording depends on it (see noteProbe());\n * whether a request is a probe never does. Keyed by the cell's list of\n * hosted checks, which a reset replaces (a new attempt notes afresh).\n */\n const probeNotes = new WeakMap<\n ConformanceCheck[],\n Map\n >();\n\n /**\n * Record a probe's note once per `key`. A probe an auth cell met with 401\n * is repeated after sign-in and then draws the cell's version answer,\n * which is what the note should report: the first note is updated in\n * place when that answer arrives.\n */\n function noteProbe(\n run: HostedRun,\n key: string,\n check: ConformanceCheck,\n answered: boolean\n ): void {\n let notes = probeNotes.get(run.hostedChecks);\n if (!notes) probeNotes.set(run.hostedChecks, (notes = new Map()));\n const seen = notes.get(key);\n if (!seen) {\n notes.set(key, { check, answered });\n sessions.recordHostedCheck(run, key, check);\n } else if (answered && !seen.answered) {\n seen.check.description = check.description;\n seen.check.details = check.details;\n seen.answered = true;\n }\n }\n\n /**\n * Dispatch (req, res) to `listener` after rewriting `req.url` so the\n * scenario sees the path it would have under start()/stop() — i.e. with\n * the cell prefix stripped and (for well-known dispatch) the well-known\n * prefix re-prepended.\n *\n * `mcp` says the request is to the cell's MCP endpoint (not a PRM,\n * canary or aux path): only those are judged for wire rejections and\n * revision discipline (see ./wire.ts).\n */\n function dispatch(\n run: HostedRun,\n listener: (req: Request, res: Response) => void,\n req: Request,\n res: Response,\n rewrittenUrl: string,\n mcp = false,\n role?: AuxOriginRole\n ) {\n res.setHeader(\n 'link',\n `<${resultsUrlFor(req, run.id)}>; rel=\"conformance-results\"`\n );\n req.url = rewrittenUrl;\n run.touched = true;\n sessions.noteActivity(run);\n\n // The exchange as the cell's traffic keeps it (./traffic.ts): the\n // request now, the answer once it is out.\n const presented = req.header('authorization');\n // A composite's copy of a request has no originalUrl.\n const asked = req.originalUrl ?? '';\n const query = asked.indexOf('?');\n const exchange: Exchange = {\n at: new Date().toISOString(),\n lane: role ? 'sign-in' : mcp ? 'mcp' : 'metadata',\n ...(role && { role }),\n method: req.method,\n path: mcp\n ? (run.mcpPath || MCP_PATH) + (query === -1 ? '' : asked.slice(query))\n : rewrittenUrl,\n headers: keptRequestHeaders(req.headers),\n authorization: presented ? 'present' : 'absent'\n };\n // A token the cell issued before its last reset is withheld: the cell\n // answers as it answers a request that carries none.\n const refused = sessions.refusedNow(run);\n if (\n refusedCredential(refused, presented, '', undefined, undefined) ===\n 'token'\n ) {\n delete req.headers.authorization;\n delete req.headers.dpop;\n exchange.refused = 'token';\n }\n const started = Date.parse(exchange.at);\n let requestBody: Buffer | undefined;\n let bodySettled = false;\n /** Whether the exchange went into the traffic (it is filled in later). */\n let added = false;\n let recorded = false;\n /** Fill in the answer (so far) and add the exchange to the traffic. */\n const record = (soFar?: string, captured?: CapturedResponse) => {\n if (!bodySettled) return;\n if (!recorded) {\n recorded = true;\n const body = capped(\n redacted(requestBody?.toString('utf8')),\n requestBody?.length\n );\n const rpc = rpcOf(requestBody?.toString('utf8'));\n if (body.text !== undefined) exchange.body = body.text;\n if (body.bytes !== undefined) exchange.bodyBytes = body.bytes;\n if (rpc) exchange.rpc = rpc;\n }\n const session = res.getHeader('mcp-session-id');\n const conn = connectionOf(req, {\n stateful: isStatefulVersion(run.revision),\n ...(typeof session === 'string' && { opened: session })\n });\n if (conn && role === undefined) exchange.conn = conn;\n exchange.status = res.statusCode;\n const responseHeaders = keptResponseHeaders(\n (n) => res.getHeader(n),\n RESPONSE_HEADERS\n );\n if (Object.keys(responseHeaders).length)\n exchange.responseHeaders = responseHeaders;\n const text = captured ? captured.head : soFar;\n const answer = capped(redacted(text), captured?.size);\n if (answer.text !== undefined) exchange.responseBody = answer.text;\n if (answer.bytes !== undefined) exchange.responseBytes = answer.bytes;\n if (captured) {\n exchange.ms = Date.now() - started;\n sessions.noteIssued(\n run,\n issuedBy(\n exchange.path,\n captured.status,\n responseHeaders.location,\n captured.body\n )\n );\n }\n if (!added) {\n added = true;\n sessions.recordExchange(run, exchange);\n }\n };\n\n // The headers as the client sent them: a scenario may rewrite them\n // before handing the request on (json-schema-ref-deref maps the draft\n // header to the SDK's), and identity is what the client said.\n const headers = { ...req.headers };\n const headerVersion = req.header('mcp-protocol-version');\n const httpMethod = req.method;\n let request: RequestInfo | undefined;\n let body: Buffer | undefined;\n let response: CapturedResponse | undefined;\n let judged = false;\n /** This response is a stream that put a request of the cell's to the client. */\n let heldOpen = false;\n\n // Write this process's view through once the scenario has answered\n // (hosted scenarios record their checks before calling end()).\n // Serverless entry points should await sessions.flush() before\n // returning the response so this write isn't abandoned.\n const persist = () => {\n if (sessions.store) void sessions.persist(run);\n };\n\n /** Once the request is parsed and the response is out, judge both. */\n const judge = (): boolean => {\n if (judged || !request || !response) return false;\n judged = true;\n // The cell handed the client input to collect from a person (MRTR),\n // or the call that did so has been answered.\n if (asksForInput(response)) sessions.noteActivity(run, true);\n else if (heldOpen || request.methods.includes('tools/call'))\n sessions.noteActivity(run, false);\n // Era detection on a dated cell (a server/discover, or another\n // 2026-07-28-shaped request it turned away) is the client negotiating:\n // noted once per revision probed for, and neither judgement — however\n // often it comes, and whatever the cell answered before it.\n if (\n mcp &&\n isModernProbe(run.revision, request, headerVersion, response)\n ) {\n const version = headerVersion ?? request.metaVersion;\n const answer = versionAnswer(run.revision, version, response);\n noteProbe(\n run,\n `modern-probe:${version ?? ''}`,\n modernProbeCheck(\n run.revision,\n request.methods[0],\n version,\n answer ?? refusalOf(response)\n ),\n !!answer\n );\n } else if (mcp) {\n const rejection = wireRejection(response, run.revision, headerVersion);\n // One mistake, one check: a wrong-revision request the wire also\n // turned away records the revision, with the rejection folded in.\n let explained = false;\n for (const method of request.methods) {\n // An initialize on the stateless wire is era detection (see\n // isLegacyProbe()): noted, never failed, and it explains the\n // rejection it may have drawn.\n if (isLegacyProbe(run.revision, method)) {\n explained = true;\n const answer = legacyAnswer(run.revision, response);\n noteProbe(\n run,\n `probe:${headerVersion ?? ''}`,\n legacyProbeCheck(\n run.revision,\n headerVersion,\n answer,\n request.bodyVersion\n ),\n answer?.code !== undefined\n );\n continue;\n }\n const reason = wrongRevision(run.revision, method, headerVersion);\n if (!reason) continue;\n explained = explained || rejection !== undefined;\n sessions.recordHostedCheck(\n run,\n `revision:${method}:${headerVersion ?? ''}`,\n wrongRevisionCheck(\n run.revision,\n method,\n headerVersion,\n reason,\n rejection\n )\n );\n }\n if (rejection && !explained) {\n sessions.recordHostedCheck(\n run,\n `rejected:${rejection.code}:${rejection.message}`,\n wireRejectedCheck(rejection, request, headerVersion)\n );\n }\n }\n if (mcp && spokeRevision(run.revision, request, headerVersion, response))\n sessions.recordHostedCheck(\n run,\n 'spoken',\n revisionSpokenCheck(run.revision)\n );\n if (mcp && reachedRevision(run.revision, request, headerVersion))\n sessions.recordHostedCheck(\n run,\n 'reached',\n revisionReachedCheck(run.revision)\n );\n // Stopped by the auth layer with a token presented, at whatever\n // revision: judged against the cell's sign-in (signedInAuthStop()).\n if (mcp && authLayerStop(headers.authorization, response))\n sessions.recordHostedCheck(\n run,\n 'auth-stop',\n authStopCheck(run.revision)\n );\n // A GET the cell serves no stream for (the scenario's own 405, or\n // fallthrough()'s): noted so the client's author sees it.\n if (mcp && httpMethod === 'GET' && response.status === 405)\n sessions.recordHostedCheck(\n run,\n 'get-on-mcp',\n getOnMcpCheck(run.revision)\n );\n if (mcp && isAcceptedInitialize(request, response)) {\n // Asked for another revision, told the cell's (pinInitializeVersion()).\n const asked = request.bodyVersion;\n if (isStatefulVersion(run.revision) && asked && asked !== run.revision)\n sessions.recordHostedCheck(\n run,\n `offered:${asked}`,\n versionOfferedCheck(run.revision, asked, answeredVersion(response))\n );\n }\n // Who the client is, from accepted exchanges only.\n const identity = identityFrom(headers, body, response);\n if (identity) sessions.recordIdentity(run, identity);\n return true;\n };\n\n onBodySettled(req, (captured) => {\n body = captured;\n request = describeRequest(captured);\n // The response is already out: what judge() recorded needs its own\n // write-through.\n if (judge() && response) persist();\n });\n onAnyBody(req, (captured) => {\n requestBody = captured;\n bodySettled = true;\n // The answer went out before the body was in: record it now.\n if (response) {\n record(undefined, response);\n persist();\n }\n });\n tapResponse(\n res,\n (captured) => {\n response = captured;\n // Noted before the response is flushed, so the client's next\n // request, to the origin-root metadata, finds the note from any\n // process.\n if (captured.status === 401 && run.scenario.servesRootPrm)\n sessions.noteChallenge(run, requesterOf(req));\n judge();\n record(undefined, captured);\n persist();\n },\n // A server-sent event stream may stay open for as long as the client\n // listens, so what the cell records as it sends each event is written\n // through then, not left for an end that may never come.\n (soFar) => {\n const type = res.getHeader('content-type');\n if (typeof type === 'string' && type.includes('text/event-stream')) {\n // A POST answered with a stream the cell writes to before its\n // result: a request of the cell's (an elicitation, say) is before\n // the client, and the cell waits on its answer until the end.\n if (httpMethod === 'POST' && !heldOpen) {\n heldOpen = true;\n sessions.noteActivity(run, true);\n }\n record(soFar());\n persist();\n }\n }\n );\n // A stream the client dropped before it ended answers nothing.\n res.on('close', () => {\n if (!heldOpen || response) return;\n sessions.noteActivity(run, false);\n persist();\n });\n // Outside the tap, so what is judged is what the client was told.\n if (mcp && req.method === 'POST' && isStatefulVersion(run.revision)) {\n pinInitializeVersion(\n res,\n run.revision,\n () => request?.methods.includes('initialize') ?? false\n );\n }\n\n // Raw node calls: a composite's replayed request has no express helpers.\n const sendJson = (status: number, body: unknown) => {\n res.statusCode = status;\n res.setHeader('content-type', 'application/json');\n res.end(JSON.stringify(body));\n };\n /** Answer a POST whose body is empty or not JSON, and note it. */\n const parseError = (empty: boolean) => {\n sessions.recordHostedCheck(\n run,\n `unparseable:${empty ? 'empty' : 'malformed'}`,\n unparseableBodyCheck(run.revision, empty, headerVersion)\n );\n sendJson(400, PARSE_ERROR_REPLY);\n };\n // An express scenario with no route for the request calls this instead\n // of answering with Express's HTML 404 (a raw listener ignores it). On\n // the MCP endpoint that is a GET the scenario serves no stream for —\n // VS Code sends one after a 400, as its old HTTP+SSE fallback — so it\n // gets the SDK transport's 405, and the cell notes it (judge()). A body\n // the scenario's JSON parser refused is a parse error, as it is before\n // dispatch, not a crash.\n const fallthrough = (err?: unknown) => {\n if (res.headersSent) return;\n if (\n err &&\n mcp &&\n (err as { type?: unknown }).type === 'entity.parse.failed'\n ) {\n parseError(false);\n return;\n }\n if (err) {\n sendJson(500, {\n jsonrpc: '2.0',\n id: null,\n error: { code: -32603, message: 'Internal error' }\n });\n return;\n }\n if (mcp && req.method === 'GET') {\n res.setHeader('allow', 'POST');\n sendJson(405, GET_ON_MCP_REPLY);\n return;\n }\n sendJson(404, { error: `Cannot ${req.method} ${req.url}` });\n };\n const handOn = () =>\n (\n listener as (\n req: Request,\n res: Response,\n next: (err?: unknown) => void\n ) => void\n )(req, res, fallthrough);\n\n // On the sign-in server, a code, refresh token or registration the cell\n // issued before its last reset is refused with the OAuth error for it,\n // before the scenario sees the request: the client must start over.\n if (role && refused.size) {\n const decide = (captured?: Buffer) => {\n const kind = refusedCredential(\n refused,\n undefined,\n rewrittenUrl,\n captured?.toString('utf8'),\n req.header('content-type')\n );\n if (!kind) return handOn();\n exchange.refused = kind;\n const status =\n kind === 'client_id' && req.method === 'POST' ? 401 : 400;\n sendJson(status, refusalBody(kind));\n };\n if (req.method === 'POST' && bodyFitsBuffer(req)) onAnyBody(req, decide);\n else decide();\n return;\n }\n\n // What every cell of a column answers alike is answered here, before the\n // scenario sees the request: a body that is empty or not JSON (a plain\n // -32700), a legacy initialize on the stateless wire (see\n // legacyInitializeReply()) and a server/discover on a dated one (see\n // discoverReply()). Not an auth cell: its resource server must answer\n // 401 before it looks at the request, and after sign-in it gives the\n // same version answers itself (auth/helpers/createServer.ts).\n if (mcp && req.method === 'POST' && !run.auxListeners) {\n if (declaresNoBody(req)) {\n parseError(true);\n return;\n }\n if (bodyFitsBuffer(req)) {\n onBodySettled(req, (captured) => {\n if (captured !== undefined && isUnparseable(captured)) {\n parseError(captured.toString().trim() === '');\n return;\n }\n const reply =\n legacyInitializeReply(run.revision, captured, headerVersion) ??\n discoverReply(run.revision, captured, headerVersion);\n if (reply) sendJson(reply.status, reply.body);\n else handOn();\n });\n return;\n }\n }\n handOn();\n }\n\n // ---------- representation ----------\n\n /** `?format=` wins; otherwise the Accept header decides (JSON by default). */\n function wantsHtml(req: Request): boolean {\n const format = req.query.format;\n if (format === 'html') return true;\n if (format === 'json') return false;\n return req.accepts(['json', 'html']) === 'html';\n }\n\n /**\n * A GET at a cell URL is a page/config request when it accepts text/html\n * (and not the MCP SSE stream) or spells out `?format=`; anything else is\n * the client under test talking to the scenario.\n */\n function isPageRequest(req: Request): boolean {\n if (req.method !== 'GET') return false;\n if (typeof req.query.format === 'string') return true;\n const accept = req.header('accept') ?? '';\n return (\n accept.includes('text/html') && !accept.includes('text/event-stream')\n );\n }\n\n // ---------- config ----------\n\n function cellConfig(\n req: Request,\n run: HostedRun,\n cell: MatrixCell\n ): CellConfig {\n const context = run.context\n ? JSON.stringify({ name: run.scenarioName, ...run.context })\n : undefined;\n return {\n scenario: run.scenarioName,\n revision: run.revision,\n url: `${cellBaseUrl(req, run)}${run.mcpPath || MCP_PATH}`,\n resultsUrl: resultsUrlFor(req, run.id),\n scoring: cell.scoring,\n ...(cell.reason !== undefined && { reason: cell.reason }),\n ...(cell.steps && { steps: cell.steps }),\n env: {\n MCP_CONFORMANCE_SCENARIO: run.scenarioName,\n MCP_CONFORMANCE_PROTOCOL_VERSION: run.revision,\n ...(context !== undefined && { MCP_CONFORMANCE_CONTEXT: context })\n }\n };\n }\n\n /** Config for every startable cell in scope; creates the cells. */\n function runConfig(\n req: Request,\n runId: string,\n scope: { revision?: SpecVersion; scenario?: string }\n ): RunConfig {\n const cells = matrix\n .cells()\n .filter(\n (c) =>\n c.startable &&\n (scope.revision === undefined || c.revision === scope.revision) &&\n (scope.scenario === undefined || c.scenario === scope.scenario)\n )\n .map((c) => {\n const run = sessions.getOrCreate(\n { runId, revision: c.revision, scenarioName: c.scenario },\n (r) => cellBaseUrl(req, r)\n );\n return cellConfig(req, run, c);\n });\n const parts = [runId];\n if (scope.revision) parts.push(scope.revision);\n if (scope.revision && scope.scenario) parts.push(scope.scenario);\n return {\n runId,\n ...(scope.revision && { revision: scope.revision }),\n ...(scope.scenario && { scenario: scope.scenario }),\n resultsUrl: resultsUrlFor(req, ...parts),\n mcpServers: Object.fromEntries(\n cells.map((c) => [\n `${c.revision}/${c.scenario}`,\n { type: 'http' as const, url: c.url }\n ])\n ),\n cells\n };\n }\n\n async function sendConfig(\n req: Request,\n res: Response,\n config: RunConfig\n ): Promise {\n if (wantsHtml(req)) {\n const { renderConfig } = await pages();\n res.type('html').send(renderConfig(origin(req), matrix, config, build));\n } else {\n res.json(config);\n }\n }\n\n // ---------- discovery ----------\n\n app.get('/', async (req, res) => {\n const { renderLanding } = await pages();\n // The page states this deployment's lifetimes, not the defaults.\n res.type('html').send(\n renderLanding(\n origin(req),\n matrix,\n {\n idleMs: sessions.ttlMs,\n ...(opts.store && { store: opts.store.retention ?? {} })\n },\n build\n )\n );\n });\n\n app.get('/scenarios', (_req, res) => {\n res.json(\n matrix.rows.map((row) => ({\n name: row.scenario,\n description: row.description,\n source: row.source,\n mcpPath: row.cells[0]?.mcpPath ?? MCP_PATH,\n ...(row.cells[0]?.steps && { steps: row.cells[0].steps }),\n cells: row.cells.map(\n ({ revision, scoring, reason, startable, startReason }) => ({\n revision,\n scoring,\n ...(reason !== undefined && { reason }),\n startable,\n ...(startReason !== undefined && { startReason })\n })\n )\n }))\n );\n });\n\n // ---------- runs ----------\n\n app.get('/s', (_req, res) => {\n res.redirect(303, `/s/${mintRunId()}`);\n });\n\n // We can't pre-register an express route per cell because run-ids are\n // open-ended and scenario names contain '/'. A single catch-all resolves\n // the cell, rewrites req.url to strip the /s///\n // prefix, and hands off to the cell's listener — exactly what\n // app.use(prefix, fn) would do, but with a dynamic prefix.\n const composite = createCompositeRoute({\n matrix,\n mountCell,\n prepare,\n dispatch,\n cellBaseUrl,\n resultsUrlFor,\n isPageRequest,\n wantsHtml\n });\n\n app.all(/^\\/s\\/(.+)$/, async (req, res) => {\n const segments = segmentsOf(req.params[0]);\n const [runId, revision] = segments;\n\n // Several scenarios' cells behind one URL, `+` (see ./composite.ts).\n const tail = segments.slice(2).join('/');\n const spec = tail.endsWith(MCP_PATH)\n ? tail.slice(0, -MCP_PATH.length)\n : tail;\n const children = segments.length > 2 ? parseComposite(spec) : undefined;\n if (children) {\n if (!RUN_ID_RE.test(runId)) {\n res.status(400).json({ error: 'invalid run-id' });\n return;\n }\n if (!revisions.includes(revision)) {\n res\n .status(404)\n .json({ error: `unknown revision '${revision}'`, revisions });\n return;\n }\n await composite(\n req,\n res,\n runId,\n revision as SpecVersion,\n children,\n spec === tail ? '' : MCP_PATH\n );\n return;\n }\n\n if (segments.length <= 2) {\n // Run or column scope, or the run's bulk page: config only.\n const bulk = segments.length === 2 && revision === BULK;\n if (!RUN_ID_RE.test(runId)) {\n res.status(400).json({ error: 'invalid run-id' });\n return;\n }\n if (segments.length === 2 && !bulk && !revisions.includes(revision)) {\n res\n .status(404)\n .json({ error: `unknown revision '${revision}'`, revisions });\n return;\n }\n if (req.method !== 'GET') {\n res.status(405).json({\n error:\n 'MCP endpoints live at /s///; GET here for the config.'\n });\n return;\n }\n // Config for every cell of the scope builds every one of them.\n await loadAllCells(matrix.revisions);\n const scope =\n segments.length === 2 && !bulk ? (revision as SpecVersion) : undefined;\n const config = runConfig(req, runId, { revision: scope });\n if (bulk) {\n const { bulkJson, renderBulkPage } = await runPages();\n if (wantsHtml(req)) {\n res\n .type('html')\n .send(renderBulkPage(origin(req), matrix, config, build));\n } else {\n res.json(bulkJson(origin(req), matrix, config));\n }\n return;\n }\n if (!wantsHtml(req)) {\n res.json(config);\n return;\n }\n // Each URL's live line, judged as the report judges its cell.\n const live = await runLive(matrix, runId, scope, reportSources(req));\n const { renderRunPage } = await runPages();\n res\n .type('html')\n .send(renderRunPage(origin(req), matrix, config, live, build));\n return;\n }\n\n const resolved = resolveCell(segments, res);\n if (!resolved) return;\n const { ref, suffix } = resolved;\n\n // A browser opening the MCP URL itself is sent to the cell's page.\n if (suffix === MCP_PATH && isPageRequest(req)) {\n const q = req.originalUrl.indexOf('?');\n const page = cellBaseUrl(req, ref);\n res.redirect(303, q === -1 ? page : page + req.originalUrl.slice(q));\n return;\n }\n\n // The cell's own scenario and no other: a discover must not wait on\n // every scenario module (see ./catalog.ts).\n await loadCells([ref]);\n\n if (suffix === '' && isPageRequest(req)) {\n // The cell's page is one page, here and at its results path; its\n // JSON here is still the cell's config.\n if (wantsHtml(req)) {\n const view = await cellView(req, ref, resolved.cell);\n await sendCellPage(req, res, ref, resolved.cell, view);\n return;\n }\n await sendConfig(\n req,\n res,\n runConfig(req, ref.runId, {\n revision: ref.revision,\n scenario: ref.scenarioName\n })\n );\n return;\n }\n\n const run = mountCell(req, ref, res);\n if (!run) return;\n // Rewrite to the path the scenario expects (it thinks it's at root).\n // The query string is preserved because we keep the express req object.\n const rewritten = scenarioPath(run, suffix) || run.mcpPath || '/';\n const mcp = isMcpEndpoint(run, rewritten);\n await prepare([run], req, mcp);\n dispatch(run, run.listener, req, res, rewritten, mcp);\n });\n\n // ---------- root well-known dispatch (RS side) ----------\n //\n // RFC 9728: a client given MCP URL /s//mcp derives the PRM\n // URL as /.well-known/oauth-protected-resource/s//mcp — i.e.\n // at the *origin root*, not under the cell prefix. We catch that here,\n // recover the cell from the path suffix, and re-dispatch to its RS handler\n // with the path it would have seen on its own origin.\n //\n // Requests that arrive *under* the cell prefix (because the WWW-Authenticate\n // header points there) already work via the /s/* mount above.\n\n app.get(\n /^\\/\\.well-known\\/oauth-protected-resource\\/s\\/(.+)$/,\n async (req, res) => {\n const resolved = resolveCell(req.params[0].split('/'), res);\n if (!resolved) return;\n await loadCells([resolved.ref]);\n const run = await createRun(req, resolved.ref, res);\n if (!run) return;\n // Scenario expects e.g. '/.well-known/oauth-protected-resource/mcp'\n // (or the bare well-known path when its MCP endpoint is its root).\n dispatch(\n run,\n run.listener,\n req,\n res,\n '/.well-known/oauth-protected-resource' +\n scenarioPath(run, resolved.suffix)\n );\n }\n );\n\n // A client falls back to the bare origin-root path when the path-inserted\n // one is a 404, which it is for a scenario serving its metadata at the\n // root. That path names no cell, so it is answered as the root-metadata\n // cell most recently challenged from the same client address, from\n // whichever process (./root-prm.ts).\n app.get(/^\\/\\.well-known\\/oauth-protected-resource\\/?$/, async (req, res) => {\n const requester = requesterOf(req);\n const challenged = await sessions.recentChallenges(\n ROOT_PRM_WINDOW_MS,\n requester\n );\n const refs = challenged.flatMap(({ id }) => {\n const ref = parseCellId(id);\n return ref && matrix.cell(ref.scenarioName, ref.revision)?.startable\n ? [ref]\n : [];\n });\n if (!refs.length) {\n res\n .status(404)\n .json(\n rootPrmUnattributed(\n hostedScenarios.names.filter(\n (n) => hostedScenarios.meta(n)?.servesRootPrm\n )\n )\n );\n return;\n }\n const [ref, ...others] = refs;\n await loadCells([ref]);\n const run = await createRun(req, ref, res);\n if (!run) return;\n const byAddress = requester !== '';\n sessions.recordHostedCheck(\n run,\n 'root-prm',\n rootPrmAttributedCheck(byAddress)\n );\n if (others.length) {\n // Revision and scenario only: another cell's run id would let anyone\n // who reads this run's results read that run's too.\n const cells = others.map(({ revision, scenarioName }) => ({\n revision,\n scenario: scenarioName\n }));\n sessions.recordHostedCheck(\n run,\n `root-prm-ambiguous:${cells.map((c) => `${c.revision}/${c.scenario}`).join(' ')}`,\n rootPrmAmbiguousCheck(cells, byAddress)\n );\n }\n const q = req.url.indexOf('?');\n dispatch(\n run,\n run.listener,\n req,\n res,\n ROOT_PRM_PATH + (q === -1 ? '' : req.url.slice(q))\n );\n });\n\n // ---------- aux-origin backchannel (relay target) ----------\n //\n // The AS relay (examples/hosted/valtown-relay.ts) forwards every request it\n // receives to /__aux/. The per-cell AS issuer is\n // /r///, so every path the client hits\n // — endpoints (/r//authorize) and RFC 8414 well-known\n // (/.well-known/oauth-authorization-server/r/[/tenant]) — carries\n // `/r/` somewhere in it. We locate it, strip it, and dispatch to the\n // cell's aux handler so it sees exactly the path createAuthServer\n // registered.\n //\n // Guarded by a shared secret so this internal mount can't be hit directly\n // to forge checks into someone else's run.\n\n if (haveAux.length) {\n const secret = opts.relaySecret ?? process.env.CONFORMANCE_RELAY_SECRET;\n const guard = (req: Request, res: Response): boolean => {\n const got = req.header('x-relay-secret') ?? '';\n // Constant-time compare; mismatch length → fast 403 is fine.\n const ok =\n !!secret &&\n got.length === secret.length &&\n timingSafeEqual(Buffer.from(got), Buffer.from(secret));\n if (!ok) {\n res\n .status(403)\n .json({ error: 'forbidden: /__aux is the relay backchannel' });\n }\n return ok;\n };\n\n /**\n * Find the first `/r///` in `segments` (plain\n * segment scan — a regex over the whole path would backtrack\n * polynomially on adversarial input) and split the path around it.\n */\n function locateCell(\n segments: string[]\n ): { prefix: string; ref: CellRef; suffix: string } | undefined {\n for (let i = 1; i < segments.length - 2; i++) {\n if (\n segments[i] !== 'r' ||\n !RUN_ID_RE.test(segments[i + 1]) ||\n !revisions.includes(segments[i + 2])\n ) {\n continue;\n }\n const resolved = resolveScenario(segments.slice(i + 3));\n if (!resolved) continue;\n return {\n prefix: segments.slice(0, i).join('/'),\n ref: {\n runId: segments[i + 1],\n revision: segments[i + 2] as SpecVersion,\n scenarioName: resolved.scenarioName\n },\n suffix: resolved.suffix\n };\n }\n return undefined;\n }\n\n app.all(/^\\/__aux\\/([a-z0-9]+)(\\/.*)$/, async (req, res) => {\n if (!guard(req, res)) return;\n const role = req.params[0] as AuxOriginRole;\n const path = req.params[1];\n if (!AUX_ROLES.includes(role)) {\n res.status(404).json({ error: `unknown aux role '${role}'` });\n return;\n }\n\n const located = locateCell(path.split('/')); // path starts with '/', so [0] === ''\n if (!located) {\n res.status(404).json({\n error:\n 'aux request path missing /r/// segment'\n });\n return;\n }\n const { prefix, ref, suffix } = located;\n const cell = matrix.cell(ref.scenarioName, ref.revision)!;\n if (!checkStartable(cell, res)) return;\n await loadCells([ref]);\n const search = req.url.includes('?')\n ? req.url.slice(req.url.indexOf('?'))\n : '';\n\n // On a multi-process host this may be the first request this process\n // sees for the cell; the id carries everything needed to rebuild it.\n const run = sessions.ensure(cellId(ref), (r) => cellBaseUrl(req, r));\n const listener = run?.auxListeners?.[role];\n if (!run || !listener) {\n res.status(404).json({ error: `no aux '${role}' handler for cell` });\n return;\n }\n await sessions.ready(run);\n // A reset in another process may have rebuilt the cell's handlers.\n dispatch(\n run,\n run.auxListeners?.[role] ?? listener,\n req,\n res,\n (prefix + suffix || '/') + search,\n false,\n role\n );\n });\n }\n\n // ---------- results ----------\n\n app.get(/^\\/results\\/(.+)$/, async (req, res) => {\n const segments = segmentsOf(req.params[0]);\n const [runId, revision, ...rest] = segments;\n if (!RUN_ID_RE.test(runId)) {\n res.status(400).json({ error: 'invalid run-id' });\n return;\n }\n // A frozen report: /results//snapshot/.\n if (revision === 'snapshot') {\n const [snapshotId, cellRevision, ...cellRest] = rest;\n // A reached cell's page as frozen with the report:\n // /results//snapshot///.\n if (cellRevision !== undefined) {\n await sendFrozenCell(\n req,\n res,\n runId,\n snapshotId,\n cellRevision,\n cellRest\n );\n return;\n }\n let body: string | undefined;\n if (segments.length === 3 && SNAPSHOT_ID_RE.test(snapshotId)) {\n try {\n body = await snapshots.loadSnapshot(runId, snapshotId);\n } catch (e) {\n console.error(\n '[hosted] snapshot:',\n e instanceof Error ? e.message : e\n );\n res\n .status(503)\n .json({ error: 'could not read the snapshot; try again' });\n return;\n }\n }\n if (body === undefined) {\n res.status(404).json({\n error: `no snapshot '${rest.join('/')}' for run '${runId}'`\n });\n return;\n }\n await sendReport(req, res, relink(req, JSON.parse(body) as RunReport));\n return;\n }\n\n if (segments.length >= 2 && !revisions.includes(revision)) {\n res\n .status(404)\n .json({ error: `unknown revision '${revision}'`, revisions });\n return;\n }\n\n if (segments.length >= 3) {\n const resolved = resolveScenario(rest);\n const suffix = resolved?.suffix;\n if (!resolved || (suffix !== '' && suffix !== TRAFFIC_SUFFIX)) {\n res.status(404).json({ error: `unknown scenario '${rest.join('/')}'` });\n return;\n }\n const ref: CellRef = {\n runId,\n revision: revision as SpecVersion,\n scenarioName: resolved.scenarioName\n };\n const cell = matrix.cell(resolved.scenarioName, ref.revision)!;\n await hostedScenarios.load([ref.scenarioName]);\n if (suffix === TRAFFIC_SUFFIX) {\n sendTraffic(res, ref, await sessions.traffic(cellId(ref)));\n return;\n }\n // A cell nobody has hit yet is a valid, incomplete cell — not an\n // unknown run: the config page links here before any traffic.\n const view = await cellView(req, ref, cell);\n if (wantsHtml(req)) {\n await sendCellPage(req, res, ref, cell, view);\n } else {\n res.json(cellJson(req, ref, view));\n }\n return;\n }\n\n // Run or column scope: a verdict per cell of the matrix.\n const scope = segments.length === 2 ? (revision as SpecVersion) : undefined;\n // A verdict per cell needs every cell's scenario.\n await hostedScenarios.loadAll();\n const report = await buildReport(matrix, runId, scope, reportSources(req));\n // The live page lists the run's frozen copies; nothing else needs them.\n const frozen =\n reportFormat(req) === 'html'\n ? await snapshots\n .listSnapshots(runId)\n .then((list) => list.filter((s) => !s.id.includes('/')))\n .catch(() => [])\n : undefined;\n await sendReport(req, res, report, frozen);\n });\n\n // Freeze the run's report as it stands now: a permalink later traffic\n // cannot change, for an issue or a chat. The whole run, whichever page\n // asked. No protection beyond the run id itself, like the rest of a run.\n app.post('/results/:runId/freeze', async (req, res) => {\n const { runId } = req.params;\n if (!RUN_ID_RE.test(runId)) {\n res.status(400).json({ error: 'invalid run-id' });\n return;\n }\n await hostedScenarios.loadAll();\n const report = await buildReport(\n matrix,\n runId,\n undefined,\n reportSources(req)\n );\n const snapshotId = mintId(8);\n const frozenAt = report.generatedAt;\n // Each reached cell's page goes with the report, traffic included, each\n // its own row beside it (`//`), written\n // first so the report never links to a page that is not there.\n const reached = report.columns.flatMap((col) =>\n col.cells.filter((c) => REACHED.includes(c.state))\n );\n const frozen: RunReport = {\n ...report,\n snapshotId,\n frozenAt,\n frozenCells: reached.map((c) => `${c.revision}/${c.scenario}`)\n };\n try {\n await Promise.all(\n reached.map(async (c) => {\n const ref: CellRef = {\n runId,\n revision: c.revision as SpecVersion,\n scenarioName: c.scenario\n };\n const cell = matrix.cell(c.scenario, c.revision)!;\n const { data } = await cellView(req, ref, cell);\n const stored: FrozenCell = { ...data, frozenAt };\n await snapshots.saveSnapshot(\n runId,\n `${snapshotId}/${c.revision}/${c.scenario}`,\n JSON.stringify(stored)\n );\n })\n );\n await snapshots.saveSnapshot(runId, snapshotId, JSON.stringify(frozen));\n } catch (e) {\n console.error('[hosted] snapshot:', e instanceof Error ? e.message : e);\n res.status(503).json({ error: 'could not save the snapshot; try again' });\n return;\n }\n const url = resultsUrlFor(req, runId, 'snapshot', snapshotId);\n if (wantsHtml(req)) {\n res.redirect(303, `/results/${runId}/snapshot/${snapshotId}`);\n return;\n }\n res\n .status(201)\n .location(url)\n .json({\n runId,\n snapshotId,\n frozenAt: frozen.frozenAt,\n url,\n markdownUrl: `${url}?format=md`,\n textUrl: `${url}?format=text`\n });\n });\n\n // Reset one cell: its client's next request starts a new attempt, which\n // sets the cell's verdict from then on; what earlier attempts recorded\n // stays, listed on the cell's page. The cell keeps its URL. Anyone with\n // the run link can, as with everything else in a run.\n app.post(/^\\/results\\/(.+)\\/reset$/, async (req, res) => {\n const [runId, revision, ...rest] = segmentsOf(req.params[0]);\n if (!RUN_ID_RE.test(runId ?? '')) {\n res.status(400).json({ error: 'invalid run-id' });\n return;\n }\n if (!revisions.includes(revision ?? '')) {\n res\n .status(404)\n .json({ error: `unknown revision '${revision ?? ''}'`, revisions });\n return;\n }\n const resolved = resolveScenario(rest);\n if (!resolved || resolved.suffix !== '') {\n res.status(404).json({ error: `unknown scenario '${rest.join('/')}'` });\n return;\n }\n const cell = matrix.cell(resolved.scenarioName, revision)!;\n if (!checkStartable(cell, res)) return;\n const ref: CellRef = {\n runId,\n revision: revision as SpecVersion,\n scenarioName: resolved.scenarioName\n };\n await loadCells([ref]);\n const attempt = await sessions.reset(cellId(ref), clock());\n if (wantsHtml(req)) {\n res.redirect(\n 303,\n req.query.back === 'report'\n ? `/results/${runId}`\n : `/results/${cellId(ref)}`\n );\n return;\n }\n res.json({\n runId,\n revision,\n scenario: ref.scenarioName,\n attempt,\n resultsUrl: resultsUrlFor(req, cellId(ref))\n });\n });\n\n app.delete('/results/:runId', async (req, res) => {\n if (!RUN_ID_RE.test(req.params.runId)) {\n res.status(400).json({ error: 'invalid run-id' });\n return;\n }\n await sessions.destroyRun(req.params.runId);\n await snapshots.deleteSnapshots(req.params.runId).catch((e) => {\n console.error('[hosted] snapshot:', e instanceof Error ? e.message : e);\n });\n res.status(204).end();\n });\n\n function reportSources(req: Request): ReportSources {\n return {\n listCells: (id) => sessions.listCells(id),\n results: (id) => sessions.results(id),\n resultsUrl: (ref) => resultsUrlFor(req, cellId(ref)),\n build,\n now: clock\n };\n }\n\n /**\n * `?format=md` (or `markdown`) is the report as Markdown; `?format=text`\n * (or `plain`) as plain lines, for a chat that renders no tables.\n */\n function reportFormat(req: Request): 'html' | 'json' | 'md' | 'text' {\n const format = req.query.format;\n if (format === 'md' || format === 'markdown') return 'md';\n if (format === 'text' || format === 'plain') return 'text';\n return wantsHtml(req) ? 'html' : 'json';\n }\n\n /**\n * A stored report's cell links, rebuilt for this request: a snapshot\n * keeps what the run said, not the host name it was frozen through.\n */\n function relink(req: Request, report: RunReport): RunReport {\n const frozen = new Set(report.frozenCells ?? []);\n for (const col of report.columns) {\n for (const c of [...col.cells, ...col.notScored]) {\n // A cell frozen with the report links to its page as frozen.\n c.resultsUrl =\n report.snapshotId && frozen.has(`${c.revision}/${c.scenario}`)\n ? resultsUrlFor(\n req,\n report.runId,\n 'snapshot',\n report.snapshotId,\n c.revision,\n c.scenario\n )\n : resultsUrlFor(req, report.runId, c.revision, c.scenario);\n }\n }\n return report;\n }\n\n /** A cell's page as its results and config paths serve it. */\n interface CellView {\n data: CellPageData;\n status: CellStatus;\n shown: ShownCheck[];\n }\n\n /**\n * What a cell's page shows: its current attempt's verdict and checks, its\n * earlier attempts each in a line, and the current attempt's traffic.\n */\n async function cellView(\n req: Request,\n ref: CellRef,\n cell: MatrixCell\n ): Promise {\n const now = clock();\n const r =\n cell.scoring === 'n/a' ? undefined : await sessions.results(cellId(ref));\n // One row per check, as the page and the report count them.\n const { shown, ...status } = cellStatus(cell, r, now);\n const traffic = r\n ? await sessions.traffic(cellId(ref))\n : new Map();\n const attempt = r?.attempt ?? 1;\n const { earlierCause } = await cellPages();\n const earlier: EarlierSummary[] = (r?.earlier ?? []).map((e) => {\n const v = viewCell(cell, e.results, now);\n const first = traffic.get(e.attempt)?.exchanges[0]?.at;\n const cause = earlierCause(v.shown ?? [], v.note);\n return {\n attempt: e.attempt,\n ...(e.startedAt && { startedAt: e.startedAt }),\n ...(first && { firstRequestAt: first }),\n ...(e.results.lastRequestAt && {\n lastRequestAt: e.results.lastRequestAt\n }),\n verdict: v.verdict,\n state: v.state,\n ...(cause && { cause })\n };\n });\n const data: CellPageData = {\n ref,\n description:\n matrix.rows.find((row) => row.scenario === ref.scenarioName)\n ?.description ?? '',\n status,\n shown,\n identities: r && !r.fresh ? identitiesIn(r.checks) : [],\n attempt,\n ...(r?.resetAt && { resetAt: r.resetAt }),\n earlier,\n traffic: traffic.get(attempt) ?? { exchanges: [], omitted: 0 },\n ...(cell.startable && {\n mcpUrl: `${cellBaseUrl(req, ref)}${cell.mcpPath}`\n }),\n ...(cell.steps && { steps: cell.steps })\n };\n return { data, status, shown };\n }\n\n /** A cell's results as JSON: its rows and status, and its attempts. */\n function cellJson(req: Request, ref: CellRef, view: CellView) {\n const { data, status, shown } = view;\n return {\n ...summarise(ref, shown),\n ...status,\n attempt: data.attempt,\n ...(data.resetAt && { resetAt: data.resetAt }),\n ...(data.earlier.length && { earlier: data.earlier }),\n trafficUrl: `${resultsUrlFor(req, cellId(ref))}${TRAFFIC_SUFFIX}`\n };\n }\n\n async function sendCellPage(\n req: Request,\n res: Response,\n ref: CellRef,\n cell: MatrixCell,\n view: CellView\n ): Promise {\n let config: CellConfig | undefined;\n if (cell.startable) {\n await loadCells([ref]);\n const run = mountCell(req, ref, res);\n if (!run) return;\n config = cellConfig(req, run, cell);\n }\n const resettable =\n cell.startable &&\n !['not-tried', 'not-startable', 'n/a'].includes(view.status.state);\n const { renderCell } = await cellPages();\n res\n .type('html')\n .send(renderCell(view.data, { live: { config, resettable }, build }));\n }\n\n /** A frozen copy of a reached cell's page (see the freeze route). */\n async function sendFrozenCell(\n req: Request,\n res: Response,\n runId: string,\n snapshotId: string,\n revision: string,\n rest: string[]\n ): Promise {\n const resolved = revisions.includes(revision)\n ? resolveScenario(rest)\n : undefined;\n const suffix = resolved?.suffix;\n let body: string | undefined;\n if (\n resolved &&\n (suffix === '' || suffix === TRAFFIC_SUFFIX) &&\n SNAPSHOT_ID_RE.test(snapshotId)\n ) {\n try {\n body = await snapshots.loadSnapshot(\n runId,\n `${snapshotId}/${revision}/${resolved.scenarioName}`\n );\n } catch (e) {\n console.error('[hosted] snapshot:', e instanceof Error ? e.message : e);\n res\n .status(503)\n .json({ error: 'could not read the snapshot; try again' });\n return;\n }\n }\n if (body === undefined || !resolved) {\n res.status(404).json({\n error: `no frozen cell '${[revision, ...rest].join('/')}' in snapshot '${snapshotId}' of run '${runId}'`\n });\n return;\n }\n const stored = JSON.parse(body) as FrozenCell;\n if (suffix === TRAFFIC_SUFFIX) {\n sendTraffic(res, stored.ref, new Map([[stored.attempt, stored.traffic]]));\n return;\n }\n if (!wantsHtml(req)) {\n res.json(stored);\n return;\n }\n const { renderCell } = await cellPages();\n res.type('html').send(\n renderCell(\n {\n ...stored,\n mcpUrl: `${cellBaseUrl(req, stored.ref)}${matrix.cell(stored.ref.scenarioName, stored.ref.revision)?.mcpPath ?? MCP_PATH}`\n },\n { frozen: { snapshotId, frozenAt: stored.frozenAt }, build: null }\n )\n );\n }\n\n /** A cell's traffic as JSON lines, one exchange a line, every attempt. */\n function sendTraffic(\n res: Response,\n ref: CellRef,\n byAttempt: ReadonlyMap\n ): void {\n const lines: string[] = [];\n for (const [attempt, { exchanges, omitted }] of byAttempt) {\n const conns = connectionNumbers(exchanges);\n exchanges.forEach((e, i) =>\n lines.push(jsonLine(e, attempt, i + 1, conns))\n );\n if (omitted) lines.push(JSON.stringify({ attempt, omitted }));\n }\n const name = `${ref.revision}-${ref.scenarioName.replace(/[^A-Za-z0-9._-]+/g, '_')}-traffic.jsonl`;\n res\n .set('content-type', 'application/jsonl; charset=utf-8')\n .set('content-disposition', `inline; filename=\"${name}\"`)\n .send(lines.map((l) => `${l}\\n`).join(''));\n }\n\n async function sendReport(\n req: Request,\n res: Response,\n judged: RunReport,\n frozen?: SnapshotInfo[]\n ): Promise {\n // Each not-tried cell's MCP URL and what the client must do there, from\n // its steps: added here for every format, a frozen copy included, and\n // never stored. The step descriptions load with the first report.\n const { describeStep } = await import('../steps/index.ts');\n const report = withNotTriedHints(\n judged,\n matrix,\n (ref) => cellBaseUrl(req, ref),\n describeStep\n );\n const live = report.snapshotId\n ? resultsUrlFor(req, report.runId)\n : resultsUrlFor(\n req,\n report.runId,\n ...(report.revision ? [report.revision] : [])\n );\n const snapshot = report.snapshotId\n ? resultsUrlFor(req, report.runId, 'snapshot', report.snapshotId)\n : undefined;\n const links = { live, ...(snapshot && { snapshot }) };\n const markdown = reportMarkdown(report, links);\n switch (reportFormat(req)) {\n case 'md':\n res.set('content-type', 'text/markdown; charset=utf-8').send(markdown);\n return;\n case 'text':\n res\n .set('content-type', 'text/plain; charset=utf-8')\n .send(reportText(report, links));\n return;\n case 'html': {\n const { renderReport } = await pages();\n res.type('html').send(\n renderReport(matrix, report, {\n markdown,\n text: reportText(report, links),\n liveUrl: live,\n ...(frozen && { snapshots: frozen })\n })\n );\n return;\n }\n default:\n res.json(reportJson(report));\n }\n }\n\n // A store that could not be read, even after retrying: say so and ask for\n // a retry, rather than show a report as if nothing had been recorded.\n app.use(\n (\n err: unknown,\n _req: Request,\n res: Response,\n next: (err?: unknown) => void\n ) => {\n if (!(err instanceof StoreUnavailableError)) return next(err);\n if (res.headersSent) return;\n res.status(503).json({ error: err.message });\n }\n );\n\n return { app, sessions, matrix };\n}\n\nexport function summarise(ref: CellRef, checks: ShownCheck[]) {\n return {\n runId: ref.runId,\n revision: ref.revision,\n scenario: ref.scenarioName,\n summary: summarize(checks),\n // A not-seen FAILURE reads NOT_SEEN, so the rows count as the summary.\n checks: jsonRows(checks)\n };\n}\n\n/** What a cell's results say about the cell itself, next to its checks. */\nexport interface CellStatus {\n scoring: MatrixCell['scoring'];\n verdict: Verdict;\n /** Where the cell stands, finer than the verdict (see CellState). */\n state: CellState;\n /**\n * On a startable incomplete cell: why, in plain words — nothing recorded\n * yet, or the checks listed are only what the scenario still expects. On\n * a waiting cell: that it waits for the flow to finish.\n */\n note?: string;\n /** For n/a (why the scenario does not apply) and not_scored/unlisted. */\n reason?: string;\n /** Present, false, when this deployment cannot start the cell. */\n startable?: false;\n startReason?: string;\n}\n\nexport function cellStatus(\n cell: MatrixCell,\n results: Parameters[1],\n now?: number\n): CellStatus & { shown: ShownCheck[] } {\n const { verdict, state, note, shown } = viewCell(cell, results, now);\n return {\n scoring: cell.scoring,\n verdict,\n state,\n ...(note && { note }),\n ...(cell.reason !== undefined && { reason: cell.reason }),\n ...(!cell.startable &&\n cell.scoring !== 'n/a' && {\n startable: false as const,\n ...(cell.startReason !== undefined && { startReason: cell.startReason })\n }),\n shown: shown ?? []\n };\n}\n","deleted",false,"label",[47,48,24],"src","hosted","7dcb6042-d92f-40c5-9cc8-0f661f96e58b",["D",1789043604380],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","imageUrl","userId","f4518a30-f52b-4b12-891c-a8fffb7240f8","pinnedFileId","e6dd13e2-ad13-11f1-a612-1607ee4eb77e","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","01a07c12-b73a-76de-b96a-421ce8582af6","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_9":10,"_105":-5},"org",{"_9":10,"_99":100,"_101":-5,"_58":-5,"_102":103,"_104":44},"branch",{"_37":89,"_11":90,"_22":30,"_91":49,"_92":-5,"_93":-5,"_94":-5,"_95":-5,"_96":-5,"_97":12,"_98":10},"isOwned",396,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","MCP Conformance","avatar","tier","free","canRestrictVals","profileImageUrl","ctx",{"_82":-5,"_139":140,"_141":142,"_143":144,"_145":44,"_146":44,"_147":44,"_148":34,"_149":-5,"_150":-7,"_151":-7,"_152":66,"_153":44,"_154":44,"_155":-5,"_156":44,"_157":44,"_158":44,"_159":-5},"ENV",{"_110":111,"_112":113,"_114":90,"_115":116,"_117":118,"_119":120,"_121":122,"_123":124,"_125":126,"_127":128,"_129":130,"_131":132,"_133":134,"_135":136,"_137":138},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town","orgs",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]