[{"_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/report.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/report.ts","extension","id","4387397a-cbc8-4bb4-b91d-50965a9555bc","report.ts","fileId","b1e76244-ae14-11f1-9d69-1607ee4eb77e","parentId","11abc952-e3be-41e6-ac33-6929c3af1284","branchId","fdc11199-683b-41f1-a3c5-d5ac53972f86","branchVersion",392,"latest",true,"createdAt",["D",1789379129291],"version",9,"fileType","script","content","/**\n * Verdicts for a run: the matrix with a result per cell.\n *\n * pass checks recorded, none FAILURE\n * fail any FAILURE seen in the client's traffic\n * incomplete the cell exists but nothing was recorded, or it was never\n * hit, or its only FAILUREs are ones not seen yet (a step the\n * flow has not reached)\n * n/a the scenario does not apply to the revision\n *\n * Each cell also has a `state` that splits `incomplete` into not tried, in\n * progress and incomplete (see CellState), and, once the client reached it,\n * its failures and warnings one line each; the run's are grouped by cause\n * (see ./findings.ts). The verdict itself is unchanged by either.\n *\n * Per column, `scored` counts passes among every cell the revision's\n * requirement set scores — N is the yaml's count, whether or not this\n * deployment can start the cell — and says separately how many of those N\n * are startable here; not_scored and unlisted cells are reported next to the\n * score, never inside it. Only FAILURE decides a verdict — INFO checks such\n * as the client identity the hosted layer records never do.\n */\n\nimport type { ConformanceCheck } from '../types.ts';\nimport type { Step } from '../steps/index.ts';\nimport type { HostedMatrix, MatrixCell } from './matrix.ts';\nimport { cellId, type CellRef, type RunResults } from './session.ts';\nimport { identitiesIn, mergeIdentities, type ClientIdentity } from './identity.ts';\nimport { shownChecks, type ShownCheck } from './shown.ts';\nimport type { BuildInfo } from './build.ts';\nimport {\n awaitingSignIn,\n eraStop,\n eraStopText,\n findingsOf,\n groupCauses,\n legacyStop,\n stopCauseKey,\n type Cause,\n type CellFindings,\n type Finding\n} from './findings.ts';\n\nexport type Verdict = 'pass' | 'fail' | 'incomplete' | 'n/a';\n\n/**\n * Where a cell stands, finer than its verdict: `incomplete` is split by\n * whether the client got there at all.\n *\n * not-tried no request reached the cell\n * in-progress the client reached it but has not yet done anything its\n * scenario tests (it lists what it is waiting for)\n * incomplete the client reached it and stopped before the scenario\n * could test anything, for a reason the server saw: it spoke\n * only an older revision and did not retry\n * not-startable this deployment cannot start the cell\n *\n * and one more whose checks were judged:\n *\n * waiting every FAILURE is \"not seen\" — the scenario's own\n * expectation that nothing has met yet (see ./shown.ts),\n * none from the client's traffic: an auth flow sitting on a\n * consent screen, an elicitation form still to answer. Its\n * verdict is `incomplete`, not `fail` (see viewCell()).\n * stopped a waiting cell whose client has sent nothing for\n * STOPPED_AFTER_MS, with no step a person is known to be\n * taking (a sign-in page opened, a form handed over and not\n * answered): the client most likely crashed or gave up. Its\n * verdict is `incomplete` too; only the label differs.\n *\n * `pass`, `fail` and `n/a` are the verdict's. The score is never changed by\n * the state.\n */\nexport type CellState =\n | 'pass'\n | 'fail'\n | 'waiting'\n | 'stopped'\n | 'in-progress'\n | 'incomplete'\n | 'not-tried'\n | 'not-startable'\n | 'n/a';\n\n/** What a `waiting` cell's note says. */\nexport const WAITING_NOTE =\n 'waiting for the client or the person to finish the flow';\n\n/** How long a waiting cell's client may be silent before it reads stopped. */\nexport const STOPPED_AFTER_MS = 60_000;\n\n/** What a `stopped` cell's note says, `quietMs` after the last request. */\nexport function stoppedNote(quietMs: number): string {\n const minutes = Math.floor(quietMs / 60_000);\n return `stopped: no request from your client for ${minutes} minute${minutes === 1 ? '' : 's'}; re-run it`;\n}\n\n/** What a cell's results say, as the pages read them. */\nexport type CellResults = Pick<\n RunResults,\n | 'checks'\n | 'recorded'\n | 'lastRequestAt'\n | 'awaitingInput'\n | 'attempt'\n | 'resetAt'\n | 'fresh'\n>;\n\n/** What a cell reset since its client's last request says. */\nexport function freshNote(\n results: Pick\n): string {\n const at = results.resetAt ? ` at ${results.resetAt.slice(11, 19)} UTC` : '';\n return `reset${at}: attempt ${results.attempt ?? 2} starts with your client’s next request`;\n}\n\n/**\n * How long a waiting cell's client has been silent at `now`, in ms, when\n * that means it stopped: STOPPED_AFTER_MS or more since its last request,\n * with no step a person is known to be taking — a sign-in page opened and\n * no token asked for, or a form handed over and not answered. Undefined\n * otherwise, including when no request time is known.\n */\nexport function stoppedFor(\n results: Pick,\n now: number\n): number | undefined {\n const quiet = now - Date.parse(results.lastRequestAt ?? '');\n if (!(quiet >= STOPPED_AFTER_MS)) return undefined;\n if (results.awaitingInput || awaitingSignIn(results.checks)) return undefined;\n return quiet;\n}\n\n/** `checks` as shown (./shown.ts), so a \"not seen\" row can be told apart. */\nexport function stateOf(\n cell: Pick,\n verdict: Verdict,\n checks: readonly ShownCheck[] | undefined\n): CellState {\n if (verdict === 'fail' && checks && onlyNotSeen(checks)) return 'waiting';\n if (verdict !== 'incomplete') return verdict;\n if (!cell.startable) return 'not-startable';\n if (!checks) return 'not-tried';\n return legacyStop(checks) || eraStop(checks) ? 'incomplete' : 'in-progress';\n}\n\nfunction onlyNotSeen(checks: readonly ShownCheck[]): boolean {\n const failures = checks.filter((c) => c.status === 'FAILURE');\n return failures.length > 0 && failures.every((c) => c.notSeen);\n}\n\n/** A cell's results as every page shows them: rows, verdict, state, note. */\nexport interface CellView {\n verdict: Verdict;\n state: CellState;\n /** On a startable incomplete cell or a waiting one: why, in plain words. */\n note?: string;\n /** The rows (./shown.ts); absent when the cell was never exercised. */\n shown?: ShownCheck[];\n}\n\nexport function viewCell(\n cell: Pick,\n results: CellResults | undefined,\n now: number = Date.now()\n): CellView {\n // Reset, and nothing has reached the new attempt: not tried, as a cell\n // no request reached reads, with a note saying so.\n if (results?.fresh) {\n if (cell.scoring === 'n/a') return { verdict: 'n/a', state: 'n/a' };\n return {\n verdict: 'incomplete',\n state: cell.startable ? 'not-tried' : 'not-startable',\n note: freshNote(results)\n };\n }\n const shown = results\n ? shownChecks(cell.scenario, cell.revision, results.checks)\n : undefined;\n const judged = verdictFor(cell, results?.checks, results?.recorded);\n const stood = stateOf(cell, judged, shown);\n // A waiting cell whose client has gone quiet, with no step a person is\n // known to be taking, has stopped: said so, so nobody waits on it.\n const quiet =\n stood === 'waiting' && results ? stoppedFor(results, now) : undefined;\n const state: CellState = quiet === undefined ? stood : 'stopped';\n // Every failure only \"not seen\": nothing the client did has failed, so\n // the cell is not done rather than failed. Neither verdict scores.\n const verdict: Verdict =\n state === 'waiting' || state === 'stopped' ? 'incomplete' : judged;\n const note =\n quiet !== undefined\n ? stoppedNote(quiet)\n : state === 'waiting'\n ? WAITING_NOTE\n : verdict === 'incomplete' && cell.startable\n ? incompleteNote(shown ?? [])\n : undefined;\n return { verdict, state, ...(note && { note }), ...(shown && { shown }) };\n}\n\nexport interface CheckSummary {\n passed: number;\n /** FAILUREs seen in the client's traffic. */\n failed: number;\n /**\n * FAILUREs that are the scenario's own expectations nothing has met yet\n * (the flow did not reach the step): a FAILURE row, but not the client's.\n */\n notSeen: number;\n warnings: number;\n info: number;\n skipped: number;\n total: number;\n}\n\nexport interface CellReport {\n scenario: string;\n revision: string;\n scoring: MatrixCell['scoring'];\n reason?: string;\n startable: boolean;\n startReason?: string;\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 (incompleteNote()).\n * On a waiting cell: WAITING_NOTE.\n */\n note?: string;\n /** Absent when the cell was never exercised or does not apply. */\n summary?: CheckSummary;\n /**\n * On a cell the client reached: its failures and warnings, one line each,\n * marked client or scenario. On an `in-progress` cell they are only what\n * the scenario is still waiting for.\n */\n findings?: Finding[];\n /** On an `incomplete` cell: the cause that stopped it (RunReport.causes). */\n cause?: string;\n resultsUrl: string;\n identities?: ClientIdentity[];\n /** The cell's current attempt, when it has been reset (2 or more). */\n attempt?: number;\n /**\n * On a `not-tried` cell as served (withNotTriedHints()), never stored:\n * the cell's MCP URL, and what the client must do there.\n */\n mcpUrl?: string;\n hint?: string;\n}\n\nexport interface ColumnReport {\n revision: string;\n /**\n * Passes among the cells the requirement set scores, out of all of them\n * (`total`, the yaml's count), with how many of those this deployment\n * can start (`startable`).\n */\n scored: { passed: number; total: number; startable: number };\n cells: CellReport[];\n /** The not_scored / unlisted cells that were exercised, with verdicts. */\n notScored: CellReport[];\n /** How many of the column's cells stand where, n/a cells left out. */\n counts: Partial>;\n identities: ClientIdentity[];\n}\n\nexport interface RunReport {\n runId: string;\n revision?: string;\n /** When the report was built (ISO 8601). */\n generatedAt: string;\n columns: ColumnReport[];\n /** Every client identity seen anywhere in the run. */\n identities: ClientIdentity[];\n /**\n * Every grouped finding said once, with the cells it covers: client\n * causes first, then those covering the most cells (see ./findings.ts).\n */\n causes: Cause[];\n /** On a frozen copy (POST /results//freeze): its id and time. */\n snapshotId?: string;\n frozenAt?: string;\n /**\n * On a frozen copy: the cells whose pages were frozen with it, as\n * `/` (every cell the client had reached); absent on a\n * copy frozen before cell pages were.\n */\n frozenCells?: string[];\n /**\n * The server build that produced the report (see ./build.ts): stored with\n * a frozen copy, so it says which build it came from. Absent on a copy\n * frozen before builds were recorded.\n */\n server?: BuildInfo;\n}\n\n/** A finding as the run report's JSON gives it (see reportJson()). */\nexport interface JsonFinding extends Omit {\n status: Finding['status'] | 'NOT_SEEN';\n}\n\ntype JsonCell = Omit & { findings?: JsonFinding[] };\n\nexport interface JsonRunReport extends Omit {\n columns: (Omit & {\n cells: JsonCell[];\n notScored: JsonCell[];\n /** Startable cells nothing reached (see groupColumn()). */\n notTried: JsonCell[];\n /** Cells this deployment cannot start (see groupColumn()). */\n unavailable: JsonCell[];\n })[];\n}\n\n/**\n * The run report as its JSON gives it: a FAILURE that is the scenario's own\n * expectation not yet met (`by: \"scenario\"`) reads NOT_SEEN, as a cell's\n * rows do (./shown.ts jsonRows()), and each column adds its `notTried` and\n * `unavailable` cells as lists of their own (`cells` still has every cell).\n * Presentation only: the HTML, the Markdown, the causes, every count and a\n * frozen copy's stored form are built from the report as it is.\n */\nexport function reportJson(report: RunReport): JsonRunReport {\n const cell = (c: CellReport): JsonCell =>\n c.findings\n ? {\n ...c,\n findings: c.findings.map((f) =>\n f.by === 'scenario' && f.status === 'FAILURE'\n ? { ...f, status: 'NOT_SEEN' }\n : f\n )\n }\n : c;\n return {\n ...report,\n columns: report.columns.map((col) => {\n const { notTried, unavailable } = groupColumn(col);\n return {\n ...col,\n cells: col.cells.map(cell),\n notScored: col.notScored.map(cell),\n notTried: notTried.map(cell),\n unavailable: unavailable.map(cell)\n };\n })\n };\n}\n\n/**\n * A column's cells in the order every form of the report lists them, n/a\n * cells left out: what needs a look, what the client has not tried, what\n * passed; and apart, what this deployment cannot start.\n */\nexport interface ColumnGroups {\n /** Reached, not passing: fail, then waiting, in progress, incomplete. */\n problems: CellReport[];\n /** Startable cells no request reached. */\n notTried: CellReport[];\n passed: CellReport[];\n /** Cells this deployment cannot start (and nothing reached). */\n unavailable: CellReport[];\n}\n\nconst PROBLEMS: readonly CellState[] = [\n 'fail',\n 'waiting',\n 'stopped',\n 'in-progress',\n 'incomplete'\n];\n\n/**\n * Grouped by `state` alone, so a frozen copy stored before the groups\n * existed is grouped the same way when it is read.\n */\nexport function groupColumn(col: Pick): ColumnGroups {\n const of = (state: CellState) => col.cells.filter((c) => c.state === state);\n return {\n problems: PROBLEMS.flatMap(of),\n notTried: of('not-tried'),\n passed: of('pass'),\n unavailable: of('not-startable')\n };\n}\n\n/** A scenario this deployment cannot start, once for all its revisions. */\nexport interface UnavailableScenario {\n scenario: string;\n revisions: string[];\n reason: string;\n}\n\nexport function unavailableScenarios(\n report: Pick\n): UnavailableScenario[] {\n const out = new Map();\n for (const col of report.columns) {\n for (const c of groupColumn(col).unavailable) {\n const reason = c.startReason ?? '';\n const key = `${c.scenario}\\n${reason}`;\n const seen = out.get(key);\n if (seen) seen.revisions.push(c.revision);\n else {\n out.set(key, { scenario: c.scenario, revisions: [c.revision], reason });\n }\n }\n }\n return Array.from(out.values());\n}\n\n/** Auth scenarios whose client gets its token without a sign-in page. */\nexport const NO_SIGN_IN =\n /^auth\\/(client-credentials-|wif-|enterprise-managed-)/;\n\n/** How many of a cell's steps a hint names before \"and N more\". */\nconst HINT_STEPS = 3;\n\n/** A step described longer than this names its tool without arguments. */\nconst HINT_STEP_CHARS = 60;\n\n/**\n * What a client must do at a cell, in a line: its steps when it has them,\n * else the sign-in for an auth cell, else what the scenario tests. `describe`\n * is ../steps describeStep(), passed in so this module does not load the\n * step schemas (see ./server.ts pages()).\n */\nexport function notTriedHint(\n cell: Pick,\n description: string,\n describe: (step: Step) => string\n): string {\n const steps = cell.steps ?? [];\n if (steps.length) {\n const short = (step: Step) => {\n const said = describe(step);\n return step.op === 'tools/call' && said.length > HINT_STEP_CHARS\n ? `call ${step.name} with the arguments on the cell’s page`\n : said;\n };\n const named = steps.slice(0, HINT_STEPS).map(short);\n const more = steps.length - named.length;\n return (\n `connect, then ${named.join(', then ')}` +\n (more ? `, and ${more} more step${more === 1 ? '' : 's'}` : '')\n );\n }\n if (cell.scenario.startsWith('auth/')) {\n return NO_SIGN_IN.test(cell.scenario)\n ? 'connect; it gets its token itself, with the credentials the cell gives it'\n : 'connect and approve the sign-in (the test authorization server approves at once), then list the tools';\n }\n const what = description\n .split('\\n')[0]\n .trim()\n .replace(/^tests?\\s+/i, '');\n return what ? `connect; the cell tests ${what}` : 'connect';\n}\n\n/**\n * The report with each not-tried cell's MCP URL and hint added, for the\n * page and every export. Never stored: a frozen copy gets them when it is\n * read, at the host it is read through, like its results links.\n */\nexport function withNotTriedHints(\n report: RunReport,\n matrix: HostedMatrix,\n cellUrl: (ref: CellRef) => string,\n describe: (step: Step) => string\n): RunReport {\n const descriptions = new Map(\n matrix.rows.map((r) => [r.scenario, r.description])\n );\n const add = (c: CellReport): CellReport => {\n const cell =\n c.state === 'not-tried' ? matrix.cell(c.scenario, c.revision) : undefined;\n if (!cell) return c;\n const ref: CellRef = {\n runId: report.runId,\n revision: cell.revision,\n scenarioName: cell.scenario\n };\n return {\n ...c,\n mcpUrl: `${cellUrl(ref)}${cell.mcpPath}`,\n hint: notTriedHint(cell, descriptions.get(c.scenario) ?? '', describe)\n };\n };\n return {\n ...report,\n columns: report.columns.map((col) => ({\n ...col,\n cells: col.cells.map(add)\n }))\n };\n}\n\n/** Counts over a cell's rows as shown (see ./shown.ts): a repeat is one. */\nexport function summarize(checks: readonly ShownCheck[]): CheckSummary {\n const counts = { SUCCESS: 0, FAILURE: 0, WARNING: 0, SKIPPED: 0, INFO: 0 };\n let notSeen = 0;\n for (const c of checks) {\n if (c.status === 'FAILURE' && c.notSeen) notSeen++;\n else counts[c.status]++;\n }\n return {\n passed: counts.SUCCESS,\n failed: counts.FAILURE,\n notSeen,\n warnings: counts.WARNING,\n info: counts.INFO,\n skipped: counts.SKIPPED,\n total: checks.length\n };\n}\n\n/**\n * `recorded` is what the scenario itself observed; judgement may add\n * \"expected but never seen\" failures to `checks`, which must not turn a cell\n * nobody talked to into a `fail`.\n */\nexport function verdictFor(\n cell: Pick,\n checks: ConformanceCheck[] | undefined,\n recorded: number = checks?.length ?? 0\n): Verdict {\n if (cell.scoring === 'n/a') return 'n/a';\n if (!checks || recorded === 0) return 'incomplete';\n return checks.some((c) => c.status === 'FAILURE') ? 'fail' : 'pass';\n}\n\n/**\n * Why a startable cell reads `incomplete`, in plain words. Every FAILURE on\n * an incomplete cell is one of the scenario's expectations that nothing has\n * met yet (\"Tool was not called by client\"; see verdictFor()), so the counts\n * shown beside the verdict are what the scenario is still waiting for.\n */\nexport function incompleteNote(checks: readonly ConformanceCheck[]): string {\n if (!checks.length) {\n return 'nothing recorded yet — point the client at the MCP endpoint';\n }\n const waiting = checks.filter((c) => c.status === 'FAILURE').length;\n const lead =\n legacyOnly(checks) ??\n 'the client has not yet done anything this scenario tests';\n if (!waiting) return lead;\n return waiting === 1\n ? `${lead}; the failure listed is what it is still waiting for`\n : `${lead}; the ${waiting} failures listed are what it is still waiting for`;\n}\n\n/**\n * Said when a legacy initialize, or requests at another revision that the\n * cell turned away (eraStop()), are all the cell has seen of the client.\n */\nfunction legacyOnly(checks: readonly ConformanceCheck[]): string | undefined {\n const stop = legacyStop(checks);\n if (!stop) {\n const era = eraStop(checks);\n return era && eraStopText(era);\n }\n return stop.asked\n ? `the client spoke ${stop.asked} only (it opened with initialize) and did not retry at ${stop.served}`\n : `the client only sent initialize, the legacy handshake, and did not retry at ${stop.served}`;\n}\n\nexport interface ReportSources {\n /** Cells of the run that were exercised (in memory or in the store). */\n listCells(runId: string): Promise;\n results(id: string): Promise;\n resultsUrl(ref: CellRef): string;\n /** The server build, recorded in the report (RunReport.server). */\n build?: BuildInfo;\n /** The time the report is built at (ms); defaults to the clock. */\n now?: () => number;\n}\n\nexport async function buildReport(\n matrix: HostedMatrix,\n runId: string,\n revision: string | undefined,\n sources: ReportSources\n): Promise {\n const exercised = new Set(\n (await sources.listCells(runId)).map((ref) => cellId(ref))\n );\n const columns: ColumnReport[] = [];\n const now = sources.now?.() ?? Date.now();\n const allIdentities = new Map();\n const reached: CellFindings[] = [];\n\n for (const rev of matrix.revisions) {\n if (revision !== undefined && rev !== revision) continue;\n const cells: CellReport[] = [];\n const identities = new Map();\n for (const row of matrix.rows) {\n const cell = matrix.cell(row.scenario, rev)!;\n const ref: CellRef = {\n runId,\n revision: cell.revision,\n scenarioName: cell.scenario\n };\n const id = cellId(ref);\n const got =\n cell.scoring !== 'n/a' && exercised.has(id)\n ? await sources.results(id)\n : undefined;\n // A cell reset since its client's last request is judged as not\n // tried (viewCell()); its earlier attempts are its own page's.\n const results = got?.fresh ? undefined : got;\n const seen = results ? identitiesIn(results.checks) : [];\n mergeIdentities(identities, seen);\n mergeIdentities(allIdentities, seen);\n const { verdict, state, note, shown } = viewCell(cell, got, now);\n // What stopped the client: a legacy handshake, or (on a cell that\n // reads incomplete for it) requests at another revision turned away.\n const stop = results\n ? (legacyStop(results.checks) ??\n (state === 'incomplete' ? eraStop(results.checks) : undefined))\n : undefined;\n // An in-progress cell's findings, and a waiting cell's not-seen ones,\n // are only what it waits for: listed on its row, never grouped as\n // causes (nothing went wrong yet).\n const findings = results\n ? findingsOf(\n cell.scenario,\n cell.revision,\n results.checks,\n stop,\n state !== 'in-progress'\n ).map((f) =>\n (state === 'waiting' || state === 'stopped') && f.by === 'scenario'\n ? { ...f, cause: undefined }\n : f\n )\n : undefined;\n const stoppedBy =\n state === 'incomplete' && stop ? stopCauseKey(stop) : undefined;\n if (results) {\n reached.push({\n cell: `${cell.revision}/${cell.scenario}`,\n findings: findings ?? [],\n ...(stop && { stop }),\n ...(stoppedBy && { stoppedBy })\n });\n }\n cells.push({\n scenario: cell.scenario,\n revision: cell.revision,\n scoring: cell.scoring,\n ...(cell.reason !== undefined && { reason: cell.reason }),\n startable: cell.startable,\n ...(cell.startReason !== undefined && {\n startReason: cell.startReason\n }),\n verdict,\n state,\n ...(note && { note }),\n ...(shown && { summary: summarize(shown) }),\n ...(findings?.length && { findings }),\n ...(stoppedBy && { cause: stoppedBy }),\n resultsUrl: sources.resultsUrl(ref),\n ...(seen.length && { identities: seen }),\n ...((got?.attempt ?? 1) > 1 && { attempt: got!.attempt })\n });\n }\n const counts: Partial> = {};\n for (const c of cells) {\n if (c.state !== 'n/a') counts[c.state] = (counts[c.state] ?? 0) + 1;\n }\n const scoredCells = cells.filter((c) => c.scoring === 'scored');\n columns.push({\n revision: rev,\n scored: {\n passed: scoredCells.filter((c) => c.verdict === 'pass').length,\n total: scoredCells.length,\n startable: scoredCells.filter((c) => c.startable).length\n },\n cells,\n notScored: cells.filter(\n (c) =>\n (c.scoring === 'not_scored' || c.scoring === 'unlisted') &&\n c.summary !== undefined\n ),\n counts,\n identities: Array.from(identities.values())\n });\n }\n\n return {\n runId,\n ...(revision !== undefined && { revision }),\n generatedAt: new Date().toISOString(),\n columns,\n identities: Array.from(allIdentities.values()),\n causes: groupCauses(reached),\n ...(sources.build && { server: sources.build })\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"]