@bitspark/horos 0.9.0 → 0.11.1

package/dist/src/diagnose.js

@@ -19,17 +19,18 @@
  *  - union/and are KLEENE: a DECISIVE alternative beats an exhausted sibling, so the evaluator
  *    short-circuits on a decisive result but NEVER on an Exhausted. The answer is a function of
  *    the SET of sub-outcomes, never of traversal order.
+ *
+ * Every outcome other than `conforms` carries one LOCATION (ADR 0009, docs/spec/horos.md
+ * "Diagnostic locations"): the value path, the descriptor position and a reason, chosen in a
+ * fixed order so the Go, Rust and TypeScript cores report the identical location. A location
+ * never changes which verdict is reported.
  */
-import { readList, readMap, readSet, readText } from "@bitspark/ontos-data";
+import { readInt, readList, readMap, readSet, readText } from "@bitspark/ontos-data";
 import { ATOM_LEN_BOUND_MAX, ATOM_LEN_BOUND_MIN, isLeafCtor, leafClassifies, leafWellFormed, MAX_RECURSION_DEPTH, NAMESPACE, readFieldDescriptor, } from "./core.js";
 /** The effective value of a limit in this build. */
 export function limitValue(l) {
     return l === "recursion_depth" ? MAX_RECURSION_DEPTH : 0;
 }
-const CONFORMS = { verdict: "conforms" };
-const MISMATCH = { verdict: "mismatch" };
-const NOT_WF = { verdict: "not_well_formed" };
-const exhausted = (limit) => ({ verdict: "exhausted", limit });
 /** Whether this outcome is a completed decision. */
 export function isComplete(d) {
     return d.verdict !== "exhausted";
@@ -59,15 +60,60 @@ export function checkingProfile() {
         atomLenBoundMax: ATOM_LEN_BOUND_MAX,
     };
 }
-// ----- the Kleene folds (ADR 0008 D2/D3) -----
+function stepInto(path, step) {
+    return { parent: path, step, length: pathLength(path) + 1 };
+}
+function pathLength(path) {
+    return path === undefined ? 0 : path.length;
+}
+function at(pos, index) {
+    return { parent: pos, index };
+}
+const CONFORMS = { verdict: "conforms" };
+const CONFORMS_D = { verdict: "conforms" };
+const mismatch = (fault) => ({ verdict: "mismatch", fault });
+const notWf = (fault) => ({ verdict: "not_well_formed", fault });
+const exhausted = (path, pos) => ({
+    verdict: "exhausted",
+    limit: "recursion_depth",
+    fault: { path, at: pos, reason: "limit" },
+});
+function materialize(f) {
+    const path = [];
+    for (let n = f.path; n !== undefined; n = n.parent)
+        path.push(n.step);
+    path.reverse();
+    const pos = [];
+    for (let n = f.at; n !== undefined; n = n.parent)
+        pos.push(n.index);
+    pos.reverse();
+    if (f.field !== undefined)
+        return { path, at: pos, reason: f.reason, field: f.field };
+    if (f.arg !== undefined)
+        return { path, at: pos, reason: f.reason, arg: f.arg };
+    return { path, at: pos, reason: f.reason };
+}
+function report(o) {
+    switch (o.verdict) {
+        case "conforms":
+            return CONFORMS_D;
+        case "mismatch":
+            return { verdict: "mismatch", location: materialize(o.fault) };
+        case "not_well_formed":
+            return { verdict: "not_well_formed", location: materialize(o.fault) };
+        case "exhausted":
+            return { verdict: "exhausted", limit: o.limit, location: materialize(o.fault) };
+    }
+}
+// ----- the Kleene folds (ADR 0008 D2/D3), with the location order of ADR 0009 -----
 /**
  * `not`: swap the completed verdicts, PRESERVE exhaustion. Never completes an incomplete
- * subdecision — the rule this module exists for.
+ * subdecision — the rule this module exists for. A `not` that fails reports itself.
  */
-function kleeneNot(inner) {
+function kleeneNot(inner, path, pos) {
     switch (inner.verdict) {
         case "conforms":
-            return MISMATCH;
+            return mismatch({ path, at: pos, reason: "complement" });
         case "mismatch":
             return CONFORMS;
         default:
@@ -75,60 +121,158 @@ function kleeneNot(inner) {
             return inner;
     }
 }
-/** Kleene disjunction: a decisive `conforms` wins over an exhausted sibling. */
-function kleeneAny(outcomes) {
-    let limit;
-    let notWF = false;
-    for (const o of outcomes) {
-        if (o.verdict === "conforms")
-            return CONFORMS; // decisive — stop here
-        if (o.verdict === "not_well_formed")
-            notWF = true;
-        else if (o.verdict === "exhausted" && limit === undefined)
-            limit = o.limit;
+/**
+ * Kleene conjunction over `count` sub-outcomes in the fixed order: a decisive `mismatch`
+ * wins over an exhausted sibling and is the first one in order. Otherwise the first
+ * exhausted, then the first not_well_formed sub-outcome decides.
+ */
+function kleeneAll(count, outcome) {
+    let firstExhausted;
+    let firstNotWf;
+    for (let i = 0; i < count; i += 1) {
+        const o = outcome(i);
+        if (o.verdict === "mismatch")
+            return o; // decisive — stop here
+        if (o.verdict === "exhausted")
+            firstExhausted ??= o;
+        else if (o.verdict === "not_well_formed")
+            firstNotWf ??= o;
     }
-    if (limit !== undefined)
-        return exhausted(limit);
-    return notWF ? NOT_WF : MISMATCH;
+    return firstExhausted ?? firstNotWf ?? CONFORMS;
 }
-/** Kleene conjunction: a decisive `mismatch` wins over an exhausted sibling. */
-function kleeneAll(outcomes) {
-    let limit;
-    let notWF = false;
-    for (const o of outcomes) {
-        if (o.verdict === "mismatch")
-            return MISMATCH; // decisive — stop here
-        if (o.verdict === "not_well_formed")
-            notWF = true;
-        else if (o.verdict === "exhausted" && limit === undefined)
-            limit = o.limit;
+/**
+ * Kleene disjunction for `union`: a decisive `conforms` wins over an exhausted sibling. A
+ * union with no conforming alternative is exhausted at its first exhausted alternative. A
+ * mismatching union reports the first alternative with the longest value path when that
+ * path goes deeper than the union's own value, and otherwise reports itself.
+ */
+function kleeneAny(count, outcome, path, pos) {
+    let firstExhausted;
+    let firstNotWf;
+    let deepest;
+    let deepestLength = pathLength(path);
+    for (let i = 0; i < count; i += 1) {
+        const o = outcome(i);
+        if (o.verdict === "conforms")
+            return CONFORMS; // decisive — stop here
+        if (o.verdict === "exhausted")
+            firstExhausted ??= o;
+        else if (o.verdict === "not_well_formed")
+            firstNotWf ??= o;
+        else if (pathLength(o.fault.path) > deepestLength) {
+            deepest = o;
+            deepestLength = pathLength(o.fault.path);
+        }
     }
-    if (limit !== undefined)
-        return exhausted(limit);
-    return notWF ? NOT_WF : CONFORMS;
+    return (firstExhausted ??
+        firstNotWf ??
+        deepest ??
+        mismatch({ path, at: pos, reason: "no-alternative" }));
 }
 // ----- the public entry points -----
 /**
  * Diagnose `wf(T)`: `conforms` when T is a well-formed descriptor, `not_well_formed` when it is
  * conclusively not, and `exhausted` when the well-formedness traversal itself could not finish
- * — the distinction horos-internal#211 asks for by name.
+ * — the distinction horos-internal#211 asks for by name. A non-conforming outcome names the
+ * descriptor position and, where one argument is at fault, its item index.
  */
 export function diagnoseWf(t) {
-    return diagnoseWfIn(t, [], [], 0);
+    return report(diagnoseWfIn(t, [], [], 0, undefined));
 }
 /**
  * Diagnose `v : T`. Mirrors `conforms`: the `wf(T)` soundness gate runs first (spec §3 MUST),
  * so a descriptor that is not well-formed yields `not_well_formed` and one whose
  * well-formedness could not be decided yields `exhausted` — neither is reported as a mismatch
- * of the value.
+ * of the value. Each carries the well-formedness location, with an empty value path.
  */
 export function diagnose(v, t) {
-    const w = diagnoseWf(t);
-    if (w.verdict === "conforms")
-        return diagnoseIn(v, t, [], [], 0);
-    if (w.verdict === "exhausted")
-        return w;
-    return NOT_WF;
+    const w = diagnoseWfIn(t, [], [], 0, undefined);
+    if (w.verdict !== "conforms")
+        return report(w);
+    return report(diagnoseIn(new DiagChecker(), v, t, [], 0, undefined, undefined, false));
+}
+/**
+ * One diagnosis's memo (ADR 0013), kept only in shared mode: below a union or intersection
+ * with two or more alternatives over one value, where a sub-check can be reached along
+ * several routes. There each composite sub-check names its place by canonical path and
+ * position nodes: the first node seen per (parent, step) and per (parent, item index); a
+ * leaf keeps the plain node it was given. The node where shared mode begins is reached by
+ * one route, so its own nodes are unique too. Within a check a path node then names one value
+ * occurrence and a position node one node of the written descriptor, whose environment the
+ * position fixes (ADR 0011). A shared composite sub-check's outcome, location included, is
+ * a function of (path, position, depth), and `get`/`put` keep it. Outside shared mode the
+ * nodes are built and nothing is kept, as before ADR 0013.
+ */
+class DiagChecker {
+    paths;
+    positions;
+    canonicalPaths;
+    canonicalPositions;
+    memo;
+    /**
+     * The canonical path node for `path`: the first seen for its canonical parent and step,
+     * `path` itself when it is the first. Nodes outside shared mode are reached by one
+     * route, so the first one seen for each step is canonical; the walk up stops at a node
+     * already seen.
+     */
+    canonPath(path) {
+        if (path === undefined || this.canonicalPaths?.has(path))
+            return path;
+        const parent = this.canonPath(path.parent);
+        this.paths ??= new Map();
+        this.canonicalPaths ??= new Set();
+        let children = this.paths.get(parent);
+        if (children === undefined) {
+            children = new Map();
+            this.paths.set(parent, children);
+        }
+        const s = path.step;
+        const key = s.kind === "field" ? `field:${s.name}` : `${s.kind}:${s.index}`;
+        const known = children.get(key);
+        if (known !== undefined)
+            return known;
+        const node = parent === path.parent ? path : stepInto(parent, s);
+        children.set(key, node);
+        this.canonicalPaths.add(node);
+        return node;
+    }
+    /** The canonical position node for `pos`, as {@link canonPath} for paths. */
+    canonPos(pos) {
+        if (pos === undefined || this.canonicalPositions?.has(pos))
+            return pos;
+        const parent = this.canonPos(pos.parent);
+        this.positions ??= new Map();
+        this.canonicalPositions ??= new Set();
+        let children = this.positions.get(parent);
+        if (children === undefined) {
+            children = new Map();
+            this.positions.set(parent, children);
+        }
+        const known = children.get(pos.index);
+        if (known !== undefined)
+            return known;
+        const node = parent === pos.parent ? pos : at(parent, pos.index);
+        children.set(pos.index, node);
+        this.canonicalPositions.add(node);
+        return node;
+    }
+    get(path, pos, depth) {
+        return this.memo?.get(path)?.get(pos)?.get(depth);
+    }
+    put(path, pos, depth, o) {
+        this.memo ??= new Map();
+        let byPos = this.memo.get(path);
+        if (byPos === undefined) {
+            byPos = new Map();
+            this.memo.set(path, byPos);
+        }
+        let byDepth = byPos.get(pos);
+        if (byDepth === undefined) {
+            byDepth = new Map();
+            byPos.set(pos, byDepth);
+        }
+        byDepth.set(depth, o);
+    }
 }
 function head(t) {
     if (t.kind !== "tuple")
@@ -161,239 +305,410 @@ function atomStringOf(v) {
         key += String.fromCharCode(byte);
     return key;
 }
-function diagnoseIn(v, t, env, pending, depth) {
+function diagnoseIn(d, v, t, env, depth, path, pos, shared) {
     if (depth > MAX_RECURSION_DEPTH)
-        return exhausted("recursion_depth");
+        return exhausted(path, pos);
+    const refused = () => mismatch({ path, at: pos, reason: "refused" });
     const h = head(t);
     if (h === undefined)
-        return MISMATCH; // not a horos descriptor
+        return refused(); // not a horos descriptor; unreachable past the wf gate
     const { ctor, args } = h;
     // Leaves never recurse into a value position, so they are always decisive here.
     if (isLeafCtor(ctor))
-        return leafClassifies(v, t) ? CONFORMS : MISMATCH;
+        return leafClassifies(v, t) ? CONFORMS : refused();
+    if (!shared)
+        return composite(d, v, ctor, args, env, depth, path, pos, false);
+    // Only a shared composite sub-check names its place canonically; a leaf never does.
+    const cpath = d.canonPath(path);
+    const cpos = d.canonPos(pos);
+    const hit = d.get(cpath, cpos, depth);
+    if (hit !== undefined)
+        return hit;
+    const o = composite(d, v, ctor, args, env, depth, cpath, cpos, true);
+    d.put(cpath, cpos, depth, o);
+    return o;
+}
+/** One composite descriptor node against `v`; `diagnoseIn` memoizes it. */
+function composite(d, v, ctor, args, env, depth, path, pos, shared) {
+    // Two or more alternatives over one value: below them, shared mode (see DiagChecker).
+    const share = shared || args.length > 1;
+    const refused = () => mismatch({ path, at: pos, reason: "refused" });
     switch (ctor) {
-        // Composition on the SAME v — pending threads through unchanged.
+        // Composition on the SAME v.
         case "union":
-            return kleeneAny(args.map((ct) => diagnoseIn(v, ct, env, pending, depth + 1)));
+            return kleeneAny(args.length, (i) => diagnoseIn(d, v, args[i], env, depth + 1, path, at(pos, i + 1), share), path, pos);
         case "and":
-            return kleeneAll(args.map((ct) => diagnoseIn(v, ct, env, pending, depth + 1)));
+            return kleeneAll(args.length, (i) => diagnoseIn(d, v, args[i], env, depth + 1, path, at(pos, i + 1), share));
         case "not": {
             if (args.length !== 1)
-                return MISMATCH;
-            return kleeneNot(diagnoseIn(v, args[0], env, pending, depth + 1));
+                return refused();
+            return kleeneNot(diagnoseIn(d, v, args[0], env, depth + 1, path, at(pos, 1), shared), path, pos);
         }
-        // Recursion — mirrors the recognizer's guard exactly.
+        // Recursion — mirrors the recognizer, and is transparent to locations. A ref denotes
+        // the rec that lexically encloses it and continues in that binding's environment, one
+        // counted frame deeper (ADR 0011). `env` holds exactly the enclosing bindings,
+        // outermost first, so a binding's closure is the prefix of `env` that ends with it.
         case "rec": {
             if (args.length !== 2)
-                return MISMATCH;
+                return refused();
             const name = atomStringOf(args[0]);
             if (name === undefined)
-                return MISMATCH;
+                return refused();
             const body = args[1];
-            return diagnoseIn(v, body, [...env, { name, body }], [...pending, name], depth + 1);
+            const bodyAt = at(pos, 2);
+            return diagnoseIn(d, v, body, [...env, { name, body, at: bodyAt }], depth + 1, path, bodyAt, shared);
         }
         case "ref": {
             if (args.length !== 1)
-                return MISMATCH;
+                return refused();
             const name = atomStringOf(args[0]);
             if (name === undefined)
-                return MISMATCH;
-            if (pending.includes(name))
-                return MISMATCH; // unguarded — the recognizer's false
+                return refused();
             for (let i = env.length - 1; i >= 0; i -= 1) {
-                if (env[i].name === name) {
-                    return diagnoseIn(v, env[i].body, env, [...pending, name], depth + 1);
+                const b = env[i];
+                if (b.name === name) {
+                    return diagnoseIn(d, v, b.body, env.slice(0, i + 1), depth + 1, path, b.at, shared);
                 }
             }
-            return MISMATCH; // unbound
+            return refused(); // unbound
         }
     }
-    // Structural arms: the gate is decisive, and a descent into a CHILD VALUE clears pending.
-    const children = structuralChildren(v, ctor, args);
-    if (children === undefined)
-        return MISMATCH;
-    return kleeneAll(children.map(([cv, ct]) => diagnoseIn(cv, ct, env, [], depth + 1)));
+    // Structural arms: the gate is decisive, then each child value against its descriptor.
+    const gate = structuralChildren(v, ctor, args, path, pos);
+    if (!Array.isArray(gate))
+        return mismatch(gate);
+    const children = gate;
+    return kleeneAll(children.length, (i) => {
+        const c = children[i];
+        return diagnoseIn(d, c.v, c.t, env, depth + 1, stepInto(path, c.step), c.at, shared);
+    });
 }
 /**
  * The structural gate plus the ordered child sub-judgments, for the arms that descend into a
- * child VALUE. Mirrors the recognizer's recursive arms; `undefined` means the gate failed, so
- * `v` cannot conform regardless of any child.
+ * child VALUE. Mirrors the recognizer's recursive arms; a {@link Fault} means the gate failed,
+ * so `v` cannot conform regardless of any child.
  */
-function structuralChildren(v, ctor, args) {
+function structuralChildren(v, ctor, args, path, pos) {
+    const refused = { path, at: pos, reason: "refused" };
     switch (ctor) {
         case "tuple": {
             if (v.kind !== "tuple")
-                return undefined;
+                return refused;
             const items = v.items();
             if (items.length !== args.length)
-                return undefined;
-            return items.map((c, i) => [c, args[i]]);
+                return refused;
+            return items.map((c, i) => ({
+                v: c,
+                t: args[i],
+                step: { kind: "item", index: i },
+                at: at(pos, i + 1),
+            }));
         }
         case "seq": {
             if (args.length !== 1 || v.kind !== "tuple")
-                return undefined;
-            return v.items().map((c) => [c, args[0]]);
+                return refused;
+            const childAt = at(pos, 1);
+            return v.items().map((c, i) => ({
+                v: c,
+                t: args[0],
+                step: { kind: "item", index: i },
+                at: childAt,
+            }));
         }
         case "compound": {
             if (args.length < 1 || v.kind !== "tuple")
-                return undefined;
+                return refused;
             const label = atomBytesOf(args[0]);
             const items = v.items();
             if (label === undefined || items.length !== args.length)
-                return undefined;
+                return refused;
             const got = atomBytesOf(items[0]);
             if (got === undefined ||
                 got.length !== label.length ||
                 got.some((b, i) => b !== label[i]))
-                return undefined;
-            return args.slice(1).map((ct, i) => [items[i + 1], ct]);
+                return refused;
+            // Value item j (j >= 1) is checked by descriptor argument j, at item index j + 1.
+            return args.slice(1).map((ct, i) => ({
+                v: items[i + 1],
+                t: ct,
+                step: { kind: "item", index: i + 1 },
+                at: at(pos, i + 2),
+            }));
         }
         case "list-of":
         case "set-of": {
             if (args.length !== 1)
-                return undefined;
+                return refused;
+            let elems;
             try {
-                const elems = ctor === "list-of" ? readList(v) : readSet(v);
-                return elems.map((e) => [e, args[0]]);
+                elems = ctor === "list-of" ? readList(v) : readSet(v);
             }
             catch {
-                return undefined;
+                return refused;
             }
+            const childAt = at(pos, 1);
+            return elems.map((e, i) => ({
+                v: e,
+                t: args[0],
+                step: { kind: "elem", index: i },
+                at: childAt,
+            }));
         }
         case "map-of": {
             if (args.length !== 2)
-                return undefined;
+                return refused;
+            let entries;
             try {
-                const out = [];
-                for (const [k, val] of readMap(v)) {
-                    out.push([k, args[0]], [val, args[1]]);
-                }
-                return out;
+                entries = readMap(v);
             }
             catch {
-                return undefined;
+                return refused;
             }
+            const keyAt = at(pos, 1);
+            const valueAt = at(pos, 2);
+            const out = [];
+            entries.forEach(([k, val], i) => {
+                out.push({ v: k, t: args[0], step: { kind: "key", index: i }, at: keyAt }, { v: val, t: args[1], step: { kind: "value", index: i }, at: valueAt });
+            });
+            return out;
         }
         case "record":
-            return args.length < 1 ? undefined : recordChildren(v, args[0], args.slice(1));
+            return args.length < 1
+                ? refused
+                : recordChildren(v, args[0], args.slice(1), path, pos);
     }
-    return undefined;
+    return refused;
 }
-/** Mirrors the recognizer's record gate and present-field worklist. */
-function recordChildren(v, mode, fields) {
+/**
+ * Mirrors the recognizer's record gate and present-field worklist, in the fixed order of
+ * ADR 0009: a canonical map, text keys, missing required fields in descriptor order, extra
+ * fields of a closed record in canonical key order, then the present declared fields.
+ */
+function recordChildren(v, mode, fields, path, pos) {
+    const refused = { path, at: pos, reason: "refused" };
     const m = atomStringOf(mode);
     if (m !== "open" && m !== "closed")
-        return undefined;
-    const closed = m === "closed";
+        return refused;
     let entries;
     try {
         entries = readMap(v);
     }
     catch {
-        return undefined;
+        return refused;
     }
     const keyed = new Map();
-    for (const [k, val] of entries) {
+    for (let i = 0; i < entries.length; i += 1) {
+        const [k, val] = entries[i];
         try {
             keyed.set(readText(k), val);
         }
         catch {
-            return undefined;
+            return {
+                path: stepInto(path, { kind: "key", index: i }),
+                at: pos,
+                reason: "refused",
+            };
         }
     }
     const out = [];
     const declared = new Set();
-    for (const f of fields) {
-        const fd = readFieldDescriptor(f);
+    for (let j = 0; j < fields.length; j += 1) {
+        const fd = readFieldDescriptor(fields[j]);
         if (fd === undefined)
-            return undefined;
+            return refused;
         declared.add(fd.name);
         const val = keyed.get(fd.name);
         if (val === undefined) {
             if (fd.required)
-                return undefined; // a missing required field is decisive
+                return { path, at: pos, reason: "missing-field", field: fd.name };
             continue;
         }
-        out.push([val, fd.ty]);
+        // Field j is descriptor item j + 2; its type is item 3 of the field form.
+        out.push({
+            v: val,
+            t: fd.ty,
+            step: { kind: "field", name: fd.name },
+            at: at(at(pos, j + 2), 3),
+        });
     }
-    if (closed) {
+    if (m === "closed") {
         for (const k of keyed.keys()) {
             if (!declared.has(k))
-                return undefined; // an extra key in a closed record is decisive
+                return { path, at: pos, reason: "extra-field", field: k };
         }
     }
     return out;
 }
-function diagnoseWfIn(t, bound, pending, depth) {
+/** In-range check of an `atom-len`/`text-len` bound: the signed 128-bit cap. */
+function boundInRange(n) {
+    return n >= ATOM_LEN_BOUND_MIN && n <= ATOM_LEN_BOUND_MAX;
+}
+/**
+ * The leaf constructors' own-form check, in the fixed order of ADR 0009: arity, then each
+ * argument in item order against the arguments before it. `undefined` is well formed;
+ * otherwise the reason and, for an argument, its item index. Mirrors the recognizer's
+ * `wfIn` leaf arms, which decide the same set.
+ */
+function leafWfFault(ctor, args) {
+    const arity = (n) => args.length === n ? undefined : { reason: "arity" };
+    const argument = (i) => ({ reason: "argument", arg: i });
+    switch (ctor) {
+        case "any":
+        case "atom":
+        case "key-grammar":
+        case "text-non-blank":
+        case "lowercase-uuid":
+            return arity(0);
+        case "exact":
+            return arity(1);
+        case "atom-exact":
+            return arity(1) ?? (atomBytesOf(args[0]) === undefined ? argument(1) : undefined);
+        case "int-min":
+        case "int-max": {
+            const a = arity(1);
+            if (a !== undefined)
+                return a;
+            try {
+                return boundInRange(readInt(args[0])) ? undefined : argument(1);
+            }
+            catch {
+                return argument(1);
+            }
+        }
+        case "atom-len":
+        case "text-len": {
+            const a = arity(2);
+            if (a !== undefined)
+                return a;
+            let lo;
+            try {
+                lo = readInt(args[0]);
+            }
+            catch {
+                return argument(1);
+            }
+            if (!boundInRange(lo) || lo < 0n)
+                return argument(1);
+            let hi;
+            try {
+                hi = readInt(args[1]);
+            }
+            catch {
+                return argument(2);
+            }
+            return !boundInRange(hi) || hi < lo ? argument(2) : undefined;
+        }
+        case "atom-in": {
+            const a = arity(1);
+            if (a !== undefined)
+                return a;
+            let elems;
+            try {
+                elems = readSet(args[0]);
+            }
+            catch {
+                return argument(1);
+            }
+            return elems.every((e) => e.kind === "atom") ? undefined : argument(1);
+        }
+        case "scalar": {
+            const a = arity(1);
+            if (a !== undefined)
+                return a;
+            const kind = atomStringOf(args[0]);
+            return kind === "int" || kind === "utf8-text" || kind === "bool"
+                ? undefined
+                : argument(1);
+        }
+    }
+    return { reason: "unknown-constructor" };
+}
+function diagnoseWfIn(t, bound, pending, depth, pos) {
     if (depth > MAX_RECURSION_DEPTH)
-        return exhausted("recursion_depth");
+        return exhausted(undefined, pos);
+    const fault = (reason, arg) => notWf(arg === undefined
+        ? { path: undefined, at: pos, reason }
+        : { path: undefined, at: pos, reason, arg });
     const h = head(t);
     if (h === undefined)
-        return NOT_WF;
+        return fault("not-descriptor");
     const { ctor, args } = h;
-    if (isLeafCtor(ctor))
-        return leafWellFormed(t) ? CONFORMS : NOT_WF;
-    const wfAll = (ts, p) => kleeneAll(ts.map((ct) => diagnoseWfIn(ct, bound, p, depth + 1)));
+    if (isLeafCtor(ctor)) {
+        // The recognizer decides the verdict; leafWfFault only names the fault.
+        if (leafWellFormed(t))
+            return CONFORMS;
+        const f = leafWfFault(ctor, args) ?? { reason: "argument" };
+        return fault(f.reason, f.arg);
+    }
+    // Child descriptors at the given item indices, in order, after the own form is accepted.
+    const wfChildren = (items, p) => kleeneAll(items.length, (i) => diagnoseWfIn(args[items[i] - 1], bound, p, depth + 1, at(pos, items[i])));
+    const all = (from) => {
+        const out = [];
+        for (let i = from; i <= args.length; i += 1)
+            out.push(i);
+        return out;
+    };
     switch (ctor) {
         case "tuple":
-            return wfAll(args, []);
+            return wfChildren(all(1), []);
         case "seq":
-            return args.length !== 1 ? NOT_WF : diagnoseWfIn(args[0], bound, [], depth + 1);
-        case "compound":
-            if (args.length < 1 || atomBytesOf(args[0]) === undefined)
-                return NOT_WF;
-            return wfAll(args.slice(1), []);
         case "list-of":
         case "set-of":
-            return args.length !== 1 ? NOT_WF : diagnoseWfIn(args[0], bound, [], depth + 1);
+            return args.length !== 1 ? fault("arity") : wfChildren([1], []);
+        case "compound":
+            if (args.length < 1)
+                return fault("arity");
+            if (atomBytesOf(args[0]) === undefined)
+                return fault("argument", 1);
+            return wfChildren(all(2), []);
         case "map-of":
-            if (args.length !== 2)
-                return NOT_WF;
-            return kleeneAll([
-                diagnoseWfIn(args[0], bound, [], depth + 1),
-                diagnoseWfIn(args[1], bound, [], depth + 1),
-            ]);
+            return args.length !== 2 ? fault("arity") : wfChildren([1, 2], []);
         case "union":
         case "and":
-            return wfAll(args, pending);
+            return wfChildren(all(1), pending);
         case "not":
-            return args.length !== 1
-                ? NOT_WF
-                : diagnoseWfIn(args[0], bound, pending, depth + 1);
+            return args.length !== 1 ? fault("arity") : wfChildren([1], pending);
         case "rec": {
             if (args.length !== 2)
-                return NOT_WF;
+                return fault("arity");
             const name = atomStringOf(args[0]);
             if (name === undefined)
-                return NOT_WF;
-            return diagnoseWfIn(args[1], [...bound, name], [...pending, name], depth + 1);
+                return fault("argument", 1);
+            return diagnoseWfIn(args[1], [...bound, name], [...pending, name], depth + 1, at(pos, 2));
         }
         case "ref": {
             if (args.length !== 1)
-                return NOT_WF;
+                return fault("arity");
             const name = atomStringOf(args[0]);
-            return name !== undefined && bound.includes(name) && !pending.includes(name)
-                ? CONFORMS
-                : NOT_WF;
+            if (name === undefined)
+                return fault("argument", 1);
+            if (!bound.includes(name))
+                return fault("unbound-ref", 1);
+            if (pending.includes(name))
+                return fault("unguarded-ref", 1);
+            return CONFORMS;
         }
         case "record": {
             if (args.length < 1)
-                return NOT_WF;
+                return fault("arity");
             const mode = atomStringOf(args[0]);
             if (mode !== "open" && mode !== "closed")
-                return NOT_WF;
+                return fault("argument", 1);
             const names = new Set();
-            const outcomes = [];
-            for (const field of args.slice(1)) {
-                const fd = readFieldDescriptor(field);
-                if (fd === undefined || names.has(fd.name))
-                    return NOT_WF;
+            const types = [];
+            for (let k = 2; k <= args.length; k += 1) {
+                const fd = readFieldDescriptor(args[k - 1]);
+                if (fd === undefined)
+                    return fault("argument", k);
+                if (names.has(fd.name))
+                    return fault("duplicate-field", k);
                 names.add(fd.name);
-                outcomes.push(diagnoseWfIn(fd.ty, bound, [], depth + 1));
+                types.push(fd.ty);
             }
-            return kleeneAll(outcomes);
+            // Field k's type is item 3 of the field form at item k.
+            return kleeneAll(types.length, (i) => diagnoseWfIn(types[i], bound, [], depth + 1, at(at(pos, i + 2), 3)));
         }
     }
-    return NOT_WF;
+    return fault("unknown-constructor");
 }
 //# sourceMappingURL=diagnose.js.map