@manta-eu/react 0.1.0

package/dist/rdfox-explain/proof-tree/proof-tree-root-view.d.ts

@@ -0,0 +1,12 @@
+import { type BindFormulaPresentation } from "../rule-presentation.js";
+import type { NormalizedNode, NormalizedTree } from "../tree-model.js";
+type ProofTreeRootView = {
+    formula?: BindFormulaPresentation;
+    formulaNodeId?: string;
+    visibleChildren: NormalizedNode[];
+    hasPremises: boolean;
+};
+export declare function proofTreeRootView(tree: NormalizedTree): ProofTreeRootView;
+export declare function hasVisiblePremises(tree: NormalizedTree): boolean;
+export {};
+//# sourceMappingURL=proof-tree-root-view.d.ts.map

package/dist/rdfox-explain/proof-tree/proof-tree-root-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-tree-root-view.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/proof-tree-root-view.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpE,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AAIF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,iBAAiB,CAwBzE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAEhE"}

package/dist/rdfox-explain/proof-tree/proof-tree-root-view.js

@@ -0,0 +1,28 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { presentRule } from "../rule-presentation.js";
+import { visiblePremiseChildren } from "./visible-premises.js";
+const rootViewByTree = new WeakMap();
+export function proofTreeRootView(tree) {
+    const cached = rootViewByTree.get(tree);
+    if (cached)
+        return cached;
+    const formula = tree.root.rule ? presentRule(tree.root.rule, tree.root.groundedRule).formula : undefined;
+    const formulaNodeId = formula
+        ? tree.root.childIds.find((childId) => {
+            const child = tree.byId[childId];
+            return child?.kind === "bind" && child.bodyIndex === formula.index;
+        })
+        : undefined;
+    const visibleChildren = visiblePremiseChildren(tree, tree.root, formulaNodeId);
+    const view = {
+        formula,
+        formulaNodeId,
+        visibleChildren,
+        hasPremises: isPresent(visibleChildren) || isPresent(formula),
+    };
+    rootViewByTree.set(tree, view);
+    return view;
+}
+export function hasVisiblePremises(tree) {
+    return proofTreeRootView(tree).hasPremises;
+}

package/dist/rdfox-explain/proof-tree/visible-premises.d.ts

@@ -0,0 +1,3 @@
+import { type NormalizedNode, type NormalizedTree } from "../tree-model.js";
+export declare function visiblePremiseChildren(tree: NormalizedTree, node: NormalizedNode, hiddenNodeId?: string): NormalizedNode[];
+//# sourceMappingURL=visible-premises.d.ts.map

package/dist/rdfox-explain/proof-tree/visible-premises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visible-premises.d.ts","sourceRoot":"","sources":["../../../src/rdfox-explain/proof-tree/visible-premises.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAMrF,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,cAAc,EACpB,YAAY,CAAC,EAAE,MAAM,GACpB,cAAc,EAAE,CASlB"}

package/dist/rdfox-explain/proof-tree/visible-premises.js

@@ -0,0 +1,14 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { isTypeFact } from "../tree-model.js";
+function carriesOwnDerivation(premise) {
+    return isPresent(premise.childIds);
+}
+export function visiblePremiseChildren(tree, node, hiddenNodeId) {
+    const premises = node.childIds
+        .filter((childId) => childId !== hiddenNodeId)
+        .flatMap((childId) => tree.byId[childId] ?? []);
+    const nonTypePremises = premises.filter((premise) => !isTypeFact(premise));
+    if (isPresent(nonTypePremises))
+        return nonTypePremises;
+    return premises.filter(carriesOwnDerivation);
+}

package/dist/rdfox-explain/rule-presentation.d.ts

@@ -0,0 +1,54 @@
+import type { DatalogTerm } from "@manta-eu/datalog-parser";
+import { type NormalizedNodeKind } from "./tree-model.js";
+export type RuleAtomPresentation = {
+    index: number;
+    text: string;
+    groundedText: string;
+    kind: NormalizedNodeKind;
+    predicateTerm?: string;
+};
+export declare function maskSubstitutedLiterals(rawText: string, groundedText: string): string;
+export type RuleHeadAtomPresentation = {
+    text: string;
+    groundedText: string;
+    predicateTerm?: string;
+};
+export declare function derivedHeadAtom(headAtoms: RuleHeadAtomPresentation[], factText: string | undefined): RuleHeadAtomPresentation | undefined;
+export type VariableBinding = {
+    variable: string;
+    value: string;
+    term: DatalogTerm;
+    predicate?: string;
+};
+export type FormulaInput = {
+    variable: string;
+    value?: string;
+    atomIndex?: number;
+};
+export type BindFormulaPresentation = {
+    index: number;
+    expression: string;
+    groundedExpression: string;
+    result: string;
+    inputs: FormulaInput[];
+};
+export type RulePresentation = {
+    name: string;
+    nameTerm: string;
+    headText: string;
+    groundedHeadText: string;
+    headAtoms: RuleHeadAtomPresentation[];
+    ruleText: string;
+    groundedRuleText: string;
+    atoms: RuleAtomPresentation[];
+    bindings: VariableBinding[];
+    resultVariable?: string;
+    formula?: BindFormulaPresentation;
+};
+export declare function formatRuleText(headText: string, atomTexts: string[]): string;
+export declare function presentRule(rule: string, groundedRule?: string): RulePresentation;
+export declare function splitComputationTerm(text: string): {
+    expression: string;
+    result: string;
+} | undefined;
+//# sourceMappingURL=rule-presentation.d.ts.map

package/dist/rdfox-explain/rule-presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-presentation.d.ts","sourceRoot":"","sources":["../../src/rdfox-explain/rule-presentation.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAKV,WAAW,EAEZ,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAIL,KAAK,kBAAkB,EAGxB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,kBAAkB,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAuJF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAUrF;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAMF,wBAAgB,eAAe,CAC7B,SAAS,EAAE,wBAAwB,EAAE,EACrC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,wBAAwB,GAAG,SAAS,CAMtC;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAOF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,wBAAwB,EAAE,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,uBAAuB,CAAC;CACnC,CAAC;AAEF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,CAE5E;AAKD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAiBjF;AAoVD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAYrG"}

package/dist/rdfox-explain/rule-presentation.js

@@ -0,0 +1,403 @@
+import { AS, isDatalogAtom, LBRACKET, LPAREN, propertyAssertionFromAtom, RBRACKET, RPAREN, tokenizeDatalog, } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { match, P } from "ts-pattern";
+import { parseDatalogRuleCached, parseGroundedDatalogRuleCached } from "../rules/datalog-cache.js";
+import { getRuleBodyTerms, kindForBodyFormula, kindForSyntheticTerm, ruleHeadTerms, ruleHeadText, } from "./tree-model.js";
+function atomPredicateTerm(formula) {
+    if (!isDatalogAtom(formula))
+        return undefined;
+    return propertyAssertionFromAtom(formula)?.predicate;
+}
+const maskedValueToken = "•••••";
+const maskWrapHead = ":m[:m] :- ";
+function parseBodyFormulas(text) {
+    const { ast } = parseDatalogRuleCached(`${maskWrapHead}${text} .`);
+    return ast && isPresent(ast.body) ? ast.body : undefined;
+}
+function combineSpans(...parts) {
+    const all = [];
+    for (const part of parts) {
+        if (!part)
+            return undefined;
+        all.push(...part);
+    }
+    return all;
+}
+function zipSpans(raws, grounds, collect) {
+    if (raws.length !== grounds.length)
+        return undefined;
+    return combineSpans(...raws.map((raw, index) => {
+        const grounded = grounds[index];
+        return grounded === undefined ? undefined : collect(raw, grounded);
+    }));
+}
+// A grounded literal standing where the raw rule has a variable is a substituted
+// runtime value; literals present in the raw rule itself are authored constants.
+function substitutedTermSpans(raw, grounded) {
+    if (raw?.type === "variable" && grounded?.type === "literal" && grounded.termSpan) {
+        return [grounded.termSpan];
+    }
+    return [];
+}
+function substitutedAtomSpans(raw, grounded) {
+    return match([raw, grounded])
+        .with([{ type: "triple" }, { type: "triple" }], ([rawAtom, groundedAtom]) => [
+        ...substitutedTermSpans(rawAtom.subject, groundedAtom.subject),
+        ...substitutedTermSpans(rawAtom.predicate, groundedAtom.predicate),
+        ...substitutedTermSpans(rawAtom.object, groundedAtom.object),
+        ...substitutedTermSpans(rawAtom.graph, groundedAtom.graph),
+    ])
+        .with([{ type: "property" }, { type: "property" }], ([rawAtom, groundedAtom]) => [
+        ...substitutedTermSpans(rawAtom.subject, groundedAtom.subject),
+        ...substitutedTermSpans(rawAtom.object, groundedAtom.object),
+        ...substitutedTermSpans(rawAtom.graph, groundedAtom.graph),
+    ])
+        .with([{ type: "class" }, { type: "class" }], ([rawAtom, groundedAtom]) => [
+        ...substitutedTermSpans(rawAtom.instance, groundedAtom.instance),
+        ...substitutedTermSpans(rawAtom.graph, groundedAtom.graph),
+    ])
+        .with([{ type: "general" }, { type: "general" }], ([rawAtom, groundedAtom]) => zipSpans(rawAtom.terms, groundedAtom.terms, (raw, grounded) => substitutedTermSpans(raw, grounded)))
+        .otherwise(() => undefined);
+}
+function substitutedExpressionSpans(raw, grounded) {
+    return match([raw, grounded])
+        .with([{ type: "binary" }, { type: "binary" }], ([rawNode, groundedNode]) => combineSpans(substitutedExpressionSpans(rawNode.left, groundedNode.left), substitutedExpressionSpans(rawNode.right, groundedNode.right)))
+        .with([{ type: "unary" }, { type: "unary" }], ([rawNode, groundedNode]) => substitutedExpressionSpans(rawNode.operand, groundedNode.operand))
+        .with([{ type: "function" }, { type: "function" }], ([rawNode, groundedNode]) => zipSpans(rawNode.args, groundedNode.args, substitutedExpressionSpans))
+        .with([{ type: "in" }, { type: "in" }], ([rawNode, groundedNode]) => combineSpans(substitutedExpressionSpans(rawNode.expression, groundedNode.expression), zipSpans(rawNode.list, groundedNode.list, substitutedExpressionSpans)))
+        .with([{ type: "term" }, { type: "term" }], ([rawNode, groundedNode]) => substitutedTermSpans(rawNode.term, groundedNode.term))
+        .otherwise(() => undefined);
+}
+function substitutedFormulaSpans(raw, grounded) {
+    return match([raw, grounded])
+        .with([{ type: P.union("triple", "property", "class", "general") }, P.any], ([rawAtom, groundedFormula]) => isDatalogAtom(groundedFormula) ? substitutedAtomSpans(rawAtom, groundedFormula) : undefined)
+        .with([{ type: "negation" }, { type: "negation" }], ([rawNode, groundedNode]) => zipSpans(rawNode.formulas, groundedNode.formulas, substitutedFormulaSpans))
+        .with([{ type: "aggregate" }, { type: "aggregate" }], ([rawNode, groundedNode]) => combineSpans(zipSpans(rawNode.atoms, groundedNode.atoms, substitutedFormulaSpans), zipSpans(rawNode.bindings ?? [], groundedNode.bindings ?? [], (rawBinding, groundedBinding) => combineSpans(rawBinding.expression === "*" || groundedBinding.expression === "*"
+        ? rawBinding.expression === groundedBinding.expression
+            ? []
+            : undefined
+        : substitutedExpressionSpans(rawBinding.expression, groundedBinding.expression), rawBinding.secondExpression && groundedBinding.secondExpression
+        ? substitutedExpressionSpans(rawBinding.secondExpression, groundedBinding.secondExpression)
+        : []))))
+        .with([{ type: "filter" }, { type: "filter" }], ([rawNode, groundedNode]) => substitutedExpressionSpans(rawNode.expression, groundedNode.expression))
+        .with([{ type: "bind" }, { type: "bind" }], ([rawNode, groundedNode]) => substitutedExpressionSpans(rawNode.expression, groundedNode.expression))
+        .with([{ type: "skolem" }, { type: "skolem" }], ([rawNode, groundedNode]) => zipSpans(rawNode.args, groundedNode.args, substitutedExpressionSpans))
+        .otherwise(() => undefined);
+}
+function maskSpans(text, spans, offset) {
+    return [...spans]
+        .sort((a, b) => b.start - a.start)
+        .reduce((masked, span) => masked.slice(0, span.start - offset) + maskedValueToken + masked.slice(span.end - offset), text);
+}
+export function maskSubstitutedLiterals(rawText, groundedText) {
+    const rawFormulas = parseBodyFormulas(rawText);
+    const groundedFormulas = parseBodyFormulas(groundedText);
+    const spans = rawFormulas && groundedFormulas ? zipSpans(rawFormulas, groundedFormulas, substitutedFormulaSpans) : undefined;
+    // Text we cannot align against the raw rule cannot be selectively masked - hide it entirely.
+    if (!spans)
+        return maskedValueToken;
+    return maskSpans(groundedText, spans, maskWrapHead.length);
+}
+function normalizeAtomText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export function derivedHeadAtom(headAtoms, factText) {
+    if (!factText)
+        return undefined;
+    const normalizedFact = normalizeAtomText(factText);
+    return headAtoms.find((atom) => normalizeAtomText(atom.groundedText) === normalizedFact);
+}
+export function formatRuleText(headText, atomTexts) {
+    return `${headText} :-\n  ${atomTexts.join(",\n  ")} .`;
+}
+const presentationCache = new Map();
+const presentationCacheMaxEntries = 200;
+export function presentRule(rule, groundedRule) {
+    const cacheKey = JSON.stringify([rule, groundedRule]);
+    const cached = presentationCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const presentation = buildRulePresentation(rule, groundedRule);
+    if (presentationCache.size >= presentationCacheMaxEntries) {
+        const oldestKey = presentationCache.keys().next().value;
+        if (oldestKey !== undefined)
+            presentationCache.delete(oldestKey);
+    }
+    presentationCache.set(cacheKey, presentation);
+    return presentation;
+}
+function buildRulePresentation(rule, groundedRule) {
+    const headText = ruleHeadText(rule);
+    const groundedHeadText = groundedRule ? ruleHeadText(groundedRule) : headText;
+    const bodyTerms = getRuleBodyTerms(rule);
+    const groundedBodyTerms = groundedRule ? getRuleBodyTerms(groundedRule) : bodyTerms;
+    const ast = explainRuleAst(rule);
+    const bodyFormulas = ast && ast.body.length === bodyTerms.length ? ast.body : undefined;
+    const atoms = bodyTerms.map((text, index) => {
+        const formula = bodyFormulas?.[index];
+        return {
+            index,
+            text,
+            groundedText: groundedBodyTerms[index] ?? text,
+            kind: formula ? kindForBodyFormula(formula) : kindForSyntheticTerm(text),
+            predicateTerm: formula ? atomPredicateTerm(formula) : undefined,
+        };
+    });
+    const headTerms = ruleHeadTerms(rule);
+    const groundedHeadTerms = groundedRule ? ruleHeadTerms(groundedRule) : headTerms;
+    const headFormulas = ast && ast.head.length === headTerms.length ? ast.head : undefined;
+    const headAtoms = headTerms.map((text, index) => {
+        const formula = headFormulas?.[index];
+        return {
+            text,
+            groundedText: groundedHeadTerms[index] ?? text,
+            predicateTerm: formula ? atomPredicateTerm(formula) : undefined,
+        };
+    });
+    const groundedAst = groundedRule ? (parseGroundedDatalogRuleCached(groundedRule).ast ?? undefined) : undefined;
+    const bindings = ast && groundedAst ? collectBindings(ast, groundedAst) : [];
+    const nameTerm = ast ? ruleNameTermFromAst(ast) : ruleNameTermFromHeadText(headText);
+    return {
+        name: nameTerm.replace(/^:/, ""),
+        nameTerm,
+        headText,
+        groundedHeadText,
+        headAtoms,
+        ruleText: formatRuleText(headText, atoms.map((atom) => atom.text)),
+        groundedRuleText: formatRuleText(groundedHeadText, atoms.map((atom) => atom.groundedText)),
+        atoms,
+        bindings,
+        resultVariable: ast?.head[0] ? objectPredicate(ast.head[0]).variable : undefined,
+        formula: extractBindFormula(ast, atoms, bindings),
+    };
+}
+function ruleNameTermFromAst(ast) {
+    const head = ast.head[0];
+    if (!head)
+        return "";
+    return match(head)
+        .with({ type: "property" }, (atom) => atom.predicate)
+        .with({ type: "class" }, (atom) => atom.className)
+        .with({ type: "general" }, (atom) => atom.tableName)
+        .with({ type: "triple" }, (atom) => termText(atom.predicate))
+        .exhaustive();
+}
+function ruleNameTermFromHeadText(headText) {
+    const predicate = headText.split("[")[0] ?? headText;
+    return predicate.trim();
+}
+// Explain payloads echo RDFox-serialized rules (bare ON, atom-free aggregates),
+// so authored text falls through to the expanded grammar when the strict parse fails.
+function explainRuleAst(rule) {
+    return parseDatalogRuleCached(rule).ast ?? parseGroundedDatalogRuleCached(rule).ast ?? undefined;
+}
+function collectBindings(ast, groundedAst) {
+    const bindings = new Map();
+    const predicates = new Map();
+    // Body before head so first-wins predicates prefer the body atom that produced the
+    // value (measure formatting / PII masking) over a later head projection.
+    if (groundedAst.body.length === ast.body.length) {
+        ast.body.forEach((formula, index) => {
+            collectFormulaBindings(formula, groundedAst.body[index], bindings, predicates);
+        });
+    }
+    if (groundedAst.head.length === ast.head.length) {
+        ast.head.forEach((headAtom, index) => {
+            const groundedAtom = groundedAst.head[index];
+            if (groundedAtom)
+                unifyAtoms(headAtom, groundedAtom, bindings, predicates);
+        });
+    }
+    return [...bindings.entries()].map(([variable, binding]) => ({
+        variable,
+        ...binding,
+        predicate: predicates.get(variable),
+    }));
+}
+function collectFormulaBindings(formula, groundedFormula, bindings, predicates) {
+    match(formula)
+        .with({ type: P.union("triple", "property", "class", "general") }, (atom) => {
+        if (!groundedFormula || !isDatalogAtom(groundedFormula))
+            return;
+        unifyAtoms(atom, groundedFormula, bindings, predicates);
+    })
+        .with({ type: "bind" }, (bind) => {
+        if (groundedFormula?.type !== "bind")
+            return;
+        recordGroundedTarget(bind.variable, groundedFormula.groundedTarget, bindings);
+    })
+        .with({ type: "aggregate" }, (aggregate) => {
+        if (groundedFormula?.type !== "aggregate")
+            return;
+        // AS targets first, then the aggregate's inner atoms — RDFox grounds those too
+        // (e.g. `:clicks[?c, ?x]` → `:clicks[:C_1, 10]`), and first-wins keeps a head binding.
+        if (groundedFormula.bindings?.length === aggregate.bindings?.length) {
+            aggregate.bindings?.forEach((binding, index) => {
+                recordGroundedTarget(binding.variable, groundedFormula.bindings?.[index]?.groundedTarget, bindings);
+            });
+        }
+        if (groundedFormula.atoms.length !== aggregate.atoms.length)
+            return;
+        aggregate.atoms.forEach((atom, index) => {
+            collectFormulaBindings(atom, groundedFormula.atoms[index], bindings, predicates);
+        });
+    })
+        .otherwise(() => undefined);
+}
+function recordGroundedTarget(variable, groundedTarget, bindings) {
+    if (!groundedTarget)
+        return;
+    const key = `?${variable}`;
+    if (bindings.has(key))
+        return;
+    bindings.set(key, { value: termText(groundedTarget), term: groundedTarget });
+}
+function objectPredicate(atom) {
+    return match(atom)
+        .with({ type: "property" }, (a) => ({
+        variable: a.object.type === "variable" ? `?${a.object.name}` : undefined,
+        predicate: a.predicate,
+    }))
+        .with({ type: "triple" }, (a) => ({
+        variable: a.object.type === "variable" ? `?${a.object.name}` : undefined,
+        predicate: a.predicate.type === "iri" ? termText(a.predicate) : undefined,
+    }))
+        .otherwise(() => ({}));
+}
+function unifyAtoms(atom, groundedAtom, bindings, predicates) {
+    const { variable: objectVariable, predicate } = objectPredicate(atom);
+    // First-wins, same as `bindings`, so a variable's displayed value and its predicate
+    // (used for measure formatting / PII masking) always come from the same atom.
+    if (objectVariable && predicate && !predicates.has(objectVariable)) {
+        predicates.set(objectVariable, predicate);
+    }
+    const termPairs = match([atom, groundedAtom])
+        .with([{ type: "triple" }, { type: "triple" }], ([raw, grounded]) => [
+        [raw.subject, grounded.subject],
+        [raw.predicate, grounded.predicate],
+        [raw.object, grounded.object],
+    ])
+        .with([{ type: "property" }, { type: "property" }], ([raw, grounded]) => [
+        [raw.subject, grounded.subject],
+        [raw.object, grounded.object],
+    ])
+        .with([{ type: "class" }, { type: "class" }], ([raw, grounded]) => [[raw.instance, grounded.instance]])
+        .with([{ type: "general" }, { type: "general" }], ([raw, grounded]) => raw.terms.map((term, index) => [term, grounded.terms[index]]))
+        .otherwise(() => []);
+    for (const [rawTerm, groundedTerm] of termPairs) {
+        if (!rawTerm || !groundedTerm)
+            continue;
+        if (rawTerm.type === "variable" && groundedTerm.type !== "variable") {
+            const variable = `?${rawTerm.name}`;
+            if (!bindings.has(variable))
+                bindings.set(variable, { value: termText(groundedTerm), term: groundedTerm });
+        }
+    }
+}
+const bareLiteralDatatypes = new Set(["xsd:integer", "xsd:decimal", "xsd:double", "xsd:boolean"]);
+function termText(term) {
+    return match(term)
+        .with({ type: "variable" }, (variable) => `?${variable.name}`)
+        .with({ type: "iri", prefixed: true }, (iri) => iri.value)
+        .with({ type: "iri" }, (iri) => `<${iri.value}>`)
+        .with({ type: "literal", datatype: P.when((datatype) => bareLiteralDatatypes.has(datatype ?? "")) }, (literal) => literal.value)
+        .with({ type: "literal", language: P.string }, (literal) => `"${literal.value}"@${literal.language}`)
+        .with({ type: "literal", datatype: P.string }, (literal) => `"${literal.value}"^^${literal.datatype}`)
+        .with({ type: "literal" }, (literal) => `"${literal.value}"`)
+        .with({ type: "blank" }, (blank) => `_:${blank.label}`)
+        .exhaustive();
+}
+function extractBindFormula(ast, atoms, bindings) {
+    const bindFormula = ast?.body.find((formula) => formula.type === "bind");
+    const bindIndex = ast?.body.findIndex((formula) => formula.type === "bind") ?? -1;
+    if (!ast || bindFormula?.type !== "bind" || bindIndex < 0)
+        return undefined;
+    const atom = atoms[bindIndex];
+    if (!atom)
+        return undefined;
+    const raw = splitComputationTerm(atom.text);
+    const grounded = splitComputationTerm(atom.groundedText);
+    if (!raw)
+        return undefined;
+    const bindingByVariable = new Map(bindings.map((binding) => [binding.variable, binding.value]));
+    const inputs = expressionVariables(bindFormula.expression).map((name) => ({
+        variable: `?${name}`,
+        value: bindingByVariable.get(`?${name}`),
+        atomIndex: boundAtomIndex(ast, name),
+    }));
+    return {
+        index: atom.index,
+        expression: raw.expression,
+        groundedExpression: grounded?.expression ?? raw.expression,
+        result: grounded?.result ?? raw.result,
+        inputs,
+    };
+}
+function expressionVariables(expression) {
+    const names = [];
+    function visit(candidate) {
+        match(candidate)
+            .with({ type: "binary" }, (binary) => {
+            visit(binary.left);
+            visit(binary.right);
+        })
+            .with({ type: "unary" }, (unary) => visit(unary.operand))
+            .with({ type: "function" }, (call) => call.args.forEach(visit))
+            .with({ type: "in" }, (inExpression) => {
+            visit(inExpression.expression);
+            inExpression.list.forEach(visit);
+        })
+            .with({ type: "term", term: { type: "variable" } }, (term) => {
+            if (!names.includes(term.term.name))
+                names.push(term.term.name);
+        })
+            .with({ type: "term" }, () => undefined)
+            .exhaustive();
+    }
+    visit(expression);
+    return names;
+}
+function boundAtomIndex(ast, variableName) {
+    const index = ast.body.findIndex((formula) => match(formula)
+        .with({ type: "property" }, (atom) => isVariableNamed(atom.object, variableName))
+        .with({ type: "triple" }, (atom) => isVariableNamed(atom.object, variableName))
+        .with({ type: "class" }, (atom) => isVariableNamed(atom.instance, variableName))
+        .with({ type: "general" }, (atom) => atom.terms.some((term) => isVariableNamed(term, variableName)))
+        .with({ type: "aggregate" }, (aggregate) => (aggregate.bindings ?? []).some((binding) => binding.variable === variableName))
+        .with({ type: P.union("negation", "filter", "bind", "skolem") }, () => false)
+        .exhaustive());
+    return index >= 0 ? index : undefined;
+}
+function isVariableNamed(term, name) {
+    return term.type === "variable" && term.name === name;
+}
+const computationPrefixPattern = /^(?:BIND|AGGREGATE)\s*\(/i;
+const openingBracketTokens = new Set([LPAREN.name, LBRACKET.name]);
+const closingBracketTokens = new Set([RPAREN.name, RBRACKET.name]);
+function lastTopLevelAsToken(text) {
+    const { tokens } = tokenizeDatalog(text);
+    let depth = 0;
+    let separator;
+    for (const token of tokens) {
+        const name = token.tokenType.name;
+        if (openingBracketTokens.has(name))
+            depth += 1;
+        else if (closingBracketTokens.has(name))
+            depth = Math.max(0, depth - 1);
+        else if (depth === 0 && name === AS.name)
+            separator = token;
+    }
+    return separator;
+}
+export function splitComputationTerm(text) {
+    if (!computationPrefixPattern.test(text))
+        return undefined;
+    const inner = text.replace(computationPrefixPattern, "").replace(/\)\s*$/, "");
+    const separator = lastTopLevelAsToken(inner);
+    if (!separator)
+        return undefined;
+    return {
+        expression: inner.slice(0, separator.startOffset).trim(),
+        result: inner.slice(separator.startOffset + separator.image.length).trim(),
+    };
+}

package/dist/rdfox-explain/tree-model.d.ts

@@ -0,0 +1,76 @@
+import { type DatalogBodyFormula } from "@manta-eu/datalog-parser";
+import { type NarrativeSegment } from "../rules/rule-narrative-format.js";
+export type RDFoxExplainOutput = {
+    [key: string]: RDFoxFact | RDFoxFact[];
+};
+export type RDFoxFact = {
+    fact?: string;
+    type?: "derived" | "explicit" | "false";
+    "rule-instances"?: RDFoxRuleInstance[];
+    [key: string]: unknown;
+};
+export type RDFoxRuleInstance = {
+    rule?: string;
+    "grounded-rule"?: string;
+    "body-facts"?: (string | null)[];
+    [key: string]: unknown;
+};
+export type NormalizedNodeKind = "derived-fact" | "explicit-fact" | "aggregate" | "bind" | "filter" | "negation" | "skolem";
+export type FactProvenance = "explicit" | "derived" | "computed" | "absent";
+export type ExplainDisplayMode = "labels" | "datalog";
+export type RuleInstanceView = {
+    rule?: string;
+    groundedRule?: string;
+    bodyFacts: (string | null)[];
+};
+export type FactSpo = {
+    subject: string;
+    predicate?: string;
+    object: string;
+};
+export type NamedFactSpo = FactSpo & {
+    namedGraph?: string;
+    objectDatatype?: string;
+};
+export declare function isRDFoxExplainOutput(value: unknown): value is RDFoxExplainOutput;
+export type AggregateOutput = {
+    segments: NarrativeSegment[];
+    variable: string;
+    value: string;
+};
+export type NormalizedNode = {
+    id: string;
+    kind: NormalizedNodeKind;
+    display: string;
+    groundedDisplay?: string;
+    rule?: string;
+    groundedRule?: string;
+    parentId: string | null;
+    childIds: string[];
+    bodyIndex?: number;
+    spo?: FactSpo;
+    narrative?: readonly NarrativeSegment[];
+    aggregateOutputs?: AggregateOutput[];
+    skolemTerm?: string;
+    negatedSpo?: FactSpo;
+    provenance?: FactProvenance;
+    supports?: RuleInstanceView[];
+};
+export type NormalizedTree = {
+    root: NormalizedNode;
+    byId: Record<string, NormalizedNode>;
+};
+export declare function isTypeFact(node: NormalizedNode): boolean;
+export declare function isFactNode(node: NormalizedNode): boolean;
+export declare function multipleSupports(node: NormalizedNode): RuleInstanceView[] | undefined;
+export declare function subjectTypeTerm(tree: NormalizedTree, subject: string): string | undefined;
+export declare function consumingRuleNode(tree: NormalizedTree, node: NormalizedNode): NormalizedNode | undefined;
+export declare function buildExplainPath(spo: NamedFactSpo): string;
+export declare function parseFactStatement(text: string): FactSpo | undefined;
+export declare function normalize(output: RDFoxExplainOutput): NormalizedTree | null;
+export declare function ruleHeadText(rule: string): string;
+export declare function ruleHeadTerms(rule: string): string[];
+export declare function getRuleBodyTerms(rule: string): string[];
+export declare function kindForBodyFormula(formula: DatalogBodyFormula): NormalizedNodeKind;
+export declare function kindForSyntheticTerm(term: string): NormalizedNodeKind;
+//# sourceMappingURL=tree-model.d.ts.map

package/dist/rdfox-explain/tree-model.d.ts.map

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