eyeling 1.33.0 → 1.33.2

package/README.md

@@ -631,6 +631,13 @@ Use the CLI option when running `.pl` programs:
 eyeling --engine eyelang examples/eyelang/ancestor.pl
 ```
 
+A paired example shows the same vulnerability-impact scenario in both engines:
+
+```bash
+eyeling examples/vulnerability-impact.n3
+eyeling --engine eyelang examples/eyelang/vulnerability-impact.pl
+```
+
 Use the CommonJS convenience API when the rest of your application already imports `eyeling`:
 
 ```js
@@ -791,7 +798,7 @@ Eyeling provides datatype built-ins in the namespace `https://eyereasoner.github
 
 Supported operations include:
 
-- `dt:datatype`, `dt:lexicalForm`, and `dt:language` for literal inspection;
+- `dt:datatype`, `dt:lexicalForm`, and `dt:language` for literal inspection. `dt:datatype` returns the literal's actual datatype IRI only, so RDF string literals return `xsd:string`; it does not return `rdfs:Literal`, which is a class of literals rather than a datatype IRI;
 - `dt:validForDatatype` and `dt:invalidForDatatype` for lexical validity and datatype membership checks, either as `?literal dt:validForDatatype ?datatype` tests or as tuple-to-boolean checks like `(?literal ?datatype) dt:validForDatatype true`;
 - `dt:sameValueAs` and `dt:differentValueFrom` for value-space equality and inequality;
 - `dt:canonicalLiteral` for canonical literal production.
@@ -1171,6 +1178,7 @@ The repository contains more than two hundred N3 examples under `examples/`, plu
 | `examples/age.n3` | Literal propagation. |
 | `examples/family-cousins.n3` | Multi-hop relational inference. |
 | `examples/dijkstra.n3` | Graph/path reasoning. |
+| `examples/vulnerability-impact.n3` and `examples/eyelang/vulnerability-impact.pl` | Paired N3 and eyelang dependency-risk example. |
 | `examples/list-map.n3` | List processing. |
 | `examples/string-builtins-tests.n3` | String built-ins. |
 | `examples/math-builtins-tests.n3` | Numeric built-ins. |

package/bin/eyeling.cjs

@@ -37,7 +37,7 @@ function normalizeEngineName(value) {
 }
 
 async function runEyelangCli(argv) {
-  const cliUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'eyelang', 'cli.mjs')).href;
+  const cliUrl = pathToFileURL(path.join(__dirname, '..', 'lib', 'eyelang', 'cli.js')).href;
   const cli = await import(cliUrl);
   await cli.main(argv);
 }

package/dist/browser/eyeling.browser.js

@@ -1888,17 +1888,7 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
-    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
-
-    // OWL 2 RL datatype rules often need common string literals to also
-    // participate in generic literal comparisons, while application rules still
-    // ask for their precise datatype explicitly.  When the datatype output is
-    // unbound, expose rdfs:Literal as an additional super-datatype answer for
-    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
-    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
-      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
-    }
-    return out;
+    return evalBindBuiltinObject(g.o, valueTerm, subst);
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {
@@ -6493,7 +6483,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
-      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
+      `      --engine <n3|eyelang>   Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/examples/eyelang/INTEGRATION.md

@@ -6,6 +6,13 @@ This directory contains eyelang examples that can be exercised through Eyeling's
 eyeling --engine eyelang examples/eyelang/ancestor.pl
 ```
 
+For a paired example, compare the N3 and eyelang versions of the same dependency-risk scenario:
+
+```bash
+eyeling examples/vulnerability-impact.n3
+eyeling --engine eyelang examples/eyelang/vulnerability-impact.pl
+```
+
 The eyelang conformance corpus is kept under `test/eyelang/` and can be run with:
 
 ```bash

package/examples/eyelang/README.md

@@ -1,5 +1,8 @@
 # eyelang
 
+[![npm version](https://img.shields.io/npm/v/eyelang.svg)](https://www.npmjs.com/package/eyelang)
+[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.1242549108-blue.svg)](https://doi.org/10.5281/zenodo.20342331)
+
 eyelang is a small rule engine for Prolog-style Horn clauses over ordinary terms, lists, arithmetic, strings, and finite search. The command-line executable is `eyelang`.
 
 Programs write relations directly, for example `ancestor(pat, emma)` or `status(case1, accepted)`. eyelang output is ordinary eyelang syntax: by default, the CLI materializes selected answer facts and prints those facts only. Pass `--proof` (or `-p`) when you also want each answer followed by a `why/2` explanation fact that records the proof. Programs may add `materialize(Name, Arity).` declarations to focus output on selected predicates.
@@ -512,6 +515,7 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`traveling-salesman.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/traveling-salesman.pl) | Finds an optimal traveling-salesman tour. | [`output/traveling-salesman.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/traveling-salesman.pl) |
 | [`turing.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/turing.pl) | Simulates a binary-increment Turing machine. | [`output/turing.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/turing.pl) |
 | [`vector-similarity.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/vector-similarity.pl) | Computes dot product, norm, and cosine similarity. | [`output/vector-similarity.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/vector-similarity.pl) |
+| [`vulnerability-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/vulnerability-impact.pl) | Analyzes vulnerable transitive dependencies and urgent patch impact. | [`output/vulnerability-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/vulnerability-impact.pl) |
 | [`witch.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/witch.pl) | Derives the classic “burn the witch” N3 rule chain. | [`output/witch.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/witch.pl) |
 | [`wolf-goat-cabbage.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/wolf-goat-cabbage.pl) | Solves the wolf-goat-cabbage river crossing. | [`output/wolf-goat-cabbage.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/wolf-goat-cabbage.pl) |
 | [`zebra.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/zebra.pl) | Solves the zebra logic puzzle. | [`output/zebra.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/zebra.pl) |

package/examples/eyelang/output/vulnerability-impact.pl

@@ -0,0 +1,20 @@
+uses(webapp, api).
+uses(worker, queue).
+uses(frontend, ui).
+uses(webapp, auth).
+uses(worker, openssl).
+uses(frontend, css).
+uses(webapp, openssl).
+impacted_by(webapp, api).
+impacted_by(worker, queue).
+impacted_by(frontend, ui).
+impacted_by(webapp, auth).
+impacted_by(worker, openssl).
+impacted_by(frontend, css).
+impacted_by(webapp, openssl).
+risk(worker, high).
+risk(webapp, high).
+mitigate(worker, cve_2026_0001).
+mitigate(webapp, cve_2026_0001).
+urgent_patch(webapp, openssl_3_0_14).
+urgent_patch(worker, openssl_3_0_14).

package/examples/eyelang/vulnerability-impact.pl

@@ -0,0 +1,70 @@
+% Vulnerability impact analysis over a transitive dependency graph.
+%
+% This mirrors examples/vulnerability-impact.n3 using eyelang rules.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(uses, 2).
+materialize(impacted_by, 2).
+materialize(risk, 2).
+materialize(mitigate, 2).
+materialize(urgent_patch, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+service(webapp).
+service(worker).
+service(frontend).
+
+critical(webapp).
+critical(worker).
+
+depends_on(webapp, api).
+depends_on(worker, queue).
+depends_on(frontend, ui).
+depends_on(api, auth).
+depends_on(auth, openssl).
+depends_on(queue, openssl).
+depends_on(ui, css).
+
+vulnerability(openssl, cve_2026_0001).
+cvss(cve_2026_0001, 9.8).
+fixed_by(cve_2026_0001, openssl_3_0_14).
+
+vulnerability(css, cve_2026_0002).
+cvss(cve_2026_0002, 5.4).
+fixed_by(cve_2026_0002, css_2_1_1).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Dependency).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Intermediate),
+  depends_on(Intermediate, Dependency).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Intermediate),
+  depends_on(Intermediate, Next),
+  depends_on(Next, Dependency).
+
+impacted_by(Service, Dependency) :-
+  uses(Service, Dependency).
+
+exposed_to(Service, Vulnerability) :-
+  uses(Service, Package),
+  vulnerability(Package, Vulnerability),
+  cvss(Vulnerability, Score),
+  gt(Score, 7.0).
+
+risk(Service, high) :-
+  exposed_to(Service, _Vulnerability).
+
+mitigate(Service, Vulnerability) :-
+  exposed_to(Service, Vulnerability).
+
+urgent_patch(Service, Patch) :-
+  critical(Service),
+  exposed_to(Service, Vulnerability),
+  fixed_by(Vulnerability, Patch).

package/examples/output/vulnerability-impact.n3

@@ -0,0 +1,22 @@
+@prefix : <https://example.org/vulnerability-impact#> .
+
+:webapp :uses :api .
+:worker :uses :queue .
+:frontend :uses :ui .
+:webapp :uses :auth .
+:worker :uses :openssl .
+:frontend :uses :css .
+:webapp :uses :openssl .
+:worker :risk :high .
+:worker :mitigate :CVE_2026_0001 .
+:webapp :risk :high .
+:webapp :mitigate :CVE_2026_0001 .
+:webapp :urgentPatch :openssl_3_0_14 .
+:worker :urgentPatch :openssl_3_0_14 .
+:webapp :impactedBy :api .
+:worker :impactedBy :queue .
+:frontend :impactedBy :ui .
+:webapp :impactedBy :auth .
+:worker :impactedBy :openssl .
+:frontend :impactedBy :css .
+:webapp :impactedBy :openssl .

package/examples/vulnerability-impact.n3

@@ -0,0 +1,80 @@
+# ===========================================================
+# Vulnerability impact analysis over a transitive dependency graph
+# ===========================================================
+
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://example.org/vulnerability-impact#>.
+
+# Services.
+:webapp a :Service; :critical true; :dependsOn :api.
+:worker a :Service; :critical true; :dependsOn :queue.
+:frontend a :Service; :dependsOn :ui.
+
+# Component dependencies.
+:api :dependsOn :auth.
+:auth :dependsOn :openssl.
+:queue :dependsOn :openssl.
+:ui :dependsOn :css.
+
+# Vulnerability data.
+:openssl :vulnerability :CVE_2026_0001.
+:CVE_2026_0001 :cvss 9.8; :fixedBy :openssl_3_0_14.
+
+:css :vulnerability :CVE_2026_0002.
+:CVE_2026_0002 :cvss 5.4; :fixedBy :css_2_1_1.
+
+# A service uses its direct dependencies and the components they pull in.
+{
+    ?S a :Service.
+    ?S :dependsOn ?D.
+} => {
+    ?S :uses ?D.
+}.
+
+{
+    ?S a :Service.
+    ?S :dependsOn ?M.
+    ?M :dependsOn ?D.
+} => {
+    ?S :uses ?D.
+}.
+
+{
+    ?S a :Service.
+    ?S :dependsOn ?M.
+    ?M :dependsOn ?N.
+    ?N :dependsOn ?D.
+} => {
+    ?S :uses ?D.
+}.
+
+# Materialize the dependency closure for impact review.
+{
+    ?S :uses ?D.
+} => {
+    ?S :impactedBy ?D.
+}.
+
+# A service is high risk when any reachable component has a severe vulnerability.
+{
+    ?S :uses ?Pkg.
+    ?Pkg :vulnerability ?V.
+    ?V :cvss ?Score.
+    ?Score math:greaterThan 7.0.
+} => {
+    ?S :risk :high.
+    ?S :mitigate ?V.
+}.
+
+# Critical services with a severe reachable vulnerability get the available patch first.
+{
+    ?S a :Service.
+    ?S :critical true.
+    ?S :uses ?Pkg.
+    ?Pkg :vulnerability ?V.
+    ?V :cvss ?Score.
+    ?Score math:greaterThan 7.0.
+    ?V :fixedBy ?Patch.
+} => {
+    ?S :urgentPatch ?Patch.
+}.

package/eyeling-builtins.ttl

@@ -45,7 +45,7 @@ ex:aliasOf a rdf:Property .
 # --- dt: datatype ---------------------------------------------------
 
 dt:datatype a ex:Builtin ; ex:kind ex:Function ;
-  rdfs:comment "Extracts the datatype IRI of a literal. Plain RDF string literals return xsd:string; language-tagged strings return rdf:langString; shorthand numeric/boolean literals return their inferred XSD datatype." .
+  rdfs:comment "Extracts the datatype IRI of a literal. Plain RDF string literals return xsd:string; language-tagged strings return rdf:langString; shorthand numeric/boolean literals return their inferred XSD datatype. It returns the literal's actual datatype IRI only; rdfs:Literal is a class and is not returned by dt:datatype." .
 
 dt:lexicalForm a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Extracts the literal lexical form as an xsd:string/plain string value, preserving the original lexical spelling such as leading zeroes." .

package/eyeling.js

@@ -1888,17 +1888,7 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
-    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
-
-    // OWL 2 RL datatype rules often need common string literals to also
-    // participate in generic literal comparisons, while application rules still
-    // ask for their precise datatype explicitly.  When the datatype output is
-    // unbound, expose rdfs:Literal as an additional super-datatype answer for
-    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
-    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
-      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
-    }
-    return out;
+    return evalBindBuiltinObject(g.o, valueTerm, subst);
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {
@@ -6493,7 +6483,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
-      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
+      `      --engine <n3|eyelang>   Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/index.js

@@ -85,7 +85,7 @@ function reasonEyelangSync(opt = {}, input = '') {
 }
 
 async function loadEyelangModule() {
-  return import(pathToFileURL(path.join(__dirname, 'lib', 'eyelang', 'index.mjs')).href);
+  return import(pathToFileURL(path.join(__dirname, 'lib', 'eyelang', 'index.js')).href);
 }
 
 async function runEyelang(input = '', opt = {}) {

package/lib/builtins.js

@@ -1877,17 +1877,7 @@ function evalDatatypeInspectionBuiltin(g, subst, kind) {
     const dt = literalDatatypeIri(g.s);
     if (dt === null) return [];
     valueTerm = internIri(dt);
-    const out = evalBindBuiltinObject(g.o, valueTerm, subst);
-
-    // OWL 2 RL datatype rules often need common string literals to also
-    // participate in generic literal comparisons, while application rules still
-    // ask for their precise datatype explicitly.  When the datatype output is
-    // unbound, expose rdfs:Literal as an additional super-datatype answer for
-    // xsd:string and rdf:langString; bound-object calls remain strictly exact.
-    if (g.o instanceof Var && (dt === XSD_STRING_DT || dt === RDF_LANGSTRING_DT)) {
-      out.push(...evalBindBuiltinObject(g.o, internIri(RDFS_LITERAL_DT), subst));
-    }
-    return out;
+    return evalBindBuiltinObject(g.o, valueTerm, subst);
   } else if (kind === 'lexicalForm') {
     valueTerm = makeStringLiteral(literalLexicalValue(g.s.value));
   } else if (kind === 'language') {

package/lib/cli.js

@@ -805,7 +805,7 @@ async function main() {
       `Options:\n` +
       `  -a, --ast                    Print parsed AST as JSON and exit.\n` +
       `      --builtin <module.js>    Load a custom builtin module (repeatable).\n` +
-      `      --engine <n3|eyelang>    Select the N3 engine (default) or eyelang engine.\n` +
+      `      --engine <n3|eyelang>   Select the N3 engine (default) or eyelang engine.\n` +
       `  -d, --deterministic-skolem   Make log:skolem stable across reasoning runs.\n` +
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +

package/lib/eyelang/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-import('./cli.mjs').then(({ main }) => main(process.argv.slice(2))).catch((error) => {
+import('./cli.js').then(({ main }) => main(process.argv.slice(2))).catch((error) => {
   console.error(`eyelang: ${error && error.message ? error.message : String(error)}`);
   process.exit(1);
 });

package/lib/eyelang/builtins/{aggregation.mjs → aggregation.js}

@@ -1,6 +1,6 @@
 // Aggregation builtins that run a inner goal and collect, count, sum, or select the best answers.
 // Each handler clones the solver so the inner goal can enumerate independently of the outer goal.
-import { compareTerms, copyResolved, isDecimalInteger, lexicalValue, listFromItems, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.mjs';
+import { compareTerms, copyResolved, isDecimalInteger, lexicalValue, listFromItems, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.js';
 
 export const aggregationBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{alphametic.mjs → alphametic.js}

@@ -2,7 +2,7 @@
 // It evaluates column constraints right-to-left, so examples such as
 // SEND+MORE=MONEY and DONALD+GERALD=ROBERT do not need to express digit search
 // with many relational select/3 and arithmetic goals.
-import { atom, deref, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
+import { atom, deref, listFromItems, numberTerm, properListItems, unify } from '../term.js';
 
 export const alphameticBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{arithmetic.mjs → arithmetic.js}

@@ -1,6 +1,6 @@
 // Numeric builtins for integer-preserving arithmetic, floating point functions, comparisons, and ranges.
 // The code keeps BigInt paths where possible so large eyelang integers remain exact.
-import { compareIntegerText, deref, isDecimalInteger, lexicalValue, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.mjs';
+import { compareIntegerText, deref, isDecimalInteger, lexicalValue, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.js';
 
 const unaryNames = ['neg', 'abs', 'sin', 'cos', 'asin', 'acos', 'rounded', 'log'];
 const binaryNames = ['add', 'sub', 'mul', 'div', 'mod', 'max', 'min', 'pow'];

package/lib/eyelang/builtins/{core.mjs → core.js}

@@ -1,6 +1,6 @@
 // Core relational builtins that do not naturally belong to arithmetic, strings, lists, or aggregation.
 // They are deterministic filters/projections and should avoid enumerating additional answers.
-import { stringTerm, lexicalValue, unify } from '../term.mjs';
+import { stringTerm, lexicalValue, unify } from '../term.js';
 
 function* ok(env) { yield env; }
 

package/lib/eyelang/builtins/{formula.mjs → formula.js}

@@ -1,6 +1,6 @@
 // Formula builtins that treat conjunctions as first-class data terms.
 // These are used by examples that construct or inspect rule bodies programmatically.
-import { atom, deref, isConjunction, unify } from '../term.mjs';
+import { atom, deref, isConjunction, unify } from '../term.js';
 
 export const formulaBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{lists.mjs → lists.js}

@@ -1,6 +1,6 @@
 // List builtins for proper lists, selection, membership, sorting, and indexing.
 // Several predicates support both checking and generation, so the argument modes are handled explicitly.
-import { compareTerms, copyResolved, deref, isCons, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
+import { compareTerms, copyResolved, deref, isCons, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.js';
 
 export const listBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{matrix.mjs → matrix.js}

@@ -1,7 +1,7 @@
 // Small dense-matrix arithmetic builtins.
 // These are reusable numeric kernels for ground matrices; when arguments are not
 // ground proper numeric lists, user-defined matrix predicates remain available.
-import { deref, isDecimalInteger, listFromItems, numberTerm, numberTextFromDouble, parseFiniteNumber, properListItems, unify } from '../term.mjs';
+import { deref, isDecimalInteger, listFromItems, numberTerm, numberTextFromDouble, parseFiniteNumber, properListItems, unify } from '../term.js';
 
 export const matrixBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{n3.mjs → n3.js}

@@ -2,10 +2,10 @@
 // RDF parser lowers body triples with math:, string:, list:, crypto:, time:, and
 // selected log: predicates to n3_* eyelang builtins.  The handlers work on the
 // explicit RDF term representation from src/rdf.js.
-import { hashHex } from '../hash.mjs';
-import { compareLexicalOrNumeric } from './arithmetic.mjs';
-import { deref, isDecimalInteger, listFromItems, parseFiniteNumber, properListItems, termToString, unify } from '../term.mjs';
-import { RDF_DIR_LANG_STRING, RDF_LANG_STRING, XSD_BOOLEAN, XSD_DECIMAL, XSD_DOUBLE, XSD_INTEGER, XSD_STRING, rdfIri, rdfLiteral } from '../rdf.mjs';
+import { hashHex } from '../hash.js';
+import { compareLexicalOrNumeric } from './arithmetic.js';
+import { deref, isDecimalInteger, listFromItems, parseFiniteNumber, properListItems, termToString, unify } from '../term.js';
+import { RDF_DIR_LANG_STRING, RDF_LANG_STRING, XSD_BOOLEAN, XSD_DECIMAL, XSD_DOUBLE, XSD_INTEGER, XSD_STRING, rdfIri, rdfLiteral } from '../rdf.js';
 
 const XSD_NS = 'http://www.w3.org/2001/XMLSchema#';
 const XSD_DATE_TIME = `${XSD_NS}dateTime`;

package/lib/eyelang/builtins/{number-theory.mjs → number-theory.js}

@@ -2,7 +2,7 @@
 // arithmetic algorithms with many small recursive rule calls.
 // The predicates are intentionally general: extended GCD, Collatz trajectories,
 // Kaprekar iteration counts, and Goldbach pair generation.
-import { deref, listFromItems, numberTerm, unify } from '../term.mjs';
+import { deref, listFromItems, numberTerm, unify } from '../term.js';
 
 export const numberTheoryBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{portfolio.mjs → portfolio.js}

@@ -1,7 +1,7 @@
 // Reusable bounded-subset optimizer for finite knapsack-style examples.
 // Items are p(Name, Value, Cost, Risk) terms; the builtin enumerates every
 // subset whose total cost/risk stays within the supplied caps.
-import { deref, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
+import { deref, listFromItems, numberTerm, properListItems, unify } from '../term.js';
 
 export const portfolioBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{registry.mjs → registry.js}

@@ -1,19 +1,19 @@
 // Registry for builtins and their execution metadata.
 // The solver uses the metadata to know when a builtin is deterministic, mode-ready, or should fall back to user clauses.
-import { arithmeticBuiltins } from './arithmetic.mjs';
-import { coreBuiltins } from './core.mjs';
-import { stringBuiltins } from './strings.mjs';
-import { listBuiltins } from './lists.mjs';
-import { aggregationBuiltins } from './aggregation.mjs';
-import { formulaBuiltins } from './formula.mjs';
-import { controlBuiltins } from './control.mjs';
-import { sudokuBuiltins } from './sudoku.mjs';
-import { portfolioBuiltins } from './portfolio.mjs';
-import { searchBuiltins } from './search.mjs';
-import { numberTheoryBuiltins } from './number-theory.mjs';
-import { matrixBuiltins } from './matrix.mjs';
-import { alphameticBuiltins } from './alphametic.mjs';
-import { n3Builtins } from './n3.mjs';
+import { arithmeticBuiltins } from './arithmetic.js';
+import { coreBuiltins } from './core.js';
+import { stringBuiltins } from './strings.js';
+import { listBuiltins } from './lists.js';
+import { aggregationBuiltins } from './aggregation.js';
+import { formulaBuiltins } from './formula.js';
+import { controlBuiltins } from './control.js';
+import { sudokuBuiltins } from './sudoku.js';
+import { portfolioBuiltins } from './portfolio.js';
+import { searchBuiltins } from './search.js';
+import { numberTheoryBuiltins } from './number-theory.js';
+import { matrixBuiltins } from './matrix.js';
+import { alphameticBuiltins } from './alphametic.js';
+import { n3Builtins } from './n3.js';
 
 export class BuiltinRegistry {
   constructor() {

package/lib/eyelang/builtins/{search.mjs → search.js}

@@ -2,8 +2,8 @@
 // of their time in small relational generators.  These predicates are generic
 // entry points (graph, CNF, QMC, range, and n-queens helpers), not compiled
 // replacements for particular example predicate names.
-import { atom, compound, deref, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
-import { compareLexicalOrNumeric } from './arithmetic.mjs';
+import { atom, compound, deref, listFromItems, numberTerm, properListItems, unify } from '../term.js';
+import { compareLexicalOrNumeric } from './arithmetic.js';
 
 export const searchBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{strings.mjs → strings.js}

@@ -1,6 +1,6 @@
 // String and atom conversion builtins.
 // They mostly project from already-ground terms to avoid guessing string domains.
-import { atom, lexicalValue, stringTerm, unify } from '../term.mjs';
+import { atom, lexicalValue, stringTerm, unify } from '../term.js';
 
 export const stringBuiltins = {
   register(registry) {

package/lib/eyelang/builtins/{sudoku.mjs → sudoku.js}

@@ -1,6 +1,6 @@
 // Sudoku-specific helpers used by the example suite.
 // The cover9/1 optimization prunes invalid row blocks early while leaving the declarative fallback available.
-import { deref, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.mjs';
+import { deref, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.js';
 
 export const sudokuBuiltins = {
   register(registry) {

package/lib/eyelang/{cli.mjs → cli.js}

@@ -87,10 +87,10 @@ export async function main(argv) {
 async function loadEngine() {
   if (engineModule == null) {
     const [term, program, solver, registry] = await Promise.all([
-      import('./term.mjs'),
-      import('./program.mjs'),
-      import('./solver.mjs'),
-      import('./builtins/registry.mjs'),
+      import('./term.js'),
+      import('./program.js'),
+      import('./solver.js'),
+      import('./builtins/registry.js'),
     ]);
     engineModule = { ...term, ...program, ...solver, ...registry };
   }
@@ -98,7 +98,7 @@ async function loadEngine() {
 }
 
 async function loadExplanation() {
-  if (explanationModule == null) explanationModule = await import('./explain.mjs');
+  if (explanationModule == null) explanationModule = await import('./explain.js');
   return explanationModule;
 }
 

package/lib/eyelang/{explain.mjs → explain.js}

@@ -2,10 +2,10 @@
 // The explanation printer replays a successful goal against the program and emits
 // ordinary eyelang facts with nested proof terms.  Explanations are therefore both
 // human-readable and machine-readable.
-import { COMPOUND, Env, Term, VAR, deref, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.mjs';
-import { selectClauseCandidates } from './program.mjs';
-import { createDefaultRegistry } from './builtins/registry.mjs';
-import { Solver, nextFreshId } from './solver.mjs';
+import { COMPOUND, Env, Term, VAR, deref, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
+import { selectClauseCandidates } from './program.js';
+import { createDefaultRegistry } from './builtins/registry.js';
+import { Solver, nextFreshId } from './solver.js';
 
 export function whyProof(program, goal, options = {}) {
   const maxDepth = options.maxDepth ?? 256;

package/lib/eyelang/{index.mjs → index.js}

@@ -1,17 +1,17 @@
 // Public JavaScript API surface for embedders and the browser playground.
 // The CLI imports the same parser, program, solver, and term primitives from here.
-export { Program, makeProgram } from './program.mjs';
-export { parseClauses, parseProgramText } from './parser.mjs';
-export { parseRdfClauses, rdfToEyelang, clausesToEyelang, rdfIri, rdfBlank, rdfLiteral, rdfTripleTerm, rdfGoal } from './rdf.mjs';
-export { Solver } from './solver.mjs';
-export * from './term.mjs';
-export { BuiltinRegistry, createDefaultRegistry, getDefaultRegistry } from './builtins/registry.mjs';
+export { Program, makeProgram } from './program.js';
+export { parseClauses, parseProgramText } from './parser.js';
+export { parseRdfClauses, rdfToEyelang, clausesToEyelang, rdfIri, rdfBlank, rdfLiteral, rdfTripleTerm, rdfGoal } from './rdf.js';
+export { Solver } from './solver.js';
+export * from './term.js';
+export { BuiltinRegistry, createDefaultRegistry, getDefaultRegistry } from './builtins/registry.js';
 
-import { Env, copyResolved, termIsGround, termToString } from './term.mjs';
-import { Program } from './program.mjs';
-import { Solver } from './solver.mjs';
-import { whyNoProof, whyProof } from './explain.mjs';
-import { getDefaultRegistry } from './builtins/registry.mjs';
+import { Env, copyResolved, termIsGround, termToString } from './term.js';
+import { Program } from './program.js';
+import { Solver } from './solver.js';
+import { whyNoProof, whyProof } from './explain.js';
+import { getDefaultRegistry } from './builtins/registry.js';
 
 export function run(source, options = {}) {
   const includeWhy = options.proof === true || options.why === true || options.explain === true;
@@ -45,4 +45,4 @@ function appendExplanation(output, program, resolved, registry) {
   if (!proof.ok) output.push(whyNoProof(resolved));
 }
 
-export * from './explain.mjs';
+export * from './explain.js';

package/lib/eyelang/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/lib/eyelang/{parser.mjs → parser.js}

@@ -1,6 +1,6 @@
 // Tokenizer and recursive-descent parser for the eyelang source language.
 // It preserves the compact Prolog-like syntax while producing Term objects for the solver.
-import { atom, compound, cons, emptyList, numberTerm, stringTerm, variable } from './term.mjs';
+import { atom, compound, cons, emptyList, numberTerm, stringTerm, variable } from './term.js';
 
 const TOK = {
   EOF: 'eof', ATOM: 'atom', VAR: 'var', STRING: 'string', NUMBER: 'number',

package/lib/eyelang/{program.mjs → program.js}

@@ -1,8 +1,8 @@
 // Program representation and clause indexing.
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
-import { ATOM, COMPOUND, Env, compound, deref, flattenConjunction, isScalar, termToString } from './term.mjs';
-import { parseClauses } from './parser.mjs';
-import { filenameLooksRdf, parseRdfClauses } from './rdf.mjs';
+import { ATOM, COMPOUND, Env, compound, deref, flattenConjunction, isScalar, termToString } from './term.js';
+import { parseClauses } from './parser.js';
+import { filenameLooksRdf, parseRdfClauses } from './rdf.js';
 
 export class Program {
   constructor(clauses = [], options = {}) {

package/lib/eyelang/{rdf.mjs → rdf.js}

@@ -17,7 +17,7 @@
 // N3 rules of the form `{ ... } => { ... } .` become Horn clauses whose heads
 // and bodies are rdf/3 goals.  RDF 1.2 reified triples and annotation syntax are
 // expanded to rdf:reifies triples.
-import { atom, compound, listFromItems, numberTerm, stringTerm, termToString, variable } from './term.mjs';
+import { atom, compound, listFromItems, numberTerm, stringTerm, termToString, variable } from './term.js';
 
 const TOKEN = {
   EOF: 'eof', IRI: 'iri', STRING: 'string', NUMBER: 'number', NAME: 'name', BNODE: 'bnode', VAR: 'var', LANG: 'lang', ATWORD: 'atword',

package/lib/eyelang/{solver.mjs → solver.js}

@@ -1,8 +1,8 @@
 // Depth-first eyelang solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
-import { COMPOUND, Env, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.mjs';
-import { createDefaultRegistry } from './builtins/registry.mjs';
-import { selectClauseCandidates } from './program.mjs';
+import { COMPOUND, Env, flattenConjunction, freshTerm, termToString, unify, variantTerms } from './term.js';
+import { createDefaultRegistry } from './builtins/registry.js';
+import { selectClauseCandidates } from './program.js';
 
 let freshCounter = 0;
 
@@ -234,4 +234,4 @@ function importResolved(term, env) {
 }
 
 // Avoid circular import surprises in older Node loaders.
-import * as termModuleCache from './term.mjs';
+import * as termModuleCache from './term.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.33.0",
+  "version": "1.33.2",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -87,8 +87,8 @@
     "./package.json": "./package.json",
     "./eyelang": {
       "types": "./eyelang.d.ts",
-      "import": "./lib/eyelang/index.mjs",
-      "default": "./lib/eyelang/index.mjs"
+      "import": "./lib/eyelang/index.js",
+      "default": "./lib/eyelang/index.js"
     }
   },
   "typesVersions": {

package/test/builtins.test.js

@@ -199,7 +199,6 @@ const cases = [
 { "11"^^xsd:integer dt:differentValueFrom "12"^^xsd:integer . } => { :different :numeric true } .
 { "hello@en"^^rdf:PlainLiteral dt:differentValueFrom "bye@en"^^rdf:PlainLiteral . } => { :different :plainLiteral true } .
 { "a" dt:differentValueFrom "b" . } => { :different :string true } .
-{ "a" dt:datatype ?sd . ?sd <http://www.w3.org/2000/10/swap/log#notEqualTo> xsd:string . } => { :string :comparisonDatatype ?sd } .
 { "<a/>"^^rdf:XMLLiteral dt:differentValueFrom "<b/>"^^rdf:XMLLiteral . } => { :different :xmlLiteral true } .
 
 { ("1"^^xsd:integer xsd:integer) dt:validForDatatype true . } => { :tuple :valid true } .
@@ -252,7 +251,6 @@ const cases = [
       assert.match(out, /:different :numeric true \./);
       assert.match(out, /:different :plainLiteral true \./);
       assert.match(out, /:different :string true \./);
-      assert.match(out, /:string :comparisonDatatype rdfs:Literal \./);
       assert.match(out, /:different :xmlLiteral true \./);
       assert.match(out, /:tuple :valid true \./);
       assert.match(out, /:tuple :invalidBoolean true \./);
@@ -265,6 +263,21 @@ const cases = [
       assert.match(out, /:canonical :dateTime "2026-06-10T12:00:00Z"\^\^xsd:dateTime \./);
       assert.match(out, /:canonical :midnightRollover "2027-01-01T00:00:00Z"\^\^xsd:dateTime \./);
       assert.match(out, /:sameAs :reflexive true \./);
+
+      const datatypeOut = runReason(`
+@prefix : <http://example.org/datatype-tests#> .
+@prefix dt: <https://eyereasoner.github.io/eyeling/datatype#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+:s :plainName "Alice" .
+:s :typedName "Alice"^^xsd:string .
+{ :s :plainName ?value . ?value dt:datatype ?datatype . } => { :plain :detectedDatatype ?datatype } .
+{ :s :typedName ?value . ?value dt:datatype ?datatype . } => { :typed :detectedDatatype ?datatype } .
+`);
+      assert.match(datatypeOut, /:plain :detectedDatatype xsd:string \./);
+      assert.match(datatypeOut, /:typed :detectedDatatype xsd:string \./);
+      assert.doesNotMatch(datatypeOut, /:plain :detectedDatatype rdfs:Literal \./);
+      assert.doesNotMatch(datatypeOut, /:typed :detectedDatatype rdfs:Literal \./);
     },
   },
   {

package/test/eyelang/run-conformance.mjs

@@ -4,7 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { Program, run } from '../../lib/eyelang/index.mjs';
+import { Program, run } from '../../lib/eyelang/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule } from './test-style.mjs';
 

package/test/eyelang/run-examples.mjs

@@ -4,7 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { Program, run } from '../../lib/eyelang/index.mjs';
+import { Program, run } from '../../lib/eyelang/index.js';
 import { fileURLToPath } from 'node:url';
 import { TestReporter, isMainModule } from './test-style.mjs';
 

package/test/eyelang/run-regression.mjs

@@ -31,11 +31,11 @@ import {
   variantTerms,
   parseProgramText,
   rdfToEyelang,
-} from '../../lib/eyelang/index.mjs';
-import { parseGoalText } from '../../lib/eyelang/parser.mjs';
-import { selectClauseCandidates } from '../../lib/eyelang/program.mjs';
+} from '../../lib/eyelang/index.js';
+import { parseGoalText } from '../../lib/eyelang/parser.js';
+import { selectClauseCandidates } from '../../lib/eyelang/program.js';
 import { TestReporter, isMainModule } from './test-style.mjs';
-import { hashHex } from '../../lib/eyelang/hash.mjs';
+import { hashHex } from '../../lib/eyelang/hash.js';
 
 const testRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
 const packageRoot = path.resolve(testRoot, '..', '..');

package/test/eyelang/test-style.mjs

@@ -1,17 +1,20 @@
 // Shared test output helpers.
 // The runners use this small reporter so individual suites and `npm test` share
-// one compact, Eyesharl-like style with a continuous grey test number.
+// one compact Eyeling-style layout: colored OK/FAIL, sequence number, test description, and dimmed timing.
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 
-const useColor = Boolean(process.stdout.isTTY) && process.env.NO_COLOR == null;
+const useColor = process.env.NO_COLOR == null && (
+  Boolean(process.stdout.isTTY) ||
+  Boolean(process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0')
+);
 
 export const colors = {
   green: useColor ? '\x1b[32m' : '',
   red: useColor ? '\x1b[31m' : '',
   yellow: useColor ? '\x1b[33m' : '',
-  grey: useColor ? '\x1b[90m' : '',
+  dim: useColor ? '\x1b[2m' : '',
   reset: useColor ? '\x1b[0m' : '',
 };
 
@@ -45,7 +48,7 @@ export class TestReporter {
     const total = this.total - this.currentSection.totalAtStart;
     const ms = nowMs() - this.currentSection.startedAt;
     const suite = label ?? defaultSectionLabel(this.currentSection.name);
-    this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests passed ${colors.grey}(${ms} ms)${colors.reset}\n`);
+    this.stdout.write(`${colors.green}OK${colors.reset} ${ok}/${total} ${suite} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }
 
   test(name, run) {
@@ -57,10 +60,10 @@ export class TestReporter {
       run();
       const ms = nowMs() - startedAt;
       this.ok++;
-      this.stdout.write(`${colors.grey}${nr}${colors.reset} ${colors.green}OK${colors.reset} ${name} ${colors.grey}(${ms} ms)${colors.reset}\n`);
+      this.stdout.write(`${colors.green}OK${colors.reset} ${nr} ${name} ${colors.dim}(${ms} ms)${colors.reset}\n`);
     } catch (error) {
       const ms = nowMs() - startedAt;
-      this.stderr.write(`${colors.grey}${nr}${colors.reset} ${colors.red}FAIL${colors.reset} ${name} ${colors.grey}(${ms} ms)${colors.reset}\n`);
+      this.stderr.write(`${colors.red}FAIL${colors.reset} ${nr} ${name} ${colors.dim}(${ms} ms)${colors.reset}\n`);
       this.stderr.write(`${error?.stack ?? String(error)}\n`);
       throw error;
     }
@@ -69,7 +72,7 @@ export class TestReporter {
   totalLine() {
     const ms = nowMs() - this.startedAt;
     this.stdout.write(`\n${colors.yellow}== Total${colors.reset}\n`);
-    this.stdout.write(`${colors.green}OK${colors.reset} ${this.ok}/${this.total} tests passed ${colors.grey}(${ms} ms)${colors.reset}\n`);
+    this.stdout.write(`${colors.green}OK${colors.reset} ${this.ok}/${this.total} tests passed ${colors.dim}(${ms} ms)${colors.reset}\n`);
   }
 }
 

package/test/eyelang.test.js

@@ -47,7 +47,7 @@ out(X) :- in(X).
   assert.match(directCli.stdout, /ancestor\(jan, emma\)\./);
 
   // Sanity check the ESM file URL too; this catches nested package type regressions.
-  const esm = await import(pathToFileURL(`${process.cwd()}/lib/eyelang/index.mjs`).href);
+  const esm = await import(pathToFileURL(`${process.cwd()}/lib/eyelang/index.js`).href);
   assert.equal(typeof esm.Program, 'function');
 
   pass(1, 'eyelang second-engine integration passed', Date.now() - startedAt);

package/test/run.js

@@ -5,57 +5,206 @@ const cp = require('node:child_process');
 
 const { C, formatDuration } = require('./report');
 
+const node = process.execPath;
+
+// Run test files directly instead of through `npm run …`. This keeps the
+// output in the compact Eyeling reporter style and avoids npm's script banners
+// between the colored OK/FAIL test lines.
 const sections = [
-  ['Build bundle', 'npm', ['run', 'build']],
-  ['Packlist checks', 'npm', ['run', 'test:packlist']],
-  ['API tests', 'npm', ['run', 'test:api']],
-  ['Streaming RDF Messages tests', 'npm', ['run', 'test:stream-messages']],
-  ['Builtin contract tests', 'npm', ['run', 'test:builtins']],
-  ['Store tests', 'npm', ['run', 'test:store']],
-  ['Examples tests', 'npm', ['run', 'test:examples']],
-  ['Proof examples tests', 'npm', ['run', 'test:examples:proof']],
-  ['Manifest tests', 'npm', ['run', 'test:manifest']],
-  ['RDF 1.2 syntax tests', 'npm', ['run', 'test:rdf12']],
-  ['Playground tests', 'npm', ['run', 'test:playground']],
-  ['Eyelang second-engine tests', 'npm', ['run', 'test:eyelang']],
-  ['Package tests', 'npm', ['run', 'test:package']],
+  ['Build bundle', node, ['tools/bundle.js']],
+  ['Packlist checks', node, ['test/packlist.test.js']],
+  ['API tests', node, ['test/api.test.js']],
+  ['Streaming RDF Messages tests', node, ['test/stream_messages.test.js']],
+  ['Builtin contract tests', node, ['test/builtins.test.js']],
+  ['Store tests', node, ['test/store.test.js']],
+  ['Examples tests', node, ['test/examples.test.js']],
+  ['Proof examples tests', node, ['test/examples.test.js', '--proof-only']],
+  ['Manifest tests', node, ['test/manifest.test.js']],
+  ['RDF 1.2 syntax tests', node, ['test/rdf12.test.js']],
+  ['Playground tests', node, ['test/playground.test.js']],
+  ['Eyelang second-engine tests', node, ['test/eyelang.test.js']],
+  ['Eyelang corpus tests', node, ['test/eyelang/run-all.mjs']],
+  ['Package tests', node, ['test/package.test.js']],
 ];
 
+const aggregate = {
+  total: 0,
+  ok: 0,
+  incomplete: 0,
+  nonconform: 0,
+  crashed: 0,
+};
+
 function sectionLine(kind, label, ms) {
   const suffix = typeof ms === 'number' ? ` (${formatDuration(ms)})` : '';
   console.log(`${C.y}==${C.n} ${kind} ${label}${suffix}`);
 }
 
+function stripAnsi(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function makeSectionSummary() {
+  return {
+    // Normal Eyeling tests use report.js: "OK 001 ..." / "FAIL 001 ...".
+    reportOk: 0,
+    reportFail: 0,
+    // Older corpus runners used: "1 OK ..." / "1 FAIL ...". Keep
+    // parsing that shape so aggregate totals remain robust across local runs.
+    numberedOk: 0,
+    numberedFail: 0,
+    // notation3tests prints a suite-level line with the real manifest count.
+    manifestTotal: null,
+  };
+}
+
+function parseLineForSummary(rawLine, summary) {
+  const line = stripAnsi(rawLine).trimEnd();
+  if (!line) return;
+
+  if (/^OK\s+\d{3}\s/.test(line)) {
+    summary.reportOk++;
+    return;
+  }
+  if (/^FAIL\s+\d{3}\s/.test(line)) {
+    summary.reportFail++;
+    return;
+  }
+  if (/^\d+\s+OK\s+/.test(line)) {
+    summary.numberedOk++;
+    return;
+  }
+  if (/^\d+\s+FAIL\s+/.test(line)) {
+    summary.numberedFail++;
+    return;
+  }
+
+  const manifest = line.match(
+    /^TOTAL\s+\[COUNT:(\d+)\]\s+OK:\s*[^0-9]*(\d+)[^0-9]+INCOMPLETE:\s*[^0-9]*(\d+)[^0-9]+NONCONFORM:\s*[^0-9]*(\d+)[^0-9]+CRASHED:\s*[^0-9]*(\d+)/,
+  );
+  if (manifest) {
+    summary.manifestTotal = {
+      count: Number(manifest[1]),
+      ok: Number(manifest[2]),
+      incomplete: Number(manifest[3]),
+      nonconform: Number(manifest[4]),
+      crashed: Number(manifest[5]),
+    };
+  }
+}
+
+function makeStreamingParser(summary) {
+  let buffer = '';
+  return {
+    feed(chunk) {
+      buffer += String(chunk);
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || '';
+      for (const line of lines) parseLineForSummary(line, summary);
+    },
+    finish() {
+      if (buffer) parseLineForSummary(buffer, summary);
+      buffer = '';
+    },
+  };
+}
+
+function addSectionToAggregate(summary) {
+  if (summary.manifestTotal) {
+    aggregate.total += summary.manifestTotal.count;
+    aggregate.ok += summary.manifestTotal.ok;
+    aggregate.incomplete += summary.manifestTotal.incomplete;
+    aggregate.nonconform += summary.manifestTotal.nonconform;
+    aggregate.crashed += summary.manifestTotal.crashed;
+    return;
+  }
+
+  const ok = summary.reportOk + summary.numberedOk;
+  const failed = summary.reportFail + summary.numberedFail;
+  aggregate.total += ok + failed;
+  aggregate.ok += ok;
+  aggregate.nonconform += failed;
+}
+
+function scoreLine() {
+  const score = aggregate.total === 0 ? 0 : (100 * aggregate.ok) / aggregate.total;
+  return `TOTAL [COUNT:${aggregate.total}] OK: ⭐${aggregate.ok}⭐ INCOMPLETE: ⭐${aggregate.incomplete}⭐ NONCONFORM: ⭐${aggregate.nonconform}⭐ CRASHED: ⭐${aggregate.crashed}⭐ => SCORE: ⭐⭐⭐${score.toFixed(1)}⭐⭐⭐`;
+}
+
+function childEnv() {
+  const env = { ...process.env };
+  if (!env.NO_COLOR && C.g && !env.FORCE_COLOR) env.FORCE_COLOR = '1';
+  return env;
+}
+
 function runSection(label, cmd, args) {
   console.log('');
   sectionLine('Start', label);
   const startedAt = Date.now();
-  const r = cp.spawnSync(cmd, args, {
-    cwd: process.cwd(),
-    env: process.env,
-    shell: process.platform === 'win32',
-    stdio: 'inherit',
+  const summary = makeSectionSummary();
+  const stdoutParser = makeStreamingParser(summary);
+  const stderrParser = makeStreamingParser(summary);
+
+  return new Promise((resolve) => {
+    const child = cp.spawn(cmd, args, {
+      cwd: process.cwd(),
+      env: childEnv(),
+      shell: process.platform === 'win32',
+      stdio: ['inherit', 'pipe', 'pipe'],
+    });
+
+    child.stdout.on('data', (chunk) => {
+      stdoutParser.feed(chunk);
+      process.stdout.write(chunk);
+    });
+    child.stderr.on('data', (chunk) => {
+      stderrParser.feed(chunk);
+      process.stderr.write(chunk);
+    });
+
+    child.on('error', (err) => {
+      stdoutParser.finish();
+      stderrParser.finish();
+      addSectionToAggregate(summary);
+      aggregate.total++;
+      aggregate.crashed++;
+      const elapsed = Date.now() - startedAt;
+      console.error(`${C.r}FAIL${C.n} ${label}: ${err.message || String(err)}`);
+      sectionLine('End', `${label} failed`, elapsed);
+      console.log('');
+      resolve(1);
+    });
+
+    child.on('close', (code, signal) => {
+      stdoutParser.finish();
+      stderrParser.finish();
+      addSectionToAggregate(summary);
+      const elapsed = Date.now() - startedAt;
+      const status = typeof code === 'number' ? code : 1;
+      if (status !== 0 && summary.reportFail + summary.numberedFail === 0 && !summary.manifestTotal) {
+        aggregate.total++;
+        aggregate.crashed++;
+      }
+      const suffix = signal ? ` (${signal})` : '';
+      sectionLine('End', status === 0 ? `${label} passed` : `${label} failed${suffix}`, elapsed);
+      console.log('');
+      resolve(status);
+    });
   });
-  const elapsed = Date.now() - startedAt;
-  if (r.error) {
-    console.error(`${C.r}FAIL${C.n} ${label}: ${r.error.message || String(r.error)}`);
-    sectionLine('End', `${label} failed`, elapsed);
-    console.log('');
-    return 1;
-  }
-  const status = typeof r.status === 'number' ? r.status : 1;
-  sectionLine('End', status === 0 ? `${label} passed` : `${label} failed`, elapsed);
-  console.log('');
-  return status;
 }
 
-let status = 0;
-for (const [label, cmd, args] of sections) {
-  const sectionStatus = runSection(label, cmd, args);
-  if (sectionStatus !== 0) {
-    status = sectionStatus;
-    break;
+(async function main() {
+  let status = 0;
+  for (const [label, cmd, args] of sections) {
+    const sectionStatus = await runSection(label, cmd, args);
+    if (sectionStatus !== 0) {
+      status = sectionStatus;
+      break;
+    }
   }
-}
 
-process.exit(status);
+  console.log('');
+  console.log(scoreLine());
+
+  process.exit(status);
+})();