eyeling 1.25.4 → 1.25.5

package/dist/browser/eyeling.browser.js

@@ -5973,6 +5973,158 @@ function __varOccursElsewhereInPremise(premise, name, idx, field) {
   return false;
 }
 
+
+function __scopedPriorityForTerm(t) {
+  if (t instanceof GraphTerm) return 0;
+  const p0 = __logNaturalPriorityFromTerm(t);
+  return p0 !== null && p0 >= 1 ? p0 : 1;
+}
+
+function __pushScopedQueryTriplesFromGraph(term, out) {
+  if (!(term instanceof GraphTerm)) return;
+  for (const tr of term.triples) out.push(tr);
+}
+
+function __analyzeForwardRuleScopedUse(rule) {
+  const out = {
+    needsSnap: false,
+    baseLevel: 0,
+    queryTriples: [],
+    hasScopedAggregate: false,
+  };
+
+  if (!rule || !Array.isArray(rule.premise)) return out;
+
+  for (let i = 0; i < rule.premise.length; i++) {
+    const tr = rule.premise[i];
+    if (!(tr && tr.p instanceof Iri)) continue;
+    const pv = tr.p.value;
+
+    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
+      // Explicit quoted scopes are local formulas, not snapshots of the global closure.
+      if (tr.s instanceof GraphTerm) continue;
+
+      // A scope variable that is bound by another premise may become an explicit GraphTerm.
+      // Still, if it remains unbound at runtime the builtin treats it as priority 1.
+      // We therefore record the scoped use, but only use quoted object triples for
+      // dependency analysis; variables inside the quoted object do not bind the scope.
+      out.needsSnap = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.s));
+      __pushScopedQueryTriplesFromGraph(tr.o, out.queryTriples);
+      continue;
+    }
+
+    if (pv === LOG_NS + 'collectAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 3) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+      continue;
+    }
+
+    if (pv === LOG_NS + 'forAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 2) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[0], out.queryTriples);
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+    }
+  }
+
+  return out;
+}
+
+function __triplePatternsMayOverlap(a, b) {
+  return unifyTriple(a, b, __emptySubst()) !== null || unifyTriple(b, a, __emptySubst()) !== null;
+}
+
+function __ruleConclusionsMayFeedScopedQueries(producer, consumerMeta) {
+  if (!consumerMeta || !consumerMeta.queryTriples || consumerMeta.queryTriples.length === 0) return false;
+
+  // Dynamic conclusions are only known after a proof solution. Conservatively
+  // assume they can feed any scoped query if the producing rule is scoped.
+  if (producer && producer.__dynamicConclusionTerm) return true;
+
+  if (!producer || !Array.isArray(producer.conclusion) || producer.conclusion.length === 0) return false;
+  for (const q of consumerMeta.queryTriples) {
+    for (const h of producer.conclusion) {
+      if (__triplePatternsMayOverlap(q, h)) return true;
+    }
+  }
+  return false;
+}
+
+function __setForwardRuleScopedStratumInfo(rule, level) {
+  const value =
+    level > 0
+      ? { needsSnap: true, requiredLevel: level, exactLevel: true }
+      : { needsSnap: false, requiredLevel: 0, exactLevel: false };
+
+  if (!hasOwn.call(rule, '__scopedStratumInfo')) {
+    Object.defineProperty(rule, '__scopedStratumInfo', {
+      value,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+  } else {
+    rule.__scopedStratumInfo = value;
+  }
+}
+
+function __computeForwardRuleScopedStrata(forwardRules) {
+  if (!Array.isArray(forwardRules) || forwardRules.length === 0) return 0;
+
+  const metas = forwardRules.map((r) => __analyzeForwardRuleScopedUse(r));
+  const levels = metas.map((m) => (m.needsSnap ? Math.max(1, m.baseLevel || 1) : 0));
+
+  let maxLevel = 0;
+  for (const lvl of levels) if (lvl > maxLevel) maxLevel = lvl;
+
+  // Stratify scoped rules by data dependency: if a scoped query can read facts
+  // produced by another scoped rule, the reader must run against a later frozen
+  // snapshot. This prevents non-monotonic scoped builtins such as collectAllIn
+  // from emitting an early result before lower strata have derived their facts.
+  const passLimit = Math.max(1, forwardRules.length) + maxLevel + 1;
+  for (let pass = 0; pass < passLimit; pass++) {
+    let changed = false;
+    for (let ci = 0; ci < forwardRules.length; ci++) {
+      if (!metas[ci].needsSnap || !metas[ci].hasScopedAggregate) continue;
+      let needed = levels[ci];
+      for (let pi = 0; pi < forwardRules.length; pi++) {
+        if (pi === ci) continue;
+        if (levels[pi] <= 0) continue;
+        if (metas[pi].hasScopedAggregate) continue;
+        if (!__ruleConclusionsMayFeedScopedQueries(forwardRules[pi], metas[ci])) continue;
+        needed = Math.max(needed, levels[pi] + 1);
+      }
+      if (needed !== levels[ci]) {
+        levels[ci] = needed;
+        if (needed > maxLevel) maxLevel = needed;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+
+
+  maxLevel = 0;
+  for (let i = 0; i < forwardRules.length; i++) {
+    __setForwardRuleScopedStratumInfo(forwardRules[i], levels[i]);
+    if (levels[i] > maxLevel) maxLevel = levels[i];
+  }
+
+  return maxLevel;
+}
+
 function __computeForwardRuleScopedSkipInfo(rule) {
   let needsSnap = false;
   let requiredLevel = 0;
@@ -7158,7 +7310,7 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
       goalPredTid: goal.p instanceof Iri ? goal.p.__tid : null,
       goalSKey,
       goalOKey,
-      needsSkipCheck: !!r.__needsForwardSkipCheck,
+      needsSkipCheck: !!(r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)),
       fastSubjectVar,
       fastObjectVar,
     };
@@ -8606,7 +8758,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     let scopedClosureLevel = 0;
 
     // Scan known rules for the maximum requested closure priority in scoped log:* goals.
-    let maxScopedClosurePriorityNeeded = __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules);
+    let maxScopedClosurePriorityNeeded = Math.max(
+      __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+      __computeForwardRuleScopedStrata(forwardRules),
+    );
 
     // Conservative fast-skip for forward rules that cannot possibly succeed
     // until a scoped snapshot exists (or a given closure level is reached).
@@ -8660,12 +8815,16 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // until a snapshot exists (and a certain closure level is reached).
       // This prevents expensive proofs that will definitely fail in Phase A
       // and in early closure levels.
-      const info = r.__scopedSkipInfo;
+      const info = r.__scopedStratumInfo || r.__scopedSkipInfo;
       if (info && info.needsSnap) {
         const snapHere = facts.__scopedSnapshot || null;
         const lvlHere = (facts && typeof facts.__scopedClosureLevel === 'number' && facts.__scopedClosureLevel) || 0;
         if (!snapHere) return true;
-        if (lvlHere < info.requiredLevel) return true;
+        if (info.exactLevel) {
+          if (lvlHere !== info.requiredLevel) return true;
+        } else if (lvlHere < info.requiredLevel) {
+          return true;
+        }
       }
 
       // Optimization: if the rule head is **structurally ground** (no vars anywhere, even inside
@@ -8865,6 +9024,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
             const outcome = __emitForwardRuleSolution(r, entry.ruleIndex, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -8878,7 +9041,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         for (let i = 0; i < forwardRules.length; i++) {
           const r = forwardRules[i];
           if (agendaIndex.indexed.has(r)) continue;
-          if (r.__needsForwardSkipCheck && __skipForwardRuleNow(r)) continue;
+          if ((r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)) && __skipForwardRuleNow(r)) continue;
 
           const headIsStrictGround = r.__headIsStrictGround;
           const maxSols = r.isFuse || headIsStrictGround ? 1 : undefined;
@@ -8899,6 +9062,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           for (const s of sols) {
             const outcome = __emitForwardRuleSolution(r, i, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -8926,8 +9093,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // Rules may have been added dynamically (rule-producing triples), possibly
       // introducing scoped builtins and/or higher closure priorities.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       // If there are no scoped builtins in the entire program, Phase B is pure
@@ -8945,8 +9112,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
       // Phase B can also derive rule-producing triples.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       if (!changedA && !changedB && scopedClosureLevel >= maxScopedClosurePriorityNeeded) break;

package/eyeling.js

@@ -5973,6 +5973,158 @@ function __varOccursElsewhereInPremise(premise, name, idx, field) {
   return false;
 }
 
+
+function __scopedPriorityForTerm(t) {
+  if (t instanceof GraphTerm) return 0;
+  const p0 = __logNaturalPriorityFromTerm(t);
+  return p0 !== null && p0 >= 1 ? p0 : 1;
+}
+
+function __pushScopedQueryTriplesFromGraph(term, out) {
+  if (!(term instanceof GraphTerm)) return;
+  for (const tr of term.triples) out.push(tr);
+}
+
+function __analyzeForwardRuleScopedUse(rule) {
+  const out = {
+    needsSnap: false,
+    baseLevel: 0,
+    queryTriples: [],
+    hasScopedAggregate: false,
+  };
+
+  if (!rule || !Array.isArray(rule.premise)) return out;
+
+  for (let i = 0; i < rule.premise.length; i++) {
+    const tr = rule.premise[i];
+    if (!(tr && tr.p instanceof Iri)) continue;
+    const pv = tr.p.value;
+
+    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
+      // Explicit quoted scopes are local formulas, not snapshots of the global closure.
+      if (tr.s instanceof GraphTerm) continue;
+
+      // A scope variable that is bound by another premise may become an explicit GraphTerm.
+      // Still, if it remains unbound at runtime the builtin treats it as priority 1.
+      // We therefore record the scoped use, but only use quoted object triples for
+      // dependency analysis; variables inside the quoted object do not bind the scope.
+      out.needsSnap = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.s));
+      __pushScopedQueryTriplesFromGraph(tr.o, out.queryTriples);
+      continue;
+    }
+
+    if (pv === LOG_NS + 'collectAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 3) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+      continue;
+    }
+
+    if (pv === LOG_NS + 'forAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 2) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[0], out.queryTriples);
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+    }
+  }
+
+  return out;
+}
+
+function __triplePatternsMayOverlap(a, b) {
+  return unifyTriple(a, b, __emptySubst()) !== null || unifyTriple(b, a, __emptySubst()) !== null;
+}
+
+function __ruleConclusionsMayFeedScopedQueries(producer, consumerMeta) {
+  if (!consumerMeta || !consumerMeta.queryTriples || consumerMeta.queryTriples.length === 0) return false;
+
+  // Dynamic conclusions are only known after a proof solution. Conservatively
+  // assume they can feed any scoped query if the producing rule is scoped.
+  if (producer && producer.__dynamicConclusionTerm) return true;
+
+  if (!producer || !Array.isArray(producer.conclusion) || producer.conclusion.length === 0) return false;
+  for (const q of consumerMeta.queryTriples) {
+    for (const h of producer.conclusion) {
+      if (__triplePatternsMayOverlap(q, h)) return true;
+    }
+  }
+  return false;
+}
+
+function __setForwardRuleScopedStratumInfo(rule, level) {
+  const value =
+    level > 0
+      ? { needsSnap: true, requiredLevel: level, exactLevel: true }
+      : { needsSnap: false, requiredLevel: 0, exactLevel: false };
+
+  if (!hasOwn.call(rule, '__scopedStratumInfo')) {
+    Object.defineProperty(rule, '__scopedStratumInfo', {
+      value,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+  } else {
+    rule.__scopedStratumInfo = value;
+  }
+}
+
+function __computeForwardRuleScopedStrata(forwardRules) {
+  if (!Array.isArray(forwardRules) || forwardRules.length === 0) return 0;
+
+  const metas = forwardRules.map((r) => __analyzeForwardRuleScopedUse(r));
+  const levels = metas.map((m) => (m.needsSnap ? Math.max(1, m.baseLevel || 1) : 0));
+
+  let maxLevel = 0;
+  for (const lvl of levels) if (lvl > maxLevel) maxLevel = lvl;
+
+  // Stratify scoped rules by data dependency: if a scoped query can read facts
+  // produced by another scoped rule, the reader must run against a later frozen
+  // snapshot. This prevents non-monotonic scoped builtins such as collectAllIn
+  // from emitting an early result before lower strata have derived their facts.
+  const passLimit = Math.max(1, forwardRules.length) + maxLevel + 1;
+  for (let pass = 0; pass < passLimit; pass++) {
+    let changed = false;
+    for (let ci = 0; ci < forwardRules.length; ci++) {
+      if (!metas[ci].needsSnap || !metas[ci].hasScopedAggregate) continue;
+      let needed = levels[ci];
+      for (let pi = 0; pi < forwardRules.length; pi++) {
+        if (pi === ci) continue;
+        if (levels[pi] <= 0) continue;
+        if (metas[pi].hasScopedAggregate) continue;
+        if (!__ruleConclusionsMayFeedScopedQueries(forwardRules[pi], metas[ci])) continue;
+        needed = Math.max(needed, levels[pi] + 1);
+      }
+      if (needed !== levels[ci]) {
+        levels[ci] = needed;
+        if (needed > maxLevel) maxLevel = needed;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+
+
+  maxLevel = 0;
+  for (let i = 0; i < forwardRules.length; i++) {
+    __setForwardRuleScopedStratumInfo(forwardRules[i], levels[i]);
+    if (levels[i] > maxLevel) maxLevel = levels[i];
+  }
+
+  return maxLevel;
+}
+
 function __computeForwardRuleScopedSkipInfo(rule) {
   let needsSnap = false;
   let requiredLevel = 0;
@@ -7158,7 +7310,7 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
       goalPredTid: goal.p instanceof Iri ? goal.p.__tid : null,
       goalSKey,
       goalOKey,
-      needsSkipCheck: !!r.__needsForwardSkipCheck,
+      needsSkipCheck: !!(r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)),
       fastSubjectVar,
       fastObjectVar,
     };
@@ -8606,7 +8758,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     let scopedClosureLevel = 0;
 
     // Scan known rules for the maximum requested closure priority in scoped log:* goals.
-    let maxScopedClosurePriorityNeeded = __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules);
+    let maxScopedClosurePriorityNeeded = Math.max(
+      __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+      __computeForwardRuleScopedStrata(forwardRules),
+    );
 
     // Conservative fast-skip for forward rules that cannot possibly succeed
     // until a scoped snapshot exists (or a given closure level is reached).
@@ -8660,12 +8815,16 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // until a snapshot exists (and a certain closure level is reached).
       // This prevents expensive proofs that will definitely fail in Phase A
       // and in early closure levels.
-      const info = r.__scopedSkipInfo;
+      const info = r.__scopedStratumInfo || r.__scopedSkipInfo;
       if (info && info.needsSnap) {
         const snapHere = facts.__scopedSnapshot || null;
         const lvlHere = (facts && typeof facts.__scopedClosureLevel === 'number' && facts.__scopedClosureLevel) || 0;
         if (!snapHere) return true;
-        if (lvlHere < info.requiredLevel) return true;
+        if (info.exactLevel) {
+          if (lvlHere !== info.requiredLevel) return true;
+        } else if (lvlHere < info.requiredLevel) {
+          return true;
+        }
       }
 
       // Optimization: if the rule head is **structurally ground** (no vars anywhere, even inside
@@ -8865,6 +9024,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
             const outcome = __emitForwardRuleSolution(r, entry.ruleIndex, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -8878,7 +9041,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         for (let i = 0; i < forwardRules.length; i++) {
           const r = forwardRules[i];
           if (agendaIndex.indexed.has(r)) continue;
-          if (r.__needsForwardSkipCheck && __skipForwardRuleNow(r)) continue;
+          if ((r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)) && __skipForwardRuleNow(r)) continue;
 
           const headIsStrictGround = r.__headIsStrictGround;
           const maxSols = r.isFuse || headIsStrictGround ? 1 : undefined;
@@ -8899,6 +9062,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           for (const s of sols) {
             const outcome = __emitForwardRuleSolution(r, i, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -8926,8 +9093,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // Rules may have been added dynamically (rule-producing triples), possibly
       // introducing scoped builtins and/or higher closure priorities.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       // If there are no scoped builtins in the entire program, Phase B is pure
@@ -8945,8 +9112,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
       // Phase B can also derive rule-producing triples.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       if (!changedA && !changedB && scopedClosureLevel >= maxScopedClosurePriorityNeeded) break;

package/lib/engine.js

@@ -484,6 +484,158 @@ function __varOccursElsewhereInPremise(premise, name, idx, field) {
   return false;
 }
 
+
+function __scopedPriorityForTerm(t) {
+  if (t instanceof GraphTerm) return 0;
+  const p0 = __logNaturalPriorityFromTerm(t);
+  return p0 !== null && p0 >= 1 ? p0 : 1;
+}
+
+function __pushScopedQueryTriplesFromGraph(term, out) {
+  if (!(term instanceof GraphTerm)) return;
+  for (const tr of term.triples) out.push(tr);
+}
+
+function __analyzeForwardRuleScopedUse(rule) {
+  const out = {
+    needsSnap: false,
+    baseLevel: 0,
+    queryTriples: [],
+    hasScopedAggregate: false,
+  };
+
+  if (!rule || !Array.isArray(rule.premise)) return out;
+
+  for (let i = 0; i < rule.premise.length; i++) {
+    const tr = rule.premise[i];
+    if (!(tr && tr.p instanceof Iri)) continue;
+    const pv = tr.p.value;
+
+    if (pv === LOG_NS + 'includes' || pv === LOG_NS + 'notIncludes') {
+      // Explicit quoted scopes are local formulas, not snapshots of the global closure.
+      if (tr.s instanceof GraphTerm) continue;
+
+      // A scope variable that is bound by another premise may become an explicit GraphTerm.
+      // Still, if it remains unbound at runtime the builtin treats it as priority 1.
+      // We therefore record the scoped use, but only use quoted object triples for
+      // dependency analysis; variables inside the quoted object do not bind the scope.
+      out.needsSnap = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.s));
+      __pushScopedQueryTriplesFromGraph(tr.o, out.queryTriples);
+      continue;
+    }
+
+    if (pv === LOG_NS + 'collectAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 3) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+      continue;
+    }
+
+    if (pv === LOG_NS + 'forAllIn') {
+      if (tr.o instanceof GraphTerm) continue;
+
+      out.needsSnap = true;
+      out.hasScopedAggregate = true;
+      out.baseLevel = Math.max(out.baseLevel, __scopedPriorityForTerm(tr.o));
+      if (tr.s instanceof ListTerm && tr.s.elems.length === 2) {
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[0], out.queryTriples);
+        __pushScopedQueryTriplesFromGraph(tr.s.elems[1], out.queryTriples);
+      }
+    }
+  }
+
+  return out;
+}
+
+function __triplePatternsMayOverlap(a, b) {
+  return unifyTriple(a, b, __emptySubst()) !== null || unifyTriple(b, a, __emptySubst()) !== null;
+}
+
+function __ruleConclusionsMayFeedScopedQueries(producer, consumerMeta) {
+  if (!consumerMeta || !consumerMeta.queryTriples || consumerMeta.queryTriples.length === 0) return false;
+
+  // Dynamic conclusions are only known after a proof solution. Conservatively
+  // assume they can feed any scoped query if the producing rule is scoped.
+  if (producer && producer.__dynamicConclusionTerm) return true;
+
+  if (!producer || !Array.isArray(producer.conclusion) || producer.conclusion.length === 0) return false;
+  for (const q of consumerMeta.queryTriples) {
+    for (const h of producer.conclusion) {
+      if (__triplePatternsMayOverlap(q, h)) return true;
+    }
+  }
+  return false;
+}
+
+function __setForwardRuleScopedStratumInfo(rule, level) {
+  const value =
+    level > 0
+      ? { needsSnap: true, requiredLevel: level, exactLevel: true }
+      : { needsSnap: false, requiredLevel: 0, exactLevel: false };
+
+  if (!hasOwn.call(rule, '__scopedStratumInfo')) {
+    Object.defineProperty(rule, '__scopedStratumInfo', {
+      value,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+  } else {
+    rule.__scopedStratumInfo = value;
+  }
+}
+
+function __computeForwardRuleScopedStrata(forwardRules) {
+  if (!Array.isArray(forwardRules) || forwardRules.length === 0) return 0;
+
+  const metas = forwardRules.map((r) => __analyzeForwardRuleScopedUse(r));
+  const levels = metas.map((m) => (m.needsSnap ? Math.max(1, m.baseLevel || 1) : 0));
+
+  let maxLevel = 0;
+  for (const lvl of levels) if (lvl > maxLevel) maxLevel = lvl;
+
+  // Stratify scoped rules by data dependency: if a scoped query can read facts
+  // produced by another scoped rule, the reader must run against a later frozen
+  // snapshot. This prevents non-monotonic scoped builtins such as collectAllIn
+  // from emitting an early result before lower strata have derived their facts.
+  const passLimit = Math.max(1, forwardRules.length) + maxLevel + 1;
+  for (let pass = 0; pass < passLimit; pass++) {
+    let changed = false;
+    for (let ci = 0; ci < forwardRules.length; ci++) {
+      if (!metas[ci].needsSnap || !metas[ci].hasScopedAggregate) continue;
+      let needed = levels[ci];
+      for (let pi = 0; pi < forwardRules.length; pi++) {
+        if (pi === ci) continue;
+        if (levels[pi] <= 0) continue;
+        if (metas[pi].hasScopedAggregate) continue;
+        if (!__ruleConclusionsMayFeedScopedQueries(forwardRules[pi], metas[ci])) continue;
+        needed = Math.max(needed, levels[pi] + 1);
+      }
+      if (needed !== levels[ci]) {
+        levels[ci] = needed;
+        if (needed > maxLevel) maxLevel = needed;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+
+
+  maxLevel = 0;
+  for (let i = 0; i < forwardRules.length; i++) {
+    __setForwardRuleScopedStratumInfo(forwardRules[i], levels[i]);
+    if (levels[i] > maxLevel) maxLevel = levels[i];
+  }
+
+  return maxLevel;
+}
+
 function __computeForwardRuleScopedSkipInfo(rule) {
   let needsSnap = false;
   let requiredLevel = 0;
@@ -1669,7 +1821,7 @@ function makeSinglePremiseAgendaIndex(forwardRules, backRules) {
       goalPredTid: goal.p instanceof Iri ? goal.p.__tid : null,
       goalSKey,
       goalOKey,
-      needsSkipCheck: !!r.__needsForwardSkipCheck,
+      needsSkipCheck: !!(r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)),
       fastSubjectVar,
       fastObjectVar,
     };
@@ -3117,7 +3269,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
     let scopedClosureLevel = 0;
 
     // Scan known rules for the maximum requested closure priority in scoped log:* goals.
-    let maxScopedClosurePriorityNeeded = __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules);
+    let maxScopedClosurePriorityNeeded = Math.max(
+      __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+      __computeForwardRuleScopedStrata(forwardRules),
+    );
 
     // Conservative fast-skip for forward rules that cannot possibly succeed
     // until a scoped snapshot exists (or a given closure level is reached).
@@ -3171,12 +3326,16 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // until a snapshot exists (and a certain closure level is reached).
       // This prevents expensive proofs that will definitely fail in Phase A
       // and in early closure levels.
-      const info = r.__scopedSkipInfo;
+      const info = r.__scopedStratumInfo || r.__scopedSkipInfo;
       if (info && info.needsSnap) {
         const snapHere = facts.__scopedSnapshot || null;
         const lvlHere = (facts && typeof facts.__scopedClosureLevel === 'number' && facts.__scopedClosureLevel) || 0;
         if (!snapHere) return true;
-        if (lvlHere < info.requiredLevel) return true;
+        if (info.exactLevel) {
+          if (lvlHere !== info.requiredLevel) return true;
+        } else if (lvlHere < info.requiredLevel) {
+          return true;
+        }
       }
 
       // Optimization: if the rule head is **structurally ground** (no vars anywhere, even inside
@@ -3376,6 +3535,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
             const outcome = __emitForwardRuleSolution(r, entry.ruleIndex, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -3389,7 +3552,7 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
         for (let i = 0; i < forwardRules.length; i++) {
           const r = forwardRules[i];
           if (agendaIndex.indexed.has(r)) continue;
-          if (r.__needsForwardSkipCheck && __skipForwardRuleNow(r)) continue;
+          if ((r.__needsForwardSkipCheck || (r.__scopedStratumInfo && r.__scopedStratumInfo.needsSnap)) && __skipForwardRuleNow(r)) continue;
 
           const headIsStrictGround = r.__headIsStrictGround;
           const maxSols = r.isFuse || headIsStrictGround ? 1 : undefined;
@@ -3410,6 +3573,10 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
           for (const s of sols) {
             const outcome = __emitForwardRuleSolution(r, i, s);
             if (outcome.rulesChanged) {
+              maxScopedClosurePriorityNeeded = Math.max(
+                __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+                __computeForwardRuleScopedStrata(forwardRules),
+              );
               agendaIndex = makeSinglePremiseAgendaIndex(forwardRules, backRules);
               agendaCursor = 0;
             }
@@ -3437,8 +3604,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
       // Rules may have been added dynamically (rule-producing triples), possibly
       // introducing scoped builtins and/or higher closure priorities.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       // If there are no scoped builtins in the entire program, Phase B is pure
@@ -3456,8 +3623,8 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */,
 
       // Phase B can also derive rule-producing triples.
       maxScopedClosurePriorityNeeded = Math.max(
-        maxScopedClosurePriorityNeeded,
         __computeMaxScopedClosurePriorityNeeded(forwardRules, backRules),
+        __computeForwardRuleScopedStrata(forwardRules),
       );
 
       if (!changedA && !changedB && scopedClosureLevel >= maxScopedClosurePriorityNeeded) break;

package/package.json

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

package/test/api.test.js

@@ -2496,6 +2496,26 @@ _:b a ex:Person ; ex:name "B" .
     ],
     notExpect: [/:result\s+:sumX\s+"329"\^\^xsd:decimal\s*\./, /:result\s+:meanX\s+"47"\^\^xsd:decimal\s*\./],
   },
+  {
+    name: '244 regression: scoped collectAllIn is stratified after scoped notIncludes',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+:a :x 1 .
+:b :x 1 .
+
+{ ?s :x 1 . ?X log:notIncludes { ?s :marked ?X } } => { ?s :marked true } .
+{ ( ?s { ?s :marked true } ?all ) log:collectAllIn ?scope } => { :result :marked ?all } .
+`,
+    expect: [
+      /^:a\s+:marked\s+true\s*\./m,
+      /^:b\s+:marked\s+true\s*\./m,
+      /^:result\s+:marked\s+\(:a\s+:b\)\s*\./m,
+    ],
+    notExpect: [/^:result\s+:marked\s+\(\)\s*\./m],
+  },
+
   {
     name: '244 regression: log:dtlit recognizes shorthand numeric and boolean literals',
     opt: { proofComments: false },

package/examples/library-and-path.n3

@@ -1,499 +0,0 @@
-# ==========================================================================
-# The Library and the Path
-#
-# Source essay:
-#   https://josd.github.io/the-library-and-the-path/
-#
-# What this file is trying to do
-# ------------------------------
-# The essay uses a philosophical image:
-#
-#   • The "Library" is the space of many possible, internally coherent ways
-#     things could be.
-#   • The "Path" is the one realized history we actually inhabit.
-#   • "Observership" is not a godlike view from outside the world. It is a
-#     process inside the Path: systems make observations, leave records, and
-#     those records constrain which earlier histories still make sense.
-#
-# This file translates that idea into semantic data and lightweight rules.
-# It is not a physics engine and not a proof of the essay. It is a readable,
-# machine-processable toy model inspired by the essay.
-#
-# Design choices
-# --------------
-# 1. The model uses five layers, echoing the essay's stacked descriptions:
-#      quantum, thermodynamic, biological, cognitive, social
-# 2. The Library contains multiple possible states and branches.
-# 3. The realized Path selects one sequence of states.
-# 4. Observations create records.
-# 5. Records act as constraints on candidate histories.
-# ==========================================================================
-
-@prefix ex:   <https://example.org/library-path#> .
-@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
-@prefix log:  <http://www.w3.org/2000/10/swap/log#> .
-
-# ----------
-# Vocabulary
-# ----------
-
-# These are the main kinds of things in the model.
-ex:Library             a rdfs:Class ; rdfs:label "Library" .
-ex:Layer               a rdfs:Class ; rdfs:label "Layer of description" .
-ex:State               a rdfs:Class ; rdfs:label "State" .
-ex:PossibleState       a rdfs:Class ; rdfs:subClassOf ex:State ; rdfs:label "Possible state" .
-ex:RealizedState       a rdfs:Class ; rdfs:subClassOf ex:State ; rdfs:label "Realized state" .
-ex:Path                a rdfs:Class ; rdfs:label "Path" .
-ex:Transition          a rdfs:Class ; rdfs:label "Transition" .
-ex:Observer            a rdfs:Class ; rdfs:label "Observer" .
-ex:Observation         a rdfs:Class ; rdfs:label "Observation" .
-ex:Record              a rdfs:Class ; rdfs:label "Record" .
-ex:Constraint          a rdfs:Class ; rdfs:label "Constraint" .
-ex:History             a rdfs:Class ; rdfs:label "Candidate history" .
-ex:Theme               a rdfs:Class ; rdfs:label "Theme" .
-ex:InterpretiveNote    a rdfs:Class ; rdfs:label "Interpretive note" .
-
-# Properties. Their names are chosen to read like plain English.
-ex:containsLayer       a rdf:Property .
-ex:containsState       a rdf:Property .
-ex:containsHistory     a rdf:Property .
-ex:throughLibrary      a rdf:Property .
-ex:hasState            a rdf:Property .
-ex:startsAt            a rdf:Property .
-ex:endsAt              a rdf:Property .
-ex:nextState           a rdf:Property .
-ex:branchesTo          a rdf:Property .
-ex:atLayer             a rdf:Property .
-ex:timeIndex           a rdf:Property .
-ex:describedByTheme    a rdf:Property .
-ex:hasTransition       a rdf:Property .
-ex:fromState           a rdf:Property .
-ex:toState             a rdf:Property .
-ex:transitionType      a rdf:Property .
-ex:observedBy          a rdf:Property .
-ex:makesObservation    a rdf:Property .
-ex:atState             a rdf:Property .
-ex:writesRecord        a rdf:Property .
-ex:aboutState          a rdf:Property .
-ex:hasRecord           a rdf:Property .
-ex:hasConstraint       a rdf:Property .
-ex:matchesRecord       a rdf:Property .
-ex:supportsConstraint  a rdf:Property .
-ex:compatibleWith      a rdf:Property .
-ex:incompatibleWith    a rdf:Property .
-ex:memberState         a rdf:Property .
-ex:realizes            a rdf:Property .
-ex:selectsFrom         a rdf:Property .
-ex:plainEnglish        a rdf:Property .
-ex:description         a rdf:Property .
-ex:glosses             a rdf:Property .
-ex:notes               a rdf:Property .
-ex:focusesOn           a rdf:Property .
-
-# -------------------
-# High-level concepts
-# -------------------
-
-ex:theLibrary a ex:Library ;
-    rdfs:label "The Library" ;
-    ex:description "The timeless space of structured possibilities." ;
-    ex:plainEnglish "Think of this as the set of coherent ways the world could be, not yet reduced to one lived history." ;
-    ex:containsLayer ex:quantum, ex:thermodynamic, ex:biological, ex:cognitive, ex:social .
-
-ex:realizedPath a ex:Path ;
-    rdfs:label "The realized Path" ;
-    ex:throughLibrary ex:theLibrary ;
-    ex:selectsFrom ex:theLibrary ;
-    ex:description "One actual history through the Library." ;
-    ex:plainEnglish "Out of many possibilities, this is the single unfolding sequence that becomes lived reality." .
-
-ex:observer a ex:Observer ;
-    rdfs:label "Observership" ;
-    ex:description "Perspective from within the Path that creates records." ;
-    ex:plainEnglish "The observer is not outside the universe. Observation happens inside the realized history and leaves traces behind." .
-
-# -----------------
-# Layers and themes
-# -----------------
-
-# Each layer is a way of describing the same broad reality at a different scale
-# or level of organization.
-ex:quantum a ex:Layer ;
-    rdfs:label "Quantum" ;
-    ex:plainEnglish "Microscopic possibilities and amplitudes." ;
-    ex:describedByTheme ex:themePossibility .
-
-ex:thermodynamic a ex:Layer ;
-    rdfs:label "Thermodynamic" ;
-    ex:plainEnglish "Flows, gradients, dissipation, and the arrow of time." ;
-    ex:describedByTheme ex:themeIrreversibility .
-
-ex:biological a ex:Layer ;
-    rdfs:label "Biological" ;
-    ex:plainEnglish "Living systems that preserve structure and memory across generations." ;
-    ex:describedByTheme ex:themePersistence .
-
-ex:cognitive a ex:Layer ;
-    rdfs:label "Cognitive" ;
-    ex:plainEnglish "Internal models, recall, anticipation, and interpretation." ;
-    ex:describedByTheme ex:themeModeling .
-
-ex:social a ex:Layer ;
-    rdfs:label "Social" ;
-    ex:plainEnglish "Language, institutions, archives, and public memory." ;
-    ex:describedByTheme ex:themeSharedRecord .
-
-ex:themePossibility a ex:Theme ;
-    rdfs:label "Possibility" ;
-    ex:glosses "Many coherent alternatives can exist in description before one history is lived." .
-
-ex:themeIrreversibility a ex:Theme ;
-    rdfs:label "Irreversibility" ;
-    ex:glosses "Records and gradients make the past different from the future." .
-
-ex:themePersistence a ex:Theme ;
-    rdfs:label "Persistence" ;
-    ex:glosses "Some structures endure and transmit form." .
-
-ex:themeModeling a ex:Theme ;
-    rdfs:label "Modeling" ;
-    ex:glosses "Minds encode and use internal representations." .
-
-ex:themeSharedRecord a ex:Theme ;
-    rdfs:label "Shared record" ;
-    ex:glosses "Groups stabilize memory in symbols, texts, norms, and institutions." .
-
-# ---------------------
-# States in the Library
-# ---------------------
-
-# A state is not meant to be a complete physical description of everything.
-# It is a compact marker for a stage in a possible history.
-
-# ---- Realized states ----
-ex:s0 a ex:PossibleState, ex:RealizedState ;
-    rdfs:label "s0" ;
-    ex:timeIndex 0 ;
-    ex:atLayer ex:quantum ;
-    ex:description "Initial low-information possibility." ;
-    ex:plainEnglish "A starting point containing many open possibilities." .
-
-ex:s1 a ex:PossibleState, ex:RealizedState ;
-    rdfs:label "s1" ;
-    ex:timeIndex 1 ;
-    ex:atLayer ex:thermodynamic ;
-    ex:description "Entropy gradient becomes a usable arrow." ;
-    ex:plainEnglish "A directionality appears: some traces can now accumulate rather than instantly disappear." .
-
-ex:s2 a ex:PossibleState, ex:RealizedState ;
-    rdfs:label "s2" ;
-    ex:timeIndex 2 ;
-    ex:atLayer ex:biological ;
-    ex:description "A living lineage persists and stores traces." ;
-    ex:plainEnglish "Something like heredity or durable adaptation now carries information forward." .
-
-ex:s3 a ex:PossibleState, ex:RealizedState ;
-    rdfs:label "s3" ;
-    ex:timeIndex 3 ;
-    ex:atLayer ex:cognitive ;
-    ex:description "A mind models the world and remembers." ;
-    ex:plainEnglish "Memory becomes explicit enough to support interpretation and anticipation." .
-
-ex:s4 a ex:PossibleState, ex:RealizedState ;
-    rdfs:label "s4" ;
-    ex:timeIndex 4 ;
-    ex:atLayer ex:social ;
-    ex:description "Shared language stabilizes public records." ;
-    ex:plainEnglish "Memory is no longer only private. It becomes collective and institutional." .
-
-# ---- Alternative states not taken on the realized Path ----
-ex:s1a a ex:PossibleState ;
-    rdfs:label "s1a" ;
-    ex:timeIndex 1 ;
-    ex:atLayer ex:thermodynamic ;
-    ex:description "Thermal structure dissipates too quickly." ;
-    ex:plainEnglish "The world remains too fleeting to support durable traces." .
-
-ex:s2a a ex:PossibleState ;
-    rdfs:label "s2a" ;
-    ex:timeIndex 2 ;
-    ex:atLayer ex:biological ;
-    ex:description "No robust biological memory emerges." ;
-    ex:plainEnglish "There are local structures, but nothing that preserves adaptive information well." .
-
-ex:s3a a ex:PossibleState ;
-    rdfs:label "s3a" ;
-    ex:timeIndex 3 ;
-    ex:atLayer ex:cognitive ;
-    ex:description "Local cognition forms, but no durable self-model." ;
-    ex:plainEnglish "Some processing happens, but not enough stable reflective memory to anchor a long narrative." .
-
-ex:s4a a ex:PossibleState ;
-    rdfs:label "s4a" ;
-    ex:timeIndex 4 ;
-    ex:atLayer ex:social ;
-    ex:description "Agents fail to coordinate stable communal archives." ;
-    ex:plainEnglish "There may be minds, but no lasting shared record of them." .
-
-ex:theLibrary
-    ex:containsState ex:s0, ex:s1, ex:s2, ex:s3, ex:s4,
-                     ex:s1a, ex:s2a, ex:s3a, ex:s4a .
-
-# -------------------
-# Branching structure
-# -------------------
-
-# The Library contains branches. The Path selects one branch.
-ex:s0  ex:branchesTo ex:s1, ex:s1a .
-ex:s1  ex:branchesTo ex:s2, ex:s2a .
-ex:s1a ex:branchesTo ex:s2a .
-ex:s2  ex:branchesTo ex:s3, ex:s3a .
-ex:s2a ex:branchesTo ex:s3a .
-ex:s3  ex:branchesTo ex:s4, ex:s4a .
-ex:s3a ex:branchesTo ex:s4a .
-
-# The single realized history.
-
-ex:realizedPath
-    ex:hasState ex:s0, ex:s1, ex:s2, ex:s3, ex:s4 ;
-    ex:startsAt ex:s0 ;
-    ex:endsAt ex:s4 ;
-    ex:notes "This is the one branch counted as lived reality in the model." .
-
-ex:s0 ex:nextState ex:s1 .
-ex:s1 ex:nextState ex:s2 .
-ex:s2 ex:nextState ex:s3 .
-ex:s3 ex:nextState ex:s4 .
-
-# -----------
-# Transitions
-# -----------
-
-# Transitions make the path easier to read for humans.
-ex:t01 a ex:Transition ;
-    ex:fromState ex:s0 ;
-    ex:toState ex:s1 ;
-    ex:transitionType "selection into durable asymmetry" ;
-    ex:description "A world with usable directional structure emerges." .
-
-ex:t12 a ex:Transition ;
-    ex:fromState ex:s1 ;
-    ex:toState ex:s2 ;
-    ex:transitionType "persistence into adaptation" ;
-    ex:description "Energy gradients support living systems that keep information." .
-
-ex:t23 a ex:Transition ;
-    ex:fromState ex:s2 ;
-    ex:toState ex:s3 ;
-    ex:transitionType "adaptation into modeling" ;
-    ex:description "Biological persistence develops into explicit internal world-models." .
-
-ex:t34 a ex:Transition ;
-    ex:fromState ex:s3 ;
-    ex:toState ex:s4 ;
-    ex:transitionType "private memory into public memory" ;
-    ex:description "Symbols and institutions stabilize records beyond individual minds." .
-
-ex:realizedPath ex:hasTransition ex:t01, ex:t12, ex:t23, ex:t34 .
-
-# ------------------------
-# Observations and records
-# ------------------------
-
-# In this model, observations produce records. Records are important because
-# they constrain which histories remain plausible from the current standpoint.
-ex:obs1 a ex:Observation ;
-    rdfs:label "Observation 1" ;
-    ex:atState ex:s1 ;
-    ex:writesRecord ex:rec1 ;
-    ex:description "A trace of an irreversible thermodynamic arrow is registered." .
-
-ex:obs2 a ex:Observation ;
-    rdfs:label "Observation 2" ;
-    ex:atState ex:s2 ;
-    ex:writesRecord ex:rec2 ;
-    ex:description "A lineage preserves information across generations." .
-
-ex:obs3 a ex:Observation ;
-    rdfs:label "Observation 3" ;
-    ex:atState ex:s3 ;
-    ex:writesRecord ex:rec3 ;
-    ex:description "A system forms a recall-capable internal model." .
-
-ex:obs4 a ex:Observation ;
-    rdfs:label "Observation 4" ;
-    ex:atState ex:s4 ;
-    ex:writesRecord ex:rec4 ;
-    ex:description "A social archive stores memory in a shared symbolic form." .
-
-ex:observer ex:makesObservation ex:obs1, ex:obs2, ex:obs3, ex:obs4 .
-
-# The records themselves are also constraints.
-ex:rec1 a ex:Record, ex:Constraint ;
-    rdfs:label "Record of thermodynamic arrow" ;
-    ex:aboutState ex:s1 ;
-    ex:description "There exists a stable thermodynamic arrow." ;
-    ex:plainEnglish "The present contains traces that imply irreversible structure in the past." .
-
-ex:rec2 a ex:Record, ex:Constraint ;
-    rdfs:label "Record of biological memory" ;
-    ex:aboutState ex:s2 ;
-    ex:description "There exists heritable biological memory." ;
-    ex:plainEnglish "Current life carries evidence of prior successful information storage." .
-
-ex:rec3 a ex:Record, ex:Constraint ;
-    rdfs:label "Record of cognitive memory" ;
-    ex:aboutState ex:s3 ;
-    ex:description "There exists an internal model with recall." ;
-    ex:plainEnglish "A remembering mind implies a history rich enough to support its memory traces." .
-
-ex:rec4 a ex:Record, ex:Constraint ;
-    rdfs:label "Record of social memory" ;
-    ex:aboutState ex:s4 ;
-    ex:description "There exists shared symbolic culture." ;
-    ex:plainEnglish "Texts, rituals, institutions, and archives act as public memory." .
-
-# The realized path is constrained by the records visible from within it.
-ex:realizedPath ex:hasConstraint ex:rec1, ex:rec2, ex:rec3, ex:rec4 .
-
-# -------------------
-# Candidate histories
-# -------------------
-
-# These are simplified rival histories the present might consider.
-# The key idea is that not all candidate pasts fit the records we now have.
-ex:historyAlpha a ex:History ;
-    rdfs:label "Alpha — realized history" ;
-    ex:memberState ex:s0, ex:s1, ex:s2, ex:s3, ex:s4 ;
-    ex:description "The full branch that supports all records in the model." ;
-    ex:matchesRecord ex:rec1, ex:rec2, ex:rec3, ex:rec4 .
-
-ex:historyBeta a ex:History ;
-    rdfs:label "Beta — dissipative branch" ;
-    ex:memberState ex:s0, ex:s1a, ex:s2a, ex:s3a, ex:s4a ;
-    ex:description "A branch where structure dissipates before rich memory can stabilize." ;
-    ex:matchesRecord ex:rec1 .
-
-ex:historyGamma a ex:History ;
-    rdfs:label "Gamma — biology without durable public memory" ;
-    ex:memberState ex:s0, ex:s1, ex:s2, ex:s3a, ex:s4a ;
-    ex:description "A branch with persistence and some adaptation, but no robust reflective or social archive." ;
-    ex:matchesRecord ex:rec1, ex:rec2 .
-
-ex:historyDelta a ex:History ;
-    rdfs:label "Delta — private minds without stable institutions" ;
-    ex:memberState ex:s0, ex:s1, ex:s2, ex:s3, ex:s4a ;
-    ex:description "A branch where memory reaches minds but does not stabilize socially." ;
-    ex:matchesRecord ex:rec1, ex:rec2, ex:rec3 .
-
-ex:theLibrary ex:containsHistory ex:historyAlpha, ex:historyBeta, ex:historyGamma, ex:historyDelta .
-
-# ------------------
-# Interpretive notes
-# ------------------
-
-# These are not required for reasoning, but they make the file more readable.
-ex:note1 a ex:InterpretiveNote ;
-    ex:focusesOn ex:theLibrary ;
-    ex:plainEnglish "The Library is not 'before time' in a literal physical sense here; it is a conceptual space of possibilities." .
-
-ex:note2 a ex:InterpretiveNote ;
-    ex:focusesOn ex:realizedPath ;
-    ex:plainEnglish "The Path is the one sequence that becomes concrete from the inside." .
-
-ex:note3 a ex:InterpretiveNote ;
-    ex:focusesOn ex:observer ;
-    ex:plainEnglish "Observership is modeled as record production, not as magical outside access to all possibilities." .
-
-ex:note4 a ex:InterpretiveNote ;
-    ex:focusesOn ex:rec1 ;
-    ex:plainEnglish "A record is evidence now that narrows what could reasonably count as the past." .
-
-# -----
-# Rules
-# -----
-
-# These rules are intentionally simple and didactic.
-
-# Rule 1
-# If an observation is at a state and writes a record,
-# then that state has that record.
-{ ?obs a ex:Observation ;
-       ex:atState ?s ;
-       ex:writesRecord ?r . }
-=>
-{ ?s ex:hasRecord ?r .
-  ?r a ex:Record . } .
-
-# Rule 2
-# If the observer makes an observation at a state that lies on the realized path,
-# then that state is observed by that observer.
-{ ?who ex:makesObservation ?obs .
-  ?obs ex:atState ?s .
-  ex:realizedPath ex:hasState ?s . }
-=>
-{ ?s ex:observedBy ?who . } .
-
-# Rule 3
-# If a history matches a record that is one of the realized path's constraints,
-# then the history supports that constraint.
-{ ex:realizedPath ex:hasConstraint ?r .
-  ?h a ex:History ;
-     ex:matchesRecord ?r . }
-=>
-{ ?h ex:supportsConstraint ?r . } .
-
-# Rule 4
-# Second-stage compatibility check.
-# Inspect closure gate 2, where record-level incompatibilities have already
-# been derived. A history is path-compatible only if no incompatibility is present.
-{
-  ?h a ex:History .
-  2 log:notIncludes { ?h ex:incompatibleWith ?any } .
-}
-=>
-{ ?h ex:compatibleWith ex:realizedPath . } .
-
-# Rule 5
-# First-stage record failure check.
-# Inspect closure gate 1 to see whether a history supports a realized-path
-# constraint. If it does not, derive incompatibility with that record.
-{
-  ex:realizedPath ex:hasConstraint ?r .
-  ?h a ex:History .
-  1 log:notIncludes { ?h ex:supportsConstraint ?r } .
-}
-=>
-{ ?h ex:incompatibleWith ?r . } .
-
-# Rule 6
-# If a state has a record and belongs to the realized path,
-# then the realized path realizes that record-bearing state.
-{ ex:realizedPath ex:hasState ?s .
-  ?s ex:hasRecord ?r . }
-=>
-{ ex:realizedPath ex:realizes ?s . } .
-
-# ----------------------------
-# Human-readable summary nodes
-# ----------------------------
-
-ex:summary a rdfs:Resource ;
-    rdfs:label "Plain-language summary" ;
-    ex:description "The Library contains many coherent alternatives. The Path is one realized sequence through them. Observation happens within the Path and leaves records. Those records narrow which candidate histories remain compatible with what is now observed." .
-
-ex:readingGuide a rdfs:Resource ;
-    rdfs:label "Where to look first" ;
-    ex:description "Start with ex:theLibrary, ex:realizedPath, ex:observer, then read the states s0..s4, then the records rec1..rec4, then the candidate histories." .
-
-{
-  3 log:includes {
-    ?s a rdfs:Resource ;
-      rdfs:label ?l ;
-      ex:description ?d .
-  }
-}
-=>
-{ ?l ex:is ?d . } .
-

package/examples/output/library-and-path.n3

@@ -1,33 +0,0 @@
-@prefix ex: <https://example.org/library-path#> .
-
-ex:s1 ex:hasRecord ex:rec1 .
-ex:s2 ex:hasRecord ex:rec2 .
-ex:s3 ex:hasRecord ex:rec3 .
-ex:s4 ex:hasRecord ex:rec4 .
-ex:s1 ex:observedBy ex:observer .
-ex:s2 ex:observedBy ex:observer .
-ex:s3 ex:observedBy ex:observer .
-ex:s4 ex:observedBy ex:observer .
-ex:historyAlpha ex:supportsConstraint ex:rec1 .
-ex:historyBeta ex:supportsConstraint ex:rec1 .
-ex:historyGamma ex:supportsConstraint ex:rec1 .
-ex:historyDelta ex:supportsConstraint ex:rec1 .
-ex:historyAlpha ex:supportsConstraint ex:rec2 .
-ex:historyGamma ex:supportsConstraint ex:rec2 .
-ex:historyDelta ex:supportsConstraint ex:rec2 .
-ex:historyAlpha ex:supportsConstraint ex:rec3 .
-ex:historyDelta ex:supportsConstraint ex:rec3 .
-ex:historyAlpha ex:supportsConstraint ex:rec4 .
-ex:realizedPath ex:realizes ex:s1 .
-ex:realizedPath ex:realizes ex:s2 .
-ex:realizedPath ex:realizes ex:s3 .
-ex:realizedPath ex:realizes ex:s4 .
-ex:historyBeta ex:incompatibleWith ex:rec2 .
-ex:historyBeta ex:incompatibleWith ex:rec3 .
-ex:historyGamma ex:incompatibleWith ex:rec3 .
-ex:historyBeta ex:incompatibleWith ex:rec4 .
-ex:historyGamma ex:incompatibleWith ex:rec4 .
-ex:historyDelta ex:incompatibleWith ex:rec4 .
-ex:historyAlpha ex:compatibleWith ex:realizedPath .
-"Plain-language summary" ex:is "The Library contains many coherent alternatives. The Path is one realized sequence through them. Observation happens within the Path and leaves records. Those records narrow which candidate histories remain compatible with what is now observed." .
-"Where to look first" ex:is "Start with ex:theLibrary, ex:realizedPath, ex:observer, then read the states s0..s4, then the records rec1..rec4, then the candidate histories." .