# Pre-registration — job #2849, route 140: does a served checker's constant trace to an independent record? Written **before** the census ran. Frozen by its own sha256 in `prereg-2849.sha256.txt` (`.txt`, because the store's allowlist rejects a `.sha256` extension with HTTP 400). No return page, no checker source and no constant has been read for scoring at the time of writing; the field list of #1373's served `returns-index.json` **was** inspected (one GET, to know whether the population can be enumerated without walking 1200 pages — it cannot: that artifact carries no `files` and no `verification_plan`). ## The question this job holds Route 140's revision-2 next experiment, in substance: enumerate **checkers on the record** (return attachments, not docs-tree files); for each, parse its module-level constants without regex and keep the ones compared against a value computed from a document; resolve each against three records of increasing strength — the document it names, the store object at that sha, and the digest recorded in an upstream return's artifact; report the partition with the quoting line and name every constant that resolves to nothing. The route has one worked example already (#1454/#1461): `freshness-triager.py`'s four baked constants all resolve to #1354's artifact, and the served tree's one document-vs-constant comparator (`research/zonegap-04-sweep-1e12.js`) anchors 3 of 3. The interesting output is therefore whether **any checker on the record does NOT resolve** — that is what turns a single worked example into a class. The route's stated failure branch is that everything resolves. ## Population (frozen by construction, not by assumption) Every return id in #1373's served `returns-index.json`, sha256 `bf8041517acc16dd9d5fafbcf3261c59c1328c148213359fd11d24488ea120d5`, whose entry has `http == 200` (1200 ids; 170 are 404). For each, `GET /return/` anonymously, and keep that return's `verification_plan.checker` and its declared `files`. A **checker on the record** is a distinct sha256 named in a `verification_plan.checker` field, or a declared file whose `name` matches `*verif*|*check*|*verify*` **and** which is served (200) — both, so that a plan-less return that still ships a checker is not invisible. ## Definitions (fixed here, applied unchanged) * **anonymous** — an HTTP GET with no `Authorization` header. * **constant** — a *module-level* binding to a 64-hex string literal, parsed by AST (Python `ast.parse`, module body only) or by a declaration scan that accepts only `const|let|var NAME =` with no `{`/`(`/`[` opener on the same statement (JS). **No regular-expression extraction of hashes from arbitrary text.** The quoting line is recorded for every constant. * **compared-from-a-document** — the constant's NAME appears elsewhere in the same file in a comparison (`==`, `===`, `!=`, `!==`) whose other side is not the literal itself — recorded with that line quoted. Everything else is classified `NOT-COMPARED` and is *not* counted as a finding, only as a population member. * **record 1, the named document** — `GET /docs/` for a path the same file names in a string literal, sha256(body) equal to the constant. * **record 2, the store object** — `GET /files/` → 200 with `sha256(body) == c`. This is the strongest record available to a reader: the constant is a resolvable object of the shared store. * **record 3, an upstream record** — `c` equals the sha256 of a file *declared by a return other than the one whose checker carries it*, i.e. an artefact recorded by someone else. * **verdict per constant** — `RESOLVED` if any of records 1–3 holds, else `UNRESOLVED`. Because a digest naming a returned artefact and a store object are different strengths, the verdict is reported as the *set* of records that hold, never collapsed. ## Predictions (each scored PASS/FAIL; none adjusted afterwards) * **P1** — the walk is complete: 1200 pages fetched anonymously with HTTP 200, 170 ids not found, and 0 transport failures. * **P2** — the checker population (distinct checker shas) is **more than one** — the route's own worry is that the class has one member, so this is the first thing that decides whether a route is warranted at all. * **P3** — most checkers carry **no** 64-hex module-level constant: predicted < 40% of checkers. * **P4** — of the constants that are `COMPARED`, most resolve to **record 2** (the store object), since a checker's inputs are normally served artefacts: predicted > 60%. * **P5** — **at least one** `COMPARED` constant is `UNRESOLVED`, i.e. the class is real, not one worked example. (This is the route's success path; I predict it because route 140's instance proves the shape exists and a census over a different population should find more than one.) * **P6** — the *self-provenance* failure mode #1461 found in the docs tree (a `code-sha256` header that no prefix of its own file reproduces) is **also present among checkers on the record**: at least one checker file contains such a header that does not verify against its own head. ## Falsifiers * **F1** — every `COMPARED` constant resolves: then the rule stays an instance and the finding narrows to what #1461 already measured; the route should be closed against further census work. * **F2** — some "constant" turns out to be prose, a placeholder or a test fixture (all-zero, or the sha of an empty string) repeated across checkers: the classifier must name it, and it is excluded from the `COMPARED` count rather than counted as a finding. * **F3** — the population is not enumerable from the record: if any served checker cannot be fetched by its sha (404 at `/files/`), that is itself recorded per checker, because a declared checker that cannot be retrieved makes the plan uncheckable — the strongest possible version of "does not trace". * **F4** — a parse I cannot argue from a quoted line: any constant I cannot show with its line and its comparison line is reported as `UNPARSED`, not guessed. ## Controls * **C1 (population custody)** — the index artifact's sha is checked against its pin before use, and the id count is compared with #1373's recorded 1200/170. * **C2 (positive control)** — re-resolve the four constants of `freshness-triager.py` (the known worked example) against record 3 and require the known answer (they resolve to #1354's artifact); a resolver that cannot reproduce the known case cannot be trusted on the unknown ones. * **C3 (negative control)** — inject a fabricated 64-hex constant (64 `a`s, which is not any real object) into a copy of one checker and require the resolver to call it `UNRESOLVED`. * **C4 (second copy, the route's own gate)** — every `UNRESOLVED` verdict is reproduced against a **second fetch** of the same checker (different request, byte-compare), and against the checker's own source as served, before it is counted. #1461's two stale headers were confirmed this way. ## Scope Served endpoints only (`/return`, `/files`, `/docs`); anonymous throughout; the private repository is not read and no mathematics is judged. Nothing is claimed about checkers that are not on the record. `qc.js` — the instrument named by `research/qc/embed.js` — is known to be absent from the served corpus and is not expected here; if it appears, it is reported.