eyeling 1.24.24 → 1.24.26

package/examples/rdf-messages.n3

@@ -1,16 +1,38 @@
 # ============
 # RDF Messages
 # ============
-# This Eyeling example models the main idea from
-# https://pietercolpaert.be/papers/eswc2026-rdf-messages/:
-# a message stream/log is not just one freely mergeable RDF graph. It is an
-# ordered sequence of RDF Datasets that are interpreted atomically, one message
-# at a time. The middle message is deliberately empty to model a heartbeat, and
-# the local blank-node label "_:b0" is deliberately reused by two messages to
-# show message-scoped blank nodes.
+#
+# Run as:
+#
+#   eyeling -r examples/rdf-messages.n3 examples/input/rdf-messages.trig
+#
+# Motivation
+# ----------
+# The RDF Messages draft defines an RDF Message as an RDF dataset interpreted
+# atomically, an RDF Message Stream as an ordered sequence of messages, and an
+# RDF Message Log as a replayable record of such a stream. The draft also says
+# that messages should not be combined by default and that blank node labels are
+# scoped to the message in which they occur.
+#
+# This Eyeling example demonstrates those ideas in ordinary N3/TriG rather than
+# in a parser-level RDF Message Log with VERSION "1.2-messages" and MESSAGE
+# delimiters. The companion TriG file therefore has two layers:
+#
+#   1. application-local envelope facts in the default graph, such as message
+#      order, offset, expected result, and the textual blank-node label seen in
+#      the original stream; and
+#   2. one named graph per non-empty message payload, treated as the atomic RDF
+#      dataset/message to be inspected.
+#
+# The rules below validate a replay archive with three message envelopes. The
+# middle message is an empty heartbeat. The first and third messages both record
+# the local blank-node label "_:b0"; because this sidecar is normal TriG, the
+# actual TriG blank nodes are unique, while the envelope records show the
+# message-scoped label reuse that a true RDF Message Log parser would preserve
+# by resetting blank-node scope at each MESSAGE delimiter.
 
 @prefix : <https://eyereasoner.github.io/eyeling/examples/rdf-messages#>.
-@prefix msg: <https://w3c-cg.github.io/rsp/spec/messages#>.
+@prefix rmsg: <https://eyereasoner.github.io/eyeling/examples/rdf-messages/vocab#>.
 @prefix prov: <http://www.w3.org/ns/prov#>.
 @prefix sosa: <http://www.w3.org/ns/sosa/>.
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
@@ -19,51 +41,49 @@
 @prefix log: <http://www.w3.org/2000/10/swap/log#>.
 @prefix string: <http://www.w3.org/2000/10/swap/string#>.
 
-
-
-# Empty RDF Message: a legal heartbeat/keep-alive event.
-
-
 # A message with an offset inside a log has an explicit replay boundary.
-
+# The envelope resource is application-local; the payload graph is the dataset
+# treated as the RDF Message.
 {
-  ?Log a msg:MessageLog;
-    msg:message ?Message.
-  ?Message a msg:RDFMessage;
-    msg:offset ?Offset.
+  ?Log a rmsg:MessageLog;
+    rmsg:message ?Message.
+  ?Message a rmsg:MessageEnvelope;
+    rmsg:offset ?Offset.
 } => {
-  ?Message msg:boundaryExplicit true.
-  ?Log msg:replayContains ?Message.
+  ?Message rmsg:boundaryExplicit true.
+  ?Log rmsg:replayContains ?Message.
 }.
 
-# The payload is a dataset-like formula. We can inspect it without merging it
-# into the global graph, preserving the message as the unit of interpretation.
+# The payload is a dataset-like named graph. Inspect it with log:includes instead
+# of merging all payload triples into the global graph.
 {
-  ?Message a msg:RDFMessage;
-    msg:expectedResult ?Result;
-    msg:payload ?Payload.
+  ?Message a rmsg:MessageEnvelope;
+    rmsg:expectedResult ?Result;
+    rmsg:payloadGraph ?Payload.
   ?Payload log:nameOf ?PayloadContext.
   ?PayloadContext log:includes { ?Observation sosa:hasSimpleResult ?Result. }.
 } => {
-  ?Message msg:payloadResult ?Result.
+  ?Message rmsg:payloadResult ?Result.
 }.
 
-# Heartbeat/keep-alive messages can be empty and still occupy a boundary.
+# Empty messages are legal RDF Messages. Here the empty second envelope acts as
+# a heartbeat/keep-alive and still occupies a boundary in the replay archive.
 {
-  ?Message a msg:RDFMessage;
-    msg:payloadKind :heartbeat.
+  ?Message a rmsg:MessageEnvelope;
+    rmsg:payloadKind :heartbeat.
 } => {
-  ?Message msg:emptyMessageAllowed true.
+  ?Message rmsg:emptyMessageAllowed true.
   :HeartbeatEvidence :accepted ?Message.
 }.
 
-# The same blank-node label may recur in a message log because blank nodes are
-# scoped to their RDF Message, not to the whole replay archive.
+# The same local blank-node label may recur in different messages. In this
+# plain-TriG sidecar the real blank nodes are unique, and the envelope metadata
+# records the per-message label visible in the source stream.
 {
-  ?First a msg:RDFMessage;
-    msg:localBlankLabel ?Label.
-  ?Second a msg:RDFMessage;
-    msg:localBlankLabel ?Label.
+  ?First a rmsg:MessageEnvelope;
+    rmsg:localBlankLabel ?Label.
+  ?Second a rmsg:MessageEnvelope;
+    rmsg:localBlankLabel ?Label.
   ?First log:notEqualTo ?Second.
 } => {
   :BlankNodeScope :reusedLabel ?Label.
@@ -71,35 +91,35 @@
 }.
 
 # Different observations from the same sensor are not a global contradiction:
-# each message is interpreted in its own communication context.
+# by default, message payloads remain separate communication contexts.
 {
-  ?First a msg:RDFMessage;
-    msg:payloadResult ?FirstResult.
-  ?Second a msg:RDFMessage;
-    msg:payloadResult ?SecondResult.
+  ?First a rmsg:MessageEnvelope;
+    rmsg:payloadResult ?FirstResult.
+  ?Second a rmsg:MessageEnvelope;
+    rmsg:payloadResult ?SecondResult.
   ?FirstResult math:notEqualTo ?SecondResult.
   ?First log:notEqualTo ?Second.
 } => {
   :MessageContext :differentObservationsStayContextual true.
 }.
 
-# The Eyeling verdict is emitted only when all message-specific validations have been
-# derived from the log, message metadata, payload formulas, and built-ins.
+# The Eyeling verdict is emitted only when all message-specific validations have
+# been derived from the log metadata, ordered message list, payload graphs, and
+# built-ins.
 {
-  :temperatureLog msg:orderedMessages ?Messages.
+  :temperatureLog rmsg:orderedMessages ?Messages.
   ?Messages list:length ?Count.
-  :m001 msg:boundaryExplicit true;
-    msg:payloadResult ?FirstResult.
-  :m002 msg:boundaryExplicit true;
-    msg:emptyMessageAllowed true.
-  :m003 msg:boundaryExplicit true;
-    msg:payloadResult ?SecondResult.
+  :m001 rmsg:boundaryExplicit true;
+    rmsg:payloadResult ?FirstResult.
+  :m002 rmsg:boundaryExplicit true;
+    rmsg:emptyMessageAllowed true.
+  :m003 rmsg:boundaryExplicit true;
+    rmsg:payloadResult ?SecondResult.
   :BlankNodeScope :reusedLabel ?Label;
     :isPerMessage true.
   :MessageContext :differentObservationsStayContextual true.
-  ("# rdf-messages\n\n## Source files\n\n- [N3 rules](../rdf-messages.n3)\n- [Input TriG](../input/rdf-messages.trig)\n\n## Answer\nRDF Message log accepted: %d explicit message boundaries are preserved. Message :m002 is an empty heartbeat, and the local blank-node label %s is safely reused in separate messages.\n\n## Explanation\nThe N3 source models an RDF Message Log as an ordered sequence of RDF Messages. Each non-empty message has a formula-valued payload that is inspected with log:includes, so the observation data stays inside the message boundary instead of being treated as one global graph. The two temperature results, %s and %s, are different observations from the same stream but are contextualized by their message boundaries." ?Count ?Label ?FirstResult ?SecondResult) string:format ?Block.
+  ("# rdf-messages\n\n## Source files\n\n- [N3 rules](../rdf-messages.n3)\n- [Input TriG](../input/rdf-messages.trig)\n\n## Answer\nRDF Message replay archive accepted: %d explicit message boundaries are preserved. Message :m002 is an empty heartbeat, and the local blank-node label %s is safely reused in separate message envelopes.\n\n## Explanation\nThe input is a single runnable example split across an N3 rule file and a TriG sidecar. The TriG file uses application-local envelope facts for stream order and replay metadata, while each non-empty named payload graph is treated as an atomic RDF Message dataset. Payloads are inspected with log:includes inside their own formulas, so the observation data stays inside the message boundary instead of being treated as one global graph. The two temperature results, %s and %s, are different observations from the same stream but are contextualized by their message boundaries.\n\nThis is intentionally not a parser-level VERSION \\\"1.2-messages\\\" / MESSAGE delimiter test. It is a reasoning example over an already-materialized sidecar representation of a message log." ?Count ?Label ?FirstResult ?SecondResult) string:format ?Block.
 } => {
   :rdfMessagesExample log:outputString ?Block.
   :rdfMessagesExample :demonstrates :ExplicitBoundaries, :AtomicMessageContext, :EmptyHeartbeat, :MessageScopedBlankNodes, :ReplayableMessageLog.
 }.
-

package/eyeling.js

@@ -1691,15 +1691,85 @@ function __listElemsForBuiltin(listLike, facts) {
   return null;
 }
 
-function evalListFirstLikeBuiltin(sTerm, oTerm, subst) {
-  if (!(sTerm instanceof ListTerm)) return [];
-  if (!sTerm.elems.length) return [];
-  const first = sTerm.elems[0];
-  const s2 = unifyTerm(oTerm, first, subst);
-  return s2 !== null ? [s2] : [];
+function __pushBuiltinDeltaLimited(out, delta, maxResults) {
+  if (delta === null) return false;
+  out.push(delta);
+  return typeof maxResults === 'number' && maxResults > 0 && out.length >= maxResults;
+}
+
+function __collectListLikeTermsFromTerm(t, out, seen) {
+  if (t instanceof ListTerm || t instanceof OpenListTerm) {
+    const k = termFastKey(t);
+    if (k === null || !seen.has(k)) {
+      if (k !== null) seen.add(k);
+      out.push(t);
+    }
+    if (t instanceof ListTerm) {
+      for (const e of t.elems) __collectListLikeTermsFromTerm(e, out, seen);
+    } else {
+      for (const e of t.prefix) __collectListLikeTermsFromTerm(e, out, seen);
+    }
+    return;
+  }
+  if (t instanceof GraphTerm) {
+    for (const tr of t.triples) {
+      __collectListLikeTermsFromTerm(tr.s, out, seen);
+      __collectListLikeTermsFromTerm(tr.p, out, seen);
+      __collectListLikeTermsFromTerm(tr.o, out, seen);
+    }
+  }
+}
+
+function __collectListLikeTermsFromFacts(facts) {
+  const out = [];
+  const seen = new Set();
+  for (const tr of facts) {
+    __collectListLikeTermsFromTerm(tr.s, out, seen);
+    __collectListLikeTermsFromTerm(tr.o, out, seen);
+  }
+  return out;
+}
+
+function evalListFirstLikeBuiltin(sTerm, oTerm, subst, facts, maxResults) {
+  if (sTerm instanceof ListTerm) {
+    if (!sTerm.elems.length) return [];
+    const first = sTerm.elems[0];
+    const s2 = unifyTerm(oTerm, first, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // For a variable subject, enumerate already-existing collection terms.
+  // This lets a rule body such as `_:x rdf:first 1; rdf:rest rdf:nil`
+  // bind `_:x` to an N3 collection literal `(1)` used elsewhere as a term.
+  // Also include ordinary rdf:first facts so the builtin path does not hide
+  // RDF-serialized lists when the subject starts unbound.
+  if (sTerm instanceof Var) {
+    const out = [];
+
+    for (const listTerm of __collectListLikeTermsFromFacts(facts)) {
+      if (!(listTerm instanceof ListTerm) || !listTerm.elems.length) continue;
+      let s2 = unifyTerm(sTerm, listTerm, subst);
+      if (s2 === null) continue;
+      s2 = unifyTerm(oTerm, listTerm.elems[0], s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    const RDF_FIRST = RDF_NS + 'first';
+    for (const tr of facts) {
+      if (!(tr.p instanceof Iri) || tr.p.value !== RDF_FIRST) continue;
+      let s2 = unifyTerm(sTerm, tr.s, subst);
+      if (s2 === null) continue;
+      s2 = unifyTerm(oTerm, tr.o, s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    return out;
+  }
+
+  return [];
 }
 
-function evalListRestLikeBuiltin(sTerm, oTerm, subst) {
+function evalListRestLikeBuiltin(sTerm, oTerm, subst, facts, maxResults) {
   // Closed list: (a b c) -> (b c)
   if (sTerm instanceof ListTerm) {
     if (!sTerm.elems.length) return [];
@@ -1720,6 +1790,32 @@ function evalListRestLikeBuiltin(sTerm, oTerm, subst) {
     return s2 !== null ? [s2] : [];
   }
 
+  // See evalListFirstLikeBuiltin(): if the collection subject is still a
+  // variable, enumerate known list literals and ordinary rdf:rest facts.
+  if (sTerm instanceof Var) {
+    const out = [];
+
+    for (const listTerm of __collectListLikeTermsFromFacts(facts)) {
+      if (!(listTerm instanceof ListTerm) || !listTerm.elems.length) continue;
+      let s2 = unifyTerm(sTerm, listTerm, subst);
+      if (s2 === null) continue;
+      const rest = new ListTerm(listTerm.elems.slice(1));
+      s2 = unifyTerm(oTerm, rest, s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    const RDF_REST = RDF_NS + 'rest';
+    for (const tr of facts) {
+      if (!(tr.p instanceof Iri) || tr.p.value !== RDF_REST) continue;
+      let s2 = unifyTerm(sTerm, tr.s, subst);
+      if (s2 === null) continue;
+      s2 = unifyTerm(oTerm, tr.o, s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    return out;
+  }
+
   return [];
 }
 
@@ -2859,14 +2955,14 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     return s2 !== null ? [s2] : [];
   }
   if (pv === RDF_NS + 'first') {
-    return evalListFirstLikeBuiltin(g.s, g.o, subst);
+    return evalListFirstLikeBuiltin(g.s, g.o, subst, facts, maxResults);
   }
 
   // list:rest and rdf:rest
   // true iff $s is a (non-empty) list and $o is the rest (tail) of that list.
   // Schema: $s+ list:rest $o-
   if (pv === LIST_NS + 'rest') {
-    if (g.s instanceof ListTerm || g.s instanceof OpenListTerm) return evalListRestLikeBuiltin(g.s, g.o, subst);
+    if (g.s instanceof ListTerm || g.s instanceof OpenListTerm) return evalListRestLikeBuiltin(g.s, g.o, subst, facts, maxResults);
     const xs = __listElemsForBuiltin(g.s, facts);
     if (!xs || !xs.length) return [];
     const rest = new ListTerm(xs.slice(1));
@@ -2874,7 +2970,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     return s2 !== null ? [s2] : [];
   }
   if (pv === RDF_NS + 'rest') {
-    return evalListRestLikeBuiltin(g.s, g.o, subst);
+    return evalListRestLikeBuiltin(g.s, g.o, subst, facts, maxResults);
   }
 
   // list:iterate
@@ -7918,7 +8014,10 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     const isRdfFirstOrRest = goalPredicateIri === RDF_NS + 'first' || goalPredicateIri === RDF_NS + 'rest';
     const shouldTreatAsBuiltin =
       isBuiltinPred(goal0.p) &&
-      !(isRdfFirstOrRest && !(goal0.s instanceof ListTerm || goal0.s instanceof OpenListTerm));
+      !(
+        isRdfFirstOrRest &&
+        !(goal0.s instanceof ListTerm || goal0.s instanceof OpenListTerm || goal0.s instanceof Var)
+      );
 
     if (shouldTreatAsBuiltin) {
       const remaining = max - results.length;
@@ -11399,6 +11498,20 @@ class Parser {
     if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'a') {
       this.next();
       pred = internIri(RDF_NS + 'type');
+    } else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'has') {
+      // N3 syntactic sugar is also valid in predicate-object lists,
+      // including blank node property lists: [ has :p :o ] means _:b :p :o.
+      this.next();
+      pred = this.parseTerm();
+    } else if (this.peek().typ === 'Ident' && (this.peek().value || '') === 'is') {
+      // N3 syntactic sugar: [ is :p of :s ] means :s :p _:b.
+      this.next();
+      pred = this.parseTerm();
+      if (!(this.peek().typ === 'Ident' && (this.peek().value || '') === 'of')) {
+        this.fail(`Expected 'of' after 'is <expr>', got ${this.peek().toString()}`);
+      }
+      this.next();
+      invert = true;
     } else if (this.peek().typ === 'OpPredInvert') {
       this.next();
       pred = this.parseTerm();
@@ -11703,14 +11816,142 @@ const STRING_NS = 'http://www.w3.org/2000/10/swap/string#';
 const SKOLEM_NS = 'https://eyereasoner.github.io/.well-known/genid/';
 const RDF_JSON_DT = RDF_NS + 'JSON';
 
+function parseUriReferenceForResolution(uri) {
+  // RFC 3986 Appendix B-style component parser, with the scheme tightened to
+  // the RFC scheme grammar. Capturing delimiter presence matters: `?` with an
+  // empty query is defined, while no `?` means undefined.
+  const m = /^(([A-Za-z][A-Za-z0-9+.-]*):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/u.exec(String(uri));
+  if (!m) return null;
+  return {
+    scheme: m[2] !== undefined ? m[2] : undefined,
+    authority: m[4] !== undefined ? m[4] : undefined,
+    path: m[5] || '',
+    query: m[6] !== undefined ? (m[7] || '') : undefined,
+    fragment: m[8] !== undefined ? (m[9] || '') : undefined,
+  };
+}
+
+function recomposeUriReference(parts) {
+  let out = '';
+  if (parts.scheme !== undefined) out += `${parts.scheme}:`;
+  if (parts.authority !== undefined) out += `//${parts.authority}`;
+  out += parts.path || '';
+  if (parts.query !== undefined) out += `?${parts.query}`;
+  if (parts.fragment !== undefined) out += `#${parts.fragment}`;
+  return out;
+}
+
+function removeLastPathSegment(path) {
+  if (!path) return '';
+  const i = path.lastIndexOf('/');
+  if (i < 0) return '';
+  if (i === 0) return '';
+  return path.slice(0, i);
+}
+
+function removeDotSegments(path) {
+  // RFC 3986 section 5.2.4.  This deliberately avoids WHATWG URL parsing so
+  // Eyeling preserves IRI spelling (for example, it does not add a trailing
+  // slash to `http://example.org`) while still normalizing `.` and `..` path
+  // segments as required by section 5.2.2.
+  let input = String(path || '');
+  let output = '';
+
+  while (input.length > 0) {
+    if (input.startsWith('../')) {
+      input = input.slice(3);
+    } else if (input.startsWith('./')) {
+      input = input.slice(2);
+    } else if (input.startsWith('/./')) {
+      input = `/${input.slice(3)}`;
+    } else if (input === '/.') {
+      input = '/';
+    } else if (input.startsWith('/../')) {
+      input = `/${input.slice(4)}`;
+      output = removeLastPathSegment(output);
+    } else if (input === '/..') {
+      input = '/';
+      output = removeLastPathSegment(output);
+    } else if (input === '.' || input === '..') {
+      input = '';
+    } else {
+      let segmentEnd;
+      if (input[0] === '/') {
+        segmentEnd = input.indexOf('/', 1);
+      } else {
+        segmentEnd = input.indexOf('/');
+      }
+
+      if (segmentEnd < 0) {
+        output += input;
+        input = '';
+      } else {
+        output += input.slice(0, segmentEnd);
+        input = input.slice(segmentEnd);
+      }
+    }
+  }
+
+  return output;
+}
+
+function mergePaths(base, refPath) {
+  if (base.authority !== undefined && base.path === '') {
+    return `/${refPath}`;
+  }
+  const i = base.path.lastIndexOf('/');
+  if (i < 0) return refPath;
+  return `${base.path.slice(0, i + 1)}${refPath}`;
+}
+
 function resolveIriRef(ref, base) {
-  if (!base) return ref;
-  if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(ref)) return ref; // already absolute
-  try {
-    return new URL(ref, base).toString();
-  } catch {
-    return ref;
+  const r = parseUriReferenceForResolution(ref);
+  if (!r) return ref;
+
+  const baseParts = base ? parseUriReferenceForResolution(base) : null;
+
+  // Absolute references do not need a base, but RFC 3986 section 5.2.2 still
+  // applies remove_dot_segments(R.path) when R.scheme is defined.
+  if (r.scheme !== undefined) {
+    return recomposeUriReference({
+      scheme: r.scheme,
+      authority: r.authority,
+      path: removeDotSegments(r.path),
+      query: r.query,
+      fragment: r.fragment,
+    });
+  }
+
+  // Without a usable base, preserve relative references as written.
+  if (!baseParts || baseParts.scheme === undefined) return ref;
+
+  const t = {
+    scheme: baseParts.scheme,
+    authority: undefined,
+    path: '',
+    query: undefined,
+    fragment: r.fragment,
+  };
+
+  if (r.authority !== undefined) {
+    t.authority = r.authority;
+    t.path = removeDotSegments(r.path);
+    t.query = r.query;
+  } else if (r.path === '') {
+    t.authority = baseParts.authority;
+    t.path = baseParts.path;
+    t.query = r.query !== undefined ? r.query : baseParts.query;
+  } else {
+    t.authority = baseParts.authority;
+    if (r.path.startsWith('/')) {
+      t.path = removeDotSegments(r.path);
+    } else {
+      t.path = removeDotSegments(mergePaths(baseParts, r.path));
+    }
+    t.query = r.query;
   }
+
+  return recomposeUriReference(t);
 }
 
 // -----------------------------------------------------------------------------

package/lib/builtins.js

@@ -1680,15 +1680,85 @@ function __listElemsForBuiltin(listLike, facts) {
   return null;
 }
 
-function evalListFirstLikeBuiltin(sTerm, oTerm, subst) {
-  if (!(sTerm instanceof ListTerm)) return [];
-  if (!sTerm.elems.length) return [];
-  const first = sTerm.elems[0];
-  const s2 = unifyTerm(oTerm, first, subst);
-  return s2 !== null ? [s2] : [];
+function __pushBuiltinDeltaLimited(out, delta, maxResults) {
+  if (delta === null) return false;
+  out.push(delta);
+  return typeof maxResults === 'number' && maxResults > 0 && out.length >= maxResults;
+}
+
+function __collectListLikeTermsFromTerm(t, out, seen) {
+  if (t instanceof ListTerm || t instanceof OpenListTerm) {
+    const k = termFastKey(t);
+    if (k === null || !seen.has(k)) {
+      if (k !== null) seen.add(k);
+      out.push(t);
+    }
+    if (t instanceof ListTerm) {
+      for (const e of t.elems) __collectListLikeTermsFromTerm(e, out, seen);
+    } else {
+      for (const e of t.prefix) __collectListLikeTermsFromTerm(e, out, seen);
+    }
+    return;
+  }
+  if (t instanceof GraphTerm) {
+    for (const tr of t.triples) {
+      __collectListLikeTermsFromTerm(tr.s, out, seen);
+      __collectListLikeTermsFromTerm(tr.p, out, seen);
+      __collectListLikeTermsFromTerm(tr.o, out, seen);
+    }
+  }
+}
+
+function __collectListLikeTermsFromFacts(facts) {
+  const out = [];
+  const seen = new Set();
+  for (const tr of facts) {
+    __collectListLikeTermsFromTerm(tr.s, out, seen);
+    __collectListLikeTermsFromTerm(tr.o, out, seen);
+  }
+  return out;
+}
+
+function evalListFirstLikeBuiltin(sTerm, oTerm, subst, facts, maxResults) {
+  if (sTerm instanceof ListTerm) {
+    if (!sTerm.elems.length) return [];
+    const first = sTerm.elems[0];
+    const s2 = unifyTerm(oTerm, first, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // For a variable subject, enumerate already-existing collection terms.
+  // This lets a rule body such as `_:x rdf:first 1; rdf:rest rdf:nil`
+  // bind `_:x` to an N3 collection literal `(1)` used elsewhere as a term.
+  // Also include ordinary rdf:first facts so the builtin path does not hide
+  // RDF-serialized lists when the subject starts unbound.
+  if (sTerm instanceof Var) {
+    const out = [];
+
+    for (const listTerm of __collectListLikeTermsFromFacts(facts)) {
+      if (!(listTerm instanceof ListTerm) || !listTerm.elems.length) continue;
+      let s2 = unifyTerm(sTerm, listTerm, subst);
+      if (s2 === null) continue;
+      s2 = unifyTerm(oTerm, listTerm.elems[0], s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    const RDF_FIRST = RDF_NS + 'first';
+    for (const tr of facts) {
+      if (!(tr.p instanceof Iri) || tr.p.value !== RDF_FIRST) continue;
+      let s2 = unifyTerm(sTerm, tr.s, subst);
+      if (s2 === null) continue;
+      s2 = unifyTerm(oTerm, tr.o, s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    return out;
+  }
+
+  return [];
 }
 
-function evalListRestLikeBuiltin(sTerm, oTerm, subst) {
+function evalListRestLikeBuiltin(sTerm, oTerm, subst, facts, maxResults) {
   // Closed list: (a b c) -> (b c)
   if (sTerm instanceof ListTerm) {
     if (!sTerm.elems.length) return [];
@@ -1709,6 +1779,32 @@ function evalListRestLikeBuiltin(sTerm, oTerm, subst) {
     return s2 !== null ? [s2] : [];
   }
 
+  // See evalListFirstLikeBuiltin(): if the collection subject is still a
+  // variable, enumerate known list literals and ordinary rdf:rest facts.
+  if (sTerm instanceof Var) {
+    const out = [];
+
+    for (const listTerm of __collectListLikeTermsFromFacts(facts)) {
+      if (!(listTerm instanceof ListTerm) || !listTerm.elems.length) continue;
+      let s2 = unifyTerm(sTerm, listTerm, subst);
+      if (s2 === null) continue;
+      const rest = new ListTerm(listTerm.elems.slice(1));
+      s2 = unifyTerm(oTerm, rest, s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    const RDF_REST = RDF_NS + 'rest';
+    for (const tr of facts) {
+      if (!(tr.p instanceof Iri) || tr.p.value !== RDF_REST) continue;
+      let s2 = unifyTerm(sTerm, tr.s, subst);
+      if (s2 === null) continue;
+      s2 = unifyTerm(oTerm, tr.o, s2);
+      if (__pushBuiltinDeltaLimited(out, s2, maxResults)) return out;
+    }
+
+    return out;
+  }
+
   return [];
 }
 
@@ -2848,14 +2944,14 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     return s2 !== null ? [s2] : [];
   }
   if (pv === RDF_NS + 'first') {
-    return evalListFirstLikeBuiltin(g.s, g.o, subst);
+    return evalListFirstLikeBuiltin(g.s, g.o, subst, facts, maxResults);
   }
 
   // list:rest and rdf:rest
   // true iff $s is a (non-empty) list and $o is the rest (tail) of that list.
   // Schema: $s+ list:rest $o-
   if (pv === LIST_NS + 'rest') {
-    if (g.s instanceof ListTerm || g.s instanceof OpenListTerm) return evalListRestLikeBuiltin(g.s, g.o, subst);
+    if (g.s instanceof ListTerm || g.s instanceof OpenListTerm) return evalListRestLikeBuiltin(g.s, g.o, subst, facts, maxResults);
     const xs = __listElemsForBuiltin(g.s, facts);
     if (!xs || !xs.length) return [];
     const rest = new ListTerm(xs.slice(1));
@@ -2863,7 +2959,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     return s2 !== null ? [s2] : [];
   }
   if (pv === RDF_NS + 'rest') {
-    return evalListRestLikeBuiltin(g.s, g.o, subst);
+    return evalListRestLikeBuiltin(g.s, g.o, subst, facts, maxResults);
   }
 
   // list:iterate

package/lib/engine.js

@@ -2600,7 +2600,10 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxR
     const isRdfFirstOrRest = goalPredicateIri === RDF_NS + 'first' || goalPredicateIri === RDF_NS + 'rest';
     const shouldTreatAsBuiltin =
       isBuiltinPred(goal0.p) &&
-      !(isRdfFirstOrRest && !(goal0.s instanceof ListTerm || goal0.s instanceof OpenListTerm));
+      !(
+        isRdfFirstOrRest &&
+        !(goal0.s instanceof ListTerm || goal0.s instanceof OpenListTerm || goal0.s instanceof Var)
+      );
 
     if (shouldTreatAsBuiltin) {
       const remaining = max - results.length;