@cruba/crubal 0.1.0 → 0.2.0

package/dist/src/corpus.js

@@ -5,17 +5,26 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { canonical } from "./canonical.js";
 import { emptyDictionary, readDefinitions, splitCaseInput } from "./defs.js";
-import { land, matchParts, rawOf, readContracts, receive, replay, reviewByKey, validate, verifyChain } from "./store.js";
-import { checkRecipe, readRecipes, restamp } from "./migrate.js";
+import { land, matchParts, proposeSplit, rawOf, readContracts, receive, replay, reviewByKey, validate, verifyChain } from "./store.js";
+import { checkRecipe, dryRun, readRecipes, restamp } from "./migrate.js";
 import { checkContracts, Exchange, readRoles, verifyBorder } from "./exchange.js";
 import { checkPackages } from "./packages.js";
 import { checkViews, readViews, Views } from "./views.js";
+import { formOf } from "./forms.js";
+import { Journal, rebuild, redactable, redactableWrite, stateJson } from "./log.js";
+import { decide as decideReview } from "./review.js";
+import { resetUnits } from "./units.js";
+import { arrive, decide } from "./arrival.js";
+import { adopt, apply as applyInstructions, archive, attach, clone, detach, emptyStore, giveBack, issue, merge, split, unarchive } from "./lifecycle.js";
+import { Access, checkPermissions, readAccess } from "./access.js";
+import { readPiece } from "./lex.js";
 import { readUnder } from "./read-text.js";
 import { readTree } from "./tree.js";
+import { MemoryRecords } from "./records.js";
 import { checkRules, Engine, readRules } from "./rules.js";
 import { checkPackage, checkRecord, facetJson, foldRecord, resolve, resolvedJson } from "./dictionary.js";
 import { serialize } from "./canonical.js";
-import { checkWrapper } from "./model.js";
+import { checkWrapper, parseJson } from "./model.js";
 import { printText } from "./print-text.js";
 import { readText } from "./read-text.js";
 import { CrubalError } from "./tree.js";
@@ -26,11 +35,11 @@ const LEVEL_FOLDERS = {
     store: ["reader", "reader-errors", "dictionary", "dictionary-errors", "rules", "rules-errors", "store", "store-errors"],
     exchange: [
         "reader", "reader-errors", "dictionary", "dictionary-errors", "rules", "rules-errors", "store", "store-errors",
-        "exchange", "exchange-errors", "package-errors",
+        "exchange", "exchange-errors", "package-errors", "forms",
     ],
     views: [
         "reader", "reader-errors", "dictionary", "dictionary-errors", "rules", "rules-errors", "store", "store-errors",
-        "exchange", "exchange-errors", "package-errors", "views", "views-errors",
+        "exchange", "exchange-errors", "package-errors", "forms", "views", "views-errors",
     ],
 };
 /** The shared definitions a folder's cases run under: the reader package, then the folder's own files. */
@@ -49,7 +58,7 @@ function loadDictionary(root, folder) {
     return dict;
 }
 function copy(d) {
-    return { facets: new Map(d.facets), classes: new Map(d.classes), levels: new Map(d.levels), vary: new Map(d.vary), trust: [...d.trust], facetTrust: new Map(d.facetTrust) };
+    return { facets: new Map(d.facets), classes: new Map(d.classes), kinds: new Map(d.kinds), levels: new Map(d.levels), vary: new Map(d.vary), varyLines: new Map(d.varyLines), trust: [...d.trust], facetTrust: new Map(d.facetTrust), identify: new Map(d.identify), match: new Map(d.match), archive: new Map(d.archive) };
 }
 /** Each expected entry must match an actual one on every field it states; entry sets must be the same. */
 function compareOutcomes(actual, expected) {
@@ -89,7 +98,7 @@ function runDictionaryCase(folder, caseDir, name, shared) {
             }
         }
         if (existsSync(longFile)) {
-            const expected = serialize(JSON.parse(readFileSync(join(caseDir, "expected.json"), "utf8")));
+            const expected = serialize(parseJson(readFileSync(join(caseDir, "expected.json"), "utf8")));
             for (const [label, text] of [["shorthand", input], ["long form", readFileSync(longFile, "utf8")]]) {
                 const d = readDefinitions(text);
                 checkPackage(d);
@@ -106,7 +115,7 @@ function runDictionaryCase(folder, caseDir, name, shared) {
         checkPackage(dict);
         const resolveLine = defs.match(/^resolve: (\S+)/m);
         if (resolveLine) {
-            const expected = JSON.parse(readFileSync(join(caseDir, "expected.json"), "utf8"));
+            const expected = parseJson(readFileSync(join(caseDir, "expected.json"), "utf8"));
             const got = serialize(resolvedJson(resolve(dict, [resolveLine[1]])));
             return got === serialize(expected.resolved) ? { folder, name, pass: true } : { folder, name, pass: false, detail: `got ${got}` };
         }
@@ -121,8 +130,8 @@ function runDictionaryCase(folder, caseDir, name, shared) {
             const problem = compareOutcomes(actual, JSON.parse(readFileSync(outcomesFile, "utf8")));
             return problem ? { folder, name, pass: false, detail: problem } : { folder, name, pass: true };
         }
-        const expected = JSON.parse(readFileSync(join(caseDir, "expected.json"), "utf8"));
-        checkWrapper(expected);
+        const expected = parseJson(readFileSync(join(caseDir, "expected.json"), "utf8"));
+        checkWrapper(expected, dict);
         const want = canonical(expected, dict);
         const got = canonical(w, dict);
         if (got !== want)
@@ -161,8 +170,8 @@ function runCase(folder, dir, name, dict) {
         }
     }
     try {
-        const expected = JSON.parse(readFileSync(join(caseDir, "expected.json"), "utf8"));
-        checkWrapper(expected);
+        const expected = parseJson(readFileSync(join(caseDir, "expected.json"), "utf8"));
+        checkWrapper(expected, dict);
         const want = canonical(expected, dict);
         const got = readText(input, dict);
         const gotC = canonical(got, dict);
@@ -225,6 +234,9 @@ function runRulesCase(folder, caseDir, name, shared, sharedRules) {
         checkPackage(dict);
         checkRules(rules, dict);
         const engine = new Engine(dict, rules);
+        const nowFile = join(caseDir, "now.txt");
+        if (existsSync(nowFile))
+            engine.now = readFileSync(nowFile, "utf8").trim();
         const altFile = join(caseDir, "alternatives.json");
         const alts = existsSync(altFile) ? JSON.parse(readFileSync(altFile, "utf8")) : {};
         const last = new Map();
@@ -256,6 +268,7 @@ function subset(actual, expected, label = "") {
     return null;
 }
 function runStoreCase(folder, caseDir, name, shared) {
+    resetUnits();
     const file = (f) => join(caseDir, f);
     const json = (f) => JSON.parse(readFileSync(file(f), "utf8"));
     const pass = { folder, name, pass: true };
@@ -275,6 +288,31 @@ function runStoreCase(folder, caseDir, name, shared) {
                 return e.line === want ? pass : fail(`refused at line ${e.line} (${e.message}), expected line ${want}`);
             }
         }
+        // Redaction (8.5.2): per entry, whether it may go whole, else which of its writes may, and why not.
+        if (existsSync(file("expected-redact.json"))) {
+            const entries = json("log.json");
+            const got = {};
+            for (const e of entries) {
+                const whole = redactable(e);
+                const writes = Array.isArray(e.writes) ? e.writes.filter((w) => typeof w === "object" && w !== null && !Array.isArray(w)) : [];
+                got[String(e.log)] = whole === null ? "redactable" : e.witnessed === true ? whole : writes.map((w) => redactableWrite(e, w) ?? "redactable");
+            }
+            const want = json("expected-redact.json");
+            for (const [k, v] of Object.entries(want))
+                if (serialize((got[k] ?? "∅")) !== serialize(v))
+                    return fail(`${k}: got ${serialize((got[k] ?? "∅"))}`);
+            return pass;
+        }
+        // Rebuild (8.5.3): the log alone gives back the state.
+        if (existsSync(file("expected-state.json"))) {
+            const got = stateJson(rebuild(json("log.json")));
+            const want = json("expected-state.json");
+            for (const [k, v] of Object.entries(want)) {
+                if (serialize((got[k] ?? "∅")) !== serialize(v))
+                    return fail(`${k}: ${firstDiff(serialize((got[k] ?? "∅")), serialize(v))}`);
+            }
+            return pass;
+        }
         if (existsSync(file("log.json"))) {
             const keys = existsSync(file("keys.json")) ? json("keys.json") : undefined;
             const got = verifyChain(json("log.json"), keys);
@@ -292,11 +330,210 @@ function runStoreCase(folder, caseDir, name, shared) {
             readDefinitions(defs, dict);
         const records = readText(data, dict).records.map((r) => foldRecord(r, dict));
         const one = (r) => canonical({ crubal: "2", records: [r] }, dict);
+        // Arrival (9.2a): a sequence of payloads through one contract, each finding or making its record.
+        if (existsSync(file("answers.json"))) {
+            const text = readFileSync(file("contract.crubal"), "utf8");
+            readDefinitions(text, dict);
+            const [contract] = readContracts(text);
+            if (!contract)
+                return fail("no contract");
+            // Every arrival is an operation on the journal's draft, logged as entries (8.5).
+            const journal = new Journal("test.example", records, "2026-10-15T00:00:00Z");
+            const store = journal.draft;
+            if (existsSync(file("bindings.json")))
+                journal.commit({ migration: "backfill" }, (d) => { for (const [k, v] of Object.entries(json("bindings.json")))
+                    d.bindings.set(k, String(v)); }, "2026-10-15T00:00:01Z");
+            const answersFile = json("answers.json");
+            const level = isPlainObject(answersFile) ? String(answersFile.level) : "product";
+            const answers = (isPlainObject(answersFile) ? answersFile.answers : answersFile);
+            let n = 0;
+            const mint = () => `${level.charAt(0).toUpperCase()}-NEW${++n}`;
+            const owner = records[0]?.owner ?? "test.example";
+            const got = [];
+            let held = null;
+            answers.forEach((a, i) => {
+                const at = `2026-10-15T00:01:${String(i).padStart(2, "0")}Z`;
+                if (isPlainObject(a) && isPlainObject(a.decide)) {
+                    if (!held)
+                        throw new Error("a decision with nothing held");
+                    const choice = a.decide.new === true ? { new: true } : { record: String(a.decide.record) };
+                    const h = held;
+                    journal.commit({ person: "reviewer" }, (d) => {
+                        got.push(decide(contract, h, choice, d, dict, { mint, owner, level }).arrival);
+                    }, at);
+                    held = null;
+                    return;
+                }
+                journal.commit({ contract: contract.name, run: `R-${i + 1}` }, (d) => {
+                    const r = arrive(contract, JSON.stringify(a), level, d, dict, { mint, owner, intakeId: `I-${i + 1}` });
+                    if (r.arrival.outcome === "held")
+                        held = { intake: r.intake, ...(r.arrival.ref !== undefined ? { ref: r.arrival.ref } : {}) };
+                    got.push(r.arrival);
+                }, at);
+            });
+            const want = json("expected-arrival.json");
+            if (got.length !== want.length)
+                return fail(`${got.length} arrivals, expected ${want.length}: ${serialize(got)}`);
+            for (let i = 0; i < want.length; i++) {
+                const p = subset(got[i], want[i], `arrival ${i + 1}: `);
+                if (p)
+                    return fail(p);
+            }
+            if (existsSync(file("expected.json"))) {
+                const want2 = json("expected.json");
+                for (const w of want2.records) {
+                    const r = store.records.get(w.id);
+                    if (!r)
+                        return fail(`no record ${w.id}`);
+                    if (one(r) !== one(w))
+                        return fail(`${w.id}: ${firstDiff(one(r), one(w))}`);
+                }
+            }
+            return pass;
+        }
+        // Lifecycle (1.7, 1.12) and instructions (10.7): operations in order, then the records.
+        if (existsSync(file("ops.crubal"))) {
+            // Every operation runs on the journal's draft and is logged; a change the entries don't describe
+            // is refused by the journal itself (8.5).
+            const journal = new Journal("test.example", records, "2026-10-15T00:00:00Z");
+            const store = journal.draft;
+            if (existsSync(file("bindings.json")))
+                journal.commit({ migration: "backfill" }, (d) => { for (const [k, v] of Object.entries(json("bindings.json")))
+                    d.bindings.set(k, String(v)); }, "2026-10-15T00:00:01Z");
+            const caseRules = readRules(defs);
+            const decisionDefs = { dict, contracts: new Map(readContracts(defs).map((c) => [c.name, c])) };
+            let adoptFlag;
+            let n = 0;
+            for (const op of readTree(readFileSync(file("ops.crubal"), "utf8"))) {
+                if (op.kind !== "pair" || !op.key)
+                    continue;
+                const piece = readPiece(op.value, op.line);
+                const detail = (k) => piece.detail.find(([n]) => n === k)?.[1].text;
+                const [a = "", b] = piece.text.split(" -> ").map((s) => s.trim());
+                const key = op.key;
+                let problem = null;
+                const extra = [];
+                journal.commit({ person: "tester" }, () => {
+                    if (key === "archive")
+                        archive(store, a, detail("reason") ?? "archived", dict, detail("into"));
+                    else if (key === "unarchive")
+                        unarchive(store, a, dict);
+                    else if (key === "merge" && b)
+                        merge(store, a, b, dict);
+                    else if (key === "attach" && b)
+                        attach(store, a, b, dict, detail("edit") !== "no");
+                    else if (key === "detach")
+                        detach(store, a, dict);
+                    else if (key === "instruct")
+                        issue(store, piece.text, op.children);
+                    else if (key === "apply")
+                        applyInstructions(store, a, dict);
+                    else if (key === "adopt" && b)
+                        adoptFlag = adopt(store, a, b, caseRules).flagged ?? adoptFlag;
+                    else if (key === "give-back" && b)
+                        giveBack(store, a, b);
+                    else if (key === "clone" && b)
+                        clone(store, a, b, detail("owner") ?? "test.example");
+                    else if (key === "split" && b) {
+                        const list = (k) => (op.children.find((c) => c.key === k)?.value ?? "").split(",").map((x) => x.trim()).filter(Boolean);
+                        const vals = {};
+                        for (const c of op.children.find((c) => c.key === "values")?.children ?? [])
+                            if (c.key)
+                                vals[c.key] = dict.facets.get(c.key) ? (readUnder(dict.facets.get(c.key), c.value, dict) ?? c.value) : c.value;
+                        split(store, a, b, { children: list("children"), values: vals, bindings: list("bindings") });
+                    }
+                    else if (key === "suggest") {
+                        // Test scaffolding: a suggestion on a record, as a gated or lands: suggestion run would leave it.
+                        const r = store.records.get(a);
+                        const address = op.children.find((c) => c.key === "address")?.value ?? "";
+                        const f = dict.facets.get(address);
+                        const raw = op.children.find((c) => c.key === "value")?.value ?? "";
+                        const value = f ? (readUnder(f, raw, dict) ?? raw) : raw;
+                        const item = { value, origin: op.children.find((c) => c.key === "origin")?.value ?? "reported", via: op.children.find((c) => c.key === "via")?.value ?? "L-S" };
+                        store.records.set(a, { ...r, suggestions: { ...(r.suggestions ?? {}), [address]: [...(r.suggestions?.[address] ?? []), item] } });
+                    }
+                    else if (key === "hold") {
+                        // Test scaffolding: a value held by a rule, with its source kept (6.7).
+                        const r = store.records.get(a);
+                        const address = op.children.find((c) => c.key === "address")?.value ?? "";
+                        const v = r.values[address];
+                        if (v === undefined) {
+                            problem = `${a} has nothing at ${address} to hold`;
+                            return;
+                        }
+                        const { [address]: _v, ...values } = r.values;
+                        const src = (r.sources?.[address] ?? r.sources?.["*"]);
+                        store.records.set(a, { ...r, values, held: { ...(r.held ?? {}), [address]: { value: v, rule: op.children.find((c) => c.key === "rule")?.value ?? "rule", ...(src ? { source: src } : {}) } } });
+                    }
+                    else if (key === "decide") {
+                        // A review decision (9.5): the item's key on the line, the decision's fields below it.
+                        const d = { key: piece.text, decision: "" };
+                        for (const c of op.children) {
+                            if (!c.key)
+                                continue;
+                            if (c.key === "instances" || c.key === "accepts")
+                                d[c.key] = c.value.split(",").map((x) => x.trim()).filter(Boolean);
+                            else if (c.key === "value" && typeof d.address === "string" && dict.facets.get(d.address))
+                                d.value = readUnder(dict.facets.get(d.address), c.value, dict) ?? c.value;
+                            else
+                                d[c.key] = c.key === "factor" || c.key === "offset" ? c.value : (dict.facets.get(c.key) ? (readUnder(dict.facets.get(c.key), c.value, dict) ?? c.value) : c.value);
+                        }
+                        extra.push(...decideReview(d, store, decisionDefs));
+                    }
+                    else if (key === "write") {
+                        const r = store.records.get(a);
+                        if (!r) {
+                            problem = `write to an unknown record ${a}`;
+                            return;
+                        }
+                        const values = { ...r.values };
+                        for (const c of op.children) {
+                            const f = c.key ? dict.facets.get(c.key) : undefined;
+                            if (c.key)
+                                values[c.key] = f ? (readUnder(f, c.value, dict) ?? c.value) : c.value;
+                        }
+                        store.records.set(a, { ...r, values });
+                    }
+                    else
+                        problem = `unknown op ${key}`;
+                }, `2026-10-15T00:01:${String(++n).padStart(2, "0")}Z`, extra);
+                if (problem)
+                    return fail(problem);
+            }
+            if (existsSync(file("expected-flag.json"))) {
+                const want = json("expected-flag.json");
+                if (want.adopt !== (adoptFlag ?? null))
+                    return fail(`adopt flagged ${adoptFlag ?? "nothing"}, expected ${serialize(want.adopt)}`);
+            }
+            if (existsSync(file("expected-entries.json"))) {
+                const got = journal.entries.map(({ at: _at, owner: _o, ...e }) => e);
+                const wantE = json("expected-entries.json");
+                if (serialize(got) !== serialize(wantE))
+                    return fail(`entries: ${firstDiff(serialize(got), serialize(wantE))}`);
+            }
+            const want = json("expected.json");
+            for (const w of want.records) {
+                const r = store.records.get(w.id);
+                if (!r)
+                    return fail(`no record ${w.id}`);
+                if (one(r) !== one(w))
+                    return fail(`${w.id}: ${firstDiff(one(r), one(w))}`);
+            }
+            if (want.review !== undefined && serialize(store.review) !== serialize(want.review))
+                return fail(`review: got ${serialize(store.review)}`);
+            if (want.bindings !== undefined && serialize(Object.fromEntries(store.bindings)) !== serialize(want.bindings))
+                return fail(`bindings: got ${serialize(Object.fromEntries(store.bindings))}`);
+            return pass;
+        }
         if (existsSync(file("recipe.crubal"))) {
             const [recipe] = readRecipes(readFileSync(file("recipe.crubal"), "utf8"));
             if (!recipe)
                 return fail("no recipe");
             checkRecipe(recipe, dict);
+            if (existsSync(file("expected-dry-run.json"))) {
+                const got = dryRun(records, recipe, dict);
+                return serialize(got) === serialize(json("expected-dry-run.json")) ? pass : fail(`dry run: ${serialize(got)}`);
+            }
             const { records: out, review } = restamp(records, recipe, dict);
             const want = json("expected.json");
             const got = { ...JSON.parse(canonical({ crubal: "2", package: recipe.to, records: out }, dict)), review };
@@ -374,6 +611,10 @@ function runStoreCase(folder, caseDir, name, shared) {
             const want = json("expected.json");
             return serialize(got) === serialize(want) ? pass : fail(`got ${serialize(got)}`);
         }
+        if (existsSync(file("observations.json")) && existsSync(file("expected-proposal.json"))) {
+            const got = proposeSplit(records, json("observations.json"));
+            return serialize(got) === serialize(json("expected-proposal.json")) ? pass : fail(`proposal: ${serialize(got)}`);
+        }
         if (existsSync(file("observations.json"))) {
             const want = json("expected-validation.json");
             const rec = records.find((r) => r.id === want.record);
@@ -405,8 +646,34 @@ function runExchangeCase(folder, caseDir, name, shared, root) {
         if (folder === "exchange-errors" || folder === "package-errors") {
             const want = Number(readFileSync(file("error.txt"), "utf8").trim().split(/\s/)[0]);
             try {
-                if (folder === "package-errors")
+                if (folder === "package-errors") {
                     checkPackages(input);
+                    checkPackage(readDefinitions(input));
+                }
+                else if (/^(edge|permissions|ownership): /m.test(input)) {
+                    // Access (14.12, 14.13): the declarations, every record's owner, and every edge, in order.
+                    const { defs, data } = splitCaseInput(input);
+                    const d = copy(shared);
+                    readDefinitions(defs, d);
+                    const { perms, edges } = readAccess(defs);
+                    checkPermissions(perms, d, new Set(readContracts(defs).map((c) => c.name)));
+                    const recs = data.trim() ? readText(data, d).records.map((r) => foldRecord(r, d)) : [];
+                    const access = new Access(d, perms, new MemoryRecords(recs.map((r) => [r.id, r])), [], "test.example");
+                    // A record's refusal names the line its header was written at.
+                    const lineOf = (id) => {
+                        const i = input.split("\n").findIndex((l) => new RegExp(`^\\w+: ${id}(\\s|$)`).test(l));
+                        return i < 0 ? undefined : i + 1;
+                    };
+                    access.checkWithin(lineOf);
+                    for (const r of recs) {
+                        access.checkOwnership(r, lineOf(r.id));
+                        access.checkWears(r, lineOf(r.id));
+                    }
+                    for (const e of edges) {
+                        access.checkEdge(e);
+                        access.edges.set(e.edge, e);
+                    }
+                }
                 else {
                     const d = copy(shared);
                     readDefinitions(input, d);
@@ -431,24 +698,145 @@ function runExchangeCase(folder, caseDir, name, shared, root) {
         if (defs.trim())
             readDefinitions(defs, dict);
         checkPackage(dict);
+        // Access (chapter 14): edges over the records, then questions.
+        if (existsSync(file("ask.crubal"))) {
+            const accessText = readFileSync(file("access.crubal"), "utf8");
+            readDefinitions(accessText, dict);
+            const { perms, edges } = readAccess(accessText);
+            checkPermissions(perms, dict, new Set(readContracts(accessText).map((c) => c.name)));
+            const recs = readText(data, dict).records.map((r) => foldRecord(r, dict));
+            const now = existsSync(file("now.txt")) ? readFileSync(file("now.txt"), "utf8").trim() : undefined;
+            const access = new Access(dict, perms, new MemoryRecords(recs.map((r) => [r.id, r])), edges, "test.example", now);
+            access.checkWithin();
+            const got = [];
+            for (const q of readTree(readFileSync(file("ask.crubal"), "utf8"))) {
+                if (q.kind !== "pair" || !q.key)
+                    continue;
+                const words = q.value.trim().split(/\s+/);
+                const ask = `${q.key}: ${q.value.trim()}`;
+                if (q.key === "may") {
+                    // may: <caller> <verb> <target> on <record>
+                    const [caller = "", verb = "", target = "", , record = ""] = words;
+                    got.push({ ask, result: access.may(caller, verb, target, record) });
+                }
+                else if (q.key === "mode") {
+                    const [caller = "", , record = ""] = words;
+                    got.push({ ask, result: access.effective(caller, record).mode });
+                }
+                else if (q.key === "stands") {
+                    // stands: <caller> <partition…> on <record>
+                    const on = words.indexOf("on");
+                    got.push({ ask, result: access.standsIn(words[0] ?? "", words[on + 1] ?? "", words.slice(1, on).join(" ")) });
+                }
+                else if (q.key === "gated") {
+                    const [caller = "", , record = ""] = words;
+                    got.push({ ask, result: access.gated(caller, record)?.edge ?? false });
+                }
+                else if (q.key === "ancestors") {
+                    got.push({ ask, result: access.ancestors(words[0] ?? "") });
+                }
+                else if (q.key === "audience") {
+                    got.push({ ask, result: access.audienceOf(words[0] ?? "") });
+                }
+                else
+                    return fail(`unknown ask ${q.key}`);
+            }
+            const want = json("expected-access.json");
+            if (got.length !== want.length)
+                return fail(`${got.length} answers, expected ${want.length}`);
+            for (let i = 0; i < want.length; i++) {
+                const p = subset(got[i], want[i], `${want[i].ask}: `);
+                if (p)
+                    return fail(p);
+            }
+            return pass;
+        }
         const shared_ = readFileSync(join(root, "exchange", "_contracts.crubal"), "utf8");
         const contracts = [...readContracts(shared_), ...readContracts(defs)];
-        checkContracts(contracts, dict);
-        const ex = new Exchange(dict, contracts, readRoles(defs));
-        for (const r of readText(data, dict).records.map((x) => foldRecord(x, dict)))
+        // A case that defines views lets its stream contracts (12.6.2) carry their projection streams.
+        const ownViews = readViews(defs);
+        checkContracts(contracts, dict, "", ownViews.views.size ? new Set(ownViews.views.keys()) : undefined);
+        const ex = new Exchange(dict, contracts, readRoles(defs), readRules(defs));
+        if (ownViews.views.size) {
+            checkViews(ownViews, dict);
+            ex.views = new Views(dict, ownViews);
+        }
+        for (const r of readText(data, dict).records.map((x) => foldRecord(x, dict))) {
             ex.put(r);
+            ex.views?.put(r);
+        }
+        // With access.crubal, the border consults access (chapter 14): permission to run, gates, consumer edges.
+        if (existsSync(file("access.crubal"))) {
+            const accessText = readFileSync(file("access.crubal"), "utf8");
+            const { perms, edges } = readAccess(accessText);
+            const now = existsSync(file("now.txt")) ? readFileSync(file("now.txt"), "utf8").trim() : undefined;
+            ex.access = new Access(dict, perms, ex.records, edges, "test.example", now);
+        }
+        // Every run is a transaction (8.5): the border works on a journal's draft and commits each run.
+        const journal = new Journal("test.example", [], "2026-01-01T00:00:00Z");
+        ex.useJournal(journal);
+        journal.commit({ migration: "backfill" }, () => { }, "2026-01-01T00:00:00Z");
         // The runs, in order.
         const results = [];
         let current = {};
+        const parseCursor = (s) => (s ? Object.fromEntries(s.split(",").map((p) => p.trim().split("=")).map(([v, n]) => [v ?? "", Number(n)])) : undefined);
         const flush = () => {
+            // The send split (docs/design/runs.md): prepare, then acted or failed; undo names its cause.
+            if (current.prepare && current.on) {
+                results.push(ex.prepare(current.prepare, current.on, current.caller));
+                current = {};
+                return;
+            }
+            if (current.acted) {
+                results.push(ex.acted(current.acted));
+                current = {};
+                return;
+            }
+            if (current.failed) {
+                results.push(ex.failed(current.failed, current.reason ?? "failed"));
+                current = {};
+                return;
+            }
+            if (current.undo) {
+                results.push(ex.undo(current.undo, current.caller));
+                current = {};
+                return;
+            }
+            if (current.decideRun) {
+                results.push(ex.decideRun(current.decideRun, current.decision === "drop" ? "drop" : "retry", current.caller));
+                current = {};
+                return;
+            }
+            if (current.tick) {
+                results.push(ex.tick(current.tick, current.now ?? "", current.caller));
+                current = {};
+                return;
+            }
+            if (current.stream) {
+                results.push(ex.streamRun(current.stream, current.caller, parseCursor(current.cursor)));
+                current = {};
+                return;
+            }
+            if (current.ack) {
+                results.push(ex.ack(current.ack, parseCursor(current.cursor) ?? {}));
+                current = {};
+                return;
+            }
+            if (current.arrive) {
+                results.push(ex.arriveRun(current.arrive, readFileSync(file(current.answer ?? "answer.json"), "utf8"), current.level ?? "product", current.caller, current.on));
+                current = {};
+                return;
+            }
             if (!current.run || !current.on)
                 return;
             const c = contracts.find((x) => x.name === current.run);
             if (current.offer) {
-                results.push(ex.take(current.run, current.offer, current.on, json("presenter.json")));
+                results.push(ex.take(current.run, current.offer, current.on, json(current.presenter ?? "presenter.json")));
             }
-            else if (c?.kind === "receive") {
-                results.push(ex.receiveRun(current.run, current.on, readFileSync(file("answer.json"), "utf8")));
+            else if (c?.kind === "receive" || c?.kind === "form" || current.forRun) {
+                // A receive lands its payload; a form is a receive whose source is a person (7.2), its answers the
+                // payload. A late answer names its run (7.5): the receive closes it and lands with its via.
+                results.push(ex.receiveRun(current.run, current.on, readFileSync(file(current.answer ?? "answer.json"), "utf8"), current.caller, current.forRun));
             }
             else {
                 results.push(ex.run(current.run, current.on, current.caller));
@@ -460,12 +848,66 @@ function runExchangeCase(folder, caseDir, name, shared, root) {
                 flush();
                 current.run = n.value;
             }
+            else if (n.key === "arrive") {
+                flush();
+                current.arrive = n.value;
+            }
+            else if (n.key === "stream") {
+                flush();
+                current.stream = n.value;
+            }
+            else if (n.key === "ack") {
+                flush();
+                current.ack = n.value;
+            }
+            else if (n.key === "prepare" || n.key === "acted" || n.key === "failed" || n.key === "undo") {
+                flush();
+                current[n.key] = n.value;
+            }
+            else if (n.key === "decide-run") {
+                flush();
+                current.decideRun = n.value;
+            }
+            else if (n.key === "decision")
+                current.decision = n.value;
+            else if (n.key === "reason")
+                current.reason = n.value;
+            else if (n.key === "for-run")
+                current.forRun = n.value;
+            else if (n.key === "cursor")
+                current.cursor = n.value;
+            else if (n.key === "tick") {
+                flush();
+                current.tick = n.value;
+            }
+            else if (n.key === "now")
+                current.now = n.value;
+            else if (n.key === "revise") {
+                flush();
+                const [view = "", version = ""] = n.value.split(" /");
+                ex.views?.revise(view.trim(), version.trim());
+            }
             else if (n.key === "on")
                 current.on = n.value;
+            else if (n.key === "level")
+                current.level = n.value;
+            else if (n.key === "answer")
+                current.answer = n.value;
             else if (n.key === "caller")
                 current.caller = n.value;
             else if (n.key === "offer")
                 current.offer = n.value;
+            else if (n.key === "presenter")
+                current.presenter = n.value;
+            else if (n.key === "give") {
+                // The owner's own offer (7.8), as its host would serve it.
+                flush();
+                results.push(ex.offer(n.value, "test.example"));
+            }
+            else if (n.key === "expire") {
+                flush();
+                results.push(ex.expire(n.value));
+            }
             else if (n.key === "write") {
                 flush();
                 const r = ex.get(n.value);
@@ -478,6 +920,7 @@ function runExchangeCase(folder, caseDir, name, shared, root) {
                         values[c.key] = f ? (readUnder(f, c.value, dict) ?? c.value) : c.value;
                 }
                 ex.put({ ...r, values });
+                ex.views?.put({ ...r, values });
             }
         }
         flush();
@@ -493,6 +936,24 @@ function runExchangeCase(folder, caseDir, name, shared, root) {
                 return fail(`alternatives/suggestions: got ${extra(got)}`);
             return pass;
         }
+        if (existsSync(file("expected-entries.json"))) {
+            const got = journal.entries.map(({ at: _at, owner: _o, ...e }) => e);
+            const wantE = json("expected-entries.json");
+            if (serialize(got) !== serialize(wantE))
+                return fail(`entries: ${firstDiff(serialize(got), serialize(wantE))}`);
+        }
+        if (existsSync(file("expected-edges.json"))) {
+            const got = [...(ex.access?.edges.values() ?? [])].map(({ line: _l, ...e }) => e);
+            const want = json("expected-edges.json");
+            for (const w of want) {
+                const a = got.find((e) => e.edge === w.edge);
+                if (!a)
+                    return fail(`no edge ${w.edge}`);
+                const p = subset(a, w, `${w.edge}: `);
+                if (p)
+                    return fail(p);
+            }
+        }
         const wantRaw = json("expected-run.json");
         const want = (Array.isArray(wantRaw) ? wantRaw : [wantRaw]);
         if (results.length !== want.length)
@@ -593,7 +1054,7 @@ function runViewsCase(folder, caseDir, name, shared, root) {
         checkPackage(dict);
         const set = readViews(sharedViews);
         const own = readViews(defs);
-        for (const k of ["shapes", "filters", "views", "roles", "shown"])
+        for (const k of ["shapes", "filters", "views", "roles", "shown", "shownFor"])
             for (const [key, val] of own[k])
                 set[k].set(key, val);
         checkViews(set, dict);
@@ -602,10 +1063,25 @@ function runViewsCase(folder, caseDir, name, shared, root) {
         const records = readText(text, dict).records.map((r) => foldRecord(r, dict));
         for (const r of records)
             views.put(r);
-        const byId = new Map(records.map((r) => [r.id, r]));
+        const byId = new MemoryRecords(records.map((r) => [r.id, r]));
         const viewName = run.view;
-        const opts = { picks: run.picks, ...(run.context ? { context: byId.get(run.context) } : {}), ...(run.page ? { page: run.page } : {}) };
+        // Partitioned views (12.6): the case's edges decide which rows a caller is served.
+        let access;
+        if (existsSync(file("access.crubal"))) {
+            const { perms, edges } = readAccess(readFileSync(file("access.crubal"), "utf8"));
+            access = new Access(dict, perms, byId, edges, "test.example");
+        }
+        const opts = { picks: run.picks, ...(run.context ? { context: byId.get(run.context) } : {}), ...(run.page ? { page: run.page } : {}), ...(access ? { access } : {}) };
         const same = (got, want, label) => (serialize(got) === serialize(want) ? pass : fail(`${label}: got ${serialize(got)}`));
+        if (existsSync(file("expected-stream.json"))) {
+            const first = views.stream(viewName, opts);
+            for (const w of readText(readFileSync(file("write.crubal"), "utf8"), dict).records) {
+                const was = byId.get(w.id);
+                views.put(was ? { ...was, values: { ...was.values, ...w.values } } : foldRecord(w, dict));
+            }
+            const second = views.stream(viewName, opts);
+            return same([first, second], json("expected-stream.json"), "stream");
+        }
         if (existsSync(file("expected-stale.json"))) {
             views.project(viewName, opts);
             const stale = new Set();
@@ -626,7 +1102,9 @@ function runViewsCase(folder, caseDir, name, shared, root) {
         }
         const p = views.project(viewName, opts);
         if (existsSync(file("expected-counts.json")))
-            return same({ records: p.records, counts: p.counts, indexable: p.indexable }, json("expected-counts.json"), "counts");
+            return same({ records: p.records, counts: p.counts, ...(p.nested ? { nested: p.nested } : {}), indexable: p.indexable }, json("expected-counts.json"), "counts");
+        if (existsSync(file("expected-jsonld.json")))
+            return same(p.rows, json("expected-jsonld.json"), "jsonld");
         if (existsSync(file("expected-pages.json")))
             return same({ pages: p.pages, records: p.records, indexable: p.indexable }, json("expected-pages.json"), "pages");
         const wantFile = existsSync(file("expected-portable.json")) ? "expected-portable.json" : "expected-projection.json";
@@ -637,6 +1115,56 @@ function runViewsCase(folder, caseDir, name, shared, root) {
     }
 }
 const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/**
+ * Forms as data (7.7, docs/design/index-and-forms.md): `form.crubal` names the contract, the record and
+ * optionally the caller (several `form:` blocks give several forms); `access.crubal` makes editability
+ * follow edges and gates; `arrival.json` is a held arrival whose candidates the form offers;
+ * `expected-form.json` is the form (or the forms) exactly.
+ */
+function runFormsCase(folder, caseDir, name, shared) {
+    const file = (f) => join(caseDir, f);
+    const json = (f) => JSON.parse(readFileSync(file(f), "utf8"));
+    const pass = { folder, name, pass: true };
+    const fail = (detail) => ({ folder, name, pass: false, detail });
+    try {
+        const input = readFileSync(file("input.crubal"), "utf8");
+        const { defs, data } = splitCaseInput(input);
+        const dict = copy(shared);
+        if (defs.trim())
+            readDefinitions(defs, dict);
+        const contracts = readContracts(defs);
+        const records = data.trim() ? readText(data, dict).records.map((r) => foldRecord(r, dict)) : [];
+        const byId = new MemoryRecords(records.map((r) => [r.id, r]));
+        let access;
+        if (existsSync(file("access.crubal"))) {
+            const { perms, edges } = readAccess(readFileSync(file("access.crubal"), "utf8"));
+            access = new Access(dict, perms, byId, edges, "test.example");
+        }
+        const arrival = existsSync(file("arrival.json")) ? json("arrival.json") : undefined;
+        // form.crubal reads like run.crubal: `form:` starts one, `record:` and `caller:` belong to it.
+        const asks = [];
+        for (const n of readTree(readFileSync(file("form.crubal"), "utf8"))) {
+            if (n.key === "form")
+                asks.push({ form: n.value.trim() });
+            else if ((n.key === "record" || n.key === "caller") && asks.length)
+                asks[asks.length - 1][n.key] = n.value.trim();
+        }
+        const forms = [];
+        for (const ask of asks) {
+            const c = contracts.find((x) => x.name === ask.form);
+            if (!c)
+                return fail(`no contract ${ask.form}`);
+            const rec = ask.record ? byId.get(ask.record) : undefined;
+            forms.push(formOf(c, rec, dict, { records: byId, ...(ask.caller ? { caller: ask.caller } : {}), ...(access ? { access } : {}), ...(arrival ? { arrival } : {}) }));
+        }
+        const want = json("expected-form.json");
+        const got = Array.isArray(want) ? forms : (forms[0] ?? {});
+        return serialize(got) === serialize(want) ? pass : fail(`form: ${firstDiff(serialize(got), serialize(want))}`);
+    }
+    catch (e) {
+        return fail(e instanceof Error ? e.message : String(e));
+    }
+}
 /** Run one level's corpus folders under `root`. */
 export function runCorpus(root, level) {
     const folders = LEVEL_FOLDERS[level];
@@ -653,17 +1181,23 @@ export function runCorpus(root, level) {
                 continue;
             if (!["input.crubal", "log.json", "border.json"].some((f) => existsSync(join(dir, name, f))))
                 continue;
-            const r = folder.startsWith("views")
-                ? runViewsCase(folder, join(dir, name), name, dict, root)
-                : folder.startsWith("exchange") || folder === "package-errors"
-                    ? runExchangeCase(folder, join(dir, name), name, dict, root)
-                    : folder.startsWith("store")
-                        ? runStoreCase(folder, join(dir, name), name, dict)
-                        : folder.startsWith("rules")
-                            ? runRulesCase(folder, join(dir, name), name, dict, sharedRules)
-                            : folder.startsWith("dictionary")
-                                ? runDictionaryCase(folder, join(dir, name), name, dict)
-                                : runCase(folder, dir, name, dict);
+            if (folder === "store" && existsSync(join(dir, name, "expected-redact.json"))) {
+                results.push(runStoreCase(folder, join(dir, name), name, dict));
+                continue;
+            }
+            const r = folder === "forms"
+                ? runFormsCase(folder, join(dir, name), name, dict)
+                : folder.startsWith("views")
+                    ? runViewsCase(folder, join(dir, name), name, dict, root)
+                    : folder.startsWith("exchange") || folder === "package-errors"
+                        ? runExchangeCase(folder, join(dir, name), name, dict, root)
+                        : folder.startsWith("store")
+                            ? runStoreCase(folder, join(dir, name), name, dict)
+                            : folder.startsWith("rules")
+                                ? runRulesCase(folder, join(dir, name), name, dict, sharedRules)
+                                : folder.startsWith("dictionary")
+                                    ? runDictionaryCase(folder, join(dir, name), name, dict)
+                                    : runCase(folder, dir, name, dict);
             if (r)
                 results.push(r);
         }