eyeling 1.12.6 → 1.12.7

package/HANDBOOK.md

@@ -893,6 +893,12 @@ These are “function-like” relations where the subject is usually a list and
 - Computes the numeric sum.
 - Chooses an output datatype based on the “widest” numeric datatype seen among inputs and (optionally) the object position; integers stay integers unless the result is non-integer.
 
+Eyeling also supports a small, EYE-style convenience for timestamp arithmetic:
+
+- **DateTime plus duration/seconds**: `(dateTime durationOrSeconds) math:sum dateTime`
+  - `xsd:duration` is interpreted as seconds (same model as `math:difference`).
+  - Output is a normalized `xsd:dateTime` in UTC lexical form (`...Z`).
+
 #### `math:product`
 
 **Shape:** `( $x1 $x2 ... ) math:product $total`
@@ -911,9 +917,10 @@ Eyeling supports:
 
 1. **Numeric subtraction**: `c = a - b`.
 2. **DateTime difference**: `(dateTime1 dateTime2) math:difference duration`
-   - Produces an `xsd:duration` in whole days (internally computed via seconds then formatted).
+   - Produces an **`xsd:duration`** in a seconds-only lexical form such as `"PT900S"^^xsd:duration`.
+   - This avoids ambiguity around month/year day-length and still plays well with `math:lessThan`, `math:greaterThan`, etc. because Eyeling's numeric comparison builtins treat `xsd:duration` as seconds.
 
-3. **DateTime minus duration**: `(dateTime duration) math:difference dateTime`
+3. **DateTime minus duration**: `(dateTime durationOrSeconds) math:difference dateTime`
    - Subtracts a duration from a dateTime and yields a new dateTime.
 
 If the types don’t fit any supported case, the builtin fails.
@@ -1963,21 +1970,19 @@ In that sense, N3 is less a bid to make the web “smarter” than a bid to make
 
 <a id="app-c"></a>
 
-## Appendix C — N3 beyond Prolog: logic that survives the open web
-
-At first glance, an N3 rule set can feel familiar if you’ve used Prolog: variables, unification, and rules that read like “if this pattern holds, then that pattern follows.” But N3 is not just “logic programming with a different syntax.” It is logic shaped for a different environment: not a single program with a single database, but a world of distributed graphs that can be published, merged, and cited across boundaries.
+## Appendix C — N3 beyond Prolog: logic for RDF-style graphs
 
-That change of environment forces a change in what “beyond Prolog” even means. It is less about being more powerful in the abstract, and more about being _more portable as meaning_ — logic that stays connected when it moves between documents, vocabularies, and authors.
+Notation3 (N3) rule sets often look similar to Prolog at the surface: they use variables, unification, and implication-style rules (“if these patterns match, then these patterns follow”). N3 is typically used in a different setting, though: instead of a single program operating over a single local database, N3 rules and data are commonly written as documents that can be published, shared, merged, and referenced across systems.
 
-Several design moves push N3 into that web-native space:
+In practice, that setting is reflected in several common features of N3-style rule writing:
 
-- **Global identity is the default.** Names are IRIs. A rule does not merely compute with local symbols; it operates over identifiers meant to be shared across datasets.
-- **Graphs are the unit of exchange.** The input is a graph; the output is a graph. Inference produces new triples rather than hidden internal state, so results can travel the same way the facts do.
-- **Statements can be treated as data.** Quoted graphs let you talk _about_ assertions: claims, policies, provenance, “this source says …,” “this formula implies …,” and other meta-level structure that is awkward in a plain predicate database.
-- **Rules can be publishable artifacts.** Rules can live alongside data as text, be versioned, reviewed, and reused — the “meaning” is not forced back into an external codebase.
-- **Web-like computation can be pulled into rule bodies.** Built-ins make room for the small computations that real integration needs (strings, lists, comparisons), and some N3 workflows even treat IRIs as pointers to more knowledge.
+- **Identifiers are IRIs.** Terms are usually global identifiers rather than local symbols, which supports linking across datasets.
+- **Input and output are graphs.** Rules consume graph patterns and produce additional triples, so the result of inference can be represented in the same form as the input data.
+- **Quoted graphs allow statements-as-data.** N3 can treat a graph (a set of triples) as a term, which makes it possible to represent and reason about assertions (e.g., “this source says …” or “this formula implies …”) as data.
+- **Rules can be distributed as text artifacts.** Rules can live alongside data, be versioned, and be reused without requiring an external host language to “carry” the meaning.
+- **Built-ins cover common computations.** Many N3 workflows rely on built-ins for operations such as string handling, list processing, comparisons, and related utilities; some workflows also use IRIs as pointers to retrievable content.
 
-In that sense, Prolog is a superb engine for proving things _inside_ a chosen world. N3 is a way to write rules so they keep working _across_ worlds: across documents, across graph boundaries, and across the open-ended growth of linked data. When an engine like Eyeling solves rule bodies with a Prolog-like prover but still saturates forward consequences, it’s exactly this bridge: Prolog-style execution serving a web-scale, graph-first notion of meaning.
+Engines can combine execution styles in different ways. One common pattern is to use a Prolog-like backward-chaining prover to satisfy rule bodies, while still using forward chaining to add the instantiated conclusions to the fact set until no new facts are produced.
 
 ---
 

package/examples/bayes-therapy.n3

@@ -0,0 +1,264 @@
+# ============================================================================
+# Bayes Therapy Decision Support
+#
+# This example extends a tiny Bayesian diagnostic model (Disease -> Symptoms)
+# with a decision layer that scores therapies by expected utility.
+#
+# NOTE: All probabilities and weights are illustrative and not medical advice.
+# ============================================================================
+
+@prefix :     <https://example.org/diag#> .
+@prefix math: <http://www.w3.org/2000/10/swap/math#> .
+@prefix list: <http://www.w3.org/2000/10/swap/list#> .
+
+# -------------------------------------------
+# 1) MODEL: Disease -> Symptoms (Naive Bayes)
+# -------------------------------------------
+
+:COVID19            a :Disease; :prior 0.05 .
+:Influenza          a :Disease; :prior 0.03 .
+:AllergicRhinitis   a :Disease; :prior 0.10 .
+:BacterialPneumonia a :Disease; :prior 0.01 .
+
+# Conditional probabilities P(symptom | disease)
+:COVID19 :pGiven [ :symptom :Fever;        :p 0.70 ] .
+:COVID19 :pGiven [ :symptom :DryCough;     :p 0.65 ] .
+:COVID19 :pGiven [ :symptom :LossOfSmell;  :p 0.40 ] .
+:COVID19 :pGiven [ :symptom :Sneezing;     :p 0.15 ] .
+:COVID19 :pGiven [ :symptom :ShortBreath;  :p 0.20 ] .
+
+:Influenza :pGiven [ :symptom :Fever;        :p 0.80 ] .
+:Influenza :pGiven [ :symptom :DryCough;     :p 0.50 ] .
+:Influenza :pGiven [ :symptom :LossOfSmell;  :p 0.05 ] .
+:Influenza :pGiven [ :symptom :Sneezing;     :p 0.20 ] .
+:Influenza :pGiven [ :symptom :ShortBreath;  :p 0.10 ] .
+
+:AllergicRhinitis :pGiven [ :symptom :Fever;        :p 0.05 ] .
+:AllergicRhinitis :pGiven [ :symptom :DryCough;     :p 0.15 ] .
+:AllergicRhinitis :pGiven [ :symptom :LossOfSmell;  :p 0.10 ] .
+:AllergicRhinitis :pGiven [ :symptom :Sneezing;     :p 0.80 ] .
+:AllergicRhinitis :pGiven [ :symptom :ShortBreath;  :p 0.05 ] .
+
+:BacterialPneumonia :pGiven [ :symptom :Fever;        :p 0.70 ] .
+:BacterialPneumonia :pGiven [ :symptom :DryCough;     :p 0.60 ] .
+:BacterialPneumonia :pGiven [ :symptom :LossOfSmell;  :p 0.02 ] .
+:BacterialPneumonia :pGiven [ :symptom :Sneezing;     :p 0.05 ] .
+:BacterialPneumonia :pGiven [ :symptom :ShortBreath;  :p 0.60 ] .
+
+# ----------------------------------------------------------------------
+# 2) THERAPY MODEL: P(improve | disease, therapy) + P(adverse | therapy)
+# ----------------------------------------------------------------------
+
+:Paxlovid a :Therapy;
+  # aligned with :Case :diseases order
+  :successByDisease ( 0.75 0.05 0.02 0.05 );
+  :adverse 0.10 .
+
+:Oseltamivir a :Therapy;
+  :successByDisease ( 0.05 0.60 0.02 0.05 );
+  :adverse 0.08 .
+
+:Antihistamine a :Therapy;
+  :successByDisease ( 0.10 0.10 0.75 0.05 );
+  :adverse 0.03 .
+
+:Antibiotic a :Therapy;
+  :successByDisease ( 0.05 0.05 0.02 0.80 );
+  :adverse 0.07 .
+
+:SupportiveCare a :Therapy;
+  :successByDisease ( 0.30 0.30 0.25 0.20 );
+  :adverse 0.01 .
+
+:Model :benefitWeight 10; :harmWeight 3 .
+
+# -------------------------------------------
+# 3) CASE: evidence (symptoms present/absent)
+# -------------------------------------------
+
+:Case a :PatientCase;
+  :diseases ( :COVID19 :Influenza :AllergicRhinitis :BacterialPneumonia );
+  :therapies ( :Paxlovid :Oseltamivir :SupportiveCare :Antibiotic :Antihistamine );
+  :evidence (
+    [ :symptom :Fever;       :present true  ]
+    [ :symptom :DryCough;    :present true  ]
+    [ :symptom :LossOfSmell; :present false ]
+    [ :symptom :Sneezing;    :present false ]
+    [ :symptom :ShortBreath; :present false ]
+  ).
+
+# -----------------------------------------------------------
+# 4) GUARDS (inference fuses): probabilities must be in [0,1]
+# -----------------------------------------------------------
+
+{ ?d :prior ?p. ?p math:lessThan 0. }     => false.
+{ ?d :prior ?p. ?p math:greaterThan 1. }  => false.
+
+{ ?d :pGiven [ :p ?p ]. ?p math:lessThan 0. }     => false.
+{ ?d :pGiven [ :p ?p ]. ?p math:greaterThan 1. }  => false.
+
+{ ?t a :Therapy. ?t :adverse ?p. ?p math:lessThan 0. }     => false.
+{ ?t a :Therapy. ?t :adverse ?p. ?p math:greaterThan 1. }  => false.
+
+{ ?t a :Therapy. ?t :successByDisease ?ps.
+  ?ps list:iterate ( ?i ?p ).
+  ?p math:lessThan 0.
+} => false.
+
+{ ?t a :Therapy. ?t :successByDisease ?ps.
+  ?ps list:iterate ( ?i ?p ).
+  ?p math:greaterThan 1.
+} => false.
+
+# ------------------------------------------
+# 5) HELPERS (all written as backward rules)
+# ------------------------------------------
+
+# pairList(d, (x1 x2 ...)) -> ((d x1) (d x2) ...)
+{ ( ?d () ) :pairList () } <= true.
+
+{ ( ?d ?xs ) :pairList ?pairs } <= {
+  ?xs list:firstRest ( ?x ?rest ).
+  ( ?d ?rest ) :pairList ?tailPairs.
+  ?pairs list:firstRest ( ( ?d ?x ) ?tailPairs ).
+}.
+
+# factor(d, evidenceItem) -> probability factor for that symptom
+{ ( ?d ?ev ) :factor ?p } <= {
+  ?ev :symptom ?s.
+  ?ev :present true.
+  ?d :pGiven [ :symptom ?s; :p ?p ].
+}.
+
+{ ( ?d ?ev ) :factor ?q } <= {
+  ?ev :symptom ?s.
+  ?ev :present false.
+  ?d :pGiven [ :symptom ?s; :p ?p ].
+  ( 1 ?p ) math:difference ?q.
+}.
+
+# pairWithConst((x1 x2 ...), c) -> ((x1 c) (x2 c) ...)
+{ ( () ?c ) :pairWithConst () } <= true.
+
+{ ( ?xs ?c ) :pairWithConst ?pairs } <= {
+  ?xs list:firstRest ( ?x ?rest ).
+  ( ?rest ?c ) :pairWithConst ?tailPairs.
+  ?pairs list:firstRest ( ( ?x ?c ) ?tailPairs ).
+}.
+
+# zip((a1 a2 ...), (b1 b2 ...)) -> ((a1 b1) (a2 b2) ...)
+{ ( () () ) :zip () } <= true.
+
+{ ( ?as ?bs ) :zip ?pairs } <= {
+  ?as list:firstRest ( ?a ?arest ).
+  ?bs list:firstRest ( ?b ?brest ).
+  ( ?arest ?brest ) :zip ?tailPairs.
+  ?pairs list:firstRest ( ( ?a ?b ) ?tailPairs ).
+}.
+
+# Helpers for list:map
+{ ?pair :mul ?p }  <= { ?pair math:product ?p }.
+{ ?pair :quot2 ?q } <= { ?pair math:quotient ?q }.
+
+# ---------------------------------------------------------
+# 6) DIAGNOSIS: unnormalized scores + normalized posteriors
+# ---------------------------------------------------------
+
+# score(d) = prior(d) * Π_e factor(d,e)
+{ ?d :scoreFor ?score } <= {
+  ?d :prior ?prior.
+  :Case :evidence ?evs.
+  ( ?d ?evs ) :pairList ?pairs.
+  ( ?pairs :factor ) list:map ?factors.
+  ?factors math:product ?likelihood.
+  ( ?prior ?likelihood ) math:product ?score.
+}.
+
+# Compute the score list, total evidence, and posterior list once.
+{
+  :Case :diseases ?ds.
+  ( ?ds :scoreFor ) list:map ?scores.
+  ?scores math:sum ?total.
+
+  ( ?scores ?total ) :pairWithConst ?scorePairs.
+  ( ?scorePairs :quot2 ) list:map ?posteriors.
+} => {
+  :Case :scores ?scores;
+        :evidenceTotal ?total;
+        :posteriors ?posteriors.
+}.
+
+# Attach each disease posterior to the disease term (no blank nodes in output)
+{
+  :Case :diseases ?ds.
+  :Case :posteriors ?posts.
+
+  ?ds list:iterate ( ?i ?d ).
+  ( ?posts ?i ) list:memberAt ?p.
+} => {
+  ?d :posterior ?p.
+}.
+
+# -------------------------------------------------------
+# 7) THERAPY SCORING: expected success + expected utility
+# -------------------------------------------------------
+
+# expectedSuccess(t) = Σ_i post[i] * successByDisease[i]
+{
+  :Case :posteriors ?posts.
+  ?t a :Therapy.
+  ?t :successByDisease ?succ.
+
+  ( ?posts ?succ ) :zip ?pairs.
+  ( ?pairs :mul ) list:map ?terms.
+  ?terms math:sum ?expectedSuccess.
+
+  ?t :adverse ?adverse.
+  :Model :benefitWeight ?bw.
+  :Model :harmWeight ?hw.
+
+  ( ?bw ?expectedSuccess ) math:product ?benefit.
+  ( ?hw ?adverse ) math:product ?harmCost.
+  ( ?benefit ?harmCost ) math:difference ?utility.
+} => {
+  ?t :expectedSuccess ?expectedSuccess;
+     :expectedAdverse ?adverse;
+     :utility ?utility.
+}.
+
+# --------------------------------------------------------------
+# 8) RECOMMENDATION: pick max-utility therapy from the case list
+# --------------------------------------------------------------
+
+# betterOf(t1,t2) chooses t1 if utility(t1) >= utility(t2), else t2.
+{ ( ?t1 ?t2 ) :betterOf ?t1 } <= {
+  ?t1 :utility ?u1.
+  ?t2 :utility ?u2.
+  ?u1 math:notLessThan ?u2.
+}.
+{ ( ?t1 ?t2 ) :betterOf ?t2 } <= {
+  ?t1 :utility ?u1.
+  ?t2 :utility ?u2.
+  ?u1 math:lessThan ?u2.
+}.
+
+# bestTherapy((t)) = t
+{ ( ?ts ) :bestTherapy ?t } <= {
+  ?ts list:firstRest ( ?t () ).
+}.
+
+# bestTherapy((head rest...)) = betterOf(head, bestTherapy(rest))
+{ ( ?ts ) :bestTherapy ?best } <= {
+  ?ts list:firstRest ( ?head ?rest ).
+  ?rest list:firstRest ( ?_ ?__ ).  # ensure rest is non-empty
+  ( ?rest ) :bestTherapy ?bestRest.
+  ( ?head ?bestRest ) :betterOf ?best.
+}.
+
+# Emit a single recommendation for this case.
+{
+  :Case :therapies ?ts.
+  ( ?ts ) :bestTherapy ?best.
+} => {
+  :Case :recommendedTherapy ?best.
+}.

package/examples/output/bayes-therapy.n3

@@ -0,0 +1,26 @@
+@prefix : <https://example.org/diag#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+:Case :scores ("0.009281999999999999"^^xsd:decimal "0.008208000000000002"^^xsd:decimal "0.00012824999999999997"^^xsd:decimal "0.00156408"^^xsd:decimal) .
+:Case :evidenceTotal "0.019182329999999997"^^xsd:decimal .
+:Case :posteriors ("0.48388282341092037"^^xsd:decimal "0.4278937960091398"^^xsd:decimal "0.006685840562642807"^^xsd:decimal "0.08153754001729718"^^xsd:decimal) .
+:COVID19 :posterior "0.48388282341092037"^^xsd:decimal .
+:Influenza :posterior "0.4278937960091398"^^xsd:decimal .
+:AllergicRhinitis :posterior "0.006685840562642807"^^xsd:decimal .
+:BacterialPneumonia :posterior "0.08153754001729718"^^xsd:decimal .
+:Paxlovid :expectedSuccess "0.388517401170765"^^xsd:decimal .
+:Paxlovid :expectedAdverse 0.10 .
+:Paxlovid :utility "3.5851740117076503"^^xsd:decimal .
+:Oseltamivir :expectedSuccess "0.28514101258814756"^^xsd:decimal .
+:Oseltamivir :expectedAdverse 0.08 .
+:Oseltamivir :utility "2.6114101258814753"^^xsd:decimal .
+:Antihistamine :expectedSuccess "0.10026891936485298"^^xsd:decimal .
+:Antihistamine :expectedAdverse 0.03 .
+:Antihistamine :utility "0.9126891936485299"^^xsd:decimal .
+:Antibiotic :expectedSuccess "0.1109525797960936"^^xsd:decimal .
+:Antibiotic :expectedAdverse 0.07 .
+:Antibiotic :utility "0.8995257979609361"^^xsd:decimal .
+:SupportiveCare :expectedSuccess "0.2915119539701382"^^xsd:decimal .
+:SupportiveCare :expectedAdverse 0.01 .
+:SupportiveCare :utility "2.8851195397013822"^^xsd:decimal .
+:Case :recommendedTherapy :Paxlovid .

package/eyeling-builtins.ttl

@@ -77,13 +77,13 @@ math:notGreaterThan a ex:Builtin ; ex:kind ex:Test;
 # --- math: arithmetic / numeric functions ----------------------------
 
 math:sum a ex:Builtin ; ex:kind ex:Function ;
-  rdfs:comment "Sum of a list of 2+ numeric terms. Binds/unifies object with the total (integer mode uses BigInt when possible)." .
+  rdfs:comment "Sum of a list of numeric terms. Binds/unifies object with the total (integer mode uses BigInt when possible). Also supports 2-element timestamp arithmetic: (xsd:dateTime xsd:duration) or (xsd:dateTime seconds) (and the commuted forms) -> xsd:dateTime." .
 
 math:product a ex:Builtin ; ex:kind ex:Function ;
-  rdfs:comment "Product of a list of 2+ numeric terms. Binds/unifies object with the product (integer mode uses BigInt when possible)." .
+  rdfs:comment "Product of a list of numeric terms. Binds/unifies object with the product (integer mode uses BigInt when possible)." .
 
 math:difference a ex:Builtin ; ex:kind ex:Function ;
-  rdfs:comment "Difference of a 2-element list (a b). Supports datetime-datetime -> duration; datetime-duration -> datetime; integer BigInt; otherwise numeric a-b." .
+  rdfs:comment "Difference of a 2-element list (a b). Supports xsd:dateTime-xsd:dateTime -> xsd:duration (normalized to PT...S); xsd:dateTime-(xsd:duration|seconds) -> xsd:dateTime; integer BigInt; otherwise numeric a-b." .
 
 math:quotient a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Quotient of a 2-element list (a b). Binds/unifies object with a/b (guards division by zero and non-finite results)." .

package/eyeling.js

@@ -788,9 +788,14 @@ function parseNumOrDuration(t) {
 }
 
 function formatDurationLiteralFromSeconds(secs) {
+  // xsd:duration allows a leading '-' sign.
+  // We emit a conservative seconds-only lexical form so we don't lose precision
+  // for sub-day differences (e.g., PT900S).
   const neg = secs < 0;
-  const days = Math.round(Math.abs(secs) / 86400.0);
-  const literalLex = neg ? `"-P${days}D"` : `"P${days}D"`;
+  const abs = Math.abs(secs);
+  const sLex = Number.isFinite(abs) ? (Number.isInteger(abs) && abs < 1e21 ? abs.toFixed(0) : String(abs)) : 'NaN';
+  const core = `P${abs === 0 ? 'T0S' : `T${sLex}S`}`;
+  const literalLex = neg ? `"-${core}"` : `"${core}"`;
   return internLiteral(`${literalLex}^^<${XSD_NS}duration>`);
 }
 function numEqualTerm(t, n, eps = 1e-9) {
@@ -1433,6 +1438,49 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     if (!(g.s instanceof ListTerm)) return [];
     const xs = g.s.elems;
 
+    // Special-case: (dateTime durationOrSeconds) math:sum dateTime
+    // This mirrors EYE-style convenience for timestamp arithmetic.
+    //
+    // Notes:
+    // - We treat xsd:duration as seconds via parseNumOrDuration (same model as math:difference).
+    // - Output is normalized to UTC lexical form ("...Z"), consistent with other dateTime outputs.
+    if (xs.length === 2) {
+      const dt0 = parseDatetimeLike(xs[0]);
+      const dt1 = parseDatetimeLike(xs[1]);
+
+      if (dt0 !== null && dt1 === null) {
+        const secs = parseNumOrDuration(xs[1]);
+        if (secs !== null) {
+          const outSecs = dt0.getTime() / 1000.0 + secs;
+          const lex = time.utcIsoDateTimeStringFromEpochSeconds(outSecs);
+          const lit = internLiteral(`"${lex}"^^<${XSD_NS}dateTime>`);
+          if (g.o instanceof Var) {
+            const s2 = { ...subst };
+            s2[g.o.name] = lit;
+            return [s2];
+          }
+          const s2 = unifyTerm(g.o, lit, subst);
+          return s2 !== null ? [s2] : [];
+        }
+      }
+
+      if (dt1 !== null && dt0 === null) {
+        const secs = parseNumOrDuration(xs[0]);
+        if (secs !== null) {
+          const outSecs = dt1.getTime() / 1000.0 + secs;
+          const lex = time.utcIsoDateTimeStringFromEpochSeconds(outSecs);
+          const lit = internLiteral(`"${lex}"^^<${XSD_NS}dateTime>`);
+          if (g.o instanceof Var) {
+            const s2 = { ...subst };
+            s2[g.o.name] = lit;
+            return [s2];
+          }
+          const s2 = unifyTerm(g.o, lit, subst);
+          return s2 !== null ? [s2] : [];
+        }
+      }
+    }
+
     const dtOut0 = commonNumericDatatype(xs, g.o);
 
     // Exact integer mode
@@ -1540,18 +1588,25 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [a0, b0] = g.s.elems;
 
-    // 1) Date/datetime difference -> duration   (needed for examples/age.n3)
+    // 1) Date/datetime difference -> xsd:duration
+    //
+    // Emit a conservative seconds-only lexical form (e.g., "PT900S"^^xsd:duration).
+    // This avoids day/month/year normalization ambiguity and still allows numeric
+    // comparisons via parseNumOrDuration (used by math:lessThan, etc.).
     const aDt = parseDatetimeLike(a0);
     const bDt = parseDatetimeLike(b0);
     if (aDt !== null && bDt !== null) {
       const diffSecs = (aDt.getTime() - bDt.getTime()) / 1000.0;
-      const durTerm = formatDurationLiteralFromSeconds(diffSecs);
+      if (!Number.isFinite(diffSecs)) return [];
+
+      const lit = formatDurationLiteralFromSeconds(diffSecs);
+
       if (g.o instanceof Var) {
         const s2 = { ...subst };
-        s2[g.o.name] = durTerm;
+        s2[g.o.name] = lit;
         return [s2];
       }
-      const s2 = unifyTerm(g.o, durTerm, subst);
+      const s2 = unifyTerm(g.o, lit, subst);
       return s2 !== null ? [s2] : [];
     }
 

package/lib/builtins.js

@@ -776,9 +776,14 @@ function parseNumOrDuration(t) {
 }
 
 function formatDurationLiteralFromSeconds(secs) {
+  // xsd:duration allows a leading '-' sign.
+  // We emit a conservative seconds-only lexical form so we don't lose precision
+  // for sub-day differences (e.g., PT900S).
   const neg = secs < 0;
-  const days = Math.round(Math.abs(secs) / 86400.0);
-  const literalLex = neg ? `"-P${days}D"` : `"P${days}D"`;
+  const abs = Math.abs(secs);
+  const sLex = Number.isFinite(abs) ? (Number.isInteger(abs) && abs < 1e21 ? abs.toFixed(0) : String(abs)) : 'NaN';
+  const core = `P${abs === 0 ? 'T0S' : `T${sLex}S`}`;
+  const literalLex = neg ? `"-${core}"` : `"${core}"`;
   return internLiteral(`${literalLex}^^<${XSD_NS}duration>`);
 }
 function numEqualTerm(t, n, eps = 1e-9) {
@@ -1421,6 +1426,49 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     if (!(g.s instanceof ListTerm)) return [];
     const xs = g.s.elems;
 
+    // Special-case: (dateTime durationOrSeconds) math:sum dateTime
+    // This mirrors EYE-style convenience for timestamp arithmetic.
+    //
+    // Notes:
+    // - We treat xsd:duration as seconds via parseNumOrDuration (same model as math:difference).
+    // - Output is normalized to UTC lexical form ("...Z"), consistent with other dateTime outputs.
+    if (xs.length === 2) {
+      const dt0 = parseDatetimeLike(xs[0]);
+      const dt1 = parseDatetimeLike(xs[1]);
+
+      if (dt0 !== null && dt1 === null) {
+        const secs = parseNumOrDuration(xs[1]);
+        if (secs !== null) {
+          const outSecs = dt0.getTime() / 1000.0 + secs;
+          const lex = time.utcIsoDateTimeStringFromEpochSeconds(outSecs);
+          const lit = internLiteral(`"${lex}"^^<${XSD_NS}dateTime>`);
+          if (g.o instanceof Var) {
+            const s2 = { ...subst };
+            s2[g.o.name] = lit;
+            return [s2];
+          }
+          const s2 = unifyTerm(g.o, lit, subst);
+          return s2 !== null ? [s2] : [];
+        }
+      }
+
+      if (dt1 !== null && dt0 === null) {
+        const secs = parseNumOrDuration(xs[0]);
+        if (secs !== null) {
+          const outSecs = dt1.getTime() / 1000.0 + secs;
+          const lex = time.utcIsoDateTimeStringFromEpochSeconds(outSecs);
+          const lit = internLiteral(`"${lex}"^^<${XSD_NS}dateTime>`);
+          if (g.o instanceof Var) {
+            const s2 = { ...subst };
+            s2[g.o.name] = lit;
+            return [s2];
+          }
+          const s2 = unifyTerm(g.o, lit, subst);
+          return s2 !== null ? [s2] : [];
+        }
+      }
+    }
+
     const dtOut0 = commonNumericDatatype(xs, g.o);
 
     // Exact integer mode
@@ -1528,18 +1576,25 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const [a0, b0] = g.s.elems;
 
-    // 1) Date/datetime difference -> duration   (needed for examples/age.n3)
+    // 1) Date/datetime difference -> xsd:duration
+    //
+    // Emit a conservative seconds-only lexical form (e.g., "PT900S"^^xsd:duration).
+    // This avoids day/month/year normalization ambiguity and still allows numeric
+    // comparisons via parseNumOrDuration (used by math:lessThan, etc.).
     const aDt = parseDatetimeLike(a0);
     const bDt = parseDatetimeLike(b0);
     if (aDt !== null && bDt !== null) {
       const diffSecs = (aDt.getTime() - bDt.getTime()) / 1000.0;
-      const durTerm = formatDurationLiteralFromSeconds(diffSecs);
+      if (!Number.isFinite(diffSecs)) return [];
+
+      const lit = formatDurationLiteralFromSeconds(diffSecs);
+
       if (g.o instanceof Var) {
         const s2 = { ...subst };
-        s2[g.o.name] = durTerm;
+        s2[g.o.name] = lit;
         return [s2];
       }
-      const s2 = unifyTerm(g.o, durTerm, subst);
+      const s2 = unifyTerm(g.o, lit, subst);
       return s2 !== null ? [s2] : [];
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.12.6",
+  "version": "1.12.7",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/examples.test.js

@@ -145,8 +145,11 @@ function main() {
   let passed = 0;
   let failed = 0;
 
+  // Pretty, stable numbering (e.g., 001..100 when running 100 tests)
+  const idxWidth = String(files.length).length;
+
   for (let i = 0; i < files.length; i++) {
-    const idx = String(i + 1).padStart(2, '0');
+    const idx = String(i + 1).padStart(idxWidth, '0');
     const file = files[i];
 
     const start = Date.now();