eyeling 1.8.2 → 1.8.4

package/README.md

@@ -21,7 +21,7 @@ Try it here:
   - Load an N3 program from a URL (in the "Load N3 from URL" box or as ?url=...).
   - Share a link with the program encoded in the URL fragment (`#...`).
 
-- Streaming demo
+- Streaming demo tab
   - Browse a Wikidata entity, load its facts, and see Eyeling’s **deductive closure appear incrementally** as triples are derived.
   - Edit **N3 rules live** and re-run to watch how different inference rules change what gets derived.
   - Demo **CORS-safe dynamic fetching**: derived “fetch requests” can trigger extra facts (e.g., Wikiquote extracts) that are injected and re-reasoned.

package/examples/doctor-advice-work-conflict.n3

@@ -0,0 +1,182 @@
+# =============================================================================
+# AIR-style policy reasoning with a paraconsistent conflict and deterministic
+# conflict resolution.
+#
+# Scenario:
+#   - Jos has Flu; Flu is a Disease -> Jos is Sick.
+#   - Doctor says Jos can do ProgrammingWork.
+#   - Policy: Sick + Work => deny Work (general).
+#   - Policy: Sick + Work + Office => deny Work (avoid infecting colleagues).
+#   - Resolution: If conflicted:
+#       * Work  => Deny
+#       * Home+ProgrammingWork => Permit
+#       * otherwise => Undecided
+#
+# Technique:
+#   - Keep facts+rules in a quoted KB formula, compute closure with log:conclusion.
+#   - Use log:includes / log:notIncludes for scoped checks (SNAF).
+# =============================================================================
+
+@prefix :    <http://example.org/#>.
+@prefix air: <http://dig.csail.mit.edu/TAMI/2007/amord/air#>.
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix log:  <http://www.w3.org/2000/10/swap/log#>.
+
+# -----------------------------------------------------------------------------
+# 1) KB formula
+# -----------------------------------------------------------------------------
+
+:kb :hasFormula {
+
+  # Facts
+  :Jos a :Person ; :has :Flu .
+  :Flu :typeOf :Disease.
+
+  :Home a :Location.
+  :Office a :Location.
+
+  :ProgrammingWork rdfs:subClassOf :Work.
+
+  # Requests
+  :Request_Jos_Prog_Home a :Request ;
+      :agent :Jos ;
+      :job :ProgrammingWork ;
+      :location :Home .
+
+  :Request_Jos_Prog_Office a :Request ;
+      :agent :Jos ;
+      :job :ProgrammingWork ;
+      :location :Office .
+
+  # Doctor said (quoted)
+  :Doctor :says { :Jos :canDo :ProgrammingWork. }.
+
+  # Lift quoted statement
+  { ?doc :says ?G.
+    ?G log:includes { ?x :canDo ?job. }.
+  } => { ?x :canDo ?job. }.
+
+  # Flu -> Disease
+  { ?x :has ?a. ?a :typeOf ?b. } => { ?x :has ?b. }.
+
+  # Disease -> Sick (context)
+  { ?x :has :Disease. } => { ?x :healthStatus :Sick. }.
+
+  # Minimal subclass closure helper
+  { ?a rdfs:subClassOf ?b. } => { ?a :isKindOf ?b. }.
+  { ?a :isKindOf ?b. ?b :isKindOf ?c. } => { ?a :isKindOf ?c. }.
+
+  # canDo propagates to supertypes
+  { ?x :canDo ?job. ?job rdfs:subClassOf ?super. } => { ?x :canDo ?super. }.
+
+  # ----------------------------------------------------------
+  # AIR-annotated rules (documentation) + executable counterparts
+  # ----------------------------------------------------------
+
+  # Doctor: if canDo requested job => Permit
+  :R_DoctorPermit a air:Rule;
+    air:if   { ?req a :Request; :agent ?x; :job ?job. ?x :canDo ?job. };
+    air:then { ?req :decision :Permit. }.
+
+  { ?req a :Request; :agent ?x; :job ?job. ?x :canDo ?job. }
+    => { ?req :decision :Permit. }.
+
+  # Health: Sick + Work => Deny
+  :R_SickNoWork a air:Rule;
+    air:if   { ?req a :Request; :agent ?x; :job ?job. ?x :healthStatus :Sick. ?job :isKindOf :Work. };
+    air:then { ?req :decision :Deny. }.
+
+  { ?req a :Request; :agent ?x; :job ?job. ?x :healthStatus :Sick. ?job :isKindOf :Work. }
+    => { ?req :decision :Deny. }.
+
+  # Health: Sick + Work + Office => Deny (avoid infecting colleagues)
+  :R_SickWork a air:Rule;
+    air:if   { ?req a :Request; :agent ?x; :job ?job; :location :Office.
+               ?x :healthStatus :Sick. ?job :isKindOf :Office. };
+    air:then { ?req :decision :Deny. ?x :avoidInfectingColleagues true. }.
+
+  { ?req a :Request; :agent ?x; :job ?job; :location :Office.
+    ?x :healthStatus :Sick. ?job :isKindOf :Office. }
+    => { ?req :decision :Deny. ?x :avoidInfectingColleagues true. }.
+
+  # Resolution hint: Sick + ProgrammingWork at Home => Permit
+  :R_SickProgHome a air:Rule;
+    air:if   { ?req a :Request; :agent ?x; :job :ProgrammingWork; :location :Home. ?x :healthStatus :Sick. };
+    air:then { ?req :decision :Permit. ?x :remoteWorkRecommended true. }.
+
+  { ?req a :Request; :agent ?x; :job :ProgrammingWork; :location :Home. ?x :healthStatus :Sick. }
+    => { ?req :decision :Permit. ?x :remoteWorkRecommended true. }.
+}.
+
+# -----------------------------------------------------------------------------
+# 2) Lift request facts out of the closure (small, deterministic output)
+# -----------------------------------------------------------------------------
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?req a :Request; :agent ?who; :job ?job; :location ?loc. }.
+} => { ?req :agent ?who; :job ?job; :location ?loc. }.
+
+# -----------------------------------------------------------------------------
+# 3) decisionStatus via scoped checks on closure
+# -----------------------------------------------------------------------------
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?req :decision :Permit. }.
+  ?C log:includes { ?req :decision :Deny. }.
+} => { ?req :decisionStatus :BothPermitDeny. }.
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?req :decision :Permit. }.
+  ?C log:notIncludes { ?req :decision :Deny. }.
+} => { ?req :decisionStatus :PermitOnly. }.
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?req :decision :Deny. }.
+  ?C log:notIncludes { ?req :decision :Permit. }.
+} => { ?req :decisionStatus :DenyOnly. }.
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:notIncludes { ?req :decision :Permit. }.
+  ?C log:notIncludes { ?req :decision :Deny. }.
+} => { ?req :decisionStatus :Neither. }.
+
+# -----------------------------------------------------------------------------
+# 4) effectiveDecision (mutually exclusive; no extra Undecided)
+# -----------------------------------------------------------------------------
+
+# Non-conflicts
+{ ?req :decisionStatus :PermitOnly. } => { ?req :effectiveDecision :Permit. }.
+{ ?req :decisionStatus :DenyOnly.   } => { ?req :effectiveDecision :Deny. }.
+{ ?req :decisionStatus :Neither.    } => { ?req :effectiveDecision :NotSpecified. }.
+
+# Conflict + Work => Deny (+ flag in same rule)
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?req :decision :Permit. }.
+  ?C log:includes { ?req :decision :Deny. }.
+  ?C log:includes { ?req :location :Office }.
+} => { ?req :effectiveDecision :Deny. }.
+
+# Conflict + Home + ProgrammingWork => Permit (+ flag)
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?req :decision :Permit. }.
+  ?C log:includes { ?req :decision :Deny. }.
+  ?C log:includes { ?req :location :Home. }.
+  ?C log:includes { ?req :job :ProgrammingWork. }.
+} => { ?req :effectiveDecision :Permit. }.
+
+# Conflict that matches neither resolver => Undecided (+ flag)
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?req :decision :Permit. }.
+  ?C log:includes    { ?req :decision :Deny. }.
+  ?C log:notIncludes { ?req :location :Office. }.
+  ?C log:notIncludes { ?req :location :Home. ?req :job :ProgrammingWork. }.
+} => { ?req :effectiveDecision :Undecided. }.
+
+# -----------------------------------------------------------------------------
+# 5) Summary: if Home permitted + Work denied => RemoteWorkOnly
+# -----------------------------------------------------------------------------
+
+{ ?rH :agent ?who; :location :Home;    :effectiveDecision :Permit.
+  ?rC :agent ?who; :location :Office; :effectiveDecision :Deny.
+} => { ?who :workDecision :RemoteWorkOnly. }.
+

package/examples/eventual-interoperability-interaction-patterns.n3

@@ -0,0 +1,379 @@
+# =============================================================================
+# This example illustrates “eventual interoperability”:
+#   1) Start with rich, internally coherent source semantics (my:*).
+#   2) Add interoperability later as explicit, reusable alignments when a
+#      concrete interaction/business case exists.
+#   3) Alignments can be versioned and swapped without changing the source.
+#   4) Same source can be aligned one-to-many: different partners, different
+#      target shapes.
+#
+# The file models a dataset owner publishing a roster using their own rich
+# vocabulary (my:) without forcing early agreement on a shared schema.
+# When two concrete reuse needs appear (exporting to Partner A and Partner B),
+# each integration is handled by introducing an interaction pattern:
+#   alignment artefact (mappings) + an expected output shape.
+# The reasoner selects the active alignment for each partner, applies
+# class/property/inverse-property mappings to produce each partner’s expected
+# shape, and then emits “ready” roster views (:PartnerA_Roster, :PartnerB_Roster).
+# In other words: local semantics first, interoperability later, and one dataset
+# can be aligned to multiple consumers without changing the producer’s model.
+#
+# SHACL note:
+#   SHACL NodeShapes describe each partner’s expected output shape and act as a
+#   consumer-facing “contract” for the aligned view (they can also be validated).
+#
+# Inspired by: https://pietercolpaert.be/interoperability/2026/01/08/eventual-interoperability
+# =============================================================================
+
+@prefix my:    <http://example.org/my#>.
+@prefix a:     <http://example.org/partnerA#>.
+@prefix b:     <http://example.org/partnerB#>.
+@prefix align: <http://example.org/align#>.
+@prefix :      <http://example.org/demo#>.
+
+@prefix list: <http://www.w3.org/2000/10/swap/list#>.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix log:   <http://www.w3.org/2000/10/swap/log#>.
+@prefix owl:   <http://www.w3.org/2002/07/owl#>.
+@prefix sh:    <http://www.w3.org/ns/shacl#>.
+
+# ----------------------------------------------------------
+# 1) Producer data (rich, local semantics)
+# ----------------------------------------------------------
+
+my:Course_KG a my:Course ;
+  my:courseCode "KG-101" ;
+  my:title "Knowledge Graphs" .
+
+my:Student_A a my:Student ;
+  my:givenName  "Ava" ;
+  my:familyName "Ng" ;
+  my:displayName "Ava Ng" ;
+  my:studentID  "S123" ;
+  my:enrolledInCourse my:Course_KG ;
+  my:enrollmentRole my:TeachingAssistant .
+
+my:Student_B a my:Student ;
+  my:givenName  "Bram" ;
+  my:familyName "Peeters" ;
+  my:displayName "Bram Peeters" ;
+  my:studentID  "S124" ;
+  my:enrolledInCourse my:Course_KG ;
+  my:enrollmentRole my:Student .
+
+# ----------------------------------------------------------
+# 2) Interaction patterns (business cases)
+# ----------------------------------------------------------
+
+:RosterExportToPartnerA a :InteractionPattern ;
+  :enabled true ;
+  :usesAlignmentFamily :AlignFamily_PartnerA ;
+  # SHACL shapes used by this interaction pattern:
+  :usesShape :AStudentShape, :ACourseShape .
+
+:RosterExportToPartnerB a :InteractionPattern ;
+  :enabled true ;
+  :usesAlignmentFamily :AlignFamily_PartnerB ;
+  # SHACL shapes used by this interaction pattern:
+  :usesShape :BLearnerShape, :BModuleShape .
+
+# ----------------------------------------------------------
+# 3) SHACL shapes (descriptions of what partners expect)
+# ----------------------------------------------------------
+
+# Partner A expects:
+#   - Students have identifier, givenName, familyName
+#   - Courses have at least one hasStudent, and those values are Students
+
+:AStudentShape a sh:NodeShape ;
+  sh:targetClass a:Student ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path a:identifier ;
+    sh:minCount 1
+  ] ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path a:givenName ;
+    sh:minCount 1
+  ] ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path a:familyName ;
+    sh:minCount 1
+  ] .
+
+:ACourseShape a sh:NodeShape ;
+  sh:targetClass a:Course ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path a:hasStudent ;
+    sh:minCount 1 ;
+    sh:class a:Student
+  ] .
+
+# Partner B expects:
+#   - Learners have learnerId and fullName
+#   - Modules have moduleCode and at least one hasLearner (values are Learners)
+
+:BLearnerShape a sh:NodeShape ;
+  sh:targetClass b:Learner ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path b:learnerId ;
+    sh:minCount 1
+  ] ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path b:fullName ;
+    sh:minCount 1
+  ] .
+
+:BModuleShape a sh:NodeShape ;
+  sh:targetClass b:Module ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path b:moduleCode ;
+    sh:minCount 1
+  ] ;
+  sh:property [
+    a sh:PropertyShape ;
+    sh:path b:hasLearner ;
+    sh:minCount 1 ;
+    sh:class b:Learner
+  ] .
+
+# ----------------------------------------------------------
+# 4) Alignment artefacts (kept separate from producer model)
+#    Demonstrates incremental/versioned alignments.
+# ----------------------------------------------------------
+
+:Align_A_v1 a :Alignment ; :active false ; :hasFormula {
+  # Minimal mapping: only identifier and enrollment link
+  my:studentID owl:equivalentProperty a:identifier .
+  my:enrolledInCourse owl:inverseOf a:hasStudent .
+  my:Student owl:equivalentClass a:Student .
+  my:Course  owl:equivalentClass a:Course .
+}.
+
+:Align_A_v2 a :Alignment ; :active true ; :hasFormula {
+  # More complete mapping (later, when the business case is clear)
+  my:studentID   owl:equivalentProperty a:identifier .
+  my:givenName   owl:equivalentProperty a:givenName .
+  my:familyName  owl:equivalentProperty a:familyName .
+  my:enrolledInCourse owl:inverseOf a:hasStudent .
+  my:Student owl:equivalentClass a:Student .
+  my:Course  owl:equivalentClass a:Course .
+}.
+
+:AlignFamily_PartnerA :hasMember :Align_A_v1, :Align_A_v2.
+
+:Align_B_v1 a :Alignment ; :active true ; :hasFormula {
+  # Partner B wants a different shape
+  my:Student owl:equivalentClass b:Learner .
+  my:studentID owl:equivalentProperty b:learnerId .
+  my:displayName owl:equivalentProperty b:fullName .
+  my:enrolledInCourse owl:inverseOf b:hasLearner .
+  my:Course owl:equivalentClass b:Module .
+  my:courseCode owl:equivalentProperty b:moduleCode .
+}.
+
+:AlignFamily_PartnerB :hasMember :Align_B_v1.
+
+# ----------------------------------------------------------
+# 5) Generic “eventual interoperability” engine
+#    - pick the active alignment for the interaction pattern
+#    - apply vocabulary-level alignments
+# ----------------------------------------------------------
+
+# Pick the active alignment for a pattern from its family
+{
+  ?pat a :InteractionPattern ;
+       :enabled true ;
+       :usesAlignmentFamily ?fam .
+  ?fam :hasMember ?al .
+  ?al :active true .
+} => {
+  ?pat :usesAlignment ?al .
+}.
+
+# Equivalent class mapping
+{
+  ?pat :usesAlignment ?al .
+  ?al :hasFormula ?A.
+  ?A log:includes { ?c1 owl:equivalentClass ?c2. }.
+  ?x a ?c1.
+} => {
+  ?x a ?c2.
+  ?x :alignedBy ?pat.
+}.
+
+# Equivalent property mapping
+{
+  ?pat :usesAlignment ?al .
+  ?al :hasFormula ?A.
+  ?A log:includes { ?p1 owl:equivalentProperty ?p2. }.
+  ?s ?p1 ?o.
+} => {
+  ?s ?p2 ?o.
+  ?s :alignedBy ?pat.
+}.
+
+# Inverse property mapping (shape translation)
+{
+  ?pat :usesAlignment ?al .
+  ?al :hasFormula ?A.
+  ?A log:includes { ?p1 owl:inverseOf ?p2. }.
+  ?s ?p1 ?o.
+} => {
+  ?o ?p2 ?s.
+  ?o :alignedBy ?pat.
+}.
+
+# ----------------------------------------------------------
+# 6) Interaction-pattern outputs (same checks as original)
+#    These rules correspond directly to the SHACL shapes above.
+# ----------------------------------------------------------
+
+# Partner A “ready” (corresponds to :AStudentShape + :ACourseShape)
+{
+  ?pat a :InteractionPattern ; :enabled true .
+  ?pat :usesShape :AStudentShape, :ACourseShape.
+
+  ?student a a:Student ;
+           a:identifier ?id ;
+           a:givenName ?gn ;
+           a:familyName ?fn .
+  ?course a a:Course ;
+          a:hasStudent ?student .
+  ?student :alignedBy ?pat.
+} => {
+  :PartnerA_Roster :fromPattern ?pat ;
+                   :includesCourse ?course ;
+                   :includesStudent ?student ;
+                   :ready true .
+}.
+
+# Partner B “ready” (corresponds to :BLearnerShape + :BModuleShape)
+{
+  ?pat a :InteractionPattern ; :enabled true .
+  ?pat :usesShape :BLearnerShape, :BModuleShape.
+
+  ?learner a b:Learner ;
+           b:learnerId ?id ;
+           b:fullName ?name .
+  ?module  a b:Module ;
+           b:moduleCode ?code ;
+           b:hasLearner ?learner .
+  ?learner :alignedBy ?pat.
+} => {
+  :PartnerB_Roster :fromPattern ?pat ;
+                   :includesModule ?module ;
+                   :includesLearner ?learner ;
+                   :ready true .
+}.
+
+# ----------------------------------------------------------
+# 7) SHACL validation in N3 (minimal subset)
+#    - sh:minCount 1
+#    - sh:class
+#
+# Reports are per interaction pattern.
+# ----------------------------------------------------------
+
+# Reports (stable IRIs; keeps things simple/deterministic)
+:PartnerA_Report a sh:ValidationReport ;
+  :forPattern :RosterExportToPartnerA ;
+  :forRoster  :PartnerA_Roster .
+
+:PartnerB_Report a sh:ValidationReport ;
+  :forPattern :RosterExportToPartnerB ;
+  :forRoster  :PartnerB_Roster .
+
+# --------------------------
+# minCount violations
+# --------------------------
+
+{
+  ?rep a sh:ValidationReport ;
+       :forPattern ?pat .
+
+  # this pattern uses this shape
+  ?pat :usesShape ?shape .
+
+  # shape definition
+  ?shape a sh:NodeShape ;
+         sh:targetClass ?class ;
+         sh:property ?ps .
+
+  ?ps sh:path ?path ;
+      sh:minCount ?min .
+
+  # focus nodes: nodes aligned for this pattern and of the target class
+  ?focus a ?class ;
+         :alignedBy ?pat .
+  # count values in the closure for (focus,path)
+  ( 1 { ?focus ?path ?v. } ?vals ) log:collectAllIn ?SCOPE.
+  ?vals list:length ?count .
+
+  # violation if count < min
+  ?count math:lessThan ?min .
+} => {
+  ?rep sh:result [
+    a sh:ValidationResult ;
+    sh:focusNode ?focus ;
+    sh:resultPath ?path ;
+    sh:sourceShape ?shape ;
+    sh:sourceConstraintComponent sh:MinCountConstraintComponent ;
+    sh:resultMessage "Missing required property (minCount)."
+  ] .
+}.
+
+# --------------------------
+# sh:class violations
+# --------------------------
+
+{
+  ?rep a sh:ValidationReport ;
+       :forPattern ?pat .
+
+  ?pat :usesShape ?shape .
+
+  ?shape a sh:NodeShape ;
+         sh:targetClass ?class ;
+         sh:property ?ps .
+
+  ?ps sh:path ?path ;
+      sh:class ?requiredClass .
+
+  ?focus a ?class ;
+         :alignedBy ?pat ;
+         ?path ?value .
+
+  # scoped NAF: value does NOT have the required rdf:type
+  ( 1 { ?value a ?requiredClass. } () ) log:collectAllIn ?SCOPE.
+} => {
+  ?rep sh:result [
+    a sh:ValidationResult ;
+    sh:focusNode ?focus ;
+    sh:resultPath ?path ;
+    sh:sourceShape ?shape ;
+    sh:sourceConstraintComponent sh:ClassConstraintComponent ;
+    sh:resultMessage "Value does not have required sh:class."
+  ] .
+}.
+
+# --------------------------
+# sh:conforms
+# --------------------------
+
+# If any result exists (in the current graph) -> conforms false
+{ ?rep a sh:ValidationReport.
+  ?rep sh:result ?r.
+} => { ?rep sh:conforms false. }.
+
+# If no result exists (SNAF in current scope) -> conforms true
+{ ?rep a sh:ValidationReport.
+  (1 { ?rep sh:result ?r. } () ) log:collectAllIn 2.
+} => { ?rep sh:conforms true. }.
+

package/examples/odrl-policy-evaluation-snaf.n3

@@ -0,0 +1,242 @@
+# =============================================================================
+# ODRL Policies with scoped NAF via log:conclusion + log:(not)Includes
+#
+# Pattern:
+#   - Put "data + rules" in a quoted KB formula
+#   - Compute its deductive closure with log:conclusion
+#   - Ask questions about what the closure entails using log:includes / log:notIncludes
+#
+# What you get as output:
+#   - :decisionStatus  in { :PermitOnly, :DenyOnly, :Both, :Neither }
+#   - :effectiveDecision applying ODRL conflict strategy
+#
+# ODRL conflict strategies:
+#   odrl:perm      => Permission overrides Prohibition
+#   odrl:prohibit  => Prohibition overrides Permission
+#   odrl:invalid   => Conflicts void the whole policy
+# =============================================================================
+
+@prefix :    <http://example.org/odrl-paraconsistent#>.
+@prefix odrl: <http://www.w3.org/ns/odrl/2/>.
+@prefix log:  <http://www.w3.org/2000/10/swap/log#>.
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
+
+# ---------------------------------------------------------------
+# 1) KB formula: ODRL policies + requests + matching rules
+#    (kept inside a formula so raw derivations don’t clutter output)
+# ---------------------------------------------------------------
+
+:kb :hasFormula {
+
+  # ----------------------
+  # Assets / Parties
+  # ----------------------
+  :Report a odrl:Asset.
+  :Alice  a odrl:Party.
+  :Bob    a odrl:Party.
+
+  # ----------------------
+  # Policy Sets
+  # ----------------------
+
+  # Same rules, different conflict strategy:
+  :PS_Prohibit a odrl:Set; odrl:conflict odrl:prohibit.
+  :PS_Perm     a odrl:Set; odrl:conflict odrl:perm.
+  :PS_Invalid  a odrl:Set; odrl:conflict odrl:invalid.
+
+  # Rule templates (blank nodes are fine here)
+  # Permission: Alice may print Report for purpose Research
+  :PS_Prohibit odrl:permission [
+    odrl:target   :Report;
+    odrl:action   odrl:print;
+    odrl:assignee :Alice;
+    odrl:constraint [
+      odrl:leftOperand odrl:purpose;
+      odrl:operator    odrl:eq;
+      odrl:rightOperand :Research
+    ]
+  ].
+
+  :PS_Perm odrl:permission [
+    odrl:target   :Report;
+    odrl:action   odrl:print;
+    odrl:assignee :Alice;
+    odrl:constraint [
+      odrl:leftOperand odrl:purpose;
+      odrl:operator    odrl:eq;
+      odrl:rightOperand :Research
+    ]
+  ].
+
+  :PS_Invalid odrl:permission [
+    odrl:target   :Report;
+    odrl:action   odrl:print;
+    odrl:assignee :Alice;
+    odrl:constraint [
+      odrl:leftOperand odrl:purpose;
+      odrl:operator    odrl:eq;
+      odrl:rightOperand :Research
+    ]
+  ].
+
+  # Prohibition: Alice is prohibited to print Report (no constraint => always)
+  :PS_Prohibit odrl:prohibition [
+    odrl:target   :Report;
+    odrl:action   odrl:print;
+    odrl:assignee :Alice
+  ].
+
+  :PS_Perm odrl:prohibition [
+    odrl:target   :Report;
+    odrl:action   odrl:print;
+    odrl:assignee :Alice
+  ].
+
+  :PS_Invalid odrl:prohibition [
+    odrl:target   :Report;
+    odrl:action   odrl:print;
+    odrl:assignee :Alice
+  ].
+
+  # Extra: Bob may read (permit-only example)
+  :PS_Prohibit odrl:permission [
+    odrl:target   :Report;
+    odrl:action   odrl:read;
+    odrl:assignee :Bob
+  ].
+
+  # Extra: Bob is prohibited to distribute (deny-only example)
+  :PS_Prohibit odrl:prohibition [
+    odrl:target   :Report;
+    odrl:action   odrl:distribute;
+    odrl:assignee :Bob
+  ].
+
+  # ----------------------
+  # Requests we want to evaluate
+  # ----------------------
+
+  :Req_Alice_Print_Research_Prohibit
+    a :Request;
+    :policy   :PS_Prohibit;
+    :assignee :Alice;
+    :action   odrl:print;
+    :target   :Report;
+    :purpose  :Research.
+
+  :Req_Alice_Print_Research_Perm
+    a :Request;
+    :policy   :PS_Perm;
+    :assignee :Alice;
+    :action   odrl:print;
+    :target   :Report;
+    :purpose  :Research.
+
+  :Req_Alice_Print_Research_Invalid
+    a :Request;
+    :policy   :PS_Invalid;
+    :assignee :Alice;
+    :action   odrl:print;
+    :target   :Report;
+    :purpose  :Research.
+
+  :Req_Bob_Read
+    a :Request;
+    :policy   :PS_Prohibit;
+    :assignee :Bob;
+    :action   odrl:read;
+    :target   :Report.
+
+  :Req_Bob_Distribute
+    a :Request;
+    :policy   :PS_Prohibit;
+    :assignee :Bob;
+    :action   odrl:distribute;
+    :target   :Report.
+
+  :Req_Bob_Archive
+    a :Request;
+    :policy   :PS_Prohibit;
+    :assignee :Bob;
+    :action   odrl:archive;   # no rules mention this action => Neither
+    :target   :Report.
+
+  # ----------------------
+  # Decision derivation rules (inside KB)
+  # ----------------------
+
+  # Permission without constraint
+  { ?req a :Request; :policy ?ps; :assignee ?who; :action ?act; :target ?asset.
+    ?ps odrl:permission ?perm.
+    ?perm odrl:assignee ?who; odrl:action ?act; odrl:target ?asset.
+  } => { ?req :decision :Permit. }.
+
+  # Permission with purpose constraint (eq)
+  { ?req a :Request; :policy ?ps; :assignee ?who; :action ?act; :target ?asset; :purpose ?purpose.
+    ?ps odrl:permission ?perm.
+    ?perm odrl:assignee ?who; odrl:action ?act; odrl:target ?asset; odrl:constraint ?c.
+    ?c odrl:leftOperand odrl:purpose; odrl:operator odrl:eq; odrl:rightOperand ?purpose.
+  } => { ?req :decision :Permit. }.
+
+  # Prohibition without constraint
+  { ?req a :Request; :policy ?ps; :assignee ?who; :action ?act; :target ?asset.
+    ?ps odrl:prohibition ?proh.
+    ?proh odrl:assignee ?who; odrl:action ?act; odrl:target ?asset.
+  } => { ?req :decision :Deny. }.
+}.
+
+# ---------------------------------------------------------------
+# 2) Pull a few “queryable” facts out of the closure
+# ---------------------------------------------------------------
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?req :policy ?ps. ?ps odrl:conflict ?strategy. }.
+} => { ?req :conflictStrategy ?strategy. }.
+
+# ---------------------------------------------------------------
+# 3) DecisionStatus via scoped NAF on the closure
+# ---------------------------------------------------------------
+
+# Both (conflict)
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?req :decision :Permit. }.
+  ?C log:includes { ?req :decision :Deny. }.
+} => { ?req :decisionStatus :Both. }.
+
+# PermitOnly
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?req :decision :Permit. }.
+  ?C log:notIncludes { ?req :decision :Deny. }.
+} => { ?req :decisionStatus :PermitOnly. }.
+
+# DenyOnly
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?req :decision :Deny. }.
+  ?C log:notIncludes { ?req :decision :Permit. }.
+} => { ?req :decisionStatus :DenyOnly. }.
+
+# Neither (no applicable rules)
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:notIncludes { ?req :decision :Permit. }.
+  ?C log:notIncludes { ?req :decision :Deny. }.
+} => { ?req :decisionStatus :Neither. }.
+
+# ---------------------------------------------------------------
+# 4) Effective decision applying ODRL conflict strategy
+# ---------------------------------------------------------------
+
+# Non-conflicts
+{ ?req :decisionStatus :PermitOnly. } => { ?req :effectiveDecision :Permit. }.
+{ ?req :decisionStatus :DenyOnly.   } => { ?req :effectiveDecision :Deny.   }.
+{ ?req :decisionStatus :Neither.    } => { ?req :effectiveDecision :NotSpecified. }.
+
+# Conflicts resolved by strategy + flag in the SAME derivation
+{ ?req :decisionStatus :Both. ?req :conflictStrategy odrl:prohibit. }
+  => { ?req :effectiveDecision :Deny;       :needsReview true. }.
+
+{ ?req :decisionStatus :Both. ?req :conflictStrategy odrl:perm. }
+  => { ?req :effectiveDecision :Permit;     :needsReview true. }.
+
+{ ?req :decisionStatus :Both. ?req :conflictStrategy odrl:invalid. }
+  => { ?req :effectiveDecision :VoidPolicy; :needsReview true. }.
+

package/examples/output/doctor-advice-work-conflict.n3

@@ -0,0 +1,13 @@
+@prefix : <http://example.org/#> .
+
+:Request_Jos_Prog_Home :agent :Jos .
+:Request_Jos_Prog_Home :job :ProgrammingWork .
+:Request_Jos_Prog_Home :location :Home .
+:Request_Jos_Prog_Office :agent :Jos .
+:Request_Jos_Prog_Office :job :ProgrammingWork .
+:Request_Jos_Prog_Office :location :Office .
+:Request_Jos_Prog_Home :decisionStatus :BothPermitDeny .
+:Request_Jos_Prog_Office :decisionStatus :BothPermitDeny .
+:Request_Jos_Prog_Office :effectiveDecision :Deny .
+:Request_Jos_Prog_Home :effectiveDecision :Permit .
+:Jos :workDecision :RemoteWorkOnly .

package/examples/output/eventual-interoperability-interaction-patterns.n3

@@ -0,0 +1,47 @@
+@prefix : <http://example.org/demo#> .
+@prefix a: <http://example.org/partnerA#> .
+@prefix b: <http://example.org/partnerB#> .
+@prefix my: <http://example.org/my#> .
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+
+:RosterExportToPartnerA :usesAlignment :Align_A_v2 .
+:RosterExportToPartnerB :usesAlignment :Align_B_v1 .
+my:Student_A a a:Student .
+my:Student_A :alignedBy :RosterExportToPartnerA .
+my:Student_B a a:Student .
+my:Student_B :alignedBy :RosterExportToPartnerA .
+my:Course_KG a a:Course .
+my:Course_KG :alignedBy :RosterExportToPartnerA .
+my:Student_A a b:Learner .
+my:Student_A :alignedBy :RosterExportToPartnerB .
+my:Student_B a b:Learner .
+my:Student_B :alignedBy :RosterExportToPartnerB .
+my:Course_KG a b:Module .
+my:Course_KG :alignedBy :RosterExportToPartnerB .
+my:Student_A a:identifier "S123" .
+my:Student_B a:identifier "S124" .
+my:Student_A a:givenName "Ava" .
+my:Student_B a:givenName "Bram" .
+my:Student_A a:familyName "Ng" .
+my:Student_B a:familyName "Peeters" .
+my:Student_A b:learnerId "S123" .
+my:Student_B b:learnerId "S124" .
+my:Student_A b:fullName "Ava Ng" .
+my:Student_B b:fullName "Bram Peeters" .
+my:Course_KG b:moduleCode "KG-101" .
+my:Course_KG a:hasStudent my:Student_A .
+my:Course_KG a:hasStudent my:Student_B .
+my:Course_KG b:hasLearner my:Student_A .
+my:Course_KG b:hasLearner my:Student_B .
+:PartnerA_Roster :fromPattern :RosterExportToPartnerA .
+:PartnerA_Roster :includesCourse my:Course_KG .
+:PartnerA_Roster :includesStudent my:Student_A .
+:PartnerA_Roster :ready true .
+:PartnerA_Roster :includesStudent my:Student_B .
+:PartnerB_Roster :fromPattern :RosterExportToPartnerB .
+:PartnerB_Roster :includesModule my:Course_KG .
+:PartnerB_Roster :includesLearner my:Student_A .
+:PartnerB_Roster :ready true .
+:PartnerB_Roster :includesLearner my:Student_B .
+:PartnerA_Report sh:conforms true .
+:PartnerB_Report sh:conforms true .

package/examples/output/odrl-policy-evaluation-snaf.n3

@@ -0,0 +1,22 @@
+@prefix : <http://example.org/odrl-paraconsistent#> .
+@prefix odrl: <http://www.w3.org/ns/odrl/2/> .
+
+:Req_Alice_Print_Research_Prohibit :conflictStrategy odrl:prohibit .
+:Req_Alice_Print_Research_Perm :conflictStrategy odrl:perm .
+:Req_Alice_Print_Research_Invalid :conflictStrategy odrl:invalid .
+:Req_Bob_Read :conflictStrategy odrl:prohibit .
+:Req_Bob_Distribute :conflictStrategy odrl:prohibit .
+:Req_Bob_Archive :conflictStrategy odrl:prohibit .
+:Req_Alice_Print_Research_Prohibit :decisionStatus :Both .
+:Req_Alice_Print_Research_Perm :decisionStatus :Both .
+:Req_Alice_Print_Research_Invalid :decisionStatus :Both .
+:Req_Bob_Read :decisionStatus :PermitOnly .
+:Req_Bob_Distribute :decisionStatus :DenyOnly .
+:Req_Bob_Read :effectiveDecision :Permit .
+:Req_Bob_Distribute :effectiveDecision :Deny .
+:Req_Alice_Print_Research_Prohibit :effectiveDecision :Deny .
+:Req_Alice_Print_Research_Prohibit :needsReview true .
+:Req_Alice_Print_Research_Perm :effectiveDecision :Permit .
+:Req_Alice_Print_Research_Perm :needsReview true .
+:Req_Alice_Print_Research_Invalid :effectiveDecision :VoidPolicy .
+:Req_Alice_Print_Research_Invalid :needsReview true .

package/examples/output/paraconsistent-animals.n3

@@ -0,0 +1,38 @@
+@prefix : <http://example.org/paraconsistent#> .
+
+:tweety :canFlyStatus :Both .
+:mythic :canFlyStatus :Both .
+:falco :canFlyStatus :TrueOnly .
+:batsy :canFlyStatus :TrueOnly .
+:opus :canFlyStatus :FalseOnly .
+:batsy :hasWingsStatus :Both .
+:tweety :hasWingsStatus :TrueOnly .
+:falco :hasWingsStatus :TrueOnly .
+:mythic :hasWingsStatus :TrueOnly .
+:nemo :hasWingsStatus :FalseOnly .
+:tweety :inconsistent :canFly .
+:tweety :needsReview :canFly .
+:mythic :inconsistent :canFly .
+:mythic :needsReview :canFly .
+:batsy :inconsistent :hasWings .
+:batsy :needsReview :hasWings .
+:falco :canFlySafely true .
+:batsy :canFlySafely true .
+:opus :canFlySafely false .
+:tweety :canFlySafely :Undecided .
+:mythic :canFlySafely :Undecided .
+:tweety :hasWingsSafely true .
+:falco :hasWingsSafely true .
+:mythic :hasWingsSafely true .
+:nemo :hasWingsSafely false .
+:batsy :hasWingsSafely :Undecided .
+:falco :movesBySafely :Flying .
+:falco :migratesSafely true .
+:batsy :movesBySafely :Flying .
+:batsy :migratesSafely true .
+:opus :movesBySafely :Walking .
+:opus :migratesSafely false .
+:tweety :movesBySafely :Unknown .
+:tweety :migratesSafely :Undecided .
+:mythic :movesBySafely :Unknown .
+:mythic :migratesSafely :Undecided .

package/examples/output/shacl-conforms.n3

@@ -0,0 +1,5 @@
+@prefix : <http://example.org/demo#> .
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+
+:PartnerA_Report sh:conforms true .
+:PartnerB_Report sh:conforms true .

package/examples/paraconsistent-animals.n3

@@ -0,0 +1,109 @@
+# =============================================================================
+# Paraconsistent N3 example
+#
+# What it demonstrates:
+#   1) Contradictions tolerated: we can have both :p true and :p false.
+#   2) Scoped NAF via deductive closure:
+#        - compute closure with log:conclusion
+#        - check "absence" using log:notIncludes (scoped NAF)
+#        - check "presence" using log:includes
+#   3) Only meaningful derivations are materialized:
+#        - raw/possibly-contradictory facts are kept inside a quoted KB graph
+#        - we only output statuses + "safe" summaries
+# =============================================================================
+
+@prefix :    <http://example.org/paraconsistent#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+
+# ---------------------------------------------------------------
+# 1) Knowledge base (data + domain rules) stored as a graph term
+#    (so its internal derivations are not printed as top-level output)
+# ---------------------------------------------------------------
+
+:kb :hasFormula {
+
+  # --- Data (intentionally inconsistent in places) ---
+  :tweety  a :Bird, :Penguin.
+  :falco   a :Bird.
+  :opus    a :Penguin.
+  :batsy   a :Mammal, :Bat.
+  :nemo    a :Fish.
+
+  # explicit observation that conflicts with "Birds fly"
+  :mythic  a :Bird.
+  :mythic  :canFly false.
+
+  # --- Domain rules that may conflict ---
+  { ?x a :Bird.    } => { ?x :canFly true.  ?x :hasWings true. }.
+  { ?x a :Penguin. } => { ?x :canFly false. }.
+
+  { ?x a :Mammal.  } => { ?x :hasWings false. }.
+  { ?x a :Bat.     } => { ?x :hasWings true.  ?x :canFly true. }.
+
+  { ?x a :Fish.    } => { ?x :canSwim true.  ?x :hasWings false. }.
+}.
+
+# ---------------------------------------------------------------
+# 2) Status computation using:
+#      ?KB log:conclusion ?C .
+#      ?C  log:includes / log:notIncludes  { ... } .
+#
+# Status values: :TrueOnly / :FalseOnly / :Both
+# ---------------------------------------------------------------
+
+# Helper: get the closure once per match (no need to print it)
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?x :canFly true. }.
+  ?C log:includes { ?x :canFly false. }.
+} => { ?x :canFlyStatus :Both. }.
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?x :canFly true. }.
+  ?C log:notIncludes { ?x :canFly false. }.
+} => { ?x :canFlyStatus :TrueOnly. }.
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?x :canFly false. }.
+  ?C log:notIncludes { ?x :canFly true. }.
+} => { ?x :canFlyStatus :FalseOnly. }.
+
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes { ?x :hasWings true. }.
+  ?C log:includes { ?x :hasWings false. }.
+} => { ?x :hasWingsStatus :Both. }.
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?x :hasWings true. }.
+  ?C log:notIncludes { ?x :hasWings false. }.
+} => { ?x :hasWingsStatus :TrueOnly. }.
+
+{ :kb :hasFormula ?F. ?F log:conclusion ?C.
+  ?C log:includes    { ?x :hasWings false. }.
+  ?C log:notIncludes { ?x :hasWings true. }.
+} => { ?x :hasWingsStatus :FalseOnly. }.
+
+# ---------------------------------------------------------------
+# 3) Localize inconsistencies (paraconsistent: flag, don't explode)
+# ---------------------------------------------------------------
+
+{ ?x :canFlyStatus :Both. }    => { ?x :inconsistent :canFly.    ?x :needsReview :canFly. }.
+{ ?x :hasWingsStatus :Both. }  => { ?x :inconsistent :hasWings.  ?x :needsReview :hasWings. }.
+
+# ---------------------------------------------------------------
+# 4) Meaningful materialized summaries ("safe" single-valued views)
+# ---------------------------------------------------------------
+
+{ ?x :canFlyStatus :TrueOnly.  } => { ?x :canFlySafely true. }.
+{ ?x :canFlyStatus :FalseOnly. } => { ?x :canFlySafely false. }.
+{ ?x :canFlyStatus :Both.      } => { ?x :canFlySafely :Undecided. }.
+
+{ ?x :hasWingsStatus :TrueOnly.  } => { ?x :hasWingsSafely true. }.
+{ ?x :hasWingsStatus :FalseOnly. } => { ?x :hasWingsSafely false. }.
+{ ?x :hasWingsStatus :Both.      } => { ?x :hasWingsSafely :Undecided. }.
+
+# Safe behavior derived only from the safe canFlyStatus
+{ ?x :canFlyStatus :TrueOnly.  } => { ?x :movesBySafely :Flying.  ?x :migratesSafely true. }.
+{ ?x :canFlyStatus :FalseOnly. } => { ?x :movesBySafely :Walking. ?x :migratesSafely false. }.
+{ ?x :canFlyStatus :Both.      } => { ?x :movesBySafely :Unknown. ?x :migratesSafely :Undecided. }.
+

package/examples/shacl-conforms.n3

@@ -0,0 +1,24 @@
+# --------------------------
+# sh:conforms example
+# --------------------------
+
+@prefix log:  <http://www.w3.org/2000/10/swap/log#>.
+@prefix sh:    <http://www.w3.org/ns/shacl#>.
+@prefix :      <http://example.org/demo#>.
+
+# If any result exists (in the closure) -> conforms false
+{ <https://eyereasoner.github.io/eyeling/examples/eventual-interoperability-interaction-patterns.n3> log:semantics ?formula.
+  #<file:///home/jdroo/github.com/eyereasoner/eyeling/examples/eventual-interoperability-interaction-patterns.n3> log:semantics ?formula.
+  ?formula log:conclusion ?closure.
+  ?closure log:includes { ?rep a sh:ValidationReport. }.
+  ?closure log:includes { ?rep sh:result ?r. }.
+} => { ?rep sh:conforms false. }.
+
+# If no result exists (in the closure) -> conforms true
+{ <https://eyereasoner.github.io/eyeling/examples/eventual-interoperability-interaction-patterns.n3> log:semantics ?formula.
+  #<file:///home/jdroo/github.com/eyereasoner/eyeling/examples/eventual-interoperability-interaction-patterns.n3> log:semantics ?formula.
+  ?formula log:conclusion ?closure.
+  ?closure log:includes { ?rep a sh:ValidationReport. }.
+  ?closure log:notIncludes { ?rep sh:result ?r. }.
+} => { ?rep sh:conforms true. }.
+

package/eyeling.js

@@ -4454,6 +4454,30 @@ function evalCryptoHashBuiltin(g, subst, algo) {
   return s2 !== null ? [s2] : [];
 }
 
+// ---------------------------------------------------------------------------
+// log: scoped-closure priority helper
+// ---------------------------------------------------------------------------
+// When log:collectAllIn / log:forAllIn are used with an object that is a
+// natural number literal, that number is treated as a *priority* (closure level).
+// See the adapted semantics near those builtins.
+function __logNaturalPriorityFromTerm(t) {
+  const info = parseNumericLiteralInfo(t);
+  if (!info) return null;
+  if (info.dt !== XSD_INTEGER_DT) return null;
+
+  const v = info.value;
+  if (typeof v === 'bigint') {
+    if (v < 0n) return null;
+    if (v > BigInt(Number.MAX_SAFE_INTEGER)) return null;
+    return Number(v);
+  }
+  if (typeof v === 'number') {
+    if (!Number.isInteger(v) || v < 0) return null;
+    return v;
+  }
+  return null;
+}
+
 // ===========================================================================
 // Builtin evaluation
 // ===========================================================================
@@ -6103,6 +6127,15 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     const [valueTempl, clauseTerm, listTerm] = g.s.elems;
     if (!(clauseTerm instanceof GraphTerm)) return [];
 
+    // Priority / closure semantics:
+    //   - object = GraphTerm: explicit scope, run immediately (no closure gating)
+    //   - object = natural number literal N: delay until saturated closure level >= N
+    //       * N = 0 => run immediately (use the live fact store)
+    //       * N >= 1 => run only when a scoped snapshot exists at closure level >= N
+    //   - object = Var: treat as priority 1 and bind it to 1
+    //   - any other object: backward-compatible default priority 1
+
+    let outSubst = { ...subst };
     let scopeFacts = null;
     let scopeBackRules = backRules;
 
@@ -6114,15 +6147,40 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
         enumerable: false,
         writable: true,
       });
+      const lvlHere = facts && typeof facts.__scopedClosureLevel === 'number' ? facts.__scopedClosureLevel : 0;
+      Object.defineProperty(scopeFacts, '__scopedClosureLevel', {
+        value: lvlHere,
+        enumerable: false,
+        writable: true,
+      });
       scopeBackRules = [];
     } else {
-      scopeFacts = facts.__scopedSnapshot || null;
-      if (!scopeFacts) return []; // DELAY until snapshot exists
+      let prio = 1;
+      if (g.o instanceof Var) {
+        // Bind the object var to 1 (default priority)
+        outSubst[g.o.name] = internLiteral('1');
+        prio = 1;
+      } else {
+        const p0 = __logNaturalPriorityFromTerm(g.o);
+        if (p0 !== null) prio = p0;
+      }
+
+      if (prio === 0) {
+        // Immediate: use live closure during the current fixpoint phase.
+        scopeFacts = facts;
+        scopeBackRules = backRules;
+      } else {
+        const snap = facts.__scopedSnapshot || null;
+        const lvl = (facts && typeof facts.__scopedClosureLevel === 'number' && facts.__scopedClosureLevel) || 0;
+        if (!snap) return []; // DELAY until snapshot exists
+        if (lvl < prio) return []; // DELAY until saturated closure prio exists
+        scopeFacts = snap;
+      }
     }
 
     // If sols is a blank node succeed without collecting/binding.
     if (listTerm instanceof Blank) {
-      return [{ ...subst }];
+      return [outSubst];
     }
 
     const visited2 = [];
@@ -6139,7 +6197,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     const collected = sols.map((sBody) => applySubstTerm(valueTempl, sBody));
     const collectedList = new ListTerm(collected);
 
-    const s2 = unifyTerm(listTerm, collectedList, { ...subst });
+    const s2 = unifyTerm(listTerm, collectedList, outSubst);
     return s2 ? [s2] : [];
   }
 
@@ -6149,6 +6207,9 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     const [whereClause, thenClause] = g.s.elems;
     if (!(whereClause instanceof GraphTerm) || !(thenClause instanceof GraphTerm)) return [];
 
+    // See log:collectAllIn above for the priority / closure semantics.
+
+    let outSubst = { ...subst };
     let scopeFacts = null;
     let scopeBackRules = backRules;
 
@@ -6160,10 +6221,33 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
         enumerable: false,
         writable: true,
       });
+      const lvlHere = facts && typeof facts.__scopedClosureLevel === 'number' ? facts.__scopedClosureLevel : 0;
+      Object.defineProperty(scopeFacts, '__scopedClosureLevel', {
+        value: lvlHere,
+        enumerable: false,
+        writable: true,
+      });
       scopeBackRules = [];
     } else {
-      scopeFacts = facts.__scopedSnapshot || null;
-      if (!scopeFacts) return []; // DELAY until snapshot exists
+      let prio = 1;
+      if (g.o instanceof Var) {
+        outSubst[g.o.name] = internLiteral('1');
+        prio = 1;
+      } else {
+        const p0 = __logNaturalPriorityFromTerm(g.o);
+        if (p0 !== null) prio = p0;
+      }
+
+      if (prio === 0) {
+        scopeFacts = facts;
+        scopeBackRules = backRules;
+      } else {
+        const snap = facts.__scopedSnapshot || null;
+        const lvl = (facts && typeof facts.__scopedClosureLevel === 'number' && facts.__scopedClosureLevel) || 0;
+        if (!snap) return []; // DELAY until snapshot exists
+        if (lvl < prio) return []; // DELAY until saturated closure prio exists
+        scopeFacts = snap;
+      }
     }
 
     const visited1 = [];
@@ -6190,7 +6274,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       );
       if (!sols2.length) return [];
     }
-    return [{ ...subst }];
+    return [outSubst];
   }
 
   // log:skolem
@@ -6844,7 +6928,45 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
   backRules.__allForwardRules = forwardRules;
   backRules.__allBackwardRules = backRules;
 
-  function setScopedSnapshot(snap) {
+  // Closure level counter used by log:collectAllIn/log:forAllIn priority gating.
+  // Level 0 means "no frozen snapshot" (during Phase A of each outer iteration).
+  let scopedClosureLevel = 0;
+
+  // Scan known rules for the maximum requested closure priority in
+  // log:collectAllIn / log:forAllIn goals.
+  function computeMaxScopedClosurePriorityNeeded() {
+    let maxP = 0;
+    function scanTriple(tr) {
+      if (!(tr && tr.p instanceof Iri)) return;
+      const pv = tr.p.value;
+      if (pv !== LOG_NS + 'collectAllIn' && pv !== LOG_NS + 'forAllIn') return;
+      // Explicit scope graphs are immediate and do not require a closure.
+      if (tr.o instanceof GraphTerm) return;
+      // Variable or non-numeric object => default priority 1 (if used).
+      if (tr.o instanceof Var) {
+        if (maxP < 1) maxP = 1;
+        return;
+      }
+      const p0 = __logNaturalPriorityFromTerm(tr.o);
+      if (p0 !== null) {
+        if (p0 > maxP) maxP = p0;
+      } else {
+        if (maxP < 1) maxP = 1;
+      }
+    }
+
+    for (const r of forwardRules) {
+      for (const tr of r.premise) scanTriple(tr);
+    }
+    for (const r of backRules) {
+      for (const tr of r.premise) scanTriple(tr);
+    }
+    return maxP;
+  }
+
+  let maxScopedClosurePriorityNeeded = computeMaxScopedClosurePriorityNeeded();
+
+  function setScopedSnapshot(snap, level) {
     if (!Object.prototype.hasOwnProperty.call(facts, '__scopedSnapshot')) {
       Object.defineProperty(facts, '__scopedSnapshot', {
         value: snap,
@@ -6855,6 +6977,17 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
     } else {
       facts.__scopedSnapshot = snap;
     }
+
+    if (!Object.prototype.hasOwnProperty.call(facts, '__scopedClosureLevel')) {
+      Object.defineProperty(facts, '__scopedClosureLevel', {
+        value: level,
+        enumerable: false,
+        writable: true,
+        configurable: true,
+      });
+    } else {
+      facts.__scopedClosureLevel = level;
+    }
   }
 
   function makeScopedSnapshot() {
@@ -6866,6 +6999,13 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
       writable: true,
       configurable: true,
     });
+    // Propagate closure level so nested scoped builtins can see it.
+    Object.defineProperty(snap, '__scopedClosureLevel', {
+      value: scopedClosureLevel,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
     return snap;
   }
 
@@ -7045,20 +7185,26 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
 
   while (true) {
     // Phase A: scoped builtins disabled => they “delay” (fail) during saturation
-    setScopedSnapshot(null);
+    setScopedSnapshot(null, 0);
     const changedA = runFixpoint();
 
     // Freeze saturated scope
+    scopedClosureLevel += 1;
     const snap = makeScopedSnapshot();
 
     // Phase B: scoped builtins enabled, but they query only `snap`
-    setScopedSnapshot(snap);
+    setScopedSnapshot(snap, scopedClosureLevel);
     const changedB = runFixpoint();
 
-    if (!changedA && !changedB) break;
+    // Rules may have been added dynamically (rule-producing triples), possibly
+    // introducing higher closure priorities. Keep iterating until we have
+    // reached the maximum requested priority and no further changes occur.
+    maxScopedClosurePriorityNeeded = Math.max(maxScopedClosurePriorityNeeded, computeMaxScopedClosurePriorityNeeded());
+
+    if (!changedA && !changedB && scopedClosureLevel >= maxScopedClosurePriorityNeeded) break;
   }
 
-  setScopedSnapshot(null);
+  setScopedSnapshot(null, 0);
 
   return derivedForward;
 }

package/index.d.ts

@@ -0,0 +1,3 @@
+declare module 'eyeling' {  
+    export function reason(opts:any,input: string): string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -17,8 +17,10 @@
   "bin": {
     "eyeling": "./eyeling.js"
   },
+  "types": "./index.d.ts",
   "files": [
     "index.js",
+    "index.d.ts",
     "eyeling.js",
     "eyeling-builtins.ttl",
     "test",