@fangorn-network/westmarch 0.0.1-dev → 0.0.3-dev

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fangorn-network/westmarch",
-  "version": "0.0.1-dev",
+  "version": "0.0.3-dev",
   "description": "Publisher and consumer surfaces for a Fangorn app: shape a graph, publish it, read it back as a searchable, agent-drivable catalog",
   "license": "MIT",
   "type": "module",
@@ -13,6 +13,7 @@
     "./rank": "./consume/rank.js",
     "./apps": "./consume/apps.js",
     "./agent-card": "./publish/agent-card.js",
+    "./view": "./publish/view.js",
     "./roles": "./consume/roles.js",
     "./directory": "./consume/directory.js",
     "./taste": "./consume/taste.js",
@@ -29,17 +30,20 @@
     "./demand": "./publish/demand.js",
     "./steam": "./consume/steam.js",
     "./tools": "./consume/tools.js",
+    "./x402": "./consume/x402.js",
     "./package.json": "./package.json"
   },
   "scripts": {
-    "test": "node publish/terms.js && node publish/reactions.js && node publish/cohort.js && node publish/vault.js && node publish/graph.js && node publish/envelope.js && node publish/demand.js && node publish/settle.js && node publish/manifest.js && node publish/agent-card.js && node publish/cli.js --selfcheck && node publish/enrich.js && node consume/embed.js && node consume/rank.js && node consume/apps.js && node consume/mcp.js --selfcheck && node consume/roles.js && node consume/shard.js && node consume/directory.js && node consume/taste.js && node consume/steam.js && node consume/taste-doc.js && node consume/corpora.js && node consume/ui.js && node consume/lint.js && node consume/tools.js",
+    "build": "tsc -p .",
+    "prepare": "tsc -p .",
+    "test": "node publish/terms.js && node publish/reactions.js && node publish/cohort.js && node publish/vault.js && node publish/graph.js && node publish/envelope.js && node publish/demand.js && node publish/settle.js && node publish/manifest.js && node publish/agent-card.js && node publish/view.js && node publish/ship.js --selfcheck && node publish/eval.ts --selfcheck && node publish/cli.js --selfcheck && node publish/enrich.js && node consume/embed.js && node consume/rank.js && node consume/apps.js && node consume/mcp.js --selfcheck && node consume/roles.js && node consume/shard.js && node consume/directory.js && node consume/taste.js && node consume/steam.js && node consume/taste-doc.js && node consume/corpora.js && node consume/ui.js && node consume/lint.js && node consume/tools.js && node consume/x402.js && node site/feed.js && node site/store.js",
     "lint": "node consume/lint.js"
   },
   "peerDependencies": {
-    "@huggingface/transformers": "^4.2.0",
-    "viem": "^2.55.1",
     "@fangorn-network/sdk": "^2026.9.22-dev",
-    "@noble/curves": "^1.9.1"
+    "@huggingface/transformers": "^4.2.0",
+    "@noble/curves": "^1.9.1",
+    "viem": "^2.55.1"
   },
   "peerDependenciesMeta": {
     "@huggingface/transformers": {
@@ -47,19 +51,29 @@
     }
   },
   "devDependencies": {
-    "@huggingface/transformers": "^4.2.0",
-    "viem": "^2.56.3",
     "@fangorn-network/sdk": "^2026.9.22-dev",
-    "@noble/curves": "^1.9.1"
+    "@huggingface/transformers": "^4.2.0",
+    "@noble/curves": "^1.9.1",
+    "typescript": "^5.9.3",
+    "viem": "^2.56.3"
   },
   "bin": {
     "westmarch-publish": "./publish/cli.js",
-    "fangorn-mcp": "./consume/mcp.js"
+    "fangorn-mcp": "./consume/mcp.js",
+    "westmarch-view": "./publish/view-cli.js",
+    "westmarch-ship": "./publish/ship.js",
+    "westmarch-eval": "./dist/ts/eval.js"
   },
   "files": [
     "consume",
     "publish",
-    "docs/app-to-agent.md"
+    "docs/app-to-agent.md",
+    "site/agent.js",
+    "site/dist",
+    "site/feed.js",
+    "site/worker.js",
+    "site/store.js",
+    "dist/ts"
   ],
   "engines": {
     "node": ">=20"

package/publish/agent-card.js

@@ -73,7 +73,7 @@ export function agentCard({ name, description, url, version = "0.0.0", tools = [
 
 /** The params `discoverApp` reads, validated the same way it validates them.
  *  A malformed card should fail the build, not the first reader. */
-export function fangornExtension({ app, fromBlock, namespaces = [], views = [], config = FangornConfig }) {
+export function fangornExtension({ app, fromBlock, namespaces = [], views = [], paid, config = FangornConfig }) {
     if (!app) throw new Error("fangorn.app is required");
     const id = HEX32.test(app) ? app : hashAppId(app);
     const from = String(fromBlock ?? "");
@@ -83,6 +83,14 @@ export function fangornExtension({ app, fromBlock, namespaces = [], views = [],
         const u = new URL(v);   // throws on garbage
         if (u.protocol !== "https:" && u.protocol !== "http:") throw new Error(`fangorn.views: not http(s): ${v}`);
     }
+    // `paid`: records sold over x402. `url` has an `{id}` for the record's id; `price` is in
+    // the token's base units. Readers only offer to buy; the 402 itself is the quote.
+    if (paid) {
+        const u = new URL(paid.url.replace("{id}", "x"));
+        if (!/^https?:$/.test(u.protocol) || !paid.url.includes("{id}")) throw new Error(`fangorn.paid.url must be http(s) with {id}: ${paid.url}`);
+        if (!/^\d+$/.test(String(paid.price))) throw new Error(`fangorn.paid.price must be base units, got ${paid.price}`);
+        if (!/^0x[0-9a-fA-F]{40}$/.test(paid.asset ?? "")) throw new Error(`fangorn.paid.asset must be a token address`);
+    }
     return {
         uri: FANGORN_APP_EXTENSION,
         description: "The Fangorn app this agent fronts.",
@@ -92,12 +100,14 @@ export function fangornExtension({ app, fromBlock, namespaces = [], views = [],
             appRegistry: config.appRegistryContractAddress,
             dataRegistry: config.dataRegistryContractAddress,
             appId: id, fromBlock: from, namespaces, views,
+            ...(paid ? { paid: { url: paid.url, price: String(paid.price), asset: paid.asset, network: paid.network,
+                                 symbol: paid.symbol ?? "USDC", decimals: paid.decimals ?? 6, description: paid.description ?? "" } } : {}),
         },
     };
 }
 
 // ── self-check: `node publish/agent-card.js` ────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}`) {
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/agent-card.js")) {
     const eq = (a, b, m) => { if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(`${m}: ${JSON.stringify(a)} != ${JSON.stringify(b)}`); };
     const throws = (f, re, m) => { try { f(); } catch (e) { if (re.test(e.message)) return; throw e; } throw new Error(`must throw: ${m}`); };
 

package/publish/cohort.js

@@ -247,7 +247,7 @@ export function readout(total, cohort, { minSupport = MIN_SUPPORT } = {}) {
 }
 
 // ── self-check: `node publish/cohort.js` ──────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}`) {
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/cohort.js")) {
     const vec = (a, b) => { const v = new Float32Array(STAT_DIM); v[0] = a; v[1] = b; return v; };
     const log = (n, seed) => Array.from({ length: n }, (_, i) => ({
         id: `row-${seed}-${i}`, corpus: "films", reaction: i % 4 === 3 ? "skip" : "like",

package/publish/demand.js

@@ -383,7 +383,7 @@ export function brief(rep, { title = "demand" } = {}) {
 }
 
 // ── self-check: `node publish/demand.js` ────────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}`) {
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/demand.js")) {
     const { keypair, statistics, contribute, aggregate, readout } = await import("./cohort.js");
 
     // A shelf with two genuine regions and a hole between them. 128 dims so the

package/publish/enrich.js

@@ -155,7 +155,7 @@ export function enrichText({ name, path, desc, mime, abs = null }) {
 // in the same browser that already runs the embedder at publish time.
 
 // ── self-check: `node server/enrich.js` — no files, no model ──────────────────
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/enrich.js")) {
     const { deflateSync } = await import("node:zlib");
     const eq = (got, want, msg) => { if (got !== want) throw new Error(`${msg}: got ${JSON.stringify(got)}`); };
 

package/publish/envelope.js

@@ -157,7 +157,7 @@ export async function deleteResource({ workerUrl, uploadToken, resourceId, chunk
 // every resourceId ever minted by fangorn.tv is derived by this function, and a
 // change here that shifts one byte makes ciphertext already in R2 unreachable from
 // the resource anyone paid for. If this fails, the extraction broke money.
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}`) {
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/envelope.js")) {
     const owner = `0x${"11".repeat(20)}`;
     const uid = "Show/S1/a.mp4";
 

package/publish/eval.ts

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+// westmarch-eval: does a view answer what its app says it should?
+//
+//   westmarch-eval <view> [--golden eval/golden.jsonl] [--base <view>] [--known 200] [--json] [--report out.json]
+//
+// A view is a URL or a directory (westmarch-ship --local writes one), served here as a reader fetches it.
+//   westmarch-eval --selfcheck
+//
+// It grades the RECIPE — how records are shaped, which fields are embedded, how rows
+// rank — never the data. New records are facts, and a view is not worse for holding
+// them. So: build a base view (main's recipe) and a candidate (the change) from the
+// same data, on the same machine, and run both through here. The exit code is the gate.
+//
+// Every check runs the reader's own code (consume/tools.js `search`, the same model),
+// so a score is what an agent calling fangorn-mcp would get, not what a test harness
+// with its own ranker would.
+//
+// golden.jsonl holds one check per line. It is data, not code, so a change proposed
+// by an agent cannot also edit how it is graded:
+//
+//   {"id":"plover","q":"Plover village board","expect":{"where":{"city":"Plover"}},"min":0.8}
+//       search: the share of the top k (default 5) that satisfies `expect`
+//   {"id":"portage-solar","kind":"count","where":{"county":"Portage"},"expect":{"match":{"heading":"solar"}},"min":3}
+//       count: rows the agent's `where` reaches AND that satisfy `expect` — can a filter get to them at all
+//   {"id":"addresses","kind":"records","expect":{"match":{"text":"/\\b\\d{2,6} [A-Z]\\w+ (St|Ave)\\b/"}},"max_pct":0.5,"hard":true}
+//       records: the % of rows that satisfy `expect`, lower is better; `hard`: any rise over the base fails.
+//       `of` (a predicate) narrows which rows count, e.g. only meeting items have a date to miss.
+//
+// A predicate is {where?, match?, not?}. `where` is fangorn's own whole-value,
+// case-insensitive match — the filter agents use. `match` maps a field (or several
+// joined by `|`) to a regex, case-insensitive unless written /like this/flags. `not`
+// negates another predicate.
+//
+// Built in, with no labels: known items. N rows are sampled (seeded, so reruns agree)
+// and searched by their own title; `known@1`/`known@10` are how often they come back.
+
+import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { configure, loadShard, trimView } from "@fangorn-network/westmarch/shard";
+import { rolesFrom, textOf, titleOf, subtitleOf } from "@fangorn-network/westmarch/roles";
+import { search, matches } from "@fangorn-network/westmarch/tools";
+import { EMBED_MODEL, embedQueryDirect } from "@fangorn-network/westmarch/embed";
+
+type Pred = { where?: Record<string, string>; match?: Record<string, string>; not?: Pred };
+type Check =
+    | { id: string; kind?: "search"; q: string; k?: number; expect: Pred; min?: number }
+    | { id: string; kind: "count"; where?: Record<string, string>; expect?: Pred; min?: number; max?: number }
+    | { id: string; kind: "records"; of?: Pred; expect: Pred; max_pct: number; hard?: boolean };
+type Result = { id: string; kind: "search" | "count" | "records" | "known"; score: number; pass: boolean; hard?: boolean; top?: string[] };
+type QueryVector = (q: string) => Promise<Float32Array | null>;
+
+/** A drop below this, in mean precision@k or known@10, is "worse". canton-corpus's number. */
+const TOLERANCE = 0.05;
+
+const regex = (s: string) => {
+    const m = /^\/(.*)\/([a-z]*)$/s.exec(s);
+    return m ? new RegExp(m[1], m[2]) : new RegExp(s, "i");
+};
+const fieldText = (v: unknown) => (Array.isArray(v) ? v.join(" ") : String(v ?? ""));
+
+/** A predicate, compiled once: it runs against every row. */
+function compile(p: Pred = {}): (r: Row) => boolean {
+    const res = Object.entries(p.match ?? {}).map(([k, re]) => [k.split("|"), regex(re)] as const);
+    const not = p.not ? compile(p.not) : null;
+    return (r) => matches(r, p.where)
+        && res.every(([fs, re]) => re.test(fs.map((f) => fieldText(r[f])).join(" ")))
+        && !not?.(r);
+}
+
+const round = (x: number) => Math.round(x * 1000) / 1000;
+
+async function grade(rows: Row[], roles: Roles, checks: Check[], qv: QueryVector, known: number): Promise<Result[]> {
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const out: Result[] = [];
+    for (const c of checks) {
+        if (c.kind === "count") {
+            const ok = compile(c.expect);
+            const n = rows.filter((r) => matches(r, c.where) && ok(r)).length;
+            out.push({ id: c.id, kind: "count", score: n, pass: n >= (c.min ?? 1) && n <= (c.max ?? Infinity) });
+        } else if (c.kind === "records") {
+            const of = rows.filter(compile(c.of)), ok = compile(c.expect);
+            const pct = of.length ? round((100 * of.filter(ok).length) / of.length) : 0;
+            out.push({ id: c.id, kind: "records", score: pct, pass: pct <= c.max_pct, hard: c.hard });
+        } else {
+            const k = c.k ?? 5, ok = compile(c.expect);
+            const hits = search(rows, c.q, roles, { qv: await qv(c.q), limit: k }).map((h) => byId.get(h.id)!);
+            const score = round(hits.filter(ok).length / k);
+            out.push({ id: c.id, kind: "search", score, pass: score >= (c.min ?? 0), top: hits.slice(0, 3).map((r) => titleOf(r, roles).slice(0, 90)) });
+        }
+    }
+    // ponytail: the pool is each view's own rows, so base and candidate sample different
+    // rows once their records differ. TOLERANCE absorbs it; sample ids from the base if it doesn't.
+    const pool = rows.filter((r) => titleOf(r, roles).split(/\s+/).length >= 4);
+    const n = Math.min(known, pool.length);
+    if (n) {
+        let seed = 42;
+        const rand = () => (seed = (Math.imul(seed, 1103515245) + 12345) >>> 0) / 2 ** 32;
+        // Many rows share a title ("Approve the minutes"): the same title and subtitle is a find.
+        const same = (a: Row, b: Row) => a.id === b.id || (titleOf(a, roles) === titleOf(b, roles) && subtitleOf(a, roles) === subtitleOf(b, roles));
+        let at1 = 0, at10 = 0;
+        for (let i = 0; i < n; i++) {
+            const r = pool[Math.floor(rand() * pool.length)], t = titleOf(r, roles);
+            const at = search(rows, t, roles, { qv: await qv(t), limit: 10 }).findIndex((h) => same(byId.get(h.id)!, r));
+            at1 += +(at === 0); at10 += +(at >= 0);
+        }
+        out.push({ id: "known@1", kind: "known", score: round(at1 / n), pass: true },
+                 { id: "known@10", kind: "known", score: round(at10 / n), pass: true });
+    }
+    return out;
+}
+
+/** The candidate against the base. Worse on any one rule is worse. */
+function compare(cand: Result[], base: Result[]) {
+    const was = new Map(base.map((r) => [r.id, r.score]));
+    const failures: string[] = [];
+    for (const r of cand) {
+        const b = was.get(r.id);
+        if (!r.pass) failures.push(`${r.id}: ${r.score} is outside its bounds`);
+        // The ratchet: a question the base answered at all, the candidate must too.
+        if (r.kind === "search" && b !== undefined && b > 0 && r.score === 0) failures.push(`${r.id}: answered before, nothing now`);
+        if (r.hard && b !== undefined && r.score > b) failures.push(`${r.id}: ${b}% → ${r.score}%, and it may not rise`);
+    }
+    // Aggregates, over the checks both sides ran: one question moving a rank is noise.
+    const both = (kind: Result["kind"]) => cand.filter((r) => (kind === "known" ? r.id === "known@10" : r.kind === kind) && was.has(r.id));
+    const mean = (rs: Result[], f: (r: Result) => number) => rs.reduce((a, r) => a + f(r), 0) / rs.length;
+    const deltas = (["search", "known"] as const).flatMap((kind) => {
+        const rs = both(kind);
+        return rs.length ? [{ kind, cand: round(mean(rs, (r) => r.score)), base: round(mean(rs, (r) => was.get(r.id)!)) }] : [];
+    });
+    for (const d of deltas) if (d.cand < d.base - TOLERANCE) failures.push(`${d.kind}: ${d.base} → ${d.cand}`);
+    const verdict = failures.length ? "worse" : deltas.some((d) => d.cand > d.base + TOLERANCE) ? "better" : "unchanged";
+    return { verdict, deltas, failures };
+}
+
+// ── CLI ───────────────────────────────────────────────────────────────────────
+
+if (process.argv[2] === "--selfcheck") await selfcheck();
+else if (realpathSync(process.argv[1]).match(/\/eval\.[jt]s$/)) await main();
+
+async function main() {
+    const flags: Record<string, string | boolean> = {};
+    const pos: string[] = [];
+    for (let i = 2; i < process.argv.length; i++) {
+        const m = /^--([^=]+)(?:=(.*))?$/.exec(process.argv[i]);
+        if (!m) pos.push(process.argv[i]);
+        else flags[m[1]] = m[2] ?? (["json", "help"].includes(m[1]) ? true : process.argv[++i]);
+    }
+    if (flags.help || pos.length !== 1) {
+        console.error("usage: westmarch-eval <view> [--golden eval/golden.jsonl] [--base <view>] [--known 200] [--json] [--report out.json]");
+        process.exit(flags.help ? 0 : 2);
+    }
+    const checks: Check[] = readFileSync(String(flags.golden ?? "eval/golden.jsonl"), "utf8")
+        .split("\n").filter((l) => l.trim() && !l.startsWith("//")).map((l) => JSON.parse(l));
+    const known = Number(flags.known ?? 200);
+
+    const { env } = await import("@huggingface/transformers");
+    env.cacheDir = `${homedir()}/.cache/fangorn-mcp/models`;   // shared with fangorn-mcp and westmarch-view
+    const roles = new Map<string, Roles>();
+    configure({ onManifests: (ms, v) => { roles.set(v, rolesFrom(ms)); }, rowText: (f, v) => textOf(f, roles.get(v)!) });
+    // No fallback to word matching: a grade the reader would not get is not a grade.
+    const vectors = new Map<string, Promise<Float32Array>>();
+    const qv = (q: string) => vectors.get(q) ?? vectors.set(q, embedQueryDirect(q)).get(q)!;
+    const run = async (at: string) => {
+        const v = existsSync(at) ? await serve(at) : trimView(at), rows = await loadShard(v);
+        return { view: at, rows: rows.length, results: await grade(rows, roles.get(v)!, checks, qv, known) };
+    };
+
+    const cand = await run(pos[0]);
+    const base = flags.base ? await run(String(flags.base)) : null;
+    const cmp = base ? compare(cand.results, base.results) : null;
+    const failures = cmp?.failures ?? cand.results.filter((r) => !r.pass).map((r) => `${r.id}: ${r.score} is outside its bounds`);
+    // What reproduces this grade: the model, the runtime, and the views (whose manifests hash every shard).
+    const report = { model: EMBED_MODEL, node: process.version, platform: `${process.platform}-${process.arch}`,
+                     candidate: cand, base, verdict: cmp?.verdict ?? null, deltas: cmp?.deltas ?? [], failures, pass: !failures.length };
+
+    if (flags.report) writeFileSync(String(flags.report), JSON.stringify(report, null, 1));
+    if (flags.json) console.log(JSON.stringify(report, null, 1));
+    else {
+        const was = new Map(base?.results.map((r) => [r.id, r.score]));
+        console.log(`${cand.view}: ${cand.rows} rows${base ? `  (base ${base.view}: ${base.rows} rows)` : ""}\n`);
+        for (const r of cand.results) {
+            const b = was.get(r.id);
+            console.log(`${r.pass ? " " : "✗"} ${r.kind.padEnd(7)} ${r.id.padEnd(32)} ${b === undefined ? "" : `${b} → `}${r.score}`);
+        }
+        for (const d of report.deltas) console.log(`\n${d.kind}: ${d.base} → ${d.cand}`);
+        console.log(`\n${report.verdict ?? (report.pass ? "pass" : "fail")}${failures.length ? `\n  ${failures.join("\n  ")}` : ""}`);
+    }
+    process.exit(report.pass ? 0 : 1);
+}
+
+/** A view directory over HTTP on a free port, for this process's lifetime. */
+async function serve(dir: string): Promise<string> {
+    const srv = createServer((q, s) => {
+        try { s.end(readFileSync(`${dir}${decodeURIComponent(new URL(q.url ?? "/", "http://x").pathname)}`)); }
+        catch { s.statusCode = 404; s.end(); }
+    });
+    await new Promise<void>((ok) => srv.listen(0, "127.0.0.1", ok));
+    srv.unref();
+    const a = srv.address();
+    return `http://127.0.0.1:${typeof a === "object" && a ? a.port : 0}`;
+}
+
+async function selfcheck() {
+    const assert = (ok: unknown, msg: string) => { if (!ok) throw new Error(msg); };
+    const roles = rolesFrom([{ role_map: { title: "heading", tags: ["city"], text: ["text"] } }]);
+    const rows: Row[] = [
+        { id: "a", heading: "Rezoning of the lot on Main", city: "Plover", text: "Rezoning of the lot on Main. Approved 5-0." },
+        { id: "b", heading: "Liquor license for the Brewing Company", city: "Plover", text: "Liquor license for the Brewing Company." },
+        { id: "c", heading: "Water main replacement on Post Road", city: "Stevens Point", county: ["Portage", "Wood"], text: "Water main replacement on Post Road, 1200 Post Rd." },
+        { id: "d", heading: "Snow removal contract for the winter", city: "Stevens Point", text: "Snow removal contract for the winter season." },
+    ];
+
+    // Predicates: fangorn's where (whole value, any case, arrays), field-joined regex, /flags/, not.
+    assert(compile({ where: { city: "plover" } })(rows[0]), "where matches case-insensitively");
+    assert(!compile({ where: { city: "Plov" } })(rows[0]), "where matches whole values only");
+    assert(compile({ where: { county: "wood" } })(rows[2]), "where matches inside an array");
+    assert(compile({ match: { "heading|text": "approved" } })(rows[0]), "match joins the fields it names");
+    assert(!compile({ match: { heading: "/rezoning/" } })(rows[0]), "/re/ is case-sensitive");
+    assert(!compile({ match: { heading: "rezon" }, not: { where: { city: "Plover" } } })(rows[0]), "not negates");
+
+    const checks: Check[] = [
+        { id: "rezoning", q: "rezoning", expect: { match: { heading: "rezon" } }, k: 1, min: 1 },
+        { id: "plover", kind: "count", where: { city: "Plover" }, min: 2, max: 2 },
+        { id: "wells", kind: "count", where: { city: "Plover" }, expect: { match: { heading: "well" } } },
+        { id: "addresses", kind: "records", expect: { match: { text: "/\\b\\d{2,6} [A-Z]\\w+ (Rd|St)\\b/" } }, max_pct: 30, hard: true },
+    ];
+    const r = Object.fromEntries((await grade(rows, roles, checks, async () => null, 2)).map((x) => [x.id, x]));
+    assert(r.rezoning.score === 1 && r.rezoning.pass, `lexical search finds the rezoning: ${JSON.stringify(r.rezoning)}`);
+    assert(r.plover.score === 2 && r.plover.pass, "count reaches both Plover rows");
+    assert(r.wells.score === 0 && !r.wells.pass, "a count with nothing to reach fails (min defaults to 1)");
+    assert(r.addresses.score === 25 && r.addresses.pass, `records is a percentage: ${r.addresses.score}`);
+    const [scoped] = await grade(rows, roles, [{ id: "s", kind: "records", of: { where: { city: "Stevens Point" } }, expect: { match: { text: "Rd" } }, max_pct: 100 }], async () => null, 0);
+    assert(scoped.score === 50, `\`of\` narrows the rows a record check counts: ${scoped.score}`);
+    assert(r["known@10"].score === 1, "every title finds its own row");
+
+    // The verdict.
+    const res = (id: string, score: number, kind: Result["kind"] = "search", extra = {}): Result => ({ id, kind, score, pass: true, ...extra });
+    const base = [res("q1", 0.8), res("q2", 0.4), res("known@10", 0.9, "known"), res("pii", 0.1, "records", { hard: true })];
+    assert(compare(base, base).verdict === "unchanged", "same is unchanged");
+    assert(compare([res("q1", 0.8), res("q2", 0.4), res("known@10", 0.93, "known"), res("pii", 0.1, "records", { hard: true })], base).verdict === "unchanged", "within tolerance is unchanged");
+    assert(compare([res("q1", 1), res("q2", 0.6), res("known@10", 0.9, "known"), res("pii", 0.1, "records", { hard: true })], base).verdict === "better", "a mean rise is better");
+    assert(compare([res("q1", 0.6), res("q2", 0.4), res("known@10", 0.9, "known"), res("pii", 0.1, "records", { hard: true })], base).verdict === "worse", "a mean drop is worse");
+    const ratchet = compare([res("q1", 1), res("q2", 0), res("known@10", 0.9, "known"), res("pii", 0.1, "records", { hard: true })], base);
+    assert(ratchet.verdict === "worse" && /answered before/.test(ratchet.failures[0]), "the ratchet holds even when the mean does not drop");
+    assert(compare([res("q1", 0.8), res("q2", 0.4), res("known@10", 0.9, "known"), res("pii", 0.2, "records", { hard: true })], base).verdict === "worse", "a hard record may not rise");
+    assert(compare([res("q1", 0.8, "search", { pass: false }), res("q2", 0.4)], base).verdict === "worse", "a floor fails whatever the base did");
+    assert(compare([res("q1", 0.8), res("q2", 0.4), res("q3", 0)], base).verdict === "unchanged", "a new question has no base to fall from");
+    console.log("eval: selfcheck ok");
+}

package/publish/graph.js

@@ -183,7 +183,7 @@ export function treeFromGraph(contents) {
 // `process` doesn't exist in the browser, and consumers import nest() from here
 // to build a viewer tree — so this guard has to survive being evaluated by a
 // browser.
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}`) {
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/graph.js")) {
     // sond3r's pinned names, which is also the case with every option exercised.
     const SOND3R = {
         file: "video",

package/publish/manifest.js

@@ -90,7 +90,7 @@ export function manifestFromTree(files, { defaultPrice = "1000", newUid: uid = n
 }
 
 // ── self-check: `node publish/manifest.js` ───────────────────────────────────
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/manifest.js")) {
     const assert = (c, m) => { if (!c) throw new Error(m); };
 
     // PINNED. sond3r's manifests are already in R2 under this exact key; if this

package/publish/reactions.js

@@ -53,7 +53,9 @@
 import { packVec } from "../consume/embed.js";
 import { lineage } from "./terms.js";
 
-export const COVERAGE_K = 8;
+// 32, not 8: on Kingsfoil the top 3 of 23 views held 92% of the true top 10 with 32
+// centroids and 86% with 8, and 8 missed whole topics (ALS → neurology).
+export const COVERAGE_K = 32;
 export const COVERAGE_DIM = 128;
 /** Fewest reactions that may stand behind one published centroid. */
 export const MIN_PER_CENTROID = 8;
@@ -235,7 +237,7 @@ export function reactionCorpus(events = [], {
 }
 
 // ── self-check: `node publish/reactions.js` ────────────────────────────────
-if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}`) {
+if (typeof process !== "undefined" && import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/reactions.js")) {
     const { splitPayment } = await import("./terms.js");
     const A = (n) => `0x${String(n).repeat(40).slice(0, 40)}`;
     const vec = (a, b) => { const v = new Float32Array(256); v[0] = a; v[1] = b; return v; };

package/publish/settle.js

@@ -70,7 +70,7 @@ export async function encryptAndUpload({ file, resourceId, workerUrl, uploadToke
 // under test here is the ENCRYPTOR: chunk addressing, the AAD index binding, the
 // ragged tail, and that pack/unpack round trip. An app's full publisher→buyer
 // round trip belongs in that app, against its own buyer.
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${process.argv[1]}` && process.argv[1].endsWith("/settle.js")) {
     const { writeFileSync, rmSync } = await import("node:fs");
     const { unseal } = await import("@fangorn-network/sdk");
     const { x25519 } = await import("@noble/curves/ed25519");