eyeprolog 1.1.0 → 1.1.2

package/README.md

@@ -33,9 +33,19 @@ Programs may declare their default queries with `%% goal:` comments.
 Double-quoted text follows the ISO `double_quotes` flag and defaults to a
 proper list of one-character atoms (`chars`), matching Trealla and Scryer.
 
-## Standard library modules
+## ISO modules and definite clause grammars
 
-EyeProlog adds 44 public library predicates to its 127-entry ISO core registry.
+EyeProlog implements ISO/IEC 13211-2 modules and the grammar rules and
+`phrase/2-3` predicates of ISO/IEC TS 13211-3:2025. For example:
+
+```prolog
+sentence --> [hello], noun.
+noun --> [world] | [prolog].
+
+%% goal: phrase(sentence, Words)
+```
+
+EyeProlog also adds 44 public library predicates to its 129-entry ISO registry.
 **All 44 are ordinary Prolog clauses** in `src/lib/eyeprolog.pl` and
 `src/lib/lists.pl`. They are ISO/IEC 13211-2 modules, loaded explicitly with
 `use_module(library(eyeprolog))` or `use_module(library(lists))`, following the

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 130 | 174 | 0 | 0 | 304 |
+| iso | 164 | 209 | 0 | 0 | 373 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **445** | **225** | **19** | **21** | **710** |
+| **Total** | **479** | **260** | **19** | **21** | **779** |

package/examples/book/README.md

@@ -127,7 +127,7 @@ npm run generate
 - [01-tree.pl](chapter-22/01-tree.pl)
 - [02-tree_member.pl](chapter-22/02-tree_member.pl)
 - [03-mirror.pl](chapter-22/03-mirror.pl) — Transforming a tree
-- [04-sentence.pl](chapter-22/04-sentence.pl) — A grammar without special syntax
+- [04-sentence.pl](chapter-22/04-sentence.pl) — A standard definite clause grammar
 - [05-evaluate.pl](chapter-22/05-evaluate.pl) — Interpreting an expression
 - [06-lookup.pl](chapter-22/06-lookup.pl)
 - [07-simplify.pl](chapter-22/07-simplify.pl) — Rewriting symbolic expressions
@@ -233,6 +233,7 @@ npm run generate
 ## Chapter 38: Language and ISO profile
 
 - [01-city.pl](chapter-38/01-city.pl)
+- [02-look_ahead.pl](chapter-38/02-look_ahead.pl) — ISO Part 3 definite clause grammars
 
 ## Chapter 39: Built-in predicates by programming role
 

package/examples/book/chapter-22/04-sentence.pl

@@ -1,19 +1,15 @@
-% From The Art of EyeProlog, Chapter 22 — A grammar without special syntax.
-sentence(Input, Rest) :-
-  noun_phrase(Input, AfterNoun),
-  verb_phrase(AfterNoun, Rest).
+% From The Art of EyeProlog, Chapter 22 — A standard definite clause grammar.
+sentence --> noun_phrase, verb_phrase.
 
-noun_phrase([the | Input], Rest) :- noun(Input, Rest).
-noun_phrase([a | Input], Rest) :- noun(Input, Rest).
+noun_phrase --> [the], noun.
+noun_phrase --> [a], noun.
 
-noun([robot | Rest], Rest).
-noun([scientist | Rest], Rest).
+noun --> [robot].
+noun --> [scientist].
 
-verb_phrase(Input, Rest) :-
-  verb(Input, AfterVerb),
-  noun_phrase(AfterVerb, Rest).
+verb_phrase --> verb, noun_phrase.
 
-verb([helps | Rest], Rest).
-verb([observes | Rest], Rest).
+verb --> [helps].
+verb --> [observes].
 
-complete_sentence(Words) :- sentence(Words, []).
+complete_sentence(Words) :- phrase(sentence, Words).

package/examples/book/chapter-38/02-look_ahead.pl

@@ -0,0 +1,2 @@
+% From The Art of EyeProlog, Chapter 38 — ISO Part 3 definite clause grammars.
+look_ahead(X), [X] --> [X].

package/examples/dcg-command-parser.pl

@@ -0,0 +1,26 @@
+% Parse and generate commands for a tiny home-automation language with a DCG.
+%
+% The grammar separates surface tokens from the structured command term used
+% by an application.  phrase/2 requires complete input, while phrase/3 leaves
+% unconsumed tokens available to a surrounding parser.
+%% goal: dcg_example(X0, X1)
+
+command(set(light(Room), State)) -->
+  [set], room(Room), [light, to], state(State).
+
+room(kitchen) --> [kitchen].
+room(hall) --> [hall].
+
+state(on) --> [on].
+state(off) --> [off].
+
+dcg_example(parsed, Command) :-
+  phrase(command(Command), [set, kitchen, light, to, on]).
+dcg_example(generated, Tokens) :-
+  phrase(command(set(light(hall), off)), Tokens).
+dcg_example(remainder, Rest) :-
+  phrase(command(set(light(kitchen), on)),
+         [set, kitchen, light, to, on, then, wait],
+         Rest).
+dcg_example(rejected, invalid_command) :-
+  \+ phrase(command(_), [set, garage, light, to, blinking]).

package/examples/output/dcg-command-parser.pl

@@ -0,0 +1,4 @@
+dcg_example(parsed, set(light(kitchen), on)).
+dcg_example(generated, [set, hall, light, to, off]).
+dcg_example(remainder, [then, wait]).
+dcg_example(rejected, invalid_command).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -475,6 +475,7 @@
           "control-system",
           "critical-path-schedule",
           "cyclic-path",
+          "dcg-command-parser",
           "d3-group",
           "dairy-energy-balance",
           "data-negotiation",

package/src/dcg.js

@@ -0,0 +1,245 @@
+// ISO/IEC TS 13211-3:2025 definite clause grammar expansion.
+// Grammar rules are lowered to ordinary clauses during program preparation;
+// phrase/2-3 use the same body expansion for dynamically supplied grammars.
+import {
+  ATOM, COMPOUND, VAR, Env, atom, compound, deref, emptyList,
+  flattenConjunction, variable,
+} from './term.js';
+import { PrologError } from './iso.js';
+
+let dcgFresh = 0;
+
+function freshDcgVariable(label = 'S') {
+  // NUL cannot occur in a source variable name, so generated difference-list
+  // variables cannot capture a variable written by the program.
+  return variable(`\u0000dcg${++dcgFresh}:${label}`);
+}
+
+function conjunction(first, second) {
+  return compound(',', [first, second]);
+}
+
+function equality(left, right) {
+  return compound('=', [left, right]);
+}
+
+function listWithTail(items, tail) {
+  let list = tail;
+  for (let index = items.length - 1; index >= 0; index--) {
+    list = compound('.', [items[index], list]);
+  }
+  return list;
+}
+
+function terminalItems(term, env = new Env()) {
+  const items = [];
+  const original = term;
+  const seen = new Set();
+  let cursor = deref(term, env);
+  while (cursor.type === COMPOUND && cursor.name === '.' && cursor.arity === 2) {
+    if (seen.has(cursor)) throw new PrologError('type_error(terminal_sequence)', original);
+    seen.add(cursor);
+    items.push(cursor.args[0]);
+    cursor = deref(cursor.args[1], env);
+  }
+  if (cursor.type === ATOM && cursor.name === '[]') return items;
+  if (cursor.type === VAR) throw new PrologError('instantiation_error');
+  throw new PrologError('type_error(terminal_sequence)', original);
+}
+
+function terminalsGoal(terminals, input, output, env) {
+  return equality(input, listWithTail(terminalItems(terminals, env), output));
+}
+
+function appendStateArguments(nonterminal, input, output, module) {
+  nonterminal = deref(nonterminal, new Env());
+  if (nonterminal.type === ATOM) {
+    const goal = compound(nonterminal.name, [input, output]);
+    goal.module = module;
+    return goal;
+  }
+  if (nonterminal.type !== COMPOUND) throw new PrologError('type_error(callable)', nonterminal);
+  if (nonterminal.name === ':' && nonterminal.arity === 2) {
+    const qualifier = nonterminal.args[0];
+    if (qualifier.type === VAR) throw new PrologError('instantiation_error');
+    if (qualifier.type !== ATOM) throw new PrologError('type_error(atom)', qualifier);
+    return compound(':', [qualifier, appendStateArguments(nonterminal.args[1], input, output, qualifier.name)]);
+  }
+  const goal = compound(nonterminal.name, [...nonterminal.args, input, output]);
+  goal.module = nonterminal.module ?? module;
+  return goal;
+}
+
+function markGoalModule(term, module) {
+  if (!term || (term.type !== ATOM && term.type !== COMPOUND)) return term;
+  term.module ??= module;
+  if (term.type === COMPOUND &&
+      [',', ';', '->', '\\+', 'call', 'once', 'catch', 'phrase'].includes(term.name)) {
+    for (const argument of term.args) markGoalModule(argument, module);
+  }
+  return term;
+}
+
+function isTerminalSequence(term) {
+  return (term.type === ATOM && term.name === '[]') ||
+    (term.type === COMPOUND && term.name === '.' && term.arity === 2);
+}
+
+export function expandDcgBody(body, input, output, options = {}) {
+  const env = options.env ?? new Env();
+  const module = options.module ?? 'user';
+  body = deref(body, env);
+
+  if (body.type === VAR) {
+    const goal = compound('phrase', [body, input, output]);
+    goal.module = module;
+    return goal;
+  }
+
+  // Empty braces are the empty embedded-goal sequence. Like {true}, they
+  // consume no terminals and leave the grammar state unchanged.
+  if (body.type === ATOM && body.name === '{}') return equality(input, output);
+
+  if (isTerminalSequence(body)) return terminalsGoal(body, input, output, env);
+
+  if (body.type === COMPOUND && body.name === ',' && body.arity === 2) {
+    const middle = freshDcgVariable('sequence');
+    return conjunction(
+      expandDcgBody(body.args[0], input, middle, options),
+      expandDcgBody(body.args[1], middle, output, options),
+    );
+  }
+
+  if (body.type === COMPOUND && [';', '|'].includes(body.name) && body.arity === 2) {
+    const left = body.args[0];
+    if (body.name === ';' && left.type === COMPOUND && left.name === '->' && left.arity === 2) {
+      const middle = freshDcgVariable('condition');
+      return compound(';', [
+        compound('->', [
+          expandDcgBody(left.args[0], input, middle, options),
+          expandDcgBody(left.args[1], middle, output, options),
+        ]),
+        expandDcgBody(body.args[1], input, output, options),
+      ]);
+    }
+    return compound(';', [
+      expandDcgBody(left, input, output, options),
+      expandDcgBody(body.args[1], input, output, options),
+    ]);
+  }
+
+  if (body.type === COMPOUND && body.name === '{}' && body.arity === 1) {
+    return conjunction(markGoalModule(body.args[0], module), equality(input, output));
+  }
+
+  if (body.type === COMPOUND && body.name === 'call' && body.arity === 1) {
+    const closure = body.args[0];
+    if (closure.type === ATOM || closure.type === COMPOUND) closure.module ??= module;
+    const goal = compound('call', [closure, input, output]);
+    goal.module = module;
+    return goal;
+  }
+
+  if (body.type === COMPOUND && body.name === 'phrase' && body.arity === 1) {
+    const goal = compound('phrase', [body.args[0], input, output]);
+    goal.module = module;
+    return goal;
+  }
+
+  if (body.type === ATOM && body.name === '!') {
+    return conjunction(body, equality(input, output));
+  }
+
+  // TS 13211-3 leaves \+//1 and ->//2 implementation dependent.  EyeProlog
+  // uses the widespread non-consuming negation and state-threading if-then
+  // definitions and documents these choices in its conformance profile.
+  if (body.type === COMPOUND && body.name === '\\+' && body.arity === 1) {
+    const ignored = freshDcgVariable('negated');
+    return conjunction(
+      compound('\\+', [expandDcgBody(body.args[0], input, ignored, options)]),
+      equality(input, output),
+    );
+  }
+
+  if (body.type === COMPOUND && body.name === '->' && body.arity === 2) {
+    const middle = freshDcgVariable('condition');
+    return compound('->', [
+      expandDcgBody(body.args[0], input, middle, options),
+      expandDcgBody(body.args[1], middle, output, options),
+    ]);
+  }
+
+  if (body.type !== ATOM && body.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', body);
+  }
+  return appendStateArguments(body, input, output, module);
+}
+
+function splitGrammarHead(head) {
+  let terminals = null;
+  if (head.type === COMPOUND && head.name === ',' && head.arity === 2) {
+    terminals = head.args[1];
+    head = head.args[0];
+  }
+  let module = null;
+  if (head.type === COMPOUND && head.name === ':' && head.arity === 2) {
+    if (head.args[0].type === VAR) throw new PrologError('instantiation_error');
+    if (head.args[0].type !== ATOM) throw new PrologError('type_error(atom)', head.args[0]);
+    module = head.args[0].name;
+    head = head.args[1];
+  }
+  if (head.type === VAR) throw new PrologError('instantiation_error');
+  if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
+  if (isTerminalSequence(head) ||
+      (head.type === COMPOUND && [',', ';', '|', '->', '{}'].includes(head.name)) ||
+      (head.type === ATOM && ['!', '{}'].includes(head.name))) {
+    throw new PrologError('permission_error(define, grammar_rule)', head);
+  }
+  return { head, terminals, module };
+}
+
+export function expandDcgRuleClause(clause, defaultModule = 'user') {
+  if (clause?.body?.length !== 0 || clause?.head?.type !== COMPOUND ||
+      clause.head.name !== '-->' || clause.head.arity !== 2) return null;
+
+  const declaration = splitGrammarHead(clause.head.args[0]);
+  const module = declaration.module ?? defaultModule;
+  const input = freshDcgVariable('input');
+  const output = freshDcgVariable('output');
+  const expandedHead = appendStateArguments(declaration.head, input, output, module);
+  delete expandedHead.module;
+
+  let bodyOutput = output;
+  if (declaration.terminals != null) bodyOutput = freshDcgVariable('semicontext');
+  let expandedBody = expandDcgBody(clause.head.args[1], input, bodyOutput, { module });
+  if (declaration.terminals != null) {
+    expandedBody = conjunction(
+      expandedBody,
+      terminalsGoal(declaration.terminals, output, bodyOutput, new Env()),
+    );
+  }
+
+  const expanded = {
+    head: expandedHead,
+    body: flattenConjunction(expandedBody),
+    module,
+    grammarRule: clause.head,
+  };
+  if (clause.source) expanded.source = clause.source;
+  return expanded;
+}
+
+export function isListOrPartialList(term, env) {
+  const seen = new Set();
+  let cursor = deref(term, env);
+  while (cursor.type === COMPOUND && cursor.name === '.' && cursor.arity === 2) {
+    if (seen.has(cursor)) return false;
+    seen.add(cursor);
+    cursor = deref(cursor.args[1], env);
+  }
+  return cursor.type === VAR || (cursor.type === ATOM && cursor.name === '[]');
+}
+
+export function emptyTerminalSequence() {
+  return emptyList();
+}

package/src/iso.js

@@ -7,6 +7,7 @@ import {
 } from './term.js';
 import { createParserOperatorState, parseClauses } from './parser.js';
 import { formatTermForWrite } from './write.js';
+import { emptyTerminalSequence, expandDcgBody, isListOrPartialList } from './dcg.js';
 
 let isoFresh = 0;
 
@@ -150,6 +151,8 @@ export const isoBuiltins = {
     registry.add('repeat', 0, repeatBuiltin);
     registry.add(';', 2, disjunctionBuiltin);
     registry.add('->', 2, ifThenBuiltin);
+    registry.add('phrase', 2, phraseBuiltin);
+    registry.add('phrase', 3, phraseBuiltin);
 
     registry.add('is', 2, isBuiltin, { deterministic: true });
     registry.add('=:=', 2, arithmeticComparison((n) => n === 0), { deterministic: true });
@@ -1545,6 +1548,38 @@ function* callClosureBuiltin({ solver, goal, env }) {
     solver.absorbStatsFrom(child);
   }
 }
+
+function* phraseBuiltin({ solver, goal, env }) {
+  const grammarBody = deref(goal.args[0], env);
+  if (grammarBody.type === VAR) throw new PrologError('instantiation_error');
+  if (grammarBody.type !== ATOM && grammarBody.type !== COMPOUND) {
+    throw new PrologError('type_error(callable)', grammarBody);
+  }
+
+  const input = goal.args[1];
+  const requestedOutput = goal.arity === 2 ? emptyTerminalSequence() : goal.args[2];
+  if (!isListOrPartialList(input, env)) {
+    throw new PrologError('type_error(terminal_sequence)', deref(input, env));
+  }
+  if (!isListOrPartialList(requestedOutput, env)) {
+    throw new PrologError('type_error(terminal_sequence)', deref(requestedOutput, env));
+  }
+
+  // Delay the final output unification to keep phrase/3 steadfast in its
+  // third argument, as required by the Part 3 execution model.
+  const finalOutput = variable(`\u0000phrase:${++isoFresh}`);
+  const expanded = expandDcgBody(grammarBody, input, finalOutput, {
+    env,
+    module: goal.module ?? grammarBody.module ?? 'user',
+  });
+  const finish = compound('=', [finalOutput, requestedOutput]);
+  const child = solver.cloneForInnerGoal();
+  try {
+    yield* child.solve([expanded, finish], env, 0);
+  } finally {
+    solver.absorbStatsFrom(child);
+  }
+}
 function formalErrorTerm(error) {
   const parse = (text) => {
     const open = text.indexOf('(');
@@ -1625,7 +1660,14 @@ function* disjunctionBuiltin({ solver, goal, env }) {
     yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
     return;
   }
+  const marker = solver.active[solver.active.length - 1] ?? null;
+  const markerCutEpoch = marker?.cutEpoch ?? 0;
+  const solverCutEpoch = solver.cutEpoch;
   yield* solver.solve([callable(goal.args[0], env)], env.clone(), 0);
+  const cutThisScope = marker == null
+    ? solver.cutEpoch !== solverCutEpoch
+    : (marker.cutEpoch ?? 0) !== markerCutEpoch;
+  if (cutThisScope) return;
   yield* solver.solve([callable(goal.args[1], env)], env.clone(), 0);
 }
 function* ifThenBuiltin({ solver, goal, env }) {

package/src/parser.js

@@ -39,6 +39,8 @@ const graphicAtomChars = '#$&*+-./<=>@^~\\;:';
 // canonical notation. Commas remain separators except inside parentheses.
 const INFIX_OPERATORS = new Map([
   [':-', { precedence: 2, associativity: 'none' }],
+  ['-->', { precedence: 2, associativity: 'none' }],
+  ['|', { precedence: 4, associativity: 'right' }],
   [';', { precedence: 5, associativity: 'right' }],
   ['->', { precedence: 7, associativity: 'right' }],
   [',', { precedence: 10, associativity: 'right' }],
@@ -82,7 +84,8 @@ const PREFIX_OPERATORS = new Map([
 ]);
 
 export const ISO_OPERATOR_DEFINITIONS = [
-  [1200, 'xfx', ':-'], [1200, 'fx', ':-'],
+  [1200, 'xfx', ':-'], [1200, 'fx', ':-'], [1200, 'xfx', '-->'],
+  [1105, 'xfy', '|'],
   [1100, 'xfy', ';'], [1050, 'xfy', '->'], [1000, 'xfy', ','],
   [900, 'fy', '\\+'],
   ...['=', '=..', '\\=', '==', '\\==', '@<', '@=<', '@>', '@>=', 'is',
@@ -618,7 +621,25 @@ class Parser {
         accept(clause);
         continue;
       }
-      const head = this.parseTerm(3);
+      let head = this.parseTerm(3);
+      // ISO/IEC TS 13211-3 grammar rules use -->/2 at the same top-level
+      // priority as clauses.  The left side may include an unparenthesized
+      // semicontext: NonTerminal, Terminals --> Body.
+      if (this.token.type === TOK.COMMA) {
+        this.advance();
+        head = compound(',', [head, this.parseTerm(3)]);
+      }
+      if (this.operatorTokenName() === '-->') {
+        this.advance();
+        const grammarBody = this.parseTerm(0, true);
+        this.expect(TOK.DOT, '.');
+        this.advance();
+        const clause = { head: compound('-->', [head, grammarBody]), body: [] };
+        clauseNumber++;
+        if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauseNumber };
+        accept(clause);
+        continue;
+      }
       const body = [];
       if (this.token.type === TOK.IF) {
         this.advance();

package/src/program.js

@@ -11,6 +11,7 @@ import {
 import { PrologError } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
 import { standardLibrarySources } from './standard-library.js';
+import { expandDcgRuleClause } from './dcg.js';
 
 const DEFER_PROGRAM_BUILD = Symbol('deferProgramBuild');
 const FAST_PARSE_ABORT = Symbol('fastParseAbort');
@@ -663,6 +664,8 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     batch.length = 0;
   };
   const accept = (clause) => {
+    const grammarClause = expandDcgRuleClause(clause, context.module);
+    if (grammarClause) clause = grammarClause;
     const moduleDeclaration = moduleDirective(clause);
     if (moduleDeclaration) {
       flush();
@@ -690,9 +693,9 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     }
     const include = includeDirective(clause);
     if (!include) {
-      clause.module = context.module;
+      clause.module ??= context.module;
       if (!isDirectiveClause(clause)) {
-        for (const goal of clause.body) annotateGoalModule(goal, context.module);
+        for (const goal of clause.body) annotateGoalModule(goal, clause.module);
       }
       batch.push(clause);
       if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
@@ -759,9 +762,14 @@ function moduleExportIndicators(term) {
   if (items == null) return null;
   const indicators = [];
   for (const item of items) {
-    if (item.type !== COMPOUND || item.name !== '/' || item.arity !== 2) return null;
+    if (item.type !== COMPOUND || !['/', '//'].includes(item.name) || item.arity !== 2) return null;
     const indicator = predicateIndicator(item.args[0], item.args[1]);
     if (!indicator) return null;
+    if (item.name === '//') {
+      indicator.arity += 2;
+      indicator.key = `${indicator.name}/${indicator.arity}`;
+      indicator.nonterminalArity = indicator.arity - 2;
+    }
     indicators.push(indicator);
   }
   return indicators;
@@ -844,12 +852,21 @@ function dynamicDirectiveIndicators(clause) {
   if (directive.type !== COMPOUND || directive.name !== 'dynamic' || directive.arity !== 1) return [];
   const terms = properListItems(directive.args[0], new Env()) ?? flattenDirectiveSequence(directive.args[0]);
   return terms.map((indicator) =>
-    indicator.type === COMPOUND && indicator.name === '/' && indicator.arity === 2
-      ? predicateIndicator(indicator.args[0], indicator.args[1])
+    indicator.type === COMPOUND && ['/', '//'].includes(indicator.name) && indicator.arity === 2
+      ? nonterminalOrPredicateIndicator(indicator)
       : null
   ).filter(Boolean);
 }
 
+function nonterminalOrPredicateIndicator(term) {
+  const indicator = predicateIndicator(term.args[0], term.args[1]);
+  if (!indicator || term.name !== '//') return indicator;
+  indicator.arity += 2;
+  indicator.key = `${indicator.name}/${indicator.arity}`;
+  indicator.nonterminalArity = indicator.arity - 2;
+  return indicator;
+}
+
 function flattenDirectiveSequence(term) {
   if (term.type === COMPOUND && term.name === ',' && term.arity === 2) {
     return [...flattenDirectiveSequence(term.args[0]), ...flattenDirectiveSequence(term.args[1])];

package/src/solver.js

@@ -61,6 +61,7 @@ export class Solver {
     this.io = options.io ?? new StreamManager(options.ioOptions);
     this.solveStacks = [];
     this.active = [];
+    this.cutEpoch = 0;
     this.memo = new Map();
     this.tableCoordinator = null;
     this.groundChainSuccess = new Set();
@@ -215,10 +216,12 @@ export class Solver {
         // be run early as pure filters. Stop at internal sentinels so rule-body
         // active guards are released before the caller's remaining goals are seen.
         const selectedIndex = selectReadyDeterministicBuiltin(goals, env, this.registry);
-        const goal = goals[selectedIndex];
+        const goal = deref(goals[selectedIndex], env);
         const rest = selectedIndex === 0 ? goals.slice(1) : [...goals.slice(0, selectedIndex), ...goals.slice(selectedIndex + 1)];
         if (goal.type === 'atom' && goal.name === '!' && goal.arity === 0) {
           const marker = active[active.length - 1] ?? null;
+          this.cutEpoch++;
+          if (marker) marker.cutEpoch = (marker.cutEpoch ?? 0) + 1;
           for (const solveStack of this.solveStacks) {
             for (let i = solveStack.length - 1; i >= 0; i--) {
               if (marker == null || solveStack[i].active?.includes(marker)) solveStack.splice(i, 1);
@@ -247,7 +250,9 @@ export class Solver {
           continue;
         }
 
+        if (goal.type === 'var') throw new PrologError('instantiation_error');
         const callable = goal.type === COMPOUND || goal.type === 'atom';
+        if (!callable) throw new PrologError('type_error(callable)', goal);
         const def = callable ? this.registry.get(goal.name, goal.arity) : null;
         this.active = active;
         if (def && builtinIsReadyOrAuthoritative(def, this, goal, env)) {
@@ -274,7 +279,6 @@ export class Solver {
         }
 
         this.stats.solve_one_goal_calls++;
-        if (!callable) break;
         const group = this.program.findGroup(goal.name, goal.arity, goal.module ?? 'user');
         if (!group) {
           if (this.prologFlags.get('unknown')?.value?.name === 'error') {

package/test/conformance/ISO-MATRIX.md

@@ -1,4 +1,4 @@
-# ISO/IEC 13211-1 conformance matrix
+# ISO Prolog conformance matrix
 
 The normative baseline for the `iso/` corpus is ISO/IEC 13211-1:1995 plus
 Technical Corrigenda 1:2007, 2:2012, and 3:2017. This matrix links the standard
@@ -18,6 +18,8 @@ case totals.
 | 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, Logtalk-derived error cases |
 | 8.17 flags and hooks | required flags, mutation permissions, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases |
 | Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power` |
+| ISO/IEC 13211-2 modules | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
+| ISO/IEC TS 13211-3 grammar rules | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
 
 Corrigendum-specific coverage includes double-quoted atom operator priority
 (Cor.1); the added predicates and evaluable functors, bar-operator rules,

package/test/conformance/README.md

@@ -7,13 +7,15 @@ supported ISO Prolog profile, built-ins, extensions, and reasoner behavior.
 
 The suite is intentionally file-based. Exact standard output, errors, warnings,
 and proof output test the behavior of the JavaScript implementation.
-[ISO-MATRIX.md](ISO-MATRIX.md) maps normative clause families and all three
-corrigenda to representative executable cases.
+[ISO-MATRIX.md](ISO-MATRIX.md) maps Part 1 normative clause families, all three
+corrigenda, Part 2 modules, and Part 3 definite clause grammars to representative
+executable cases.
 
 “Conformance” here means conformance to EyeProlog's documented ISO compatibility
 profile and implementation extensions. The default registry covers the exact
 predicate indicators listed in Appendix B of the book across the supported
-ISO/IEC 13211-1:1995 standard families. This suite is still not an independent certification of
+ISO/IEC 13211-1:1995, ISO/IEC 13211-2:2000, and ISO/IEC TS 13211-3:2025
+standard families. This suite is still not an independent certification of
 every processor requirement, lexical edge, option combination, or prescribed
 error precedence. Cases under `iso/` identify standards-derived behavior;
 other directories cover EyeProlog host contracts and extensions.
@@ -88,11 +90,11 @@ ISO/IEC 13211-1 clauses 7 and 8. In particular, isolated negative cases keep
 instantiation, type, domain, permission, representation, and evaluation errors
 independently observable.
 
-Selected cases are adapted from the ISO and standard-core suites of Scryer
-Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
+Selected cases are adapted from the ISO and standard-core suites of Logtalk,
+Scryer Prolog, Trealla Prolog, and SWI-Prolog. Their upstream identifiers and licenses
 are recorded in [THIRD_PARTY.md](THIRD_PARTY.md).
 
-The corpus has 304 cases in `iso/` and 710 file-based conformance cases in
+The corpus has 373 cases in `iso/` and 779 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 example, and book-example checks, `npm test` is the release gate.