eyeling 1.24.1 → 1.24.2

package/HANDBOOK.md

@@ -36,6 +36,7 @@
 - [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)
 
 ---
 
@@ -236,6 +237,20 @@ The lexer turns the input into tokens like:
 
 Parsing becomes dramatically simpler because tokenization already decided where strings end, where numbers are, and so on.
 
+One compatibility wrinkle is handled in the lexer before normal parsing: RDF 1.2 triple terms written as `<<( s p o )>>` are accepted and 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. This keeps Eyeling's N3 model stable while allowing small RDF 1.2 triple-term inputs to run through the existing `GraphTerm` machinery. For example:
+
+```n3
+:observation rdf:reifies <<( :sensor :reports :overheating )>> .
+```
+
+is treated internally like:
+
+```n3
+:observation rdf:reifies { :sensor :reports :overheating } .
+```
+
+This is intentionally a compatibility translation, not a new full RDF 1.2 parser layer. Nested or more exotic future triple-term forms should be added only if they can be mapped cleanly onto Eyeling's quoted-formula term model.
+
 ### 4.2 Parsing triples, with Turtle-style convenience
 
 The parser supports:
@@ -2561,6 +2576,8 @@ 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).
 
+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 }`. This is useful for inputs that use `rdf:reifies` or other predicates whose objects are RDF 1.2 triple terms, while keeping the rest of Eyeling on its N3 formula-term model.
+
 For the formal grammar, see the N3 spec grammar:
 
 - [https://w3c.github.io/N3/spec/#grammar](https://w3c.github.io/N3/spec/#grammar)
@@ -3794,3 +3811,84 @@ The becoming examples should therefore be read as **executable schemata** rather
 For the handbook, these examples matter for two reasons. First, they provide a concrete demonstration that Eyeling can handle a style of reasoning that feels closer to **becoming, development, and transformation** than to static classification. Second, they show how expressive gains can come from modeling choices rather than from adding new machinery to the engine. The same forward-chaining core that proves `:Socrates a :Mortal` can also prove that a lineage becomes evolvable, that a controller becomes approved, or that a wake switch becomes serviceable under a low-bias regime.
 
 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 also includes a triple-term example. Its input can contain RDF 1.2 triple terms such as:
+
+```trig
+VERSION "1.2"
+
+:observation rdf:reifies <<( :sensor :reports :overheating )>> .
+```
+
+Eyeling accepts this surface form by translating the triple term to a singleton quoted formula internally:
+
+```n3
+:observation rdf:reifies { :sensor :reports :overheating } .
+```
+
+That is enough for the SEE example to demonstrate RDF 1.2-style triple terms as input and output without forcing Eyeling to implement a separate full RDF 1.2 syntax model.
+
+### 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, and RDF 1.2 triple-term 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/dist/browser/eyeling.browser.js

@@ -9555,7 +9555,110 @@ function stripQuotes(lex) {
   return lex;
 }
 
+
+// RDF 1.2 triple terms use <<( s p o )>>. Eyeling's N3 engine does not
+// implement a new RDF 1.2 term kind; instead, it accepts this syntax as a
+// compatibility surface and normalizes it to the existing N3 singleton quoted
+// graph term { s p o }. This keeps ordinary N3 reasoning unchanged while making
+// RDF 1.2 examples parseable by the current engine.
+function normalizeRdf12TripleTerms(inputText) {
+  const text = String(inputText ?? '');
+  let i = 0;
+
+  function startsAt(needle, at = i) {
+    return text.startsWith(needle, at);
+  }
+
+  function readString() {
+    const quote = text[i];
+    let out = quote;
+    const long = text.startsWith(quote.repeat(3), i);
+    if (long) {
+      out = quote.repeat(3);
+      i += 3;
+      while (i < text.length) {
+        if (text.startsWith(quote.repeat(3), i)) {
+          out += quote.repeat(3);
+          i += 3;
+          return out;
+        }
+        if (text[i] === '\\' && i + 1 < text.length) {
+          out += text.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += text[i++];
+        }
+      }
+      return out;
+    }
+    i += 1;
+    let escaped = false;
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+    }
+    return out;
+  }
+
+  function readIri() {
+    let out = text[i++];
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (ch === '>') break;
+    }
+    return out;
+  }
+
+  function convertUntil(stopToken) {
+    let out = '';
+    while (i < text.length) {
+      if (stopToken && startsAt(stopToken)) {
+        i += stopToken.length;
+        return out;
+      }
+      if (startsAt('<<(')) {
+        i += 3;
+        out += '{ ' + convertUntil(')>>').trim() + ' }';
+        continue;
+      }
+      const ch = text[i];
+      if (ch === '"' || ch === "'") {
+        out += readString();
+        continue;
+      }
+      if (ch === '<') {
+        out += readIri();
+        continue;
+      }
+      if (ch === '#') {
+        while (i < text.length) {
+          const c = text[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        continue;
+      }
+      out += ch;
+      i += 1;
+    }
+    if (stopToken) throw new N3SyntaxError(`Unterminated RDF 1.2 triple term, expected ${stopToken}`);
+    return out;
+  }
+
+  const converted = convertUntil(null);
+  return converted.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+}
+
 function lex(inputText) {
+  inputText = normalizeRdf12TripleTerms(inputText);
   const chars = Array.from(inputText);
   const n = chars.length;
   let i = 0;

package/eyeling.js

@@ -9555,7 +9555,110 @@ function stripQuotes(lex) {
   return lex;
 }
 
+
+// RDF 1.2 triple terms use <<( s p o )>>. Eyeling's N3 engine does not
+// implement a new RDF 1.2 term kind; instead, it accepts this syntax as a
+// compatibility surface and normalizes it to the existing N3 singleton quoted
+// graph term { s p o }. This keeps ordinary N3 reasoning unchanged while making
+// RDF 1.2 examples parseable by the current engine.
+function normalizeRdf12TripleTerms(inputText) {
+  const text = String(inputText ?? '');
+  let i = 0;
+
+  function startsAt(needle, at = i) {
+    return text.startsWith(needle, at);
+  }
+
+  function readString() {
+    const quote = text[i];
+    let out = quote;
+    const long = text.startsWith(quote.repeat(3), i);
+    if (long) {
+      out = quote.repeat(3);
+      i += 3;
+      while (i < text.length) {
+        if (text.startsWith(quote.repeat(3), i)) {
+          out += quote.repeat(3);
+          i += 3;
+          return out;
+        }
+        if (text[i] === '\\' && i + 1 < text.length) {
+          out += text.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += text[i++];
+        }
+      }
+      return out;
+    }
+    i += 1;
+    let escaped = false;
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+    }
+    return out;
+  }
+
+  function readIri() {
+    let out = text[i++];
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (ch === '>') break;
+    }
+    return out;
+  }
+
+  function convertUntil(stopToken) {
+    let out = '';
+    while (i < text.length) {
+      if (stopToken && startsAt(stopToken)) {
+        i += stopToken.length;
+        return out;
+      }
+      if (startsAt('<<(')) {
+        i += 3;
+        out += '{ ' + convertUntil(')>>').trim() + ' }';
+        continue;
+      }
+      const ch = text[i];
+      if (ch === '"' || ch === "'") {
+        out += readString();
+        continue;
+      }
+      if (ch === '<') {
+        out += readIri();
+        continue;
+      }
+      if (ch === '#') {
+        while (i < text.length) {
+          const c = text[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        continue;
+      }
+      out += ch;
+      i += 1;
+    }
+    if (stopToken) throw new N3SyntaxError(`Unterminated RDF 1.2 triple term, expected ${stopToken}`);
+    return out;
+  }
+
+  const converted = convertUntil(null);
+  return converted.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+}
+
 function lex(inputText) {
+  inputText = normalizeRdf12TripleTerms(inputText);
   const chars = Array.from(inputText);
   const n = chars.length;
   let i = 0;

package/lib/lexer.js

@@ -347,7 +347,110 @@ function stripQuotes(lex) {
   return lex;
 }
 
+
+// RDF 1.2 triple terms use <<( s p o )>>. Eyeling's N3 engine does not
+// implement a new RDF 1.2 term kind; instead, it accepts this syntax as a
+// compatibility surface and normalizes it to the existing N3 singleton quoted
+// graph term { s p o }. This keeps ordinary N3 reasoning unchanged while making
+// RDF 1.2 examples parseable by the current engine.
+function normalizeRdf12TripleTerms(inputText) {
+  const text = String(inputText ?? '');
+  let i = 0;
+
+  function startsAt(needle, at = i) {
+    return text.startsWith(needle, at);
+  }
+
+  function readString() {
+    const quote = text[i];
+    let out = quote;
+    const long = text.startsWith(quote.repeat(3), i);
+    if (long) {
+      out = quote.repeat(3);
+      i += 3;
+      while (i < text.length) {
+        if (text.startsWith(quote.repeat(3), i)) {
+          out += quote.repeat(3);
+          i += 3;
+          return out;
+        }
+        if (text[i] === '\\' && i + 1 < text.length) {
+          out += text.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += text[i++];
+        }
+      }
+      return out;
+    }
+    i += 1;
+    let escaped = false;
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+    }
+    return out;
+  }
+
+  function readIri() {
+    let out = text[i++];
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (ch === '>') break;
+    }
+    return out;
+  }
+
+  function convertUntil(stopToken) {
+    let out = '';
+    while (i < text.length) {
+      if (stopToken && startsAt(stopToken)) {
+        i += stopToken.length;
+        return out;
+      }
+      if (startsAt('<<(')) {
+        i += 3;
+        out += '{ ' + convertUntil(')>>').trim() + ' }';
+        continue;
+      }
+      const ch = text[i];
+      if (ch === '"' || ch === "'") {
+        out += readString();
+        continue;
+      }
+      if (ch === '<') {
+        out += readIri();
+        continue;
+      }
+      if (ch === '#') {
+        while (i < text.length) {
+          const c = text[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        continue;
+      }
+      out += ch;
+      i += 1;
+    }
+    if (stopToken) throw new N3SyntaxError(`Unterminated RDF 1.2 triple term, expected ${stopToken}`);
+    return out;
+  }
+
+  const converted = convertUntil(null);
+  return converted.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+}
+
 function lex(inputText) {
+  inputText = normalizeRdf12TripleTerms(inputText);
   const chars = Array.from(inputText);
   const n = chars.length;
   let i = 0;

package/package.json

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

package/see/README.md

@@ -18,6 +18,8 @@ Each example starts from a Notation3 source and is compiled by `see.js` into a s
 
 The trust gate is executable verification. If a required fact is missing, the program fails instead of emitting an unsupported entailment.
 
+The `triple_terms` example uses RDF 1.2 `<<( ... )>>` triple-term syntax. Eyeling accepts that syntax by normalizing it to the existing N3 singleton graph term `{ ... }`; SEE keeps the committed `.trig` input and formal output in RDF 1.2 triple-term form.
+
 
 ## Run
 
@@ -141,5 +143,6 @@ The repository currently contains **50 N3-compiled SEE examples**. Each example
 | <a id="example-school-placement-route-audit"></a>[School placement route audit](#example-school-placement-route-audit) | compiled from Notation3 by `see.js`; student, school, distance, and policy facts derive an auditable school-placement route decision. | [doc](examples/doc/school_placement_audit.md), [js](examples/school_placement_audit.js), [input](examples/input/school_placement_audit.trig), [output](examples/output/school_placement_audit.md), [n3](examples/n3/school_placement_audit.n3) |
 | <a id="example-smoke-arithmetic"></a>[Smoke Arithmetic](#example-smoke-arithmetic) | compiled from Notation3 by `see.js`; arithmetic compiler smoke test deriving 6 × 7 through rules and builtins. | [doc](examples/doc/smoke_arithmetic.md), [js](examples/smoke_arithmetic.js), [input](examples/input/smoke_arithmetic.trig), [output](examples/output/smoke_arithmetic.md), [n3](examples/n3/smoke_arithmetic.n3) |
 | <a id="example-socrates-inference"></a>[Socrates inference](#example-socrates-inference) | compiled from Notation3 by `see.js`; subclass closure with top-level `log:query` projection. | [doc](examples/doc/socrates.md), [js](examples/socrates.js), [input](examples/input/socrates.trig), [output](examples/output/socrates.md), [n3](examples/n3/socrates.n3) |
+| <a id="example-triple-terms"></a>[Triple terms](#example-triple-terms) | compiled from Notation3 by `see.js`; RDF 1.2 TriG triple terms are used as input evidence and as a derived entailment. | [doc](examples/doc/triple_terms.md), [js](examples/triple_terms.js), [input](examples/input/triple_terms.trig), [output](examples/output/triple_terms.md), [n3](examples/n3/triple_terms.n3) |
 | <a id="example-wind-turbine-envelope"></a>[Wind turbine envelope](#example-wind-turbine-envelope) | compiled from Notation3 by `see.js`; wind-speed samples are classified against cut-in, rated, and cut-out thresholds and accumulated into energy. | [doc](examples/doc/wind_turbine.md), [js](examples/wind_turbine.js), [input](examples/input/wind_turbine.trig), [output](examples/output/wind_turbine.md), [n3](examples/n3/wind_turbine.n3) |
 | <a id="example-burn-the-witch"></a>[Burn the witch](#example-burn-the-witch) | compiled from Notation3 by `see.js`; rule-chain explanation for the witch entailment. | [doc](examples/doc/witch.md), [js](examples/witch.js), [input](examples/input/witch.trig), [output](examples/output/witch.md), [n3](examples/n3/witch.n3) |

package/see/examples/_see.js

@@ -7,11 +7,31 @@ function lit(value) { return { kind: 'lit', value }; }
 function blank(value) { return { kind: 'blank', value }; }
 function list(items) { return { kind: 'list', items }; }
 function formula(atoms) { return { kind: 'formula', atoms }; }
+function triple(s, p, o) { return { kind: 'triple', s, p, o }; }
 
 function readTermToken(text, start = 0) {
   let i = start;
   while (/\s/.test(text[i])) i += 1;
   const begin = i;
+  if (text.startsWith('<<(', i)) {
+    let depth = 0;
+    while (i < text.length) {
+      if (text[i] === '"') {
+        const [, next] = readTermToken(text, i);
+        i = next;
+        continue;
+      }
+      if (text.startsWith('<<(', i)) { depth += 1; i += 3; continue; }
+      if (text.startsWith(')>>', i)) {
+        depth -= 1;
+        i += 3;
+        if (depth === 0) break;
+        continue;
+      }
+      i += 1;
+    }
+    return [text.slice(begin, i), i];
+  }
   if (text[i] === '"') {
     i += 1;
     let escaped = false;
@@ -60,7 +80,10 @@ function splitListItems(text) {
     while (/\s/.test(text[i])) i += 1;
     if (i >= text.length) break;
     const start = i;
-    if (text[i] === '"') {
+    if (text.startsWith('<<(', i)) {
+      const [, next] = readTermToken(text, i);
+      i = next;
+    } else if (text[i] === '"') {
       i += 1;
       let escaped = false;
       while (i < text.length) {
@@ -83,9 +106,17 @@ function splitListItems(text) {
   }
   return out;
 }
+function parseTripleTermBody(text) {
+  const [s, i1] = readTermToken(text, 0);
+  const [p, i2] = readTermToken(text, i1);
+  const [o, i3] = readTermToken(text, i2);
+  if (!s || !p || !o || text.slice(i3).trim()) throw new Error('bad triple term: ' + text);
+  return triple(parseTerm(s), parseTerm(p), parseTerm(o));
+}
 function parseTerm(text) {
   const t = String(text || '').trim();
   if (!t) throw new Error('empty term');
+  if (t.startsWith('<<(') && t.endsWith(')>>')) return parseTripleTermBody(t.slice(3, -3).trim());
   const first = t[0];
   if (first === '"') return lit(JSON.parse(t));
   if (first === '(' && t[t.length - 1] === ')') return list(splitListItems(t.slice(1, -1)).map(parseTerm));
@@ -112,7 +143,7 @@ function parseInputTrigFast(trig) {
   const lines = String(trig || '').split(/\r?\n/);
   for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i].trim();
-    if (!line || line.startsWith('#') || line.toLowerCase().startsWith('@prefix ')) continue;
+    if (!line || line.startsWith('#') || line.toLowerCase().startsWith('@prefix ') || /^(@version|version)\s+/i.test(line)) continue;
     const graphStart = line.match(/^(\S+)\s*\{\s*$/);
     if (graphStart) {
       const atoms = [];

package/see/examples/age.js

@@ -8,6 +8,7 @@ const crypto = require('crypto');
 
 function canonical(term) {
   if (term.kind === 'list') return ['list', term.items.map(canonical)];
+  if (term.kind === 'triple') return ['triple', canonical(term.s), canonical(term.p), canonical(term.o)];
   if (term.kind === 'formula') return ['formula', term.atoms.map((a) => [canonical(a.s), canonical(a.p), canonical(a.o)])];
   return [term.kind, term.value];
 }
@@ -17,6 +18,7 @@ function compoundIndexKey() { return Array.from(arguments).map(termIndexKey).joi
 function termIsConcrete(t) {
   if (!t || t.kind === 'var') return false;
   if (t.kind === 'list') return t.items.every(termIsConcrete);
+  if (t.kind === 'triple') return termIsConcrete(t.s) && termIsConcrete(t.p) && termIsConcrete(t.o);
   if (t.kind === 'formula') return t.atoms.every((a) => termIsConcrete(a.s) && termIsConcrete(a.p) && termIsConcrete(a.o));
   return true;
 }
@@ -32,6 +34,7 @@ function primitive(t) {
   if (t.kind === 'iri') return t.value.replace(/^:/, '');
   if (t.kind === 'blank') return t.value;
   if (t.kind === 'list') return t.items.map(primitive);
+  if (t.kind === 'triple') return termToN3(t);
   if (t.kind === 'formula') return termToN3(t);
   return undefined;
 }
@@ -52,6 +55,7 @@ function termToN3(t) {
   if (t.kind === 'var') return '?' + t.value;
   if (t.kind === 'blank') return t.value.startsWith('_:') ? t.value : '_:' + t.value.replace(/^_+/, '');
   if (t.kind === 'list') return '(' + t.items.map(termToN3).join(' ') + ')';
+  if (t.kind === 'triple') return '<<( ' + termToN3(t.s) + ' ' + termToN3(t.p) + ' ' + termToN3(t.o) + ' )>>';
   if (t.kind === 'formula') return '{ ' + t.atoms.map(atomToN3).join(' . ') + ' }';
   return String(t.value ?? t);
 }
@@ -74,6 +78,7 @@ function resolve(term, env, seen = new Set()) {
     return resolve(env[term.value], env, seen);
   }
   if (term.kind === 'list') return list(term.items.map((item) => resolve(item, env, seen)));
+  if (term.kind === 'triple') return { kind: 'triple', s: resolve(term.s, env), p: resolve(term.p, env), o: resolve(term.o, env) };
   if (term.kind === 'formula') return { kind: 'formula', atoms: term.atoms.map((a) => ({ s: resolve(a.s, env), p: resolve(a.p, env), o: resolve(a.o, env) })) };
   return term;
 }
@@ -91,6 +96,14 @@ function unify(a, b, env) {
     }
     return out;
   }
+  if (a.kind === 'triple' || b.kind === 'triple') {
+    if (a.kind !== 'triple' || b.kind !== 'triple') return null;
+    let out = unify(a.s, b.s, env);
+    if (!out) return null;
+    out = unify(a.p, b.p, out);
+    if (!out) return null;
+    return unify(a.o, b.o, out);
+  }
   return deepEqual(a, b) ? env : null;
 }
 function bind(pattern, value, env) { return unify(pattern, value, env); }
@@ -106,6 +119,7 @@ function termIsGround(t, env) {
   const r = resolve(t, env);
   if (r.kind === 'var') return false;
   if (r.kind === 'list') return r.items.every((item) => termIsGround(item, env));
+  if (r.kind === 'triple') return termIsGround(r.s, env) && termIsGround(r.p, env) && termIsGround(r.o, env);
   if (r.kind === 'formula') return r.atoms.every((atom) => atomIsGround(atom, env));
   return true;
 }
@@ -665,6 +679,7 @@ function instantiate(term, env, ruleId) {
   }
   if (term.kind === 'blank') return blank('_:r' + ruleId + '_' + envSignature(env) + '_' + term.value.replace(/^_/, ''));
   if (term.kind === 'list') return list(term.items.map((item) => instantiate(item, env, ruleId)));
+  if (term.kind === 'triple') return { kind: 'triple', s: instantiate(term.s, env, ruleId), p: instantiate(term.p, env, ruleId), o: instantiate(term.o, env, ruleId) };
   if (term.kind === 'formula') return { kind: 'formula', atoms: term.atoms.map((a) => ({ s: instantiate(a.s, env, ruleId), p: instantiate(a.p, env, ruleId), o: instantiate(a.o, env, ruleId) })) };
   return cloneTerm(term);
 }
@@ -1368,6 +1383,16 @@ function formalOutputFacts(graph, queries, rules, initialFacts) {
   }
   return out;
 }
+function termHasTripleTerm(term) {
+  if (!term) return false;
+  if (term.kind === 'triple') return true;
+  if (term.kind === 'list') return term.items.some(termHasTripleTerm);
+  if (term.kind === 'formula') return term.atoms.some(atomHasTripleTerm);
+  return false;
+}
+function atomHasTripleTerm(atom) { return termHasTripleTerm(atom.s) || termHasTripleTerm(atom.p) || termHasTripleTerm(atom.o); }
+function factsHaveTripleTerms(facts) { return (facts || []).some(atomHasTripleTerm); }
+function trigHasVersion12(trig) { return /^s*(?:@version|VERSION)s+["']1.2["']/mi.test(String(trig || '')); }
 function trigGraphBlock(label, atoms) {
   const lines = [label + ' {'];
   for (const atom of atoms || []) lines.push('  ' + atomToN3(atom) + ' .');
@@ -1415,7 +1440,8 @@ function formalOutputToTrig(facts, trig) {
   const prefixes = prefixLinesFromTrig(trig);
   if (state.needOutPrefix && !prefixes.some((line) => line.toLowerCase().startsWith('@prefix out:'))) prefixes.push('@prefix out: <https://example.org/see/output#> .');
   const nl = String.fromCharCode(10);
-  return prefixes.join(nl) + nl + nl + body.join(nl);
+  const version = factsHaveTripleTerms(facts) ? 'VERSION "1.2"' + nl + nl : '';
+  return version + prefixes.join(nl) + nl + nl + body.join(nl);
 }
 function appendFormalTrigOutput(markdown, graph, queries, rules, initialFacts, data) {
   const trig = formalOutputToTrig(formalOutputFacts(graph, queries, rules, initialFacts), data && data.trig);