eyeling 1.24.4 → 1.24.6

package/HANDBOOK.md

@@ -36,7 +36,6 @@
 - [Appendix I — The Eyeling Playground](#app-i)
 - [Appendix J — Formalism Is Fine](#app-j)
 - [Appendix K — Whitehead-inspired becoming examples](#app-k)
-- [Appendix L — SEE: Specialized Eyeling Executables](#app-l)
 
 ---
 
@@ -239,7 +238,7 @@ Parsing becomes dramatically simpler because tokenization already decided where
 
 By default, Eyeling parses ordinary N3. Selected RDF/TriG surface syntax is accepted only when RDF compatibility is explicitly enabled with `eyeling -r file.trig`, `eyeling --rdf file.trig`, or API option `{ rdf: true }`. In that mode, the lexer normalizes RDF/TriG input syntax to ordinary N3 graph terms before normal parsing, and the printer emits RDF/TriG-compatible output where feasible. Eyeling remains an N3 reasoner; this is syntax compatibility, not a separate RDF dataset reasoning model.
 
-In RDF compatibility mode, RDF 1.2 triple terms written as `<<( s p o )>>` are normalized to Eyeling's existing singleton quoted-formula term `{ s p o }`. A leading `VERSION "1.2"` or `@version "1.2"` directive is ignored for the same reason. On output, `--rdf` converts a singleton graph term back to `<<( ... )>>` only when its inner triple is valid as an RDF triple term; otherwise it stays in N3 graph-term form. It also prints `log:nameOf` graph-term triples back as TriG named graph blocks. For example:
+In RDF compatibility mode, RDF 1.2 triple terms written as `<<( s p o )>>`, plus the reified triple form `<<s p o ~ r>>`, are normalized to Eyeling's existing singleton quoted-formula term `{ s p o }`. A reifier `r` is preserved as `r rdf:reifies { s p o }`. A leading `VERSION "1.2"` or `@version "1.2"` directive is ignored for the same reason. On output, `--rdf` converts a singleton graph term back to `<<( ... )>>` only when its inner triple is valid as an RDF triple term; otherwise it stays in N3 graph-term form. It also prints `log:nameOf` graph-term triples back as TriG named graph blocks. For example:
 
 ```n3
 :observation rdf:reifies <<( :sensor :reports :overheating )>> .
@@ -2594,7 +2593,7 @@ Quoted graphs/formulas use `{ ... }`. Inside a quoted formula, directive scope m
 
 - `@prefix/@base` and `PREFIX/BASE` directives may appear at top level **or inside `{ ... }`**, and apply to the formula they occur in (formula-local scoping).
 
-With `-r, --rdf` / `{ rdf: true }`, Eyeling also accepts the RDF 1.2 triple-term surface form `<<( s p o )>>` as a compatibility spelling for a singleton quoted formula `{ s p o }`. In the same mode, feasible singleton graph terms are printed back as RDF 1.2 triple terms, while invalid cases such as a literal subject remain ordinary N3 graph terms. This is useful for inputs that use `rdf:reifies` or other predicates whose objects are RDF 1.2 triple terms, while keeping the default language and the rest of Eyeling on its N3 formula-term model.
+With `-r, --rdf` / `{ rdf: true }`, Eyeling also accepts RDF 1.2 triple-term surface forms such as `<<( s p o )>>` and `<<s p o ~ r>>` as compatibility spellings for a singleton quoted formula `{ s p o }`. In the same mode, feasible singleton graph terms are printed back as RDF 1.2 triple terms, while invalid cases such as a literal subject remain ordinary N3 graph terms. This is useful for inputs that use `rdf:reifies` or other predicates whose objects are RDF 1.2 triple terms, while keeping the default language and the rest of Eyeling on its N3 formula-term model.
 
 For the formal grammar, see the N3 spec grammar:
 
@@ -3830,101 +3829,3 @@ For the handbook, these examples matter for two reasons. First, they provide a c
 
 That is why this appendix belongs after Appendix J. “Formalism is fine” not only because it supports rigor, but because it can remain flexible enough to describe worlds in motion. The becoming examples are small demonstrations of that claim. They show that a compact N3 reasoner can host process-oriented models without ceasing to be simple, readable, and executable.
 
----
-
-<a id="app-l"></a>
-
-## Appendix L — SEE: Specialized Eyeling Executables
-
-SEE, **Specialized Eyeling Executables**, is the companion example system under `see/`. It compiles selected Eyeling-style N3 programs into small, standalone JavaScript runners. The goal is not to replace the main reasoner. The goal is to turn a particular reasoning task into an executable artifact that carries its input evidence, derivation logic, entailment, explanation, and reference output together.
-
-The short mental model is:
-
-```text
-N3 source + TriG evidence -> specialized JavaScript -> entailment + explanation
-```
-
-### L.1 Why SEE exists
-
-The normal Eyeling CLI is a general reasoner: it parses an input file, runs the engine, and prints the resulting closure, selected query output, or rendered `log:outputString` report.
-
-SEE is narrower and more packageable. For each committed example, `see.js` generates:
-
-- `see/examples/<name>.js` — a runnable JavaScript derivation program,
-- `see/examples/input/<name>.trig` — the RDF/TriG evidence read by the runner,
-- `see/examples/output/<name>.md` — the expected Markdown result,
-- `see/examples/doc/<name>.md` — a short generated explanation of the compiled example.
-
-That makes each example easier to audit. A reviewer can inspect the source N3, the generated runner, the input evidence, and the expected entailment/explanation without reconstructing the whole test setup.
-
-### L.2 Entailment plus explanation
-
-SEE reports use an **Entailment** section and an **Explanation** section. The entailment is the selected result of the reasoning task. The explanation records how the compiled runner reached it: source facts, rules, selected support trees, and the formal TriG output when relevant.
-
-This vocabulary is deliberately more precise than a generic “result”. It says: the program is not merely presenting a suggestion; it is presenting something that follows from the encoded facts, rules, gates, and query projection.
-
-### L.3 Direct TriG input
-
-Generated SEE runners read their committed `.trig` input directly. Earlier versions used an intermediate `.n3` conversion step, but the current design keeps the evidence in TriG and lets the runner parse that committed input. This matters for examples that are closer to RDF data exchange than to hand-written N3 rule files.
-
-SEE includes RDF compatibility examples. The `triple_terms` example uses RDF 1.2 triple terms, and the `rdf_dataset` example combines ordinary default-graph triples, an RDF/TriG named graph block, and RDF 1.2 triple terms.
-
-A triple-term input can contain:
-
-```trig
-VERSION "1.2"
-
-:observation rdf:reifies <<( :sensor :reports :overheating )>> .
-```
-
-In RDF compatibility mode, Eyeling accepts this surface form by translating the triple term to a singleton quoted formula internally:
-
-```n3
-:observation rdf:reifies { :sensor :reports :overheating } .
-```
-
-The dataset example also uses named graph syntax, which RDF compatibility mode normalizes to `log:nameOf` graph terms:
-
-```trig
-:factoryDataset {
-  :observation rdf:reifies <<( :sensor :reports :overheating )>> .
-}
-```
-
-is compiled through the same internal N3 shape:
-
-```n3
-:factoryDataset log:nameOf {
-  :observation rdf:reifies { :sensor :reports :overheating } .
-} .
-```
-
-That is enough for SEE to demonstrate RDF 1.1/RDF 1.2-style dataset input and triple-term output without forcing Eyeling to implement a separate full RDF dataset model. The compatibility layer is explicit rather than default, so ordinary N3 files remain strict N3.
-
-### L.4 Generation and tests
-
-The root package scripts treat SEE as part of the normal repository workflow:
-
-```bash
-npm run generate
-npm run test:see
-```
-
-`npm run generate` refreshes the generated SEE artifacts from `see/examples/n3/*.n3`. `npm run test:see` runs every generated SEE example and compares its Markdown output with the committed reference output.
-
-In the full test suite, this means SEE is not just documentation. It is executable regression coverage for a broad range of Eyeling behavior: forward rules, backward rules, builtins, fuses, queries, RDF lists, formula-valued terms, generated explanations, opt-in RDF 1.2 triple-term compatibility, and opt-in RDF/TriG dataset-syntax compatibility.
-
-### L.5 When to add a SEE example
-
-A normal Eyeling example is best when you want to demonstrate a language feature or a compact reasoning pattern directly in N3.
-
-A SEE example is best when you want a more self-contained artifact:
-
-- the input evidence matters,
-- the final entailment should be explained in Markdown,
-- the example should be runnable without an external reasoner at runtime,
-- the generated JavaScript itself is worth inspecting,
-- or the example should become stable regression coverage for a specific reasoning workflow.
-
-In that sense, SEE is an executable publication format for selected Eyeling examples: small enough to read, deterministic enough to test, and explicit enough to audit.
-

package/README.md

@@ -1,6 +1,7 @@
 # eyeling
 
-[![npm version](https://img.shields.io/npm/v/eyeling.svg)](https://www.npmjs.com/package/eyeling) [![DOI](https://zenodo.org/badge/581706557.svg)](https://doi.org/10.5281/zenodo.19068086)
+[![npm version](https://img.shields.io/npm/v/eyeling.svg)](https://www.npmjs.com/package/eyeling)
+[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.19068086-blue.svg)](https://doi.org/10.5281/zenodo.19068086)
 
 A compact [Notation3 (N3)](https://notation3.org/) reasoner in **JavaScript**.
 
@@ -16,5 +17,4 @@ echo '@prefix : <http://example.org/> .
 
 - [Handbook](https://eyereasoner.github.io/eyeling/HANDBOOK)
 - [Playground](https://eyereasoner.github.io/eyeling/demo)
-- [SEE: Specialized Eyeling Executables](https://github.com/eyereasoner/eyeling/tree/main/see)
 - [Conformance report](https://codeberg.org/phochste/notation3tests/src/branch/main/reports/report.md)

package/dist/browser/eyeling.browser.js

@@ -4249,6 +4249,12 @@ function isBuiltinPred(p) {
     return v === LOG_NS + 'implies' || v === LOG_NS + 'impliedBy';
   }
 
+  // log:nameOf is the ordinary fact predicate used by the RDF/TriG
+  // compatibility layer for named graph blocks. It must remain matchable
+  // against extensional facts instead of being swallowed as an unimplemented
+  // log:* builtin.
+  if (v === LOG_NS + 'nameOf') return false;
+
   // Treat RDF Collections as list-term builtins too.
   if (v === RDF_NS + 'first' || v === RDF_NS + 'rest') {
     return true;
@@ -9590,6 +9596,7 @@ function stripQuotes(lex) {
 //   - A top-level default graph block { ... } is unwrapped into ordinary triples.
 // This keeps all downstream parsing/reasoning N3-only.
 const LOG_NAME_OF_IRI = '<http://www.w3.org/2000/10/swap/log#nameOf>';
+const RDF_REIFIES_IRI = '<http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies>';
 
 function normalizeRdfCompatibility(inputText) {
   let text = String(inputText ?? '');
@@ -9598,11 +9605,12 @@ function normalizeRdfCompatibility(inputText) {
   // surface-syntax normalization. Avoid scanning large files character-by-character
   // unless they actually contain RDF 1.2 triple terms, VERSION directives, or a
   // plausible top-level TriG named graph block.
-  const hasTripleTerms = text.includes('<<(');
+  const hasTripleTerms = text.includes('<<');
   const hasVersionDirective = /^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/im.test(text);
   const hasNamedGraphCandidate = /(?:^|[.\r\n])\s*(?:GRAPH\s+)?(?:<[^>\r\n]*>|_:[A-Za-z][A-Za-z0-9_-]*|[A-Za-z][A-Za-z0-9_-]*:[^\s{};,.()[\]]*)\s*\{/m.test(text);
+  const hasAnnotationSyntax = /(?:^|\s)~\s*(?:<|_:[A-Za-z]|[A-Za-z][A-Za-z0-9_-]*:|\{\|)|\{\|/.test(text);
 
-  if (!hasTripleTerms && !hasVersionDirective && !hasNamedGraphCandidate) return text;
+  if (!hasTripleTerms && !hasVersionDirective && !hasNamedGraphCandidate && !hasAnnotationSyntax) return text;
 
   function isWordChar(ch) {
     return ch != null && /[A-Za-z0-9_:-]/.test(ch);
@@ -9664,11 +9672,67 @@ function normalizeRdfCompatibility(inputText) {
 
   function convertTripleTerms(s) {
     let i = 0;
+    const reifierTriples = [];
 
     function startsAt(needle, at = i) {
       return s.startsWith(needle, at);
     }
 
+    function splitTopLevelReifier(body) {
+      let depthBrace = 0;
+      let depthBracket = 0;
+      let depthParen = 0;
+      for (let j = 0; j < body.length; j++) {
+        const ch = body[j];
+        if (ch === '"' || ch === "'") {
+          const str = readStringAt(body, j);
+          j = str.end - 1;
+          continue;
+        }
+        if (ch === '<') {
+          const iri = readIriAt(body, j);
+          j = iri.end - 1;
+          continue;
+        }
+        if (ch === '#') {
+          while (j < body.length && body[j] !== '\n' && body[j] !== '\r') j += 1;
+          continue;
+        }
+        if (ch === '{') depthBrace += 1;
+        else if (ch === '}' && depthBrace > 0) depthBrace -= 1;
+        else if (ch === '[') depthBracket += 1;
+        else if (ch === ']' && depthBracket > 0) depthBracket -= 1;
+        else if (ch === '(') depthParen += 1;
+        else if (ch === ')' && depthParen > 0) depthParen -= 1;
+        else if (ch === '~' && depthBrace === 0 && depthBracket === 0 && depthParen === 0) {
+          return { triple: body.slice(0, j).trim(), reifier: body.slice(j + 1).trim() };
+        }
+      }
+      return { triple: body.trim(), reifier: '' };
+    }
+
+    function firstTerm(text) {
+      const at = skipWsAndComments(text, 0);
+      if (at >= text.length) return '';
+      if (text[at] === '<') return readIriAt(text, at).text;
+      let j = at;
+      while (j < text.length && !/\s/.test(text[j]) && !'{}[](),;.'.includes(text[j])) j += 1;
+      return text.slice(at, j);
+    }
+
+    function graphTermFromTripleBody(rawBody, parenthesized) {
+      let body = rawBody.trim();
+      if (parenthesized && body.startsWith('(') && body.endsWith(')')) body = body.slice(1, -1).trim();
+      const split = splitTopLevelReifier(body);
+      const triple = split.triple;
+      const graph = '{ ' + triple + ' }';
+      if (split.reifier) {
+        const reifier = firstTerm(split.reifier);
+        if (reifier) reifierTriples.push(`${reifier} ${RDF_REIFIES_IRI} ${graph} .`);
+      }
+      return graph;
+    }
+
     function convertUntil(stopToken) {
       let out = '';
       while (i < s.length) {
@@ -9678,7 +9742,12 @@ function normalizeRdfCompatibility(inputText) {
         }
         if (startsAt('<<(')) {
           i += 3;
-          out += '{ ' + convertUntil(')>>').trim() + ' }';
+          out += graphTermFromTripleBody(convertUntil(')>>'), false);
+          continue;
+        }
+        if (startsAt('<<')) {
+          i += 2;
+          out += graphTermFromTripleBody(convertUntil('>>'), false);
           continue;
         }
         const ch = s[i];
@@ -9709,7 +9778,189 @@ function normalizeRdfCompatibility(inputText) {
       return out;
     }
 
-    return convertUntil(null);
+    const converted = convertUntil(null);
+    if (reifierTriples.length === 0) return converted;
+    return converted + (converted.endsWith('\n') ? '' : '\n') + reifierTriples.join('\n') + '\n';
+  }
+
+
+  function convertAnnotations(s) {
+    let out = '';
+    let i = 0;
+    let statementStart = true;
+    let generatedBlank = 0;
+
+    function readBalancedDelimited(s, at, open, close) {
+      if (!s.startsWith(open, at)) return null;
+      let j = at + open.length;
+      let depth = 1;
+      while (j < s.length) {
+        const ch = s[j];
+        if (ch === '"' || ch === "'") {
+          j = readStringAt(s, j).end;
+          continue;
+        }
+        if (ch === '<' && !s.startsWith('<<', j)) {
+          j = readIriAt(s, j).end;
+          continue;
+        }
+        if (ch === '#') {
+          while (j < s.length && s[j] !== '\n' && s[j] !== '\r') j += 1;
+          continue;
+        }
+        if (s.startsWith(open, j)) {
+          depth += 1;
+          j += open.length;
+          continue;
+        }
+        if (s.startsWith(close, j)) {
+          depth -= 1;
+          j += close.length;
+          if (depth === 0) return { text: s.slice(at, j), inner: s.slice(at + open.length, j - close.length), end: j };
+          continue;
+        }
+        j += 1;
+      }
+      throw new N3SyntaxError(`Unterminated RDF annotation block, expected ${close}`);
+    }
+
+    function readTermLikeAt(s, at) {
+      const j = skipWsAndComments(s, at);
+      if (j >= s.length) return null;
+      if (s[j] === '<') return readIriAt(s, j);
+      if (s[j] === '"' || s[j] === "'") {
+        const str = readStringAt(s, j);
+        let end = str.end;
+        let text = str.text;
+        if (s.startsWith('^^', end)) {
+          const dt = readTermAt(s, end + 2);
+          if (dt) {
+            text += '^^' + dt.text;
+            end = dt.end;
+          }
+        } else if (s[end] === '@') {
+          let k = end + 1;
+          if (/[A-Za-z]/.test(s[k] || '')) {
+            while (k < s.length && /[A-Za-z0-9-]/.test(s[k])) k += 1;
+            text += s.slice(end, k);
+            end = k;
+          }
+        }
+        return { text, end };
+      }
+      if (s[j] === '{') return readBalancedBlock(s, j);
+      if (s[j] === '[') return readBalancedDelimited(s, j, '[', ']');
+      if (s[j] === '(') return readBalancedDelimited(s, j, '(', ')');
+      return readTermAt(s, j);
+    }
+
+    function readAnnotationBlockAt(s, at) {
+      if (!s.startsWith('{|', at)) return null;
+      return readBalancedDelimited(s, at, '{|', '|}');
+    }
+
+    function tryReadAnnotatedTriple(at) {
+      const start = skipWsAndComments(s, at);
+      if (start >= s.length) return null;
+      if (s[start] === '@') return null;
+      if (startsWordAt(s, 'PREFIX', start) || startsWordAt(s, 'BASE', start) || startsWordAt(s, 'VERSION', start)) return null;
+      if (startsWordAt(s, 'GRAPH', start)) return null;
+
+      const subj = readTermLikeAt(s, start);
+      if (!subj) return null;
+      let j = skipWsAndComments(s, subj.end);
+      const pred = readTermLikeAt(s, j);
+      if (!pred) return null;
+      j = skipWsAndComments(s, pred.end);
+      const obj = readTermLikeAt(s, j);
+      if (!obj) return null;
+      j = skipWsAndComments(s, obj.end);
+      if (s[j] !== '~' && !s.startsWith('{|', j)) return null;
+
+      let reifier = '';
+      const annotationBlocks = [];
+      while (j < s.length) {
+        j = skipWsAndComments(s, j);
+        if (s[j] === '~') {
+          j += 1;
+          j = skipWsAndComments(s, j);
+          const term = readTermAt(s, j);
+          if (term) {
+            reifier = term.text;
+            j = term.end;
+          } else if (!reifier) {
+            reifier = `_:rdfAnnotation${++generatedBlank}`;
+          }
+          continue;
+        }
+        if (s.startsWith('{|', j)) {
+          const block = readAnnotationBlockAt(s, j);
+          if (!reifier) reifier = `_:rdfAnnotation${++generatedBlank}`;
+          annotationBlocks.push(block.inner.trim());
+          j = block.end;
+          continue;
+        }
+        break;
+      }
+
+      const after = skipWsAndComments(s, j);
+      if (s[after] !== '.') return null;
+      if (!reifier && annotationBlocks.length === 0) return null;
+
+      const baseTriple = `${subj.text} ${pred.text} ${obj.text}`;
+      const graph = `{ ${baseTriple} }`;
+      const extra = [];
+      if (reifier) extra.push(`${reifier} ${RDF_REIFIES_IRI} ${graph} .`);
+      for (const inner of annotationBlocks) {
+        if (inner) extra.push(`${reifier} ${inner} .`);
+      }
+      return {
+        start,
+        end: after + 1,
+        text: `${baseTriple} .${extra.length ? '\n' + extra.join('\n') : ''}`,
+      };
+    }
+
+    while (i < s.length) {
+      if (statementStart) {
+        const converted = tryReadAnnotatedTriple(i);
+        if (converted) {
+          out += s.slice(i, converted.start) + converted.text;
+          i = converted.end;
+          statementStart = true;
+          continue;
+        }
+      }
+
+      const ch = s[i];
+      if (ch === '"' || ch === "'") {
+        const str = readStringAt(s, i);
+        out += str.text;
+        i = str.end;
+        continue;
+      }
+      if (ch === '<' && !s.startsWith('<<', i)) {
+        const iri = readIriAt(s, i);
+        out += iri.text;
+        i = iri.end;
+        continue;
+      }
+      if (ch === '#') {
+        while (i < s.length) {
+          const c = s[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        statementStart = true;
+        continue;
+      }
+      out += ch;
+      if (ch === '.' || ch === '{' || ch === '}' || ch === '\n' || ch === '\r') statementStart = true;
+      else if (!/\s/.test(ch)) statementStart = false;
+      i += 1;
+    }
+
+    return out;
   }
 
   function stripVersionDirectives(s) {
@@ -9868,6 +10119,7 @@ function normalizeRdfCompatibility(inputText) {
   }
 
   if (hasTripleTerms) text = convertTripleTerms(text);
+  if (hasAnnotationSyntax) text = convertAnnotations(text);
   if (hasVersionDirective) text = stripVersionDirectives(text);
   if (hasVersionDirective || hasNamedGraphCandidate) text = normalizeNamedGraphs(text);
   return text;

package/examples/annotation.n3

@@ -1,7 +1,6 @@
-@prefix : <http://example.com/> .
-@prefix log: <http://www.w3.org/2000/10/swap/log#> .
-@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
-
+@prefix : <https://eyereasoner.github.io/eyeling/examples/annotation#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
 :a :name "Alice" .
 :t log:nameOf { :a :name "Alice" . } .
 :t :statedBy :bob .

package/{see/examples/n3/backward_recursion.n3 → examples/backward-recursion.n3}

@@ -2,8 +2,6 @@
 # Demonstrates recursive <= rules compiled into specialized JavaScript.
 
 @prefix : <urn:example#>.
-:a :parent :b.
-:b :parent :c.
 
 { ?x :ancestor ?y } <= { ?x :parent ?y }.
 { ?x :ancestor ?z } <= { ?x :parent ?y. ?y :ancestor ?z }.

package/examples/collection.n3

@@ -1,4 +1,3 @@
-@prefix : <http://example.org/stuff/1.0/> .
-
+@prefix : <https://eyereasoner.github.io/eyeling/examples/collection#>.
 (1 _:b2 (2)) :p2 :q2 .
 _:b2 :p :q .

package/examples/context-association.n3

@@ -1,33 +1,59 @@
-@prefix : <http://example.org/#> .
-@prefix foaf: <http://xmlns.com/foaf/0.1/> .
-@prefix sec: <https://w3id.org/security#> .
-@prefix skolem: <https://eyereasoner.github.io/.well-known/genid/5649fff4-464d-5969-88ed-956a6b5f0d90#> .
-@prefix log: <http://www.w3.org/2000/10/swap/log#> .
-@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+# Context association
+#
+# Uses an external RDF/TriG input dataset whose named graph blocks associate a
+# data graph, a signature graph, and a metadata graph. This Eyeling example
+# verifies that the graph contexts form a signed association around Bob's data.
 
-skolem:g0 log:nameOf {
-  :Bob foaf:name "Bob" .
-} .
+@prefix foaf: <http://xmlns.com/foaf/0.1/>.
+@prefix sec: <https://w3id.org/security#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix : <http://example.org/#>.
 
-skolem:g1 log:nameOf {
-  skolem:g0 sec:proof _:dataSignature .
-  _:signature1 a sec:DataIntegrityProof .
-  _:signature1 sec:cryptosuite "ecdsa-rdfc-2019" .
-  _:signature1 sec:created "2021-11-13T18:19:39Z" .
-  _:signature1 sec:verificationMethod "https://university.example/issuers/14#key-1" .
-  _:signature1 sec:proofPurpose "assertionMethod" .
-  _:signature1 sec:proofValue "z58DAdFfa9SkqZMVPxAQp...jQCrfFPP2oumHKtz" .
-  _:signature1 sec:issuer <https://university.example/issuers/14> .
-  _:signature1 sec:validFrom "2024-04-03T00:00:00.000Z"^^xsd:dateTime .
-  _:signature1 sec:validUntil "2025-04-03T00:00:00.000Z"^^xsd:dateTime .
-} .
+{
+  ?dataGraph log:nameOf ?dataContext.
+  ?dataContext log:includes { :Bob foaf:name "Bob" }.
 
-_:g3 log:nameOf {
-  skolem:g1 sec:proof _:signature2 .
-  _:signature2 a sec:DataIntegrityProof .
-  _:signature2 sec:cryptosuite "ecdsa-rdfc-2019" .
-  _:signature2 sec:created "2021-11-13T18:19:39Z" .
-  _:signature2 sec:verificationMethod "https://university.example/issuers/14#key-1" .
-  _:signature2 sec:proofPurpose "assertionMethod" .
-  _:signature2 sec:proofValue "adad123efv434r5200...dqed2t44v43das" .
-} .
+  ?signatureGraph log:nameOf ?signatureContext.
+  ?signatureContext log:includes {
+    ?dataGraph sec:proof ?dataSignature.
+    ?proof a sec:DataIntegrityProof.
+    ?proof sec:cryptosuite "ecdsa-rdfc-2019".
+    ?proof sec:issuer <https://university.example/issuers/14>.
+    ?proof sec:validUntil "2025-04-03T00:00:00.000Z"^^xsd:dateTime.
+  }.
+
+  ?metadataGraph log:nameOf ?metadataContext.
+  ?metadataContext log:includes {
+    ?signatureGraph sec:proof ?metadataSignature.
+    ?metadataProof a sec:DataIntegrityProof.
+    ?metadataProof sec:proofPurpose "assertionMethod".
+  }.
+}
+=>
+{
+  :association :subject :Bob.
+  :association :dataGraph ?dataGraph.
+  :association :signatureGraph ?signatureGraph.
+  :association :metadataGraph ?metadataGraph.
+  :association :cryptosuite "ecdsa-rdfc-2019".
+  :association :issuer <https://university.example/issuers/14>.
+  :association :status :contextAssociationVerified.
+}.
+
+{
+  :association :status :contextAssociationVerified.
+}
+=>
+{
+  :report log:outputString "# Context association\n\n## Entailment\nThe RDF dataset associates Bob's data graph with a Data Integrity proof graph and a second metadata proof graph.\n\n## Explanation\nThe input TriG names three graph contexts. The data graph states Bob's name. The signature graph links to that data graph with a proof and records an ecdsa-rdfc-2019 Data Integrity proof from the university issuer. The metadata graph then signs the signature graph itself, giving a chained context association.".
+}.
+
+# query
+{
+  :association ?P ?O.
+}
+log:query
+{
+  :association ?P ?O.
+}.

package/{see/examples/n3/dijkstra_risk_path.n3 → examples/dijkstra-risk-path.n3}

@@ -1,35 +1,20 @@
 # ==================
 # Dijkstra Risk Path
 # ==================
-# N3-compiled version of the risk-adjusted route example. The original JSON
+# N3 version of the risk-adjusted route example. The original JSON
 # input is preserved as the data-input sidecar; this source compiles the
 # executable derivation and report.
 
-@prefix : <https://eyereasoner.github.io/see/examples/dijkstra-risk-path#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/dijkstra-risk-path#>.
 @prefix math: <http://www.w3.org/2000/10/swap/math#>.
 @prefix log: <http://www.w3.org/2000/10/swap/log#>.
 @prefix string: <http://www.w3.org/2000/10/swap/string#>.
 
-:Case
-  :question "Which clinic-to-hub route has the lowest risk-adjusted score?";
-  :start :ClinicA;
-  :goal :HubZ;
-  :riskWeight 2.0.
 
-:pathB
-  :routeText "ClinicA -> DepotB -> LabD -> HubZ";
-  :rawCost 10.0;
-  :riskSum 0.55;
-  :score 11.10;
-  :edgeCount 3;
-  :uses :ClinicA, :DepotB, :LabD, :HubZ.
 
-:pathC :score 11.30.
-:pathRelay :score 11.70.
-:pathDirectC :rawCost 10.0; :score 11.60; :riskSum 0.80.
-:pathViaC :rawCost 8.0; :score 11.20; :riskSum 1.60.
 
 # The selected route must be strictly lower than each enumerated alternative.
+
 {
   :pathB :score ?Best.
   :pathC :score ?CScore.