[{"_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/session.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/session.ts","extension","id","7c9bf96f-1414-4f2f-9ed0-a76a67ac9efb","session.ts","fileId","d48fd9ae-ad13-11f1-9b49-1607ee4eb77e","parentId","11abc952-e3be-41e6-ac33-6929c3af1284","branchId","fdc11199-683b-41f1-a3c5-d5ac53972f86","branchVersion",395,"latest",true,"createdAt",["D",1789379131411],"version",14,"fileType","script","content","/**\n * Session management for the hosted conformance server.\n *\n * A \"cell\" is one scenario exercised at one specification revision inside a\n * run. Its id, `//`, is at once the URL path the\n * client is pointed at, the store key and the results path. Each cell owns a\n * fresh Scenario instance built for that revision's wire and the\n * RequestListener it returns from handler() — no loopback port, no proxy.\n * Cells are created lazily on first reference and can be rebuilt from their\n * id alone, which is what lets a cold serverless isolate answer for a run it\n * never saw (an aux-origin request arriving before the RS was ever hit, say).\n */\n\nimport { randomBytes } from 'node:crypto';\nimport {\n Scenario,\n ConformanceCheck,\n RequestListener,\n AuthHandlerScenario,\n AuxOriginRole,\n SpecVersion,\n isSpecVersion\n} from '../types.ts';\nimport type {\n MockHandler,\n RequestHandlers,\n ScenarioContext\n} from '../mock-server/index.ts';\nimport { isStatefulVersion } from '../connection/versions.ts';\nimport { hostedScenarios } from './catalog.ts';\nimport {\n MemoryRunStore,\n attemptOfWriter,\n attemptWriter,\n type RunStore\n} from './store.ts';\nimport {\n addExchange,\n addIssued,\n emptyRow,\n mergeRows,\n substance,\n type Exchange,\n type TrafficRow\n} from './traffic.ts';\nimport { missingRelaysReason, NOT_HOSTED_REASON } from './matrix.ts';\nimport {\n addProtocolVersion,\n atCellRevision,\n identityCheck,\n identityChecksIn,\n identityKey,\n identityOf,\n IDENTITY_CHECK_ID,\n type IdentityObservation\n} from './identity.ts';\nimport {\n ACTIVITY_CHECK_ID,\n activityCheck,\n AUTH_STOP_CHECK_ID,\n REVISION_REACHED_CHECK_ID,\n REVISION_SPOKEN_CHECK_ID,\n revisionNotSpokenCheck,\n signedInAuthStop\n} from './wire.ts';\n\n/**\n * Store writer suffix for the hosted layer's own checks (client identity,\n * probe notes, …). Their row belongs to one build of a cell in one process\n * (HostedRun.hostedWriter), not to the process.\n */\nconst HOSTED_WRITER_SUFFIX = '/hosted';\n\n/**\n * Run ids are one path segment: safe in URLs and after the relay's /r/.\n * Any such id is accepted (pick your own, or keep an older minted one);\n * mintRunId() only draws from the unambiguous alphabet below.\n */\nexport const RUN_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;\n\n/**\n * Crockford's base32 alphabet in lower case: no i, l, o or u, so an id read\n * off a monospace breadcrumb or a screenshot can't be misread (O vs 0).\n */\nconst ID_ALPHABET = '0123456789abcdefghjkmnpqrstvwxyz';\n\n/** A random id of `length` characters from ID_ALPHABET (5 bits each). */\nexport function mintId(length: number): string {\n let id = '';\n for (const byte of randomBytes(length)) id += ID_ALPHABET[byte & 31];\n return id;\n}\n\nexport function mintRunId(): string {\n return mintId(10);\n}\n\n/** One scenario at one revision inside one run. */\nexport interface CellRef {\n runId: string;\n revision: SpecVersion;\n scenarioName: string;\n}\n\n/** `//` — scenario names may contain '/'. */\nexport function cellId(ref: CellRef): string {\n return `${ref.runId}/${ref.revision}/${ref.scenarioName}`;\n}\n\nexport function parseCellId(id: string): CellRef | undefined {\n const [runId, revision, ...rest] = id.split('/');\n if (!RUN_ID_RE.test(runId ?? '') || !isSpecVersion(revision) || !rest.length)\n return undefined;\n return { runId, revision, scenarioName: rest.join('/') };\n}\n\n/**\n * Per-cell context for a hosted scenario: the column's revision is the wire\n * the mock speaks, exactly as `--spec-version` sets it for the CLI runner\n * (src/runner/client.ts). `createServer()` would bind a loopback port, which\n * serverless hosts don't allow — hosted scenarios use `createHandler()`.\n */\nexport function hostedScenarioContext(\n specVersion: SpecVersion\n): ScenarioContext {\n return {\n specVersion,\n createServer: () =>\n Promise.reject(\n new Error(\n 'ScenarioContext.createServer() binds a loopback port and is not available when hosted; use createHandler()'\n )\n ),\n createHandler: (handlers) => mockFactory(specVersion)(handlers, specVersion)\n };\n}\n\ntype MockFactory = (\n handlers: RequestHandlers,\n specVersion: SpecVersion\n) => MockHandler;\n\n/**\n * The mock servers cells are built on, one per lifecycle, each loaded with\n * the first cell that needs it (see loadCells()): the stateful one brings the\n * SDK server, which a stateless cell never needs.\n */\nconst mockFactories: { stateful?: MockFactory; stateless?: MockFactory } = {};\n\nfunction mockFactory(specVersion: SpecVersion): MockFactory {\n const factory = isStatefulVersion(specVersion)\n ? mockFactories.stateful\n : mockFactories.stateless;\n if (!factory) {\n throw new Error(\n `the mock server for ${specVersion} is not loaded; await loadCells() before building its cells`\n );\n }\n return factory;\n}\n\nasync function loadMock(specVersion: SpecVersion): Promise {\n if (isStatefulVersion(specVersion)) {\n mockFactories.stateful ??= (\n await import('../mock-server/stateful.ts')\n ).createHandlerStateful;\n } else {\n mockFactories.stateless ??= (\n await import('../mock-server/stateless.ts')\n ).createHandlerStateless;\n }\n}\n\n/**\n * Load what building these cells needs: each one's scenario and the mock\n * server of its revision. A request loads what it touches and nothing more,\n * so a cold process answers it without evaluating every scenario module.\n */\nexport async function loadCells(\n cells: Iterable>\n): Promise {\n const list = Array.from(cells);\n const revisions = new Set(list.map((c) => c.revision));\n await Promise.all([\n hostedScenarios.load(list.map((c) => c.scenarioName)),\n ...Array.from(revisions, loadMock)\n ]);\n}\n\n/** loadCells() for every scenario at each of `revisions`. */\nexport async function loadAllCells(\n revisions: readonly SpecVersion[]\n): Promise {\n await Promise.all([hostedScenarios.loadAll(), ...revisions.map(loadMock)]);\n}\n\nexport interface HostedRun extends CellRef {\n /** Cell id — see cellId(). */\n id: string;\n scenario: Scenario;\n /** The mounted RS handler — invoke directly with (req, res). */\n listener: RequestListener;\n /** Aux-origin handlers (AS, IdP, …) for auth scenarios. */\n auxListeners?: Partial>;\n /** Sub-path under the cell URL where the MCP endpoint lives. */\n mcpPath: string;\n createdAt: number;\n lastSeenAt: number;\n /** Scenario-provided client context (credentials, steps, …). */\n context?: Record;\n /** Whether the store has been told this cell exists. */\n saved: boolean;\n /**\n * Whether any request was dispatched to the cell. A cell created only to\n * answer a config request has not been exercised and stays out of the\n * results listing.\n */\n touched: boolean;\n /**\n * Checks the hosted layer records about the cell (client identity, wire\n * rejections, revision discipline), kept apart from the scenario's own log\n * so they never enter its judgement.\n */\n hostedChecks: ConformanceCheck[];\n /**\n * The store row `hostedChecks` is written to. Each build of the cell gets\n * its own, so a cell evicted and rebuilt starts a new row instead of\n * writing over what the process recorded before, and never has to read\n * the old one first; results() merges the rows as it does other\n * processes'.\n */\n hostedWriter: string;\n /** The identity check per client (name, version) already recorded. */\n identities: Map;\n /** Keys of hosted checks already recorded, so each finding is one check. */\n hostedKeys: Set;\n /**\n * Checks seeded into the scenario from other processes' persisted rows\n * (see hydrate()), each with its JSON as seeded. They are those writers'\n * to persist, not ours — unless the scenario has changed one since.\n */\n seeded: Map;\n /**\n * Settled once an attempt to seed the cell from the store has finished;\n * cleared again when the store could not be read, so the next request\n * tries again.\n */\n hydration?: Promise;\n /** The cell holds the run's history: seeded, or there is none to seed. */\n hydrated?: true;\n /** The last write queued for the cell; writes land one after another. */\n lastWrite?: Promise;\n /** A write queued but not started yet: a persist() meanwhile joins it. */\n queuedWrite?: Promise;\n /** Each of this process's rows as last written (JSON), by writer id. */\n written: Map;\n /**\n * Which attempt at the cell this build serves: 1 until the cell is reset\n * (see SessionManager.reset()). Its checks and traffic go to rows of that\n * attempt (see attemptWriter()).\n */\n attempt: number;\n /** This build's traffic (see ./traffic.ts), written as a row of its own. */\n traffic: TrafficRow;\n /** Bytes of `traffic.exchanges` so far, for the row's cap. */\n trafficSize: { bytes: number };\n /** `traffic` as last written, without repeat counts (see substance()). */\n trafficWritten?: string;\n /**\n * Hashes of the credentials the cell issued in earlier attempts: a client\n * presenting one after a reset is treated as having none.\n */\n refused: Set;\n /**\n * Hashes of what the cell issued in this attempt in other processes (see\n * refreshIssued()): the test sign-in server may issue the same value\n * again (a fixed client_id, a code packed from the same request), and\n * what this attempt issued is the client's to use.\n */\n issuedNow: Set;\n /** Builds the cell's scenario and handlers afresh, for a new attempt. */\n build: () => CellParts;\n /** The move to a newer attempt under way, if any (see renew()). */\n renewal?: Promise;\n}\n\n/** What building a cell makes: its scenario and the handlers it mounts. */\nexport interface CellParts {\n scenario: Scenario;\n listener: RequestListener;\n auxListeners?: Partial>;\n mcpPath: string;\n context?: Record;\n}\n\nexport interface SessionManagerOptions {\n /** Idle ms after which a cell is evicted from memory. Default 5 minutes. */\n ttlMs?: number;\n sweepIntervalMs?: number;\n /**\n * Public origins of the relay deployments, keyed by role. Required for any\n * scenario that exposes `authHandlers()`. Each value is the relay's public\n * URL (no trailing slash); the per-cell AS issuer becomes\n * `/r///`.\n */\n auxOrigins?: Partial>;\n /**\n * Optional persistence so results survive being load-balanced across\n * processes (serverless isolates). Omit for a single long-lived process.\n */\n store?: RunStore;\n}\n\n/** Results view: the cell plus its judged checks. */\nexport interface RunResults extends CellRef {\n checks: ConformanceCheck[];\n /**\n * How many checks were recorded from traffic: the scenario's own raw log\n * (before judgement, which may add \"expected but never seen\" failures)\n * plus the hosted layer's FAILUREs (a request the wire turned away is\n * traffic too), but not its INFO checks. Zero means nothing was exercised\n * at the cell's revision: also zero when nothing failed and the client\n * never spoke it (see judgedAtRevision()).\n */\n recorded: number;\n /**\n * When the client last sent the cell a request (ISO 8601), as any process\n * saw it; absent when nothing records one.\n */\n lastRequestAt?: string;\n /**\n * The cell has handed the client something to put before a person (an\n * MRTR input_required result, a request on a stream still open) that no\n * answer has closed yet.\n */\n awaitingInput?: true;\n /** The attempt these results are from: the cell's current one. */\n attempt?: number;\n /** When a reset started the current attempt (ISO 8601). */\n resetAt?: string;\n /**\n * Nothing has reached the current attempt yet: the cell was reset and the\n * client has not sent it a request since.\n */\n fresh?: true;\n /** The attempts before the current one, oldest first, each judged. */\n earlier?: EarlierAttempt[];\n}\n\n/** An attempt before a cell's current one, as its results page lists it. */\nexport interface EarlierAttempt {\n attempt: number;\n /** When a reset started it (ISO 8601); absent for the first. */\n startedAt?: string;\n results: Pick<\n RunResults,\n 'checks' | 'recorded' | 'lastRequestAt' | 'awaitingInput'\n >;\n}\n\n/** Hosted checks that count as exercise: what went wrong on the wire. */\nfunction hostedFailures(checks: ConformanceCheck[]): number {\n return checks.filter((c) => c.status === 'FAILURE').length;\n}\n\n/**\n * The scenario's raw event log — what it actually observed — as opposed to\n * getChecks(), which for most client scenarios also appends \"expected X,\n * never saw it\" FAILUREs (and mutates). Persisting the raw log per process\n * and judging the merged log once is what makes multi-process hosting work.\n */\nexport function rawChecksOf(scenario: Scenario): ConformanceCheck[] {\n if (scenario.rawChecks) return scenario.rawChecks();\n const bag = (scenario as unknown as { checks?: unknown }).checks;\n if (Array.isArray(bag)) return bag as ConformanceCheck[];\n return scenario.getChecks();\n}\n\n/**\n * The scenario's log as an array the hosted server can seed from the store:\n * its plain `checks` array (what finalizeChecks() re-judges), when its\n * rawChecks(), if it has one, reads that same array. A scenario whose raw\n * view is something else is not seeded. A rebuilt cell that is not seeded\n * writes its process's row over with only what it saw since the rebuild.\n */\nfunction seedableLog(scenario: Scenario): ConformanceCheck[] | undefined {\n const bag = (scenario as unknown as { checks?: unknown }).checks;\n if (!Array.isArray(bag)) return undefined;\n if (scenario.rawChecks && scenario.rawChecks() !== bag) return undefined;\n return bag as ConformanceCheck[];\n}\n\n/**\n * New, unstarted instance of a registered scenario. Prefers `Scenario.fresh()`\n * so scenarios registered with constructor parameters keep them; falls back\n * to the no-arg constructor.\n */\nexport function freshScenario(proto: Scenario): Scenario {\n if (typeof proto.fresh === 'function') return proto.fresh();\n const Ctor = proto.constructor as new () => Scenario;\n return new Ctor();\n}\n\n/**\n * Judge a merged raw log with the scenario's own end-of-run logic by loading\n * it into a fresh instance. Falls back to the raw log for scenarios that\n * don't keep a plain `checks` array.\n */\nexport function finalizeChecks(\n scenarioName: string,\n merged: ConformanceCheck[],\n revision?: SpecVersion\n): ConformanceCheck[] {\n const proto = hostedScenarios.get(scenarioName);\n if (!proto) return merged;\n try {\n const scenario = freshScenario(proto);\n if (revision) scenario.judgeAt?.(revision);\n const fresh = scenario as unknown as {\n checks?: unknown;\n getChecks(): ConformanceCheck[];\n };\n if (!Array.isArray(fresh.checks)) return merged;\n fresh.checks = merged.map((c) => ({ ...c }));\n return fresh.getChecks();\n } catch {\n return merged;\n }\n}\n\n/** Default SessionManagerOptions.ttlMs (and the CLI's `--ttl`). */\nexport const DEFAULT_CELL_TTL_MS = 5 * 60_000;\n\nexport class SessionManager {\n private runs = new Map();\n /** How long a cell with no request stays in this process's memory. */\n readonly ttlMs: number;\n private readonly auxOrigins: Partial>;\n private sweeper: ReturnType;\n readonly store: RunStore | undefined;\n private pending = new Set>();\n /** Identifies this process's rows in the store. */\n readonly writerId = randomBytes(4).toString('hex');\n /** Cells built so far, numbering each build's hosted row. */\n private builds = 0;\n /**\n * Cells whose scenario row this process has written, whichever build of\n * the cell wrote it: only such a row can be written over with less.\n */\n private ownRows = new Set();\n /** Without a store: the challenge notes (see noteChallenge()). */\n private challenges = new MemoryRunStore();\n /**\n * Without a store: each cell's attempts, and what its earlier attempts\n * recorded (see renew()). This process is the only one.\n */\n private local = new MemoryRunStore();\n\n /** Where a cell's attempts and traffic live. */\n private get cells(): RunStore {\n return this.store ?? this.local;\n }\n\n /** The row id of this process's scenario checks for the run's attempt. */\n private rowOf(run: HostedRun): string {\n return attemptWriter(this.writerId, run.attempt);\n }\n\n constructor(opts: SessionManagerOptions = {}) {\n this.ttlMs = opts.ttlMs ?? DEFAULT_CELL_TTL_MS;\n this.auxOrigins = opts.auxOrigins ?? {};\n this.store = opts.store;\n const sweepIntervalMs = opts.sweepIntervalMs ?? 30_000;\n this.sweeper = setInterval(() => this.sweep(), sweepIntervalMs);\n this.sweeper.unref?.();\n }\n\n /**\n * Get the cell, creating it on first reference. `baseUrlFor` is the public\n * URL of the cell (no trailing slash) — the scenario embeds it in\n * self-referential responses (PRM `resource`, canary `$ref`s).\n */\n getOrCreate(ref: CellRef, baseUrlFor: (ref: CellRef) => string): HostedRun {\n const id = cellId(ref);\n const existing = this.runs.get(id);\n if (existing) {\n existing.lastSeenAt = Date.now();\n return existing;\n }\n\n const proto = hostedScenarios.get(ref.scenarioName);\n if (!proto) throw new UnknownScenarioError(ref.scenarioName);\n const build = () => this.buildCell(ref, id, proto, baseUrlFor);\n const run: HostedRun = {\n ...ref,\n id,\n ...build(),\n createdAt: Date.now(),\n lastSeenAt: Date.now(),\n saved: false,\n touched: false,\n hostedChecks: [],\n hostedWriter: `${this.writerId}.${++this.builds}${HOSTED_WRITER_SUFFIX}`,\n identities: new Map(),\n hostedKeys: new Set(),\n seeded: new Map(),\n written: new Map(),\n attempt: 1,\n traffic: emptyRow(),\n trafficSize: { bytes: 0 },\n refused: new Set(),\n issuedNow: new Set(),\n build\n };\n this.runs.set(id, run);\n return run;\n }\n\n /** A fresh scenario for the cell and the handlers it mounts. */\n private buildCell(\n ref: CellRef,\n id: string,\n proto: Scenario,\n baseUrlFor: (ref: CellRef) => string\n ): CellParts {\n const scenario = freshScenario(proto);\n const ctx = hostedScenarioContext(ref.revision);\n\n let listener: RequestListener;\n let auxListeners: HostedRun['auxListeners'];\n let context: Record | undefined;\n\n if (scenario instanceof AuthHandlerScenario) {\n // Multi-origin scenario: build RS + aux handlers from authHandlers().\n // Aux issuer is /r/ so the cell is recoverable\n // from any RFC 8414 well-known path the client constructs from it.\n const missing = scenario.auxRoles.filter((r) => !this.auxOrigins[r]);\n if (missing.length) {\n throw new NotHostableError(\n ref.scenarioName,\n missingRelaysReason(missing)\n );\n }\n const handlers = scenario.authHandlers({\n ...ctx,\n getRsBaseUrl: () => baseUrlFor(ref),\n getAuxBaseUrl: (role) => `${this.auxOrigins[role]}/r/${id}`\n });\n listener = handlers.rs;\n auxListeners = handlers.aux;\n } else if (scenario.handler) {\n listener = scenario.handler(() => baseUrlFor(ref), ctx);\n } else {\n throw new NotHostableError(ref.scenarioName);\n }\n\n // What start() would hand the CLI runner's client (credentials, tool\n // arguments, …): a hosted cell never runs start(), so ask directly.\n context = (\n scenario as unknown as {\n scenarioContext?: () => Record;\n }\n ).scenarioContext?.();\n const steps = (scenario as Scenario).steps;\n if (steps) context = { ...context, steps };\n return {\n scenario,\n listener,\n auxListeners,\n mcpPath: scenario.mcpPath ?? '',\n context\n };\n }\n\n /**\n * getOrCreate() plus hydrate(): the cell, seeded with what other processes\n * already recorded about it. What every request must go through before it\n * is dispatched, so a scenario that keys its behaviour on its own log (the\n * one-time rejection in request-metadata, say) sees the run's history and\n * not just this process's.\n */\n async acquire(\n ref: CellRef,\n baseUrlFor: (ref: CellRef) => string\n ): Promise {\n await loadCells([ref]);\n const run = this.getOrCreate(ref, baseUrlFor);\n await this.ready(run);\n return run;\n }\n\n /**\n * Seed the cell's scenario with the merged raw log the store holds for it,\n * once per cell per process. Only scenarios that keep a plain `checks`\n * array can be seeded (the same ones finalizeChecks() can re-judge); the\n * rest are left alone. Rows this process wrote itself (a cell evicted and\n * rebuilt) are loaded as its own, so they are persisted again rather than\n * dropped from its row. The hosted layer's rows are not seeded: each build\n * of a cell writes its own (HostedRun.hostedWriter). Without a store this\n * settles at once. It never rejects: when the store cannot be read, the\n * cell is served as it stands, `hydrated` stays unset and the next call\n * tries again.\n */\n hydrate(run: HostedRun): Promise {\n if (run.hydration) return run.hydration;\n const store = this.store;\n if (!store) {\n run.hydrated = true;\n return (run.hydration = Promise.resolve());\n }\n const attempt: Promise = (async () => {\n // A cell moved to a newer attempt meanwhile (renew()) seeds itself.\n const scenario = run.scenario;\n const bag = seedableLog(scenario);\n if (!bag) {\n run.hydrated = true;\n return;\n }\n const byWriter = await retrying(() => store.loadChecks(run.id));\n if (run.scenario !== scenario) return;\n run.hydrated = true;\n const own = this.rowOf(run);\n const merged: ConformanceCheck[] = [];\n for (const [writer, checks] of byWriter) {\n if (writer.endsWith(HOSTED_WRITER_SUFFIX)) continue;\n if (attemptOfWriter(writer) !== run.attempt) continue;\n for (const c of checks) {\n const copy = { ...c };\n if (writer !== own) run.seeded.set(copy, JSON.stringify(copy));\n merged.push(copy);\n }\n }\n if (!merged.length) return;\n merged.sort(byTime);\n bag.unshift(...merged);\n })().catch((e: unknown) => {\n logStoreError(e);\n if (run.hydration === attempt) run.hydration = undefined;\n });\n run.hydration = attempt;\n return attempt;\n }\n\n /**\n * What a request goes through before it is dispatched: the cell seeded\n * from the store (hydrate()), and for a scenario that decides how to\n * answer from its log (Scenario.answersFromLog), what other processes\n * have recorded since. Without that, a process whose copy of the log\n * predates another's request answers as if it had not happened.\n */\n async ready(run: HostedRun): Promise {\n const seededBefore = run.hydrated === true;\n const scenario = run.scenario;\n // Whether the cell was reset since, read beside the seeding: a reset\n // in another process means a fresh scenario here, seeded afresh.\n await Promise.all([this.syncAttempt(run), this.hydrate(run)]);\n if (run.scenario !== scenario) await this.hydrate(run);\n else if (seededBefore && run.scenario.answersFromLog)\n await this.refresh(run);\n if (run.refused.size) await this.refreshIssued(run);\n }\n\n /**\n * After a reset, what this attempt has issued so far in any process\n * (run.issuedNow), so a credential issued again is not refused. When the\n * store cannot be read, what this process knows stands.\n */\n private async refreshIssued(run: HostedRun): Promise {\n try {\n const rows = await retrying(() => this.cells.loadTraffic(run.id));\n for (const [writer, row] of rows) {\n if (attemptOfWriter(writer) !== run.attempt) continue;\n for (const h of row.issued) run.issuedNow.add(h);\n }\n } catch (e) {\n logStoreError(e);\n }\n }\n\n /**\n * The hashes of the credentials the cell refuses now: issued in an\n * earlier attempt, and not issued again in this one.\n */\n refusedNow(run: HostedRun): ReadonlySet {\n if (!run.refused.size) return run.refused;\n const now = new Set([...run.issuedNow, ...run.traffic.issued]);\n return new Set([...run.refused].filter((h) => !now.has(h)));\n }\n\n /**\n * Move the cell to the store's current attempt if it has been reset\n * since this process built it. When the store cannot be read, the cell\n * is served as it stands.\n */\n private async syncAttempt(run: HostedRun): Promise {\n let resets: number[];\n try {\n resets = await retrying(() => this.cells.loadAttempts(run.id));\n } catch (e) {\n logStoreError(e);\n return;\n }\n const attempt = resets.length + 1;\n if (attempt > run.attempt) await this.renewTo(run, attempt);\n }\n\n /** renew() once per newer attempt, however many requests notice it. */\n private renewTo(run: HostedRun, attempt: number): Promise {\n const next = (run.renewal ?? Promise.resolve()).then(() =>\n attempt > run.attempt ? this.renew(run, attempt) : undefined\n );\n run.renewal = next.catch(logStoreError);\n return run.renewal;\n }\n\n /**\n * Start attempt `attempt` at the cell in this process: a fresh scenario\n * and handlers, so nothing the client did before (a registration, a\n * token, a step the scenario counts) carries over, and new rows for its\n * checks and traffic. What the finished attempt recorded stays where it\n * is: its last write lands first, and without a store it is kept in\n * this process for results() to list. Every credential an earlier\n * attempt issued, in any process, is refused from now on (see\n * refusedCredential()).\n */\n private async renew(run: HostedRun, attempt: number): Promise {\n if (run.lastWrite) await run.lastWrite;\n const refused = new Set(run.refused);\n for (const h of run.traffic.issued) refused.add(h);\n if (!this.store && run.touched) {\n const raw = rawChecksOf(run.scenario).map((c) => ({ ...c }));\n await this.local.saveChecks(run.id, this.rowOf(run), raw);\n await this.local.saveChecks(run.id, run.hostedWriter, [\n ...run.hostedChecks.map((c) => ({ ...c }))\n ]);\n await this.local.saveTraffic(run.id, run.hostedWriter, run.traffic);\n }\n try {\n const rows = await retrying(() => this.cells.loadTraffic(run.id));\n for (const [writer, row] of rows) {\n if (attemptOfWriter(writer) >= attempt) continue;\n for (const h of row.issued) refused.add(h);\n }\n } catch (e) {\n logStoreError(e);\n }\n if (attempt <= run.attempt) return;\n const old = run.scenario;\n Object.assign(run, run.build(), {\n attempt,\n hostedChecks: [],\n hostedWriter: attemptWriter(\n `${this.writerId}.${++this.builds}${HOSTED_WRITER_SUFFIX}`,\n attempt\n ),\n identities: new Map(),\n hostedKeys: new Set(),\n seeded: new Map(),\n written: new Map(),\n hydration: undefined,\n hydrated: undefined,\n traffic: emptyRow(),\n trafficSize: { bytes: 0 },\n trafficWritten: undefined,\n refused,\n issuedNow: new Set()\n } satisfies Partial);\n try {\n await old.stop();\n } catch {\n // best-effort, as in destroy()\n }\n }\n\n /**\n * Reset cell `id`: start a new attempt, at `at`, which the client's next\n * request opens. The cell keeps its URL; what earlier attempts recorded\n * stays and is listed under the latest. Returns the new attempt's number.\n */\n async reset(id: string, at: number = Date.now()): Promise {\n const cells = this.cells;\n let attempt: number;\n try {\n attempt = await retrying(() => cells.startAttempt(id, at));\n } catch (e) {\n logStoreError(e);\n throw new StoreUnavailableError(e);\n }\n const run = this.runs.get(id);\n if (run) await this.renewTo(run, attempt);\n return attempt;\n }\n\n /**\n * Add an exchange to the cell's traffic (see addExchange()): the entry\n * the row holds for it, or undefined when the row is at its cap.\n */\n recordExchange(run: HostedRun, exchange: Exchange): Exchange | undefined {\n return addExchange(run.traffic, exchange, run.trafficSize);\n }\n\n /** Note the credentials a response of the cell's issued (hashes). */\n noteIssued(run: HostedRun, hashes: readonly string[]): void {\n addIssued(run.traffic, hashes);\n }\n\n /**\n * Add to the cell's scenario log, in time order, the checks other\n * processes have written since it was seeded. Each is marked seeded, so\n * it stays its writer's to persist. When the store cannot be read, the\n * cell is served as it stands.\n */\n private async refresh(run: HostedRun): Promise {\n const store = this.store;\n const log = seedableLog(run.scenario);\n if (!store || !log) return;\n let byWriter: Map;\n try {\n byWriter = await retrying(() => store.loadChecks(run.id));\n } catch (e) {\n logStoreError(e);\n return;\n }\n const known = new Set(run.seeded.values());\n const fresh: ConformanceCheck[] = [];\n const own = this.rowOf(run);\n for (const [writer, checks] of byWriter) {\n if (writer === own || writer.endsWith(HOSTED_WRITER_SUFFIX)) continue;\n if (attemptOfWriter(writer) !== run.attempt) continue;\n for (const c of checks) {\n const json = JSON.stringify(c);\n if (known.has(json)) continue;\n known.add(json);\n const copy = { ...c };\n run.seeded.set(copy, json);\n fresh.push(copy);\n }\n }\n for (const c of fresh.sort(byTime)) {\n let i = log.length;\n while (i > 0 && byTime(log[i - 1], c) > 0) i--;\n log.splice(i, 0, c);\n }\n }\n\n /**\n * This process's contribution to the cell's raw log: everything the\n * scenario recorded except seeded checks it has not touched. A seeded\n * check the scenario replaced or rewrote in place is ours to persist.\n */\n ownChecks(run: HostedRun): ConformanceCheck[] {\n const raw = rawChecksOf(run.scenario);\n if (!run.seeded.size) return raw;\n return raw.filter((c) => run.seeded.get(c) !== JSON.stringify(c));\n }\n\n /**\n * Record a hosted-layer check about the cell once per `key` (what makes\n * the finding distinct — e.g. the rejection's code and message).\n */\n recordHostedCheck(\n run: HostedRun,\n key: string,\n check: ConformanceCheck\n ): void {\n if (run.hostedKeys.has(key)) return;\n run.hostedKeys.add(key);\n run.hostedChecks.push(check);\n }\n\n /**\n * Record who is talking to the cell — one INFO check per client (name,\n * version), accumulating the protocol versions it negotiated.\n */\n recordIdentity(run: HostedRun, observed: IdentityObservation): void {\n const key = identityKey(observed);\n const existing = run.identities.get(key);\n if (existing) {\n addProtocolVersion(existing, observed.protocolVersion);\n return;\n }\n const check = identityCheck(identityOf(observed));\n run.identities.set(key, check);\n run.hostedChecks.push(check);\n }\n\n /**\n * Note a request from the client to the cell at `at`, and whether the cell\n * now waits on input the client must collect from a person (undefined\n * leaves that as it stands). The marker is re-stamped at most once per\n * ACTIVITY_RESOLUTION_MS, so a busy client does not rewrite the cell's\n * hosted row on every request: how long a client has been quiet is told\n * in minutes.\n */\n noteActivity(run: HostedRun, awaitingInput?: boolean, at = Date.now()): void {\n const marker = run.hostedChecks.find((c) => c.id === ACTIVITY_CHECK_ID);\n if (!marker) {\n run.hostedChecks.push(activityCheck(at, awaitingInput ?? false));\n return;\n }\n const was = marker.details?.awaitingInput === true;\n const awaiting = awaitingInput ?? was;\n const since = at - Date.parse(marker.timestamp ?? '');\n if (since < ACTIVITY_RESOLUTION_MS && awaiting === was) return;\n marker.timestamp = new Date(at).toISOString();\n marker.details = { awaitingInput: awaiting };\n }\n\n /**\n * Note that the cell answered a request from `requester` (a keyed hash of\n * the client's address, '' when unknown) with a sign-in challenge (401),\n * so that a later request from the same requester naming no cell can be\n * attributed to it (see ./root-prm.ts). With a store the note is written\n * through and flush() waits for it: a client following the challenge to\n * another process finds it there.\n */\n noteChallenge(run: HostedRun, requester: string, at = Date.now()): void {\n const store = this.store;\n if (!store) {\n // In memory: written before this returns.\n void this.challenges.saveChallenge(run.id, requester, at);\n return;\n }\n const p: Promise = retrying(() =>\n store.saveChallenge(run.id, requester, at)\n )\n .catch(logStoreError)\n .finally(() => this.pending.delete(p));\n this.pending.add(p);\n }\n\n /**\n * Cells challenged from `requester` in the last `windowMs`, latest first.\n * Never another requester's.\n */\n async recentChallenges(\n windowMs: number,\n requester: string\n ): Promise> {\n const since = Date.now() - windowMs;\n const store = this.store;\n if (!store) return this.challenges.listChallenges(since, requester);\n try {\n return await retrying(() => store.listChallenges(since, requester));\n } catch (e) {\n logStoreError(e);\n throw new StoreUnavailableError(e);\n }\n }\n\n get(id: string): HostedRun | undefined {\n const r = this.runs.get(id);\n if (r) r.lastSeenAt = Date.now();\n return r;\n }\n\n /**\n * Like get(), but rebuilds the cell from its id when this process has never\n * seen it — the id carries everything needed. Returns undefined for an id\n * that does not parse or names a scenario this deployment cannot mount.\n */\n ensure(\n id: string,\n baseUrlFor: (ref: CellRef) => string\n ): HostedRun | undefined {\n const local = this.get(id);\n if (local) return local;\n const ref = parseCellId(id);\n if (!ref) return undefined;\n try {\n return this.getOrCreate(ref, baseUrlFor);\n } catch (e) {\n if (e instanceof UnknownScenarioError || e instanceof NotHostableError)\n return undefined;\n throw e;\n }\n }\n\n /**\n * Write this process's view of a cell's checks through to the store; the\n * first write also records that the cell exists, so a cell that was only\n * configured (never hit) does not show up as exercised. A cell's writes\n * land in order, each with the cell as it stands when the write starts,\n * so an older view never overwrites a newer one.\n */\n persist(run: HostedRun): Promise {\n const store = this.store;\n if (!store) return Promise.resolve();\n if (run.queuedWrite) return run.queuedWrite;\n const p: Promise = (run.lastWrite ?? Promise.resolve())\n .then(() => {\n run.queuedWrite = undefined;\n return this.write(run, store);\n })\n .catch(logStoreError)\n .finally(() => this.pending.delete(p));\n run.queuedWrite = run.lastWrite = p;\n this.pending.add(p);\n return p;\n }\n\n /**\n * One write of the cell's rows, sent together: a flush waits one store\n * round trip, not one per row. A row that has not changed since this\n * process last wrote it is not sent again. A store call that fails is\n * made again before the write gives up (see retrying()): on a serverless\n * host the isolate may never see the cell again, so a write left for the\n * next request is often a write lost.\n */\n private async write(run: HostedRun, store: RunStore): Promise {\n // A cell not yet seeded from the store holds only what this process saw\n // since it built the cell: written over this writer's row, that could\n // drop what the writer recorded before the cell was evicted. So it is\n // seeded first; but when it has recorded nothing (a request answered\n // before seeding), its row is left alone and the write waits on nothing\n // but itself. The hosted row needs neither: it is this build's own.\n const ownRow =\n run.hydration !== undefined || rawChecksOf(run.scenario).length > 0;\n if (ownRow) await this.hydrate(run);\n // Unseeded because the store could not be read, the cell is still\n // written if this process has no row for it yet: there is nothing to\n // write over. Otherwise its row waits for a write that can seed first.\n const own = this.rowOf(run);\n const ownKey = `${run.id}#${run.attempt}`;\n const deferred = ownRow && !run.hydrated && this.ownRows.has(ownKey);\n const rows: Array<[string, ConformanceCheck[]]> = [];\n if (ownRow && !deferred) rows.push([own, this.ownChecks(run)]);\n if (run.hostedChecks.length)\n rows.push([run.hostedWriter, run.hostedChecks]);\n const writes: Promise[] = [];\n for (const [writer, checks] of rows) {\n const json = JSON.stringify(checks);\n if (run.written.get(writer) === json) continue;\n writes.push(\n retrying(() =>\n store.saveChecks(\n run.id,\n writer,\n JSON.parse(json) as ConformanceCheck[]\n )\n ).then(() => {\n run.written.set(writer, json);\n if (writer === own) this.ownRows.add(ownKey);\n })\n );\n }\n // The traffic row, with the checks: one round trip for both. A row\n // whose only news is a repeat is left for the next write.\n const traffic = run.traffic;\n const said = substance(traffic);\n if (\n traffic.exchanges.length + traffic.omitted > 0 &&\n said !== run.trafficWritten\n ) {\n const json = JSON.stringify(traffic);\n const writer = run.hostedWriter;\n writes.push(\n retrying(() =>\n store.saveTraffic(run.id, writer, JSON.parse(json) as TrafficRow)\n ).then(() => {\n if (run.traffic === traffic) run.trafficWritten = said;\n })\n );\n }\n if (!run.saved) {\n // Marked saved only once the write landed: a failed saveRun must be\n // retried on the next persist, or the cell never appears in\n // listRuns() and the report shows it as never exercised even though\n // its checks are in the store.\n writes.push(\n retrying(() => store.saveRun(run.id, run.scenarioName)).then(() => {\n run.saved = true;\n })\n );\n }\n // Every write is let finish before a failure is reported, so what did\n // land is remembered and only the rest is retried.\n const failed = (await Promise.allSettled(writes)).find(\n (r): r is PromiseRejectedResult => r.status === 'rejected'\n );\n if (failed) throw failed.reason;\n if (deferred) {\n throw new Error(\n `${run.id}: the store could not be read, so this process's row waits for the next write`\n );\n }\n }\n\n /**\n * Resolve once every in-flight persist() has settled. Serverless entry\n * points await this before handing back the response so the write isn't\n * abandoned when the isolate is frozen after responding.\n */\n async flush(): Promise {\n while (this.pending.size) await Promise.all(Array.from(this.pending));\n }\n\n /**\n * Judged checks for a cell, or undefined when neither this process nor the\n * store has seen it. Without a store this is the scenario's own getChecks().\n * With a store it is every process's raw log merged (this process's live\n * log wins over its own persisted row) and re-judged once. The hosted\n * layer's own checks are appended after judgement, deduplicated across\n * processes, so they never influence the scenario's verdicts — though a\n * hosted FAILURE (wire rejection, wrong revision) does decide the cell's.\n */\n async results(id: string): Promise {\n const ref = parseCellId(id);\n if (!ref) return undefined;\n await hostedScenarios.load([ref.scenarioName]);\n // A cell that only a config page created has seen no client: there is\n // nothing to judge, so it reads like a cell that does not exist yet.\n const run = this.runs.get(id)?.touched ? this.runs.get(id) : undefined;\n if (!this.store) {\n if (!run) return undefined;\n // What earlier attempts recorded, kept here when the cell was reset.\n const [earlierRows, resets] = await Promise.all([\n this.local.loadChecks(id),\n this.local.loadAttempts(id)\n ]);\n const raw = rawChecksOf(run.scenario);\n // Judged on a copy, as with a store: many scenarios' getChecks()\n // appends its \"expected but never seen\" FAILUREs to the live log, so\n // judging the live instance would let a page view change the verdict.\n const latest = judgedAtRevision(ref, raw, run.hostedChecks);\n return withAttempts(\n ref,\n latest,\n run.attempt,\n resets,\n earlierRows,\n raw.length + run.hostedChecks.length === 0\n );\n }\n // A cell built for a discover and not seeded since (see write()) holds\n // less than this process's row: seeded, its log is the whole of it.\n if (run) await this.hydrate(run);\n // A store that cannot be read is said so (StoreUnavailableError), not\n // read as a cell nobody recorded anything for: a report built on that\n // shows every cell empty, and can be frozen that way.\n const store = this.store;\n let byWriter: Map;\n let known: boolean;\n let resets: number[];\n try {\n [byWriter, known, resets] = await Promise.all([\n retrying(() => store.loadChecks(id)),\n retrying(() => store.loadRun(id)).then((s) => s !== undefined),\n retrying(() => store.loadAttempts(id))\n ]);\n } catch (e) {\n logStoreError(e);\n throw new StoreUnavailableError(e);\n }\n if (run) {\n byWriter.set(this.rowOf(run), this.ownChecks(run));\n byWriter.set(run.hostedWriter, run.hostedChecks);\n }\n if (!run && !known && byWriter.size === 0) return undefined;\n const current = Math.max(\n resets.length + 1,\n run?.attempt ?? 1,\n ...Array.from(byWriter.keys(), attemptOfWriter)\n );\n const latest = new Map();\n const earlierRows = new Map();\n for (const [writer, checks] of byWriter) {\n (attemptOfWriter(writer) === current ? latest : earlierRows).set(\n writer,\n checks\n );\n }\n const fresh = Array.from(latest.values()).every((c) => c.length === 0);\n return withAttempts(\n ref,\n judgedRows(ref, latest),\n current,\n resets,\n earlierRows,\n fresh\n );\n }\n\n /**\n * The cell's traffic by attempt (see ./traffic.ts): every process's rows\n * merged in time order, this process's live row included.\n */\n async traffic(\n id: string\n ): Promise> {\n const run = this.runs.get(id)?.touched ? this.runs.get(id) : undefined;\n let rows: Map;\n try {\n rows = await retrying(() => this.cells.loadTraffic(id));\n } catch (e) {\n logStoreError(e);\n throw new StoreUnavailableError(e);\n }\n if (run) rows.set(run.hostedWriter, run.traffic);\n const byAttempt = new Map();\n for (const [writer, row] of rows) {\n const n = attemptOfWriter(writer);\n byAttempt.set(n, [...(byAttempt.get(n) ?? []), row]);\n }\n return new Map(\n Array.from(byAttempt, ([n, list]) => [n, mergeRows(list)] as const).sort(\n (a, b) => a[0] - b[0]\n )\n );\n }\n\n /** Exercised cells of a run: hit in this process, or saved to the store. */\n async listCells(runId: string): Promise {\n const ids = new Set();\n for (const r of this.runs.values()) {\n if (r.runId === runId && r.touched) ids.add(r.id);\n }\n const store = this.store;\n if (store) {\n try {\n const saved = await retrying(() => store.listRuns(`${runId}/`));\n for (const { id } of saved) ids.add(id);\n } catch (e) {\n logStoreError(e);\n throw new StoreUnavailableError(e);\n }\n }\n return Array.from(ids)\n .map(parseCellId)\n .filter((r): r is CellRef => r !== undefined);\n }\n\n list(): HostedRun[] {\n return Array.from(this.runs.values());\n }\n\n async destroy(id: string, fromStore = true): Promise {\n const r = this.runs.get(id);\n if (fromStore) void this.store?.deleteRun(id).catch(logStoreError);\n if (!r) return;\n this.runs.delete(id);\n // handler() never started a server, but some scenarios hold timers/streams\n // that stop() cleans up. Safe to call even though start() wasn't.\n try {\n await r.scenario.stop();\n } catch {\n // best-effort\n }\n }\n\n /** Tear down every cell of a run, here and in the store. */\n async destroyRun(runId: string): Promise {\n const cells = await this.listCells(runId);\n await Promise.all(cells.map((ref) => this.destroy(cellId(ref))));\n }\n\n async close(): Promise {\n clearInterval(this.sweeper);\n await Promise.all(\n Array.from(this.runs.keys()).map((id) => this.destroy(id, false))\n );\n }\n\n private sweep(): void {\n const now = Date.now();\n for (const [id, r] of this.runs) {\n // Local eviction only — the store has its own retention.\n if (now - r.lastSeenAt > this.ttlMs) void this.destroy(id, false);\n }\n }\n}\n\n/** How often a cell's activity marker is re-stamped at most (noteActivity()). */\nexport const ACTIVITY_RESOLUTION_MS = 15_000;\n\nconst byTime = (a: ConformanceCheck, b: ConformanceCheck) =>\n (a.timestamp ?? '').localeCompare(b.timestamp ?? '');\n\n/**\n * Judge one attempt's rows, keyed by writer: the scenario's rows merged, the\n * hosted layer's deduplicated across processes, and both judged at the\n * cell's revision (judgedAtRevision()). The hosted layer's own checks are\n * appended after judgement, so they never influence the scenario's\n * verdicts — though a hosted FAILURE (wire rejection, wrong revision) does\n * decide the cell's.\n */\nfunction judgedRows(\n ref: CellRef,\n byWriter: ReadonlyMap\n): RunResults {\n const scenarioLog: ConformanceCheck[] = [];\n const hostedLog: ConformanceCheck[] = [];\n for (const [writer, checks] of byWriter) {\n (writer.endsWith(HOSTED_WRITER_SUFFIX) ? hostedLog : scenarioLog).push(\n ...checks\n );\n }\n // Identity checks collapse to one per client (their protocol versions\n // pooled); every other hosted finding is one check per distinct details.\n const seen = new Set();\n hostedLog.sort(byTime);\n const hosted = [\n ...identityChecksIn(hostedLog),\n ...hostedLog.filter((c) => {\n if (c.id === IDENTITY_CHECK_ID) return false;\n // Every process's activity marker, so the latest can be read.\n if (c.id === ACTIVITY_CHECK_ID) return true;\n const key = `${c.id}:${JSON.stringify(c.details ?? null)}`;\n if (seen.has(key)) return false;\n seen.add(key);\n return true;\n })\n ].sort(byTime);\n return judgedAtRevision(ref, scenarioLog.sort(byTime), hosted);\n}\n\n/**\n * `latest`, the current attempt's results, with the attempt's number, when\n * a reset started it, whether nothing has reached it yet (`fresh`), and\n * each earlier attempt judged from its own rows (`earlierRows`, keyed by\n * writer; see attemptOfWriter()).\n */\nfunction withAttempts(\n ref: CellRef,\n latest: RunResults,\n attempt: number,\n resets: readonly number[],\n earlierRows: ReadonlyMap,\n fresh: boolean\n): RunResults {\n if (attempt === 1) return { ...latest, attempt };\n const iso = (ms: number | undefined) =>\n ms === undefined ? undefined : new Date(ms).toISOString();\n const earlier: EarlierAttempt[] = [];\n for (let n = 1; n < attempt; n++) {\n const rows = new Map(\n Array.from(earlierRows).filter(([w]) => attemptOfWriter(w) === n)\n );\n if (!rows.size) continue;\n const { checks, recorded, lastRequestAt, awaitingInput } = judgedRows(\n ref,\n rows\n );\n const startedAt = n > 1 ? iso(resets[n - 2]) : undefined;\n earlier.push({\n attempt: n,\n ...(startedAt && { startedAt }),\n results: {\n checks,\n recorded,\n ...(lastRequestAt && { lastRequestAt }),\n ...(awaitingInput && { awaitingInput })\n }\n });\n }\n const resetAt = iso(resets[attempt - 2]);\n return {\n ...latest,\n attempt,\n ...(resetAt && { resetAt }),\n ...(fresh && { fresh: true as const }),\n ...(earlier.length && { earlier })\n };\n}\n\n/**\n * A cell's results from its scenario's raw log (merged across processes)\n * and the hosted layer's checks: the scenario's judgement, as a cell served\n * on its revision reads it (atCellRevision()), then the hosted checks.\n *\n * A cell must not pass on checks recorded around the protocol — a finished\n * OAuth flow, say — when the client never spoke the cell's revision there:\n * without a REVISION_SPOKEN_CHECK_ID marker (spokeRevision()) and with no\n * FAILURE, `recorded` is zero, so the verdict is incomplete, and the cell\n * says why (revisionNotSpokenCheck()). A scenario that expects the client\n * to stop before it is let in (`allowClientError`: it must reject a bad\n * issuer, say) passes once the client sent the cell an MCP request at its\n * revision, even one met with the sign-in challenge (reachedRevision());\n * metadata fetches alone, as a client listing its servers makes, are not\n * enough. The markers themselves are never shown.\n */\nfunction judgedAtRevision(\n ref: CellRef,\n scenarioLog: ConformanceCheck[],\n hostedLog: ConformanceCheck[]\n): RunResults {\n const spoke = hostedLog.some((c) => c.id === REVISION_SPOKEN_CHECK_ID);\n // A client that signed in and was then stopped by the auth layer reached\n // the cell too, whatever revision that request carried (see\n // signedInAuthStop()).\n const reached =\n spoke ||\n hostedLog.some((c) => c.id === REVISION_REACHED_CHECK_ID) ||\n signedInAuthStop(hostedLog, scenarioLog);\n const tested = hostedScenarios.meta(ref.scenarioName)?.allowClientError\n ? reached\n : spoke;\n const hosted = hostedLog.filter(\n (c) =>\n c.id !== REVISION_SPOKEN_CHECK_ID &&\n c.id !== REVISION_REACHED_CHECK_ID &&\n c.id !== AUTH_STOP_CHECK_ID &&\n c.id !== ACTIVITY_CHECK_ID\n );\n const checks = [\n ...atCellRevision(\n finalizeChecks(ref.scenarioName, scenarioLog, ref.revision),\n ref.revision\n ),\n ...hosted\n ];\n let recorded = scenarioLog.length + hostedFailures(hosted);\n if (recorded > 0 && !tested && !checks.some((c) => c.status === 'FAILURE')) {\n const last = checks.reduce(\n (t, c) => ((c.timestamp ?? '') > t ? (c.timestamp ?? '') : t),\n ''\n );\n checks.push(\n revisionNotSpokenCheck(ref.revision, last || new Date().toISOString())\n );\n recorded = 0;\n }\n // When the client last sent the cell anything, as any process saw it: the\n // activity markers (re-stamped as requests come) and the logs' own times.\n const lastRequestAt = [...scenarioLog, ...hostedLog].reduce(\n (t, c) => ((c.timestamp ?? '') > t ? (c.timestamp ?? '') : t),\n ''\n );\n const latest = hostedLog\n .filter((c) => c.id === ACTIVITY_CHECK_ID)\n .reduce<\n ConformanceCheck | undefined\n >((m, c) => (!m || (c.timestamp ?? '') > (m.timestamp ?? '') ? c : m), undefined);\n const awaitingInput = latest?.details?.awaitingInput === true;\n return {\n ...ref,\n checks,\n recorded,\n ...(lastRequestAt && { lastRequestAt }),\n ...(awaitingInput && { awaitingInput })\n };\n}\n\nfunction logStoreError(e: unknown): void {\n console.error('[hosted] run store:', e instanceof Error ? e.message : e);\n}\n\n/** Waits before each repeat of a store call that failed (see retrying()). */\nconst STORE_RETRY_DELAYS_MS = [50, 250];\n\n/**\n * A store call, made again after a short wait when it fails: a hosted\n * SQLite API can refuse a statement now and then, and a write not made\n * again before the response may never be made.\n */\nasync function retrying(call: () => Promise): Promise {\n for (const wait of STORE_RETRY_DELAYS_MS) {\n try {\n return await call();\n } catch {\n await new Promise((r) => setTimeout(r, wait));\n }\n }\n return call();\n}\n\n/** The run store could not be read, so a cell's results cannot be told. */\nexport class StoreUnavailableError extends Error {\n constructor(cause: unknown) {\n super(\n `the results store did not answer (${cause instanceof Error ? cause.message : String(cause)}); try again`\n );\n }\n}\n\nexport class UnknownScenarioError extends Error {\n constructor(name: string) {\n super(\n `Unknown scenario '${name}'. Available: ${hostedScenarios.names.join(', ')}`\n );\n }\n}\n\nexport class NotHostableError extends Error {\n constructor(name: string, why?: string) {\n super(\n `scenario '${name}' cannot be started here: ${why ?? NOT_HOSTED_REASON}`\n );\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"]