@intentius/tsad-conformance 1.4.0 → 1.6.0

package/src/corpus.ts

@@ -31,6 +31,9 @@ import { foldProject as chantFoldProject } from "@intentius/chant";
 import { findInfraFiles } from "@intentius/chant/discovery/files";
 import { FOLDABLE_AUTHORING_HELPERS, isChantOwnedSpecifier } from "@intentius/chant/fold/foldable-helpers";
 import { foldProject as referenceFoldProject, type Host } from "@intentius/tsad-reference";
+import type { ConformanceAdapter } from "./adapter.js";
+import type { ConformanceHost } from "./host.js";
+import { rustAdapter, rustEvaluatorPath } from "./adapters/rust.js";
 
 const REPO_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
 
@@ -125,6 +128,15 @@ export async function discoverCorpus(checkout: ChantCheckout): Promise<CorpusEnt
  * A specifier whose module will not load is reported, not skipped silently:
  * every file that imports it is host-limited, and the count has to show it.
  */
+/**
+ * The third column (#86): the evaluator with no JavaScript runtime, judged in
+ * `data-host` against the reference judged in the same profile with the same
+ * host description. Present when the binary is built; the column is omitted
+ * from the report otherwise, never silently empty.
+ */
+const rust: ConformanceAdapter | undefined = (() => { const p = rustEvaluatorPath(REPO_ROOT); return p ? rustAdapter(p) : undefined; })();
+export const dataHostEvaluator = rust ? { name: rust.name, specVersion: rust.specVersion } : undefined;
+
 export interface CorpusHost extends Host {
   /** Host-owned specifiers whose module could not be loaded. */
   readonly unloadable: ReadonlySet<string>;
@@ -174,9 +186,7 @@ export type Side = "fold" | "run";
  */
 export type Limit =
   /** The reference has no bindings for a package it cannot load (#20 is not finished). */
-  | "host"
-  /** The reference implements no composite factory form; see `packages/reference/CAVEATS.md`. */
-  | "composite";
+  "host";
 
 /**
  * Both limits disarm the reference, and a limit can only make its own side
@@ -184,7 +194,15 @@ export type Limit =
  * build parameters chant's entry could not be given; chant-v0.71.0 takes both
  * (chant#2422) and they are gone (#96).
  */
-export const LIMIT_SIDE: Readonly<Record<Limit, "reference">> = { host: "reference", composite: "reference" };
+export const LIMIT_SIDE: Readonly<Record<Limit, "reference">> = { host: "reference" };
+
+/** The data-host column of one file: the reference and the Rust evaluator, both in `data-host`. */
+export interface DataHostComparison {
+  reference: Side;
+  rust: Side;
+  agreed: boolean;
+  diff?: string;
+}
 
 export interface FileComparison {
   readonly file: string;
@@ -192,6 +210,8 @@ export interface FileComparison {
   readonly reference: Side;
   /** The first limit that applies, for the comparable-set accounting. */
   readonly limit?: Limit;
+  /** The data-host column, when the evaluator with no JavaScript runtime was present (#86). */
+  readonly dataHost?: DataHostComparison;
   /** Both folded, and their export namespaces were compared as data. */
   readonly values?: "equal" | "differ" | "not-data";
   /** Where the two encodings first differ, with a little context either side, so a difference is a diff and not a verdict. */
@@ -252,24 +272,6 @@ function hostBoundNames(source: string, path: string, host: CorpusHost): Set<str
  * message wording is explicitly non-normative, and a classifier that reads it
  * would silently stop classifying the day the wording changed.
  */
-function usesCompositeFactory(source: string, path: string, host: CorpusHost): boolean {
-  const bound = hostBoundNames(source, path, host);
-  if (bound.size === 0) return false;
-  const known = new Set([...host.intrinsics.map((i) => i.name), ...host.helpers.map((h) => h.name)]);
-  const sf = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true);
-  let found = false;
-  const visit = (node: ts.Node): void => {
-    if (found) return;
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-      const name = node.expression.text;
-      if (bound.has(name) && !known.has(name)) found = true;
-    }
-    ts.forEachChild(node, visit);
-  };
-  ts.forEachChild(sf, visit);
-  return found;
-}
-
 /** The reference's own resolution: a relative specifier against the project's key set. */
 function resolveKey(from: string, spec: string, keys: ReadonlySet<string>): string | undefined {
   const base = from.includes("/") ? from.slice(0, from.lastIndexOf("/") + 1) : "";
@@ -402,27 +404,44 @@ export async function runCorpusEntry(checkout: ChantCheckout, entry: CorpusEntry
   const reference = referenceFoldProject(sources, host);
 
   const hostSeed = new Set<string>();
-  const compositeSeed = new Set<string>();
   for (const [key, source] of sources) {
     const { bare } = specifiersOf(source, key);
     if (bare.some((s) => !isChantOwnedSpecifier(s) || host.unloadable.has(s))) hostSeed.add(key);
-    if (usesCompositeFactory(source, key, host)) compositeSeed.add(key);
   }
   const hostLimited = spread(hostSeed, sources, reference.taintSource);
-  const compositeLimited = spread(compositeSeed, sources, reference.taintSource);
+
+  // The data-host column: the same host as a description, no code in it.
+  const description: Host = { profile: "data-host", intrinsics: host.intrinsics, helpers: [], ownedSpecifierPrefixes: host.ownedSpecifierPrefixes, values: new Map() };
+  const conformanceHost: ConformanceHost = { name: "chant", ownedSpecifierPrefixes: host.ownedSpecifierPrefixes, intrinsics: host.intrinsics, helpers: [], values: new Map() };
+  const dataHostReference = rust ? referenceFoldProject(sources, description) : undefined;
+  const dataHostRust = rust?.foldProject ? await rust.foldProject(new Map(sources), conformanceHost) : undefined;
 
   const comparisons: FileComparison[] = paths.map((abs) => {
     const file = keyOf(abs);
+    let dataHost: DataHostComparison | undefined;
+    if (dataHostReference && dataHostRust && dataHostRust !== "unavailable") {
+      const dr = dataHostReference.verdicts.get(file), xr = dataHostRust.verdicts[file];
+      const referenceSide: Side = dr?.kind === "fold" ? "fold" : "run", rustSide: Side = xr?.kind === "fold" ? "fold" : "run";
+      let agreed = referenceSide === rustSide, diff: string | undefined;
+      if (agreed && dr?.kind === "fold" && xr?.kind === "fold") {
+        const c = compareData(Object.fromEntries(dr.exports), xr.exports);
+        if (c.values === "differ") { agreed = false; diff = c.valuesDiff; }
+      } else if (!agreed) {
+        diff = dr?.kind === "run" ? `reference ${dr.rule}: ${dr.reason}` : xr?.kind === "run" ? `rust ${xr.rule ?? ""}: ${xr.reason}` : undefined;
+      }
+      dataHost = { reference: referenceSide, rust: rustSide, agreed, diff };
+    }
     const cv = chant.get(abs);
     const rv = reference.verdicts.get(file);
     const chantSide: Side = cv?.verdict === "fold" ? "fold" : "run";
     const referenceSide: Side = rv?.kind === "fold" ? "fold" : "run";
-    const limit: Limit | undefined = hostLimited.has(file) ? "host" : compositeLimited.has(file) ? "composite" : undefined;
+    const limit: Limit | undefined = hostLimited.has(file) ? "host" : undefined;
     const base: FileComparison = {
       file,
       chant: chantSide,
       reference: referenceSide,
       limit,
+      dataHost,
       referenceRule: rv?.kind === "run" ? rv.rule : undefined,
       referenceReason: rv?.kind === "run" ? rv.reason : undefined,
       chantReason:
@@ -461,16 +480,24 @@ export interface CorpusSummary {
    * reaches and chant does not has no benign explanation wherever it appears.
    */
   readonly referenceMorePermissive: readonly Disagreement[];
+  /** The data-host column, when the evaluator with no JavaScript runtime was present. */
+  readonly dataHost?: { readonly files: number; readonly agreed: number; readonly bothFold: number; readonly disagreements: readonly Disagreement[] };
 }
 
 export function summarize(reports: readonly EntryReport[]): CorpusSummary {
   let files = 0, comparable = 0, comparableAgreed = 0, comparableBothFold = 0, comparableValuesNotData = 0;
-  const limited: Record<Limit, number> = { host: 0, composite: 0 };
+  const limited: Record<Limit, number> = { host: 0 };
   const disagreements: Disagreement[] = [];
   const referenceMorePermissive: Disagreement[] = [];
+  let dhFiles = 0, dhAgreed = 0, dhBothFold = 0;
+  const dhDisagreements: Disagreement[] = [];
   for (const report of reports) {
     files += report.files;
     for (const c of report.comparisons) {
+      if (c.dataHost) {
+        dhFiles++;
+        if (c.dataHost.agreed) { dhAgreed++; if (c.dataHost.reference === "fold") dhBothFold++; } else dhDisagreements.push({ ...c, entry: report.name });
+      }
       if (c.reference === "fold" && c.chant === "run") referenceMorePermissive.push({ ...c, entry: report.name });
       if (c.limit) { limited[c.limit]++; continue; }
       comparable++;
@@ -483,6 +510,7 @@ export function summarize(reports: readonly EntryReport[]): CorpusSummary {
   return {
     entries: reports.length, files, comparable, comparableAgreed, comparableBothFold,
     comparableValuesNotData, limited, disagreements, referenceMorePermissive,
+    dataHost: dhFiles ? { files: dhFiles, agreed: dhAgreed, bothFold: dhBothFold, disagreements: dhDisagreements } : undefined,
   };
 }
 
@@ -495,7 +523,7 @@ export function renderCorpusReport(
 ): string {
   const rows = reports.map((r) => {
     const s = summarize([r]);
-    return `| \`${r.name}\` | ${r.files} | ${s.comparable} | ${s.comparableAgreed} | ${s.limited.host} | ${s.limited.composite} |`;
+    return `| \`${r.name}\` | ${r.files} | ${s.comparable} | ${s.comparableAgreed} | ${s.limited.host} |`;
   });
   const line = (d: Disagreement) =>
     `- \`${d.entry}/${d.file}\`: chant ${d.chant}, reference ${d.reference}${d.values ? `, values ${d.values}` : ""}${d.valuesDiff ? ` (${d.valuesDiff})` : ""}` +
@@ -511,12 +539,12 @@ export function renderCorpusReport(
     "",
     "## Totals",
     "",
-    "| Files | Comparable | Agreed | Both fold | No host | No composite form |",
-    "|---|---|---|---|---|---|",
+    "| Files | Comparable | Agreed | Both fold | No host |",
+    "|---|---|---|---|---|",
     `| ${summary.files} | ${summary.comparable} | ${summary.comparableAgreed} | ${summary.comparableBothFold} |` +
-      ` ${summary.limited.host} | ${summary.limited.composite} |`,
+      ` ${summary.limited.host} |`,
     "",
-    "Both limits disarm the reference. chant is given the entry's lexicons and build parameters, the inputs a real build has.",
+    "The one limit disarms the reference. chant is given the entry's lexicons and build parameters, the inputs a real build has.",
     "",
     `Of the comparable files both implementations folded, ${summary.comparableValuesNotData} held something that is not data on one side or the other, so only the verdict was compared there.`,
     "",
@@ -530,10 +558,24 @@ export function renderCorpusReport(
       ? "None."
       : summary.referenceMorePermissive.map(line).join("\n"),
     "",
+    ...(summary.dataHost && dataHostEvaluator ? [
+      "## The data-host column",
+      "",
+      `- evaluator: \`${dataHostEvaluator.name}\`, declaring spec \`${dataHostEvaluator.specVersion}\`, no JavaScript runtime`,
+      "",
+      "| Files | Agreed | Both fold |",
+      "|---|---|---|",
+      `| ${summary.dataHost.files} | ${summary.dataHost.agreed} | ${summary.dataHost.bothFold} |`,
+      "",
+      "The reference and the evaluator are both judged in `data-host`, on the same host description and no code. A file that folds on both sides has the same namespace on both, envelopes included.",
+      "",
+      summary.dataHost.disagreements.length === 0 ? "No disagreements." : summary.dataHost.disagreements.map((d) => `- \`${d.entry}/${d.file}\`: reference ${d.dataHost!.reference}, evaluator ${d.dataHost!.rust}${d.dataHost!.diff ? ` (${d.dataHost!.diff})` : ""}`).join("\n"),
+      "",
+    ] : []),
     "## Per entry",
     "",
-    "| Entry | Files | Comparable | Agreed | No host | No composite form |",
-    "|---|---|---|---|---|---|",
+    "| Entry | Files | Comparable | Agreed | No host |",
+    "|---|---|---|---|---|",
     ...rows,
     "",
   ].join("\n");

package/src/fixture.ts

@@ -24,14 +24,31 @@
  *                    "exports":   { "config.ts": { "port": 8080 } },              // optional, for files that finally fold
  *                    "rejectRule": { "app.ts": "F-Eval-CallLocal" },              // optional, the rule a run verdict must name; checked when the adapter reports one
  *                    "host":      "shapes",                                       // optional, a named host from host.ts; required if the sources import one
+ *                    "mode":      "isolated",                                     // optional, J2's ι; "open" by default. An adapter that cannot honour it reports "unavailable"
+ *                    "findings":  { "bucket.ts": [ { "rule": "SHAPES001", "subject": "bad", "severity": "error" } ],   // optional (#101): the host's rules' findings, keyed by the
+ *                                   "artifact":  [ { "rule": "SHAPES002", "subject": "missing: Bucket", "severity": "warning" } ] }, //   file whose namespace holds the subject (pre) or "artifact" (post); "at" optional
+ *                    "counters":  { "projectFactoryInvocations": 0 },              // optional (F-Obs-Counters): the build's counters; the keys given are compared, all three must be reported
  *                    "profiles":  ["full"],                                       // optional; see profilesOf for the default
  *                    "note": "why this fixture exists" }
  * `tentative` and `taintedBy` are what separate "folds because nothing
  * reached it" from "would have folded, and an edge killed it" — without them
  * a project fixture cannot tell F-Seed from F-Taint.
+ *
+ * `findings` is what an F-Rule-* fixture asserts (#101): the findings of the
+ * named host's rules, as data. Matched on rule, subject and severity; the
+ * message is non-normative, and a location only when both sides give one.
+ *
+ * A *roundtrip* fixture (#80) has no source at all. Its input is a namespace
+ * as data and the implementation's generator writes the source:
+ *   value.json   — { "<export>": <value> }, envelopes as F-Val-Domain writes them, "$undefined" as in expect.json
+ *   expect.json  — { "rules": ["F-Val-Source"], "roundtrip": true, "host": "shapes", "profiles": ["data-host"], "note": "…" }
+ * The fold of the generated source must equal the input. Judged in
+ * `data-host` unless the fixture says otherwise, since in `full` the fold of
+ * a resource's form is a live instance and not the envelope (F-Val-Fate).
  */
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative } from "node:path";
+import type { ExecutionCounters } from "./adapter.js";
 
 export interface ExpressionFixture {
   kind: "expression";
@@ -41,6 +58,7 @@ export interface ExpressionFixture {
   shape: "accept" | "reject"; fold: "fold" | "run";
   value?: unknown; rejectAt?: { line: number; column: number }; note?: string;
 }
+export interface ExpectedFinding { rule: string; subject: string; severity: "error" | "warning" | "info"; at?: { line: number; column: number } }
 export interface ProjectFixture {
   kind: "project";
   profiles: Profile[];
@@ -55,9 +73,23 @@ export interface ProjectFixture {
   rejectRule?: Record<string, string>;
   /** A named host from host.ts. Required for any fixture whose sources import one. */
   host?: string;
+  /** J2's ι, `open` unless the fixture says `isolated` (F-IsolatedRefusal). */
+  mode?: "open" | "isolated";
+  /** The host's rules' findings, keyed by file (pre-synthesis) or "artifact" (post-synthesis). */
+  findings?: Record<string, ExpectedFinding[]>;
+  /** F-Obs-Counters: the values the build's counters must show. An adapter reporting none is skipped, not failed. */
+  counters?: Partial<ExecutionCounters>;
   note?: string;
 }
-export type Fixture = ExpressionFixture | ProjectFixture;
+export interface RoundtripFixture {
+  kind: "roundtrip";
+  profiles: Profile[];
+  id: string; dir: string; rules: string[];
+  value: Record<string, unknown>;
+  host?: string;
+  note?: string;
+}
+export type Fixture = ExpressionFixture | ProjectFixture | RoundtripFixture;
 
 export type Profile = "full" | "data-host";
 
@@ -69,6 +101,7 @@ export type Profile = "full" | "data-host";
  */
 export function profilesOf(f: Fixture, explicit?: string[]): Profile[] {
   if (explicit) return explicit as Profile[];
+  if (f.kind === "roundtrip") return ["data-host"];
   const sources = f.kind === "expression" ? [f.input] : [...f.files.values()];
   const usesNew = sources.some((s) => /\bnew\s+[A-Za-z_$]/.test(s));
   if (f.kind === "project" && (f.host || f.tentative || f.taintedBy)) return ["full"];
@@ -78,6 +111,7 @@ export function profilesOf(f: Fixture, explicit?: string[]): Profile[] {
 /** Kept as the name the expression-only callers import; `kind` narrows. */
 export const expressionFixtures = (all: Fixture[]): ExpressionFixture[] => all.filter((f): f is ExpressionFixture => f.kind === "expression");
 export const projectFixtures = (all: Fixture[]): ProjectFixture[] => all.filter((f): f is ProjectFixture => f.kind === "project");
+export const roundtripFixtures = (all: Fixture[]): RoundtripFixture[] => all.filter((f): f is RoundtripFixture => f.kind === "roundtrip");
 
 function readProject(dir: string): Map<string, string> {
   const files = new Map<string, string>();
@@ -100,9 +134,14 @@ export function loadFixtures(root: string): Fixture[] {
       const d = join(rd, name); if (!statSync(d).isDirectory()) continue;
       const e = JSON.parse(readFileSync(join(d, "expect.json"), "utf8"));
       const id = `${rule}/${name}`;
-      if (e.project) {
+      if (e.roundtrip) {
+        const fx: RoundtripFixture = { kind: "roundtrip", id, dir: d, rules: e.rules, profiles: [], host: e.host, note: e.note,
+          value: JSON.parse(readFileSync(join(d, "value.json"), "utf8")) };
+        fx.profiles = profilesOf(fx, e.profiles);
+        out.push(fx);
+      } else if (e.project) {
         const fx: ProjectFixture = { kind: "project", id, dir: d, rules: e.rules, files: readProject(join(d, "project")), profiles: [],
-          verdicts: e.verdicts, tentative: e.tentative, taintedBy: e.taintedBy, exports: e.exports, rejectRule: e.rejectRule, host: e.host, note: e.note };
+          verdicts: e.verdicts, tentative: e.tentative, taintedBy: e.taintedBy, exports: e.exports, rejectRule: e.rejectRule, host: e.host, mode: e.mode, findings: e.findings, counters: e.counters, note: e.note };
         fx.profiles = profilesOf(fx, e.profiles);
         out.push(fx);
       } else {

package/src/host.ts

@@ -17,6 +17,18 @@ export interface HostIntrinsic {
   readonly outputKey?: string;
 }
 
+/**
+ * A rule the host supplies (F-Rule-Supply), by identifier. The rule's code is
+ * the implementation's; what the harness carries is the id, the phase, the
+ * rule's own severity (L11.6) and what it checks, in words.
+ */
+export interface HostRule {
+  readonly id: string;
+  readonly phase: "pre" | "post";
+  readonly severity: "error" | "warning" | "info";
+  readonly description: string;
+}
+
 export interface ConformanceHost {
   readonly name: string;
   /** F-Host-Trust arm 1: the specifiers this host owns. */
@@ -25,6 +37,8 @@ export interface ConformanceHost {
   readonly helpers: readonly { name: string; module: string; note: string }[];
   /** Specifier, then export name, to the real value. Revival calls these (F-Val-Fate). */
   readonly values: ReadonlyMap<string, ReadonlyMap<string, unknown>>;
+  /** F-Host-Interface item 7: the rules this host supplies, if any. */
+  readonly rules?: readonly HostRule[];
 }
 
 const DECLARABLE = Symbol.for("tsad.conformance.declarable");
@@ -51,6 +65,30 @@ class Pair {
   }
 }
 
+/**
+ * F-Host-Interface item 6: the registration form. What it returns is what a
+ * *running* file would call; a folding one never invokes it, because
+ * F-Host-Composite makes the registered factory interpretable instead. The
+ * instance keeps its members enumerable and carries a marker on the
+ * prototype, so it is live (F-Val-Live) and spreads to its members.
+ */
+const COMPOSITE = Symbol.for("tsad.conformance.composite");
+class CompositeInstance {
+  readonly [COMPOSITE]: true = true;
+}
+const Composite = <P>(factory: (props: P) => Record<string, unknown>, name = "anonymous") => {
+  const definition = (props: P) => Object.assign(new CompositeInstance(), factory(props));
+  return Object.assign(definition, { compositeName: name });
+};
+
+/** A host-published composite (L7.1: never interpreted, invoked at a declarator or read through a const, F-Eval-CompositeConst). */
+const Stack = Composite((props: { left: unknown; right: unknown }) => ({ pair: new Pair(props.left, props.right) }), "Stack");
+
+/** A host-published factory (F-Call step 6): invoked with the resolved arguments, it returns an entity. */
+const makePair = (left: unknown, right: unknown): Pair => new Pair(left, right);
+/** A host export that is a function but returns plain data: step 7 refuses its result. */
+const describe = (name: string): { described: string } => ({ described: name });
+
 /** A live object the host owns outright, for the F-CallLeak case: no construction involved. */
 const registry = new Map<string, string>([["one", "1"]]);
 
@@ -79,6 +117,14 @@ const SHAPES: ConformanceHost = {
     { name: "count", isTag: false, foldsEagerly: true },
   ],
   helpers: [{ name: "upper", module: "@tsad/shapes", note: "pure string transform, no environment read" }],
+  // Two rules, one per phase (F-Rule-Phase). The pre-synthesis one reads
+  // the folded namespace and names the export it concerns; the
+  // post-synthesis one reads the artifact and, finding nothing to attach
+  // to, reports the missing-resource form (F-Rule-Finding, L11.5).
+  rules: [
+    { id: "SHAPES001", phase: "pre", severity: "error", description: "every Bucket declares a BucketName; the subject is the export that does not" },
+    { id: "SHAPES002", phase: "post", severity: "warning", description: "the artifact declares at least one Bucket; otherwise the subject is `missing: Bucket`" },
+  ],
   values: new Map([
     [
       "@tsad/shapes",
@@ -91,6 +137,10 @@ const SHAPES: ConformanceHost = {
         ["count", count],
         ["SIZES", SIZES],
         ["registry", registry],
+        ["Composite", Composite],
+        ["makePair", makePair],
+        ["Stack", Stack],
+        ["describe", describe],
       ]),
     ],
   ]),

package/src/runner.test.ts

@@ -14,10 +14,14 @@ describe("conformance runner (#7) over the reference implementation (#10)", () =
     const failed = reports.filter((r) => !r.pass).map((r) => `${r.fixture}: ${r.failures.join("; ")}`);
     expect(failed, failed.join("\n")).toEqual([]);
   });
-  test("the data-host profile: the reference with an empty host passes every fixture tagged for it (#78)", async () => {
+  test("the data-host profile: the reference passes every fixture tagged for it, a named host reduced to its description (#78)", async () => {
     const tagged = fixtures.filter((f) => f.profiles.includes("data-host"));
     expect(tagged.length).toBeGreaterThan(40);
-    expect(tagged.every((f) => f.kind === "expression" || !f.host)).toBe(true);
+    // A data-host fixture may name a host for its intrinsic registry and trust
+    // set (F-Profile-DataHost, F-Host-Interface items 3 and 5); the adapter is
+    // what drops the classes, helpers and values, and these fixtures are what
+    // would fail if it did not.
+    expect(tagged.some((f) => f.kind === "project" && f.host)).toBe(true);
     const failed = (await runFixtures(referenceDataHostAdapter, tagged)).filter((r) => !r.pass).map((r) => `${r.fixture}: ${r.failures.join("; ")}`);
     expect(failed, failed.join("\n")).toEqual([]);
   });

package/src/runner.ts

@@ -1,6 +1,6 @@
-import type { ConformanceAdapter } from "./adapter.js";
-import type { ExpressionFixture, Fixture, ProjectFixture } from "./fixture.js";
-import { expressionFixtures, projectFixtures } from "./fixture.js";
+import type { ConformanceAdapter, Finding, RulePhase, ExecutionCounters } from "./adapter.js";
+import type { ExpressionFixture, Fixture, ProjectFixture, RoundtripFixture } from "./fixture.js";
+import { expressionFixtures, projectFixtures, roundtripFixtures } from "./fixture.js";
 import { requireHost } from "./host.js";
 
 export interface FixtureReport { fixture: string; adapter: string; pass: boolean; skipped?: string; failures: string[] }
@@ -45,14 +45,49 @@ export async function runFixtures(adapter: ConformanceAdapter, fixtures: Fixture
   return [
     ...expressionFixtures(fixtures).map((f) => runFixture(adapter, f)),
     ...(await Promise.all(projectFixtures(fixtures).map((f) => runProjectFixture(adapter, f)))),
+    ...(await Promise.all(roundtripFixtures(fixtures).map((f) => runRoundtripFixture(adapter, f)))),
   ];
 }
 
+/**
+ * #80 — the round trip. The input is data; the implementation's generator
+ * writes source for it and the fold of that source must be the input. The
+ * "$undefined" sentinel in value.json is decoded before generation so the
+ * generator sees the value the domain has.
+ */
+export async function runRoundtripFixture(adapter: ConformanceAdapter, f: RoundtripFixture): Promise<FixtureReport> {
+  const base = { fixture: f.id, adapter: adapter.name };
+  if (!adapter.generate || !adapter.foldProject) return { ...base, pass: true, skipped: "no generator", failures: [] };
+  const host = f.host ? requireHost(f.host) : undefined;
+  const source = adapter.generate(decodeValue(f.value) as Record<string, unknown>, host);
+  if (source === "unavailable") return { ...base, pass: true, skipped: "generator unavailable for this value", failures: [] };
+  const r = await adapter.foldProject(new Map([["generated.ts", source]]), host);
+  if (r === "unavailable") return { ...base, pass: true, skipped: "project entry unavailable", failures: [] };
+  const failures: string[] = [];
+  const v = r.verdicts["generated.ts"];
+  if (v?.kind !== "fold") failures.push(`generated source does not fold${v?.kind === "run" ? ` (${v.reason})` : ""}:\n${source}`);
+  else {
+    for (const name of new Set([...Object.keys(f.value), ...Object.keys(v.exports)])) {
+      if (!(name in f.value)) { failures.push(`export ${name} generated but not in the input`); continue; }
+      if (encodeValue(v.exports[name]) !== encodeValue(f.value[name])) failures.push(`export ${name} = ${encodeValue(v.exports[name])} ≠ input ${encodeValue(f.value[name])}\n${source}`);
+    }
+  }
+  return { ...base, pass: failures.length === 0, failures };
+}
+
+/** The inverse of encodeValue's sentinel: "$undefined" in fixture data is the domain's undefined. */
+export function decodeValue(v: unknown): unknown {
+  if (v === "$undefined") return undefined;
+  if (v === null || typeof v !== "object") return v;
+  if (Array.isArray(v)) return v.map(decodeValue);
+  return Object.fromEntries(Object.entries(v).map(([k, e]) => [k, decodeValue(e)]));
+}
+
 /** #24 — a whole-build fixture. J3's edges are invisible in any single file, so this is the only shape that can test them. */
 export async function runProjectFixture(adapter: ConformanceAdapter, f: ProjectFixture): Promise<FixtureReport> {
   const base = { fixture: f.id, adapter: adapter.name };
   if (!adapter.foldProject) return { ...base, pass: true, skipped: "no project entry", failures: [] };
-  const r = await adapter.foldProject(f.files, f.host ? requireHost(f.host) : undefined);
+  const r = await adapter.foldProject(f.files, f.host ? requireHost(f.host) : undefined, f.mode);
   if (r === "unavailable") return { ...base, pass: true, skipped: "project entry unavailable", failures: [] };
   const failures: string[] = [];
   for (const [path, want] of Object.entries(f.verdicts)) {
@@ -83,16 +118,74 @@ export async function runProjectFixture(adapter: ConformanceAdapter, f: ProjectF
       }
     }
   }
+  if (f.findings) {
+    const got = await collectFindings(adapter, f);
+    if (got === "unavailable") return { ...base, pass: failures.length === 0, skipped: "rules unavailable", failures };
+    failures.push(...compareFindings(f.findings, got));
+  }
+  if (f.counters) {
+    // F-Obs-Counters: the shape is normative, so all three must be present as non-negative integers; the fixture then pins the values it names.
+    if (!r.counters) return { ...base, pass: failures.length === 0, skipped: "counters unavailable", failures };
+    for (const k of ["factoryInvocations", "projectFactoryInvocations", "factoryInterpretations"] as const) {
+      const v = r.counters[k];
+      if (!Number.isInteger(v) || v < 0) failures.push(`counters.${k}: ${String(v)} is not a non-negative integer (F-Obs-Counters)`);
+    }
+    for (const [k, want] of Object.entries(f.counters)) {
+      const got = r.counters[k as keyof ExecutionCounters];
+      if (got !== want) failures.push(`counters.${k}: ${got} ≠ expected ${want}`);
+    }
+  }
   return { ...base, pass: failures.length === 0, failures };
 }
 
+/** The key a finding is filed under: the file whose namespace holds the subject, or the artifact. */
+const findingKey = (x: Finding, phase: RulePhase): string => (phase === "post" ? "artifact" : x.file ?? "artifact");
+const findingSig = (x: { rule: string; subject: string; severity: string }): string => `${x.rule} ${x.severity} ${x.subject}`;
+
+/**
+ * Every finding of both phases (#101). Each phase is run twice and the two
+ * runs must agree: F-Rule-Pure says a rule is a function of its input, and
+ * a rule that reads a clock or the environment fails here before its
+ * findings are compared with anything.
+ */
+export async function collectFindings(adapter: ConformanceAdapter, f: ProjectFixture): Promise<Map<string, Finding[]> | "unavailable"> {
+  if (!adapter.rules || !f.host) return "unavailable";
+  const host = requireHost(f.host);
+  const out = new Map<string, Finding[]>();
+  for (const phase of ["pre", "post"] as const) {
+    const first = await adapter.rules(f.files, host, phase);
+    if (first === "unavailable") return "unavailable";
+    const second = await adapter.rules(f.files, host, phase);
+    if (second === "unavailable") return "unavailable";
+    const a = first.map((x) => `${findingKey(x, phase)}: ${findingSig(x)}`).sort(), b = second.map((x) => `${findingKey(x, phase)}: ${findingSig(x)}`).sort();
+    if (a.join("\n") !== b.join("\n")) throw new Error(`${f.id}: ${phase}-synthesis findings differ between two runs of the same input (F-Rule-Pure)\n${a.join("\n")}\n---\n${b.join("\n")}`);
+    for (const x of first) { const k = findingKey(x, phase); out.set(k, [...(out.get(k) ?? []), x]); }
+  }
+  return out;
+}
+
+/** Findings matched on rule, subject and severity; `at` only when both sides carry one. */
+export function compareFindings(want: Record<string, { rule: string; subject: string; severity: string; at?: { line: number; column: number } }[]>, got: Map<string, Finding[]>): string[] {
+  const failures: string[] = [];
+  for (const key of new Set([...Object.keys(want), ...got.keys()])) {
+    const w = want[key] ?? [], g = got.get(key) ?? [];
+    for (const x of w) {
+      const hit = g.find((y) => findingSig(y) === findingSig(x));
+      if (!hit) { failures.push(`${key}: expected finding ${findingSig(x)}, not reported`); continue; }
+      if (x.at && hit.at && (hit.at.line !== x.at.line || hit.at.column !== x.at.column)) failures.push(`${key}: ${findingSig(x)} at ${hit.at.line}:${hit.at.column}, expected ${x.at.line}:${x.at.column}`);
+    }
+    for (const y of g) if (!w.some((x) => findingSig(x) === findingSig(y))) failures.push(`${key}: finding ${findingSig(y)} reported but not expected (${y.message})`);
+  }
+  return failures;
+}
+
 /** #11 — two implementations must agree on every fixture, independently of what the fixture expects. */
 export async function compareAdapters(a: ConformanceAdapter, b: ConformanceAdapter, fixtures: Fixture[]): Promise<string[]> {
   const dis: string[] = [];
   for (const f of projectFixtures(fixtures)) {
     if (!a.foldProject || !b.foldProject) continue;
     const host = f.host ? requireHost(f.host) : undefined;
-    const [ra, rb] = await Promise.all([a.foldProject(f.files, host), b.foldProject(f.files, host)]);
+    const [ra, rb] = await Promise.all([a.foldProject(f.files, host, f.mode), b.foldProject(f.files, host, f.mode)]);
     if (ra === "unavailable" || rb === "unavailable") continue;
     for (const path of new Set([...Object.keys(ra.verdicts), ...Object.keys(rb.verdicts)])) {
       const va = ra.verdicts[path]?.kind ?? "absent", vb = rb.verdicts[path]?.kind ?? "absent";
@@ -107,6 +200,15 @@ export async function compareAdapters(a: ConformanceAdapter, b: ConformanceAdapt
         dis.push(`${f.id} ${path}: tainted by — ${a.name} ${ra.taintedBy[path] ?? "nothing"}, ${b.name} ${rb.taintedBy[path] ?? "nothing"}`);
       }
     }
+    // F-Rule-Equivalence, across implementations: the same host rules over
+    // the same source report the same findings, whichever path each took.
+    if (f.findings) {
+      const [fa, fb] = await Promise.all([collectFindings(a, f), collectFindings(b, f)]);
+      if (fa !== "unavailable" && fb !== "unavailable") {
+        const sig = (m: Map<string, Finding[]>) => [...m.entries()].flatMap(([k, xs]) => xs.map((x) => `${k}: ${findingSig(x)}`)).sort().join("\n");
+        if (sig(fa) !== sig(fb)) dis.push(`${f.id}: findings — ${a.name}\n${sig(fa)}\n${b.name}\n${sig(fb)}`);
+      }
+    }
   }
   for (const f of expressionFixtures(fixtures)) {
     const ra = a.foldExport(f.input, f.exportName), rb = b.foldExport(f.input, f.exportName);

package/src/rust-agreement.test.ts

@@ -0,0 +1,37 @@
+/**
+ * #86 — the evaluator with no JavaScript runtime, held to the data-host
+ * profile's fixtures and to agreement with the reference judged in the same
+ * profile. Skips, visibly, when the binary is not built: `cargo build
+ * --release` in evaluators/rust, or TSAD_RUST_EVAL naming it.
+ */
+import { describe, test, expect } from "vitest";
+import { join } from "node:path";
+import { loadFixtures, runFixtures, compareAdapters } from "./index";
+import { rustAdapter, rustEvaluatorPath } from "./adapters/rust";
+import { referenceDataHostAdapter } from "../../reference/src/index";
+
+const root = join(__dirname, "..", "..", "..");
+const binary = rustEvaluatorPath(root);
+const suite = binary ? describe : describe.skip;
+if (!binary) console.warn("[rust] skipped: evaluators/rust is not built (cargo build --release) and TSAD_RUST_EVAL is unset");
+
+suite("the Rust evaluator (#86) in the data-host profile", () => {
+  // The callback is collected even when the suite is skipped, so the adapter is made only when the binary exists.
+  const rust = binary ? rustAdapter(binary) : (undefined as unknown as ReturnType<typeof rustAdapter>);
+  const fixtures = loadFixtures(join(root, "spec", "fixtures")).filter((f) => f.profiles.includes("data-host"));
+  test("declares the specification version the fixtures are at", () => {
+    expect(rust.specVersion).toBe(referenceDataHostAdapter.specVersion);
+  });
+  test("passes every fixture tagged for the profile", async () => {
+    const reports = await runFixtures(rust, fixtures);
+    const failed = reports.filter((r) => !r.pass).map((r) => `${r.fixture}: ${r.failures.join("; ")}`);
+    expect(failed, failed.join("\n")).toEqual([]);
+    // Nothing is skipped: the evaluator generates as well as folds (F-Val-Source), so the round trip runs here too.
+    const skipped = reports.filter((r) => r.skipped).map((r) => r.fixture);
+    expect(skipped, `skipped: ${skipped.join(", ")}`).toEqual([]);
+  });
+  test("agrees with the reference on every fixture, independently of what the fixture expects", async () => {
+    const dis = await compareAdapters(referenceDataHostAdapter, rust, fixtures);
+    expect(dis, dis.join("\n")).toEqual([]);
+  });
+});