aontu 0.52.1 → 0.53.0

package/dist/provenance.js

@@ -0,0 +1,335 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provenance = exports.INNER_OF = exports.WRITTEN = exports.FROM_SPREAD = void 0;
+exports.markSpread = markSpread;
+// Set on a spread template's per-key clone, at the one place a spread
+// is applied (MapVal/ListVal.unify). Nothing else reads it.
+exports.FROM_SPREAD = '_fromSpread';
+// THE AUTHORED MARK, and it is a property of the VALUE rather than a
+// set of ids held beside it (the review's finding E). A contribution
+// is a value the author wrote, and the recorder used to decide that by
+// looking the operand's id up in a set stamped over the parsed tree --
+// which is true of the parsed tree and of nothing derived from it. So
+// every value that reached a path through a CLONE was dark: a default
+// flowing into a `pack()`-generated child, a shape carried by a `$ref`,
+// one side of an id()-merge. `why` answered "(no contributions:
+// nothing met at this path)" over a value it had just printed, with
+// exit 0 -- a false statement, and the one an audit surface may not
+// make (use-cases/BUGS.md §23, §24).
+//
+// A clone of a written value IS that written value, re-instantiated
+// somewhere else: it carries the author's site, so it can be pointed
+// at. Val.clone therefore carries this mark, exactly as it carries the
+// site -- provenance is part of the clone contract, not a recorder
+// bolted beside it. Values the engine MINTS (a kind lifted while a
+// disjunct trials its members, a fold's intermediate) are constructed
+// rather than cloned and stay unmarked, which is what keeps the record
+// to what the author can edit.
+//
+// The mark is only ever SET by an instrumented run (`why` calls
+// writtenFrom; nothing else does), so an ordinary evaluation pays one
+// undefined property read per clone.
+exports.WRITTEN = '_written';
+// THE CONTAINER A VALUE IS PART OF, when the two stand at the SAME
+// path: a junction's members, a preference's inner value, a function's
+// arguments, an operator's operands. `*1|integer` is one thing the
+// author wrote, and `*1` is not a second thing beside it.
+//
+// The recorder already knew that where the container itself met
+// something -- contributing it marked its members `inside` and the
+// filter dropped them. But the container only appears as an operand
+// when the fixpoint happens to meet it whole; where it resolves
+// member-wise instead (a later sibling of a spread, a default reaching
+// a generated child) the members arrived alone and the record split
+// one written value into two contributions at two columns. Which
+// happened was decided by evaluation order, so `why` answered
+// differently for identical statements (use-cases/BUGS.md §22).
+//
+// So the relation is recorded as a fact about the DOCUMENT, at
+// stamping time, and an operand is reported as the outermost written
+// value it is part of. NOT set for a bag's children (they stand at
+// their own, deeper paths) nor for a conjunct's terms (a conjunct is
+// the statement that several things must all hold, and each term is
+// one of them -- which is exactly what the author needs shown).
+exports.INNER_OF = '_innerOf';
+// Mark a spread clone and everything inside it, so a contribution
+// several levels down a template is still known to have come from the
+// template. ONLY on an instrumented run: the walk is O(template) per
+// key per pass, which is real money on a large model and buys nothing
+// when no one is recording.
+//
+// THE GUARD IS A CYCLE GUARD, NOT A "DONE" FLAG, and that distinction
+// is the whole of the review's finding E for sibling position. A
+// template is applied once per destination, and the fixpoint advances
+// values IN PLACE between those applications (AGENTS.md, the mutation
+// caveat): by the time the second key is spread, the template's
+// `replicas` child is no longer the disjunction the first key saw but
+// the value that meet produced. Skipping the walk because the
+// CONTAINER was already marked left every one of those replacements
+// unmarked, so `why` at the first sibling reported the written
+// `*1|integer` as one contribution and at the second reported `*1` and
+// `integer` as two -- identical statements, different answers, decided
+// by which key the fixpoint reached first (use-cases/BUGS.md §22).
+// Marking is idempotent, so re-walking costs a pass and changes
+// nothing where nothing moved.
+function markSpread(v, seen) {
+    const marked = seen ?? new Set();
+    if (null == v || true !== v.isVal || marked.has(v)) {
+        return;
+    }
+    marked.add(v);
+    v[exports.FROM_SPREAD] = true;
+    if (true === v.isMap && null != v.peg) {
+        for (const k of Object.keys(v.peg)) {
+            markSpread(v.peg[k], marked);
+        }
+    }
+    else if (true === v.isList && null != v.peg) {
+        for (const k of Object.keys(v.peg)) {
+            markSpread(v.peg[k], marked);
+        }
+    }
+    else if (Array.isArray(v.peg)) {
+        // A junction, a func's arguments, an op's operands: every one of
+        // them can hold the value that reaches the destination.
+        for (const m of v.peg) {
+            markSpread(m, marked);
+        }
+    }
+    else if (true === v.isPref) {
+        markSpread(v.peg, marked);
+    }
+}
+// The children that stand at the SAME path as v. See INNER_OF.
+function samePathKids(v) {
+    if (true === v.isMap || true === v.isList || true === v.isConjunct) {
+        return [];
+    }
+    if (true === v.isPref) {
+        return null != v.peg && true === v.peg.isVal ? [v.peg] : [];
+    }
+    return Array.isArray(v.peg)
+        ? v.peg.filter((k) => null != k && true === k.isVal) : [];
+}
+// Order contributions the way the document reads: by file, then row,
+// then column, with the canon as the last tiebreak so the order is
+// total even for two values written at the same position (which a
+// merged duplicate key can produce).
+function cmpSite(a, b) {
+    return a.site.file.localeCompare(b.site.file) ||
+        a.site.row - b.site.row ||
+        a.site.col - b.site.col ||
+        a.canon.localeCompare(b.canon);
+}
+function roleOf(v) {
+    if (true === v[exports.FROM_SPREAD]) {
+        return 'spread';
+    }
+    if (true === v.isRef) {
+        return 'ref';
+    }
+    if (true === v.isPref) {
+        return 'pref';
+    }
+    return 'literal';
+}
+class Provenance {
+    constructor() {
+        this.paths = new Map();
+        // id -> the written container it names, for INNER_OF. The mark on a
+        // value is the container's ID rather than the container itself: a
+        // Val holding another Val as an own property is a reference cycle
+        // through the tree, and enough of the engine walks a value's own
+        // properties that one is not safe to introduce.
+        this.containers = new Map();
+    }
+    // Stamp the parsed tree with the AUTHORED mark: everything the
+    // author wrote, before unification starts. A value minted during
+    // unification — a kind lifted from a leaf while a disjunct trials
+    // its members, a fold's intermediate — is the engine's own work, not
+    // a contribution the author can be pointed at. A CLONE of a marked
+    // value keeps the mark (see WRITTEN above), because it is the same
+    // written value somewhere else. Called once, before unify, by `why`.
+    writtenFrom(v) {
+        if (null == v || true !== v.isVal || true === v[exports.WRITTEN]) {
+            return;
+        }
+        v[exports.WRITTEN] = true;
+        const kids = (true === v.isMap || true === v.isList) && null != v.peg
+            ? Object.keys(v.peg).map((k) => v.peg[k])
+            : Array.isArray(v.peg) ? v.peg
+                : null != v.peg && true === v.peg.isVal ? [v.peg]
+                    : [];
+        for (const k of kids) {
+            this.writtenFrom(k);
+        }
+        // OUTERMOST WINS: the walk is top-down, so a value already pointed
+        // at a container is inside that one and this one, and the answer
+        // the author wants is the whole written statement.
+        for (const k of samePathKids(v)) {
+            if (null == k[exports.INNER_OF]) {
+                k[exports.INNER_OF] = v.id;
+                this.containers.set(v.id, v);
+            }
+        }
+        if (null != v.spread?.cj) {
+            this.writtenFrom(v.spread.cj);
+        }
+    }
+    // One meet. Both operands are candidate contributions; the result is
+    // remembered so a later meet does not mistake it for a source.
+    record(path, a, b, out) {
+        const key = path.join('.');
+        let rec = this.paths.get(key);
+        if (null == rec) {
+            rec = {
+                conjuncts: [], made: new Set(), seen: new Set(),
+            };
+            this.paths.set(key, rec);
+        }
+        this.contribute(rec, a);
+        this.contribute(rec, b);
+        if (null != out && true === out.isVal && out !== a && out !== b) {
+            rec.made.add(out.id);
+        }
+    }
+    contribute(rec, v) {
+        // TOP is the unit element and a nil is a failure, neither of which
+        // is information the author wrote. A value an earlier meet MADE is
+        // an intermediate; the source that made it is already recorded.
+        if (null == v || true !== v.isVal || true === v.isTop || true === v.isNil ||
+            rec.made.has(v.id) || rec.seen.has(v.id)) {
+            return;
+        }
+        // PART OF a written value is not a value beside it: report the
+        // whole statement the author wrote, whichever piece of it the
+        // fixpoint happened to meet here. See INNER_OF.
+        let outer = v;
+        for (let up = this.containers.get(outer[exports.INNER_OF]); null != up; up = this.containers.get(outer[exports.INNER_OF])) {
+            outer = up;
+        }
+        if (outer !== v) {
+            this.contribute(rec, outer);
+            return;
+        }
+        // Not the author's: see WRITTEN.
+        if (true !== v[exports.WRITTEN] && true !== v[exports.FROM_SPREAD]) {
+            return;
+        }
+        // A CONJUNCT is not one contribution, it is the statement that
+        // several must all hold — duplicate keys merged at parse, an
+        // explicit `a & b`. Its own site is nowhere (the merge has no
+        // source position), while its terms each have one, which is what
+        // the author needs to be shown.
+        if (true === v.isConjunct && Array.isArray(v.peg)) {
+            rec.seen.add(v.id);
+            for (const term of v.peg) {
+                this.contribute(rec, term);
+            }
+            return;
+        }
+        rec.seen.add(v.id);
+        rec.conjuncts.push({
+            canon: v.canon,
+            id: v.id,
+            role: roleOf(v),
+            // COALESCED, unlike vet's siteOf: a `why` run reads whatever
+            // source it was handed, and an inline document (a spec row, a
+            // piped stdin) has no file name to stamp. The Go port answers
+            // the empty string for the same value, so the two agree.
+            site: {
+                col: v.site.col, file: v.site.url ?? '', len: v.site.len,
+                row: v.site.row,
+            },
+            src: v.site.src,
+        });
+    }
+    // THE VALUE THAT STANDS at a path is a contribution when nothing met
+    // there and the author wrote it. A meet is where information
+    // vanishes, so a meet is what the recorder watches -- but a
+    // generator PLACES a value without meeting anything, and `why` then
+    // answered "(no contributions: nothing met at this path)" over a
+    // value it had just printed. That is literally true and practically
+    // false: the author is asking where the value came from, and it came
+    // from somewhere they can be shown (use-cases/BUGS.md §23).
+    //
+    // Only when the record is otherwise EMPTY. Where something did meet,
+    // the standing value is that meet's result -- an intermediate, and
+    // the recorder's oldest rule is that a result is not a source.
+    stands(path, v) {
+        const key = path.join('.');
+        const rec = this.paths.get(key);
+        if (null != rec && 0 < rec.conjuncts.length) {
+            return;
+        }
+        this.record(path, v, undefined, undefined);
+    }
+    // The record at one path. Empty when nothing met there and nothing
+    // the author wrote stands there either — which is a true and useful
+    // answer rather than an error.
+    //
+    // ONLY WHOLE WRITTEN VALUES are contributions. A Val's own unify
+    // re-enters `unite` at the same path — a disjunct trials each member
+    // there, a constraint meets its atoms there — and those members are
+    // PARTS OF one written value, not further values beside it. That is
+    // settled BEFORE a member is ever pushed, by the INNER_OF fact
+    // stamped over the document (see `contribute`), which is why no
+    // filter runs here: a per-path "inside" set used to do it, and it
+    // could only work where the container itself happened to meet
+    // something at the same path — the order-dependence finding E
+    // records.
+    at(path) {
+        const rec = this.paths.get(path.join('.'));
+        if (null == rec) {
+            return [];
+        }
+        // SOURCE ORDER, not meet order: the two are the same in simple
+        // cases and diverge with the fixpoint's fold order, which is an
+        // engine detail and a parity risk. Sites are parse data, identical
+        // in both ports, so ordering by them makes the record read as the
+        // document reads and pins it across implementations.
+        // ONE WRITTEN TOKEN IS ONE CONTRIBUTION, and the SITE is what
+        // identifies it -- not the val id, and not the canon.
+        //
+        // Not the id, because provenance travels through clones now: a
+        // written value and a clone of it are the same statement in the
+        // same place, and a path that met both would list it twice.
+        //
+        // Not the canon, because the same written value reaches a path at
+        // different stages of narrowing -- `3|(1|2)` as the author wrote
+        // it and `3|1|2` after a fold -- and both name one token.
+        //
+        // Not the role either: the role says how the value REACHED this
+        // path, not which value it is, and one written value can reach a
+        // path both ways (a template applied to a key whose value is also
+        // written there). Keeping the literal would throw away the more
+        // informative half, so the roles have a precedence.
+        //
+        // ONLY WHERE THE SITE IS REAL. An unsited contribution (row -1)
+        // cannot be told apart from another unsited one, so those are kept
+        // as they come rather than collapsed into whichever arrived first.
+        const shown = new Map();
+        const order = ['spread', 'ref', 'pref', 'literal'];
+        const out = [];
+        for (const c of rec.conjuncts.slice().sort(cmpSite)) {
+            if (c.site.row < 0) {
+                out.push(c);
+                continue;
+            }
+            const key = [c.src, c.site.file,
+                c.site.row, c.site.col, c.site.len].join('\u0000');
+            const had = shown.get(key);
+            if (null == had) {
+                shown.set(key, c);
+                out.push(c);
+            }
+            else if (order.indexOf(c.role) < order.indexOf(had.role)) {
+                had.role = c.role;
+            }
+        }
+        return out.map(({ id, ...rest }) => rest);
+    }
+}
+exports.Provenance = Provenance;
+//# sourceMappingURL=provenance.js.map

package/dist/provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.js","sourceRoot":"","sources":["../src/provenance.ts"],"names":[],"mappings":"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"}

package/dist/query.d.ts

@@ -0,0 +1,27 @@
+import type { TrustOptions } from './type';
+import type { VetFinding } from './vet';
+import type { WhyRecord } from './provenance';
+export type QueryView = 'json' | 'canon' | 'types' | 'keys';
+export type QueryOptions = {
+    view?: QueryView;
+    depth?: number;
+    path?: string;
+    trust?: TrustOptions;
+};
+export type QueryReport = {
+    ok: boolean;
+    out: string;
+    findings: VetFinding[];
+};
+export declare function nearestKey(want: string, have: string[]): string | undefined;
+export declare function pathParts(path: string): string[];
+export declare function projectFor(v: any, view: QueryView, depth: number): string;
+export declare function evalFailure(ctx: any): VetFinding;
+export declare function noPathFinding(root: any, path: string): VetFinding;
+export declare function get(src: string, path: string, opts?: QueryOptions): QueryReport;
+export type WhyReport = {
+    ok: boolean;
+    record?: WhyRecord;
+    findings: VetFinding[];
+};
+export declare function why(src: string, path: string, opts?: QueryOptions): WhyReport;

package/dist/query.js

@@ -0,0 +1,294 @@
+"use strict";
+/* Copyright (c) 2025 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nearestKey = nearestKey;
+exports.pathParts = pathParts;
+exports.projectFor = projectFor;
+exports.evalFailure = evalFailure;
+exports.noPathFinding = noPathFinding;
+exports.get = get;
+exports.why = why;
+// THE QUERY SURFACE (G7 phase 1,
+// docs/capability-review/g7-machine-access.md): select one node of an
+// evaluated document by path and render it — the slice an agent asks
+// for, instead of the whole file as one JSON blob.
+//
+// Evaluation is still GLOBAL. Unification has no partial mode to sell:
+// the whole document is evaluated and then one node is selected. What
+// `get` buys is the SIZE OF THE ANSWER, not the cost of producing it.
+//
+// The three projections are lattice ABSTRACTIONS, and each is defined
+// so that the view it prints is a valid Aontu document that SUBSUMES
+// the truth — generalisation, never distortion:
+//
+//   - `types` replaces every concrete leaf with its own kind, using
+//     the lattice's own superior() rather than a table of this file's
+//     opinions: {"replicas":3} becomes {"replicas":integer}.
+//   - `depth n` keeps structure to depth n and renders every elided
+//     subtree as `top` — "no further information at this tier".
+//   - `keys` is `depth 1` degenerated to a listing.
+//
+// That property is not a promise here: every projection row of
+// test/spec/query.tsv asserts subsume(view, truth) == 'subsumes' in
+// both runners, which G3 made mechanically checkable.
+//
+// Projections are NOT canonical form and are never fed to G6's hash,
+// which is why they are named views rather than spellings of --canon.
+const aontu_1 = require("./aontu");
+const exactjson_1 = require("./exactjson");
+const vet_1 = require("./vet");
+const keyorder_1 = require("./keyorder");
+const provenance_1 = require("./provenance");
+const TOP = 'top';
+// The nearest key at the parent of a path that named nothing, by a
+// plain edit distance over the sibling names — the "did you mean"
+// half of the no_path contract. Undefined when nothing is close
+// enough to be worth suggesting.
+function nearestKey(want, have) {
+    let best;
+    let bestd = Infinity;
+    for (const k of have) {
+        const d = editDistance(want, k);
+        if (d < bestd) {
+            bestd = d;
+            best = k;
+        }
+    }
+    // Half the name may differ, no more: past that the suggestion is
+    // noise, and a wrong suggestion costs more than none.
+    return bestd <= Math.max(1, Math.floor(want.length / 2)) ? best : undefined;
+}
+function editDistance(a, b) {
+    const prev = [];
+    for (let j = 0; j <= b.length; j++) {
+        prev[j] = j;
+    }
+    for (let i = 1; i <= a.length; i++) {
+        let diag = prev[0];
+        prev[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = prev[j];
+            prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diag + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diag = tmp;
+        }
+    }
+    return prev[b.length];
+}
+// The path split anchorAt walks: `$` and empty segments dropped, so
+// `$`, `$.` and `` all name the root.
+function pathParts(path) {
+    const trimmed = path.startsWith('$') ? path.slice(1) : path;
+    return trimmed.split('.').filter((p) => '' !== p);
+}
+// The queried path, normalised the way anchorAt reads it — so a
+// finding names `$.a.b` whether the caller wrote that, `a.b` or
+// `$.a.b.` — and `$` for the root.
+function pathText(path) {
+    const parts = pathParts(path);
+    return '$' + (0 < parts.length ? '.' + parts.join('.') : '');
+}
+// The projection walk, exported for the direct unit tests (ADR-002,
+// ts/test/coverage3.test.ts): a junction member that is itself a
+// junction of more than one term keeps its parens, and no SOURCE
+// reaches that arm because norm flattens junctions at unification.
+function projectFor(v, view, depth) {
+    return project(v, view, depth);
+}
+// The canon-shaped views. One walk, two knobs: `types` generalises
+// each leaf through the lattice, `depth` elides below its level. Bags
+// recurse (their canon getters would render children through plain
+// canon, which neither knob can reach); everything else is a leaf.
+function project(v, view, depth) {
+    if (depth <= 0) {
+        return TOP;
+    }
+    if (true === v?.isMap) {
+        const keys = Object.keys(v.peg).sort(keyorder_1.cmpCodePoint);
+        return '{' +
+            (v.spread.cj ? '&:' + project(v.spread.cj, view, depth - 1) +
+                (0 < keys.length ? ',' : '') : '') +
+            keys.map((k) => JSON.stringify(k) +
+                (v.optionalKeys.includes(k) ? '?' : '') +
+                ':' +
+                project(v.peg[k], view, depth - 1)).join(',') +
+            '}';
+    }
+    if (true === v?.isList) {
+        const keys = Object.keys(v.peg);
+        return '[' +
+            (v.spread.cj ? '&:' + project(v.spread.cj, view, depth - 1) +
+                (0 < keys.length ? ',' : '') : '') +
+            keys.map((k) => project(v.peg[k], view, depth - 1)).join(',') +
+            ']';
+    }
+    // Junctions and prefs are TRANSPARENT: not a structural tier (so
+    // they do not spend a level of depth) but not a leaf either (so
+    // `*8080|integer` generalises to `*integer|integer` rather than
+    // collapsing to `top` and throwing the alternatives away).
+    if (true === v?.isPref) {
+        return '*' + project(v.peg, view, depth);
+    }
+    if (true === v?.isConjunct || true === v?.isDisjunct) {
+        return v.peg.map((m) => true === m?.isJunction && 1 < m.peg.length
+            ? '(' + project(m, view, depth) + ')'
+            : project(m, view, depth))
+            .join(true === v.isConjunct ? '&' : '|');
+    }
+    // A LEAF. Under `types` a CONCRETE scalar lifts to its own kind —
+    // superior() is the lattice's answer, so the view subsumes the truth
+    // by construction and not by this file's good intentions. Everything
+    // else is already an abstraction (a kind marker, a constraint, an
+    // unresolved reference) and is left alone: lifting `integer` to
+    // `number` would generalise a shape view that was already a shape.
+    return 'types' === view && true === v?.isScalar ? v.superior().canon : v.canon;
+}
+// The `keys` listing: the node's own key names (or list indices), one
+// per line, code-point ordered as canon orders them. A leaf has none,
+// which is an empty answer rather than an error — "nothing below
+// here" is a true statement about a scalar.
+function keyList(v) {
+    if (true === v?.isMap) {
+        return Object.keys(v.peg).sort(keyorder_1.cmpCodePoint).join('\n');
+    }
+    if (true === v?.isList) {
+        return Object.keys(v.peg).join('\n');
+    }
+    return '';
+}
+function finding(code, path, message, note) {
+    return {
+        code,
+        class: 'reference',
+        severity: 'error',
+        path,
+        message,
+        sites: [],
+        ...(null == note ? {} : { note }),
+    };
+}
+// A document that does not stand up has no node to select. The
+// engine's own first error IS the report: the query surface adds
+// nothing to a diagnosis the evaluator already made. The path is the
+// DOCUMENT — what failed is the whole thing standing up, not the node
+// the caller asked about, which may never have existed.
+function evalFailure(ctx) {
+    // ctx.err is never empty at a call site: every failure that reaches
+    // one collected an error first — a parse that did not stand up, a
+    // root that came back nil. Not coalesced, on the vet siteOf
+    // precedent: an impossible state should fail loudly rather than be
+    // quietly papered over with a made-up code.
+    const err = ctx.err[0];
+    return finding(err.why, '$', err.msg);
+}
+// The refusal for a path that names nothing, shared by `get` and
+// `why`: WHICH segment failed, and what was there instead — the "did
+// you mean" the no_path contract promises. Walking again is cheap (the
+// tree is in hand) and is the only way to name the parent.
+function noPathFinding(root, path) {
+    const parts = pathParts(path);
+    let at = root;
+    let want = '';
+    for (const part of parts) {
+        const next = (0, vet_1.anchorAt)(at, part);
+        if (null == next) {
+            want = part;
+            break;
+        }
+        at = next;
+    }
+    const have = true === at?.isMap
+        ? Object.keys(at.peg).sort(keyorder_1.cmpCodePoint)
+        : (true === at?.isList ? Object.keys(at.peg) : []);
+    const near = nearestKey(want, have);
+    return finding('no_path', pathText(path), `The path ${path} names nothing in this document.`, null == near ? undefined : `did you mean ${near}?`);
+}
+// Evaluate the document, select the node at `path`, and render it.
+function get(src, path, opts) {
+    const options = opts ?? {};
+    const view = options.view ?? 'json';
+    const aontu = new aontu_1.Aontu(null == options.trust ? undefined : { trust: options.trust });
+    const ctx = aontu.ctx({ collect: true });
+    const parseOpts = null == options.path ? undefined : { path: options.path };
+    const root = aontu.unify(src, parseOpts, ctx);
+    if (0 < ctx.err.length || null == root || true === root.isNil) {
+        return { ok: false, out: '', findings: [evalFailure(ctx)] };
+    }
+    const node = (0, vet_1.anchorAt)(root, path);
+    if (null == node) {
+        return { ok: false, out: '', findings: [noPathFinding(root, path)] };
+    }
+    if ('json' === view) {
+        // GENERATION CAN FAIL WHERE UNIFICATION DID NOT: `k: integer` is a
+        // perfectly good unified document and not a concrete value, so the
+        // json view of it is an error, exactly as `aontu file.aon` on the
+        // same document is. Under `collect` the failure lands on the
+        // context rather than throwing, so it has to be read back — the Go
+        // port's Gen returns it as an error and the two must agree.
+        const before = ctx.err.length;
+        const gen = node.gen(ctx);
+        if (before < ctx.err.length) {
+            const err = ctx.err[before];
+            return {
+                ok: false,
+                out: '',
+                findings: [finding(err?.why ?? 'no_gen', pathText(path), err?.msg ?? 'The value at this path is not concrete.')],
+            };
+        }
+        return { ok: true, out: (0, exactjson_1.exactJSON)(gen, 2), findings: [] };
+    }
+    if ('keys' === view) {
+        return { ok: true, out: keyList(node), findings: [] };
+    }
+    return {
+        ok: true,
+        out: project(node, view, options.depth ?? Infinity),
+        findings: [],
+    };
+}
+// WHY does the value at this path hold? Evaluate with the provenance
+// recorder on, select the node, and answer the ordered contributions
+// that met there — the positive twin of G2's error report.
+//
+// Two evaluations are NOT needed: the recorder rides the one run this
+// call makes. What it costs is site materialisation and one map entry
+// per path met, which an instrumented run pays knowingly.
+function why(src, path, opts) {
+    const options = opts ?? {};
+    const aontu = new aontu_1.Aontu(null == options.trust ? undefined : { trust: options.trust });
+    const prov = new provenance_1.Provenance();
+    const ctx = aontu.ctx({ collect: true, prov });
+    const parseOpts = null == options.path ? undefined : { path: options.path };
+    // Parse and unify SEPARATELY, so the parsed tree can be stamped
+    // before the fixpoint runs: a contribution is a value the author
+    // wrote, and after unification there is no longer any way to tell
+    // one from a value the engine minted on the way.
+    const parsed = aontu.parse(src, parseOpts, ctx);
+    if (0 < ctx.err.length || null == parsed) {
+        return { ok: false, findings: [evalFailure(ctx)] };
+    }
+    prov.writtenFrom(parsed);
+    const root = aontu.unify(parsed, parseOpts, ctx);
+    if (0 < ctx.err.length || null == root || true === root.isNil) {
+        return { ok: false, findings: [evalFailure(ctx)] };
+    }
+    const node = (0, vet_1.anchorAt)(root, path);
+    if (null == node) {
+        return { ok: false, findings: [noPathFinding(root, path)] };
+    }
+    // The value that stands here is a contribution when nothing met
+    // (see Provenance.stands): a generator places a value without a
+    // meet, and "nothing met at this path" is not an answer to "where
+    // did this come from".
+    const parts = pathParts(path);
+    prov.stands(parts, node);
+    return {
+        ok: true,
+        record: {
+            conjuncts: prov.at(parts),
+            path: pathText(path),
+            value: node.canon,
+        },
+        findings: [],
+    };
+}
+//# sourceMappingURL=query.js.map