eyeprolog 1.5.40 → 1.5.41

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.40",
+  "version": "1.5.41",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -75,6 +75,7 @@
     "conformance:update:neumerkel": "node test/run-neumerkel.mjs --update-report",
     "conformance:check:neumerkel": "node test/run-neumerkel.mjs --cached --verify-report",
     "conformance:sync:neumerkel": "node test/run-neumerkel.mjs --cached --update-report",
-    "test:http-json": "node test/run-http-json.mjs"
+    "test:http-json": "node test/run-http-json.mjs",
+    "test:iso-part2-amendment": "node test/run-iso-part2-amendment.mjs"
   }
 }

package/src/parser.js

@@ -112,7 +112,6 @@ const INFIX_OPERATORS = new Map([
   ['=<', { precedence: 501, associativity: 'none' }],
   ['>', { precedence: 501, associativity: 'none' }],
   ['>=', { precedence: 501, associativity: 'none' }],
-  [':', { precedence: 601, associativity: 'right' }],
   ['+', { precedence: 701, associativity: 'left' }],
   ['-', { precedence: 701, associativity: 'left' }],
   ['/\\', { precedence: 701, associativity: 'left' }],
@@ -142,13 +141,21 @@ export const ISO_OPERATOR_DEFINITIONS = [
   [900, 'fy', '\\+'],
   ...['=', '=..', '\\=', '==', '\\==', '@<', '@=<', '@>', '@>=', 'is',
     '=:=', '=\\=', '<', '=<', '>', '>='].map((name) => [700, 'xfx', name]),
-  [600, 'xfy', ':'],
   ...['+', '-', '/\\', '\\/'].map((name) => [500, 'yfx', name]),
   ...['*', '/', '//', 'div', 'mod', 'rem', '<<', '>>'].map((name) => [400, 'yfx', name]),
   [200, 'xfx', '**'], [200, 'xfy', '^'],
   [200, 'fy', '+'], [200, 'fy', '-'], [200, 'fy', '\\'],
 ];
 
+// ISO/IEC 13211-2 adds module qualification to the Part 1 operator table.
+// The 2013 amendment also writes meta_predicate/1 in directive operator form,
+// so normal module mode accepts that standard spelling while strict Part 1
+// keeps both additions out of its initial operator table.
+export const PART2_OPERATOR_DEFINITIONS = [
+  [600, 'xfy', ':'],
+  [1150, 'fx', 'meta_predicate'],
+];
+
 // The alternative operator belongs to the Part 3 grammar-rule profile. Part 1
 // reserves `|` as list punctuation but permits a program to declare it as an
 // infix operator at priority 1001 or greater (Corrigendum 2).
@@ -226,7 +233,7 @@ export function createParserOperatorState(definitions = [], includeDefaults = tr
     postfixOperators: new Map(),
   };
   if (includeDefaults && options.isoStrict !== true) {
-    for (const [priority, specifier, name] of [...PART3_OPERATOR_DEFINITIONS, ...QUAD_OPERATOR_DEFINITIONS]) {
+    for (const [priority, specifier, name] of [...PART2_OPERATOR_DEFINITIONS, ...PART3_OPERATOR_DEFINITIONS, ...QUAD_OPERATOR_DEFINITIONS]) {
       defineParserOperator(state, priority, specifier, name);
     }
   }

package/src/program.js

@@ -4,6 +4,7 @@ import { ATOM, COMPOUND, NUMBER, STRING, VAR, Env, atom, compound, deref, flatte
 import { formatTermForWrite } from './write.js';
 import {
   ISO_OPERATOR_DEFINITIONS,
+  PART2_OPERATOR_DEFINITIONS,
   PART3_OPERATOR_DEFINITIONS,
   QUAD_OPERATOR_DEFINITIONS,
   createParserOperatorState,
@@ -41,6 +42,7 @@ const PROGRAM_BUILD_BATCH_SIZE = 16384;
 const preparedBundledLibraryCache = new Map();
 const NORMAL_OPERATOR_DEFINITIONS = [
   ...ISO_OPERATOR_DEFINITIONS,
+  ...PART2_OPERATOR_DEFINITIONS,
   ...PART3_OPERATOR_DEFINITIONS,
   ...QUAD_OPERATOR_DEFINITIONS,
 ];
@@ -206,7 +208,7 @@ export class Program {
       name,
       arity,
       module,
-      metaArgumentPositions: this.moduleMetaPredicates.get(module)?.get(`${name}/${arity}`) ?? [],
+      metaArgumentModes: this.moduleMetaPredicates.get(module)?.get(`${name}/${arity}`) ?? [],
       clauses: [],
       argIndexes: Array.from({ length: arity }, makeArgumentIndex),
       demandIndexes: new Map(),
@@ -303,17 +305,23 @@ export class Program {
   }
   defineMetaPredicate(module, template) {
     if (template.type !== COMPOUND) return;
-    const positions = [];
+    const modes = [];
     for (let index = 0; index < template.args.length; index++) {
       const spec = template.args[index];
-      if ((spec.type === 'number' && RE_DECIMAL_INT.test(spec.name)) ||
-          (spec.type === ATOM && spec.name === ':')) positions.push(index);
+      if (spec.type === ATOM && spec.name === ':') {
+        modes.push({ index, kind: 'context' });
+      } else if (spec.type === NUMBER && RE_DECIMAL_INT.test(spec.name)) {
+        // Numeric closure modes are a widely implemented compatibility
+        // extension. Keep their existing hidden lexical qualification while
+        // reserving explicit Module:Goal wrapping for ISO Part 2 ':' modes.
+        modes.push({ index, kind: 'closure' });
+      }
     }
     const definitions = this.moduleMetaPredicates.get(module) ?? new Map();
-    definitions.set(`${template.name}/${template.arity}`, positions);
+    definitions.set(`${template.name}/${template.arity}`, modes);
     this.moduleMetaPredicates.set(module, definitions);
     const group = this.groups.get(modulePredicateKey(module, template.name, template.arity));
-    if (group) group.metaArgumentPositions = positions;
+    if (group) group.metaArgumentModes = modes;
   }
   ensureDynamicGroup(name, arity, module = 'user') {
     assertPredicateIsDefinable(name, arity, this.strictIso);
@@ -1401,6 +1409,12 @@ function sourcePath(options) {
 function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules, fast, context) {
   const batch = [];
   const deferredGoalExpansions = [];
+  // ISO/IEC 13211-2 amendment (2013), 6.2.5: a module body is one
+  // Prolog text whose first term is module/2 and whose body continues to the
+  // end of that text. Track prepared source terms per load so a later module/2
+  // cannot silently switch the owning module mid-text. A recursive load gets
+  // its own counter, so a distinct Prolog text may begin a distinct module.
+  let sourceTermCount = 0;
   const preparedCacheKey = preparedBundledLibraryCacheKey(builder.program, options);
   const preparedForCache = preparedCacheKey == null ? null : [];
   const flush = () => {
@@ -1436,6 +1450,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
   };
 
   const acceptPreparedClause = (clause, lexicalModule, record = true) => {
+    const sourceTermIndex = sourceTermCount++;
     const remember = () => {
       if (record && preparedForCache != null) {
         preparedForCache.push({ clause: cachedClauseCopy(clause), lexicalModule });
@@ -1444,6 +1459,9 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
 
     const moduleDeclaration = moduleDirective(clause);
     if (moduleDeclaration) {
+      if (sourceTermIndex !== 0) {
+        throw new PrologError('permission_error(redefine, module)', atom(moduleDeclaration.name));
+      }
       flush();
       clause.module = moduleDeclaration.name;
       clause.textUnit = context.textUnit;
@@ -1507,7 +1525,27 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       builder.lastPredicateByText.set(context.textUnit ?? '<input>', '@directive');
     }
     const child = readIncludedSource(include, options, ensured);
-    if (!child) return;
+    if (include.name === 'ensure_loaded') {
+      const declaration = sourceModuleDeclaration(child.text, child.options);
+      if (declaration) {
+        // ISO/IEC 13211-2 amendment (2013), 6.2.5.6 notes that the public
+        // predicates of a module loaded with ensure_loaded/1 are imported in
+        // the same sense as use_module/1. Loading remains idempotent, but each
+        // importing module still receives its own import mapping.
+        if (!loadedModules.has(declaration.name)) {
+          const childContext = {
+            module: declaration.name,
+            textUnit: sourcePath(child.options) ?? context.textUnit,
+          };
+          if (!loadSourceIntoBuilder(builder, child.text, child.options, ensured, loadedModules, fast, childContext)) {
+            throw FAST_PARSE_ABORT;
+          }
+        }
+        builder.program.importModule(context.module, declaration.name, null);
+        return;
+      }
+      if (child.alreadyLoaded) return;
+    }
     const childContext = include.name === 'include'
       ? context
       : { module: context.module, textUnit: sourcePath(child.options) ?? context.textUnit };
@@ -1530,7 +1568,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     // while unqualified calls in the body retain the lexical module of the
     // source text. This distinction is essential for conventional hooks such
     // as user:term_expansion/2 defined from library modules.
-    clause = normalizeQualifiedClauseHead(clause, lexicalModule);
+    if (!builder.program.strictIso) clause = normalizeQualifiedClauseHead(clause, lexicalModule);
 
     if (!builder.program.strictIso && !isDirectiveClause(clause)) {
       try {
@@ -1674,6 +1712,11 @@ function moduleExportIndicators(term) {
   return indicators;
 }
 
+function sourceModuleDeclaration(text, options = {}) {
+  const clauses = parseClauses(text, { ...options, sourceMetadata: false });
+  return clauses.length > 0 ? moduleDirective(clauses[0]) : null;
+}
+
 function readModuleSource(designation, options) {
   if (designation.type === COMPOUND && designation.name === 'library' && designation.arity === 1 &&
       designation.args[0].type === ATOM) {
@@ -1696,7 +1739,7 @@ function readModuleSource(designation, options) {
   } catch (_) {
     throw new PrologError('existence_error(source_sink)', designation);
   }
-  const declaration = parseClauses(text, { filename, sourceMetadata: false }).map(moduleDirective).find(Boolean);
+  const declaration = sourceModuleDeclaration(text, { filename });
   if (!declaration) throw new PrologError('existence_error(module)', designation);
   return { name: declaration.name, text, options: { ...options, filename, baseDir: path.dirname(filename) } };
 }
@@ -1727,8 +1770,8 @@ function readIncludedSource(directive, options, ensured) {
       : currentWorkingDirectory()
   );
   const filename = path.resolve(base, designation.name);
-  if (directive.name === 'ensure_loaded' && ensured.has(filename)) return null;
-  if (directive.name === 'ensure_loaded') ensured.add(filename);
+  const alreadyLoaded = directive.name === 'ensure_loaded' && ensured.has(filename);
+  if (directive.name === 'ensure_loaded' && !alreadyLoaded) ensured.add(filename);
 
   let text;
   try {
@@ -1739,6 +1782,7 @@ function readIncludedSource(directive, options, ensured) {
   return {
     text,
     options: { ...options, filename, baseDir: path.dirname(filename) },
+    alreadyLoaded,
   };
 }
 

package/src/solver.js

@@ -1,7 +1,7 @@
 // Depth-first EyeProlog solver with builtin dispatch, memoization, and guarded recursion handling.
 // Most semantic decisions still flow through unification; optimizations only select candidates earlier.
 import {
-  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
+  ATOM, COMPOUND, NUMBER, STRING, VAR, Env, Term, atom, compactListLength, compactVariableList, compound, cons, copyResolved, deref, emptyList,
   flattenConjunction, freshTerm, isCons, isDecimalInteger, isEmptyList, isScalar,
   numberTerm, numberTextFromDouble, properListItems, termIsGround, termToString, unify, variable, variantTerms,
 } from './term.js';
@@ -708,7 +708,7 @@ export class Solver {
           depth++;
           continue;
         }
-        if (goal.type === COMPOUND && goal.name === ':' && goal.arity === 2) {
+        if (!this.isoStrict && goal.type === COMPOUND && goal.name === ':' && goal.arity === 2) {
           const module = deref(goal.args[0], env);
           if (module.type === 'var') throw new PrologError('instantiation_error');
           if (module.type !== 'atom') throw new PrologError('type_error(atom)', module);
@@ -1224,9 +1224,21 @@ function normalizeHostResourceError(error) {
 
 function qualifyMetaArguments(goal, group) {
   const callerModule = goal.module ?? 'user';
-  for (const index of group.metaArgumentPositions ?? []) {
-    const argument = goal.args[index];
-    if (argument && (argument.type === COMPOUND || argument.type === 'atom')) {
+  for (const mode of group.metaArgumentModes ?? []) {
+    const argument = goal.args[mode.index];
+    if (argument == null) continue;
+    if (mode.kind === 'context') {
+      // ISO/IEC 13211-2 amendment (2013), 6.2.5.7: ':' arguments are
+      // visibly prefixed with the current source/calling module. Preserve an
+      // already explicit qualification, otherwise wrap even a variable so a
+      // later binding retains the caller context and Module:Goal inspection
+      // observes the standardized term shape.
+      if (!(argument.type === COMPOUND && argument.name === ':' && argument.arity === 2)) {
+        goal.args[mode.index] = compound(':', [atom(callerModule), argument]);
+      }
+      continue;
+    }
+    if (mode.kind === 'closure' && (argument.type === COMPOUND || argument.type === ATOM)) {
       qualifyTerm(argument, callerModule);
     }
   }

package/test/conformance/ISO-IMPLEMENTATION-DEFINED.md

@@ -131,7 +131,9 @@ features overlap standardized Part 2 and Part 3 facilities. They are extensions
 relative to the Part 1 strict-core boundary and are tested separately; this
 ledger does not assert complete Part 2 or Part 3 conformance. The concrete
 compatibility boundary, including the normal-profile `phrase/2-3` terminal-sequence
-error choice, is recorded in `ISO-PART2-PART3-SCOPE.md`.
+error choice, is recorded in `ISO-PART2-PART3-SCOPE.md`. The requirements
+clarified by the 2013 Part 2 amendment are tracked separately in the executable
+`ISO-PART2-AMENDMENT-2013.md` ledger.
 
 ## Important implementation-dependent behavior (not the 5.4 mandatory table)
 

package/test/conformance/ISO-PART2-AMENDMENT-2013.md

@@ -0,0 +1,36 @@
+# ISO/IEC 13211-2 module amendment (2013) coverage
+
+This ledger maps EyeProlog's normal module profile to the requirements clarified
+by the attached 2013 ISO/IEC 13211-2 amendment draft (WG17 N251). It is narrowly
+scoped to that amendment. It does **not** turn the broader ISO/IEC 13211-2:2000
+base document into a release-facing certification claim; unchanged Part 2
+facilities outside the amendment still need their own clause-by-clause audit.
+
+Executable evidence lives in `test/run-iso-part2-amendment.mjs` and is included
+in both `npm test` and the conformance aggregate.
+
+| Amendment clause | Required behavior | EyeProlog behavior / evidence |
+| --- | --- | --- |
+| 6.2.4.1 | A `module(Name, Exports)` directive identifies a named module and its public predicate indicators. | `Program.defineModule()` records the named module and export map. The focused suite checks that public predicates import and private predicates remain module-local. |
+| 6.2.5 | A module body is a Prolog text beginning with its `module/2` directive and extending to the end of that text. | Files designated by `use_module/1-2` are accepted as module sources only when their first read term is `module/2`. A second `module/2` later in the same Prolog text is rejected rather than switching modules mid-text, while a distinct Prolog text may begin a distinct module body. |
+| 6.2.5.5 | `use_module(F, L)` selectively imports the predicates in `L` from the exports of the module defined by `F`. | `Program.importModule()` validates requested indicators against the source module's export map and installs only those imports. The focused suite verifies selective import. |
+| 6.2.5.6 | `use_module(F)` imports all exported predicates; the amendment also aligns the public-predicate effect of `ensure_loaded(F)` for a module source. | `use_module/1` imports the full export map. `ensure_loaded/1` now imports a module's public predicates while retaining idempotent source loading, including when the same module was already loaded for another caller. |
+| 6.2.5.7 | `meta_predicate/1` marks context-sensitive arguments; `:` arguments carry the current source/calling module. | Normal parsing accepts the amendment spelling `:- meta_predicate p(:).`. Colon-mode arguments are represented as an observable `Module:Goal` term, including when the argument is a variable. Numeric closure modes remain a separate compatibility extension. |
+| 6.4.4.3 | Imported metapredicates preserve the caller's module context for their meta-arguments. | The focused suite verifies both visible `Module:Goal` decomposition and execution of a caller-private predicate through a variable meta-argument. Explicit `Module:Goal` calls continue to set their stated module context. |
+
+## Operator boundary
+
+ISO/IEC 13211-2 adds `:` as the module-qualification operator relative to the
+Part 1 initial operator table. EyeProlog therefore predeclares `:` only in its
+normal module profile; `--iso-strict` no longer includes it in the Part 1
+initial table. Normal mode also predeclares `meta_predicate` as a directive
+operator so the amendment's source spelling is accepted, while the parenthesized
+`meta_predicate(...)` compatibility spelling remains valid.
+
+## Remaining Part 2 scope
+
+The amendment coverage above is executable and release-gated. EyeProlog still
+describes the overall Part 2 surface as a compatibility profile until the
+unchanged portions of ISO/IEC 13211-2:2000 - including its broader module
+interface and re-export model - have a complete processor/semantics ledger.
+See `ISO-PART2-PART3-SCOPE.md` for that release boundary.

package/test/conformance/ISO-PART2-PART3-SCOPE.md

@@ -13,12 +13,20 @@ Normal mode implements a procedure-oriented module compatibility layer:
 qualification, exports/imports, nonterminal indicators, and module-aware meta
 calls are covered by the regression and conformance corpora.
 
-This overlap is intentionally described as a compatibility profile rather than
-a complete Part 2 conformance claim. In particular, the Part 1 strict registry
-does not enable module directives, and the project does not infer full Part 2
-coverage from interoperability with Scryer, Trealla, or Logtalk. A future Part 2
-claim would require a clause-by-clause Part 2 processor and module-semantics
-ledger comparable to the existing Part 1 matrices.
+The requirements clarified by the 2013 ISO/IEC 13211-2 module amendment draft
+(WG17 N251) now have a dedicated executable ledger in
+`ISO-PART2-AMENDMENT-2013.md`: module/2 exports, selective and full imports, the
+module-source behavior of ensure_loaded/1, the amendment's meta_predicate
+directive spelling, and visible caller-module qualification of `:`
+meta-arguments. The focused runner is part of the release gate.
+
+This amendment coverage is intentionally narrower than a complete Part 2
+conformance claim. In particular, the Part 1 strict registry does not enable
+module directives or the Part 2 `:` operator, and the project does not infer
+full Part 2 coverage from interoperability with Scryer, Trealla, or Logtalk. A
+future complete Part 2 claim would require a clause-by-clause audit of the
+unchanged ISO/IEC 13211-2:2000 module-interface and re-export facilities as well
+as the amendment.
 
 ## Part 3 definite clause grammars
 
@@ -45,7 +53,7 @@ rather than silently changing the compatibility profile.
 ## Release boundary
 
 - Part 1 + Corrigenda 1-3: release-facing strict-core conformance target.
-- Part 2: normal-mode compatibility profile, tested but not certified complete.
+- Part 2: 2013 amendment requirements release-gated; broader Part 2 remains a normal-mode compatibility profile, not a complete certification.
 - Part 3: normal-mode compatibility profile, tested but not certified complete.
 
 This separation keeps Part 1 conformance evidence independent of useful module

package/test/conformance/README.md

@@ -16,8 +16,10 @@ closes 7.9/Clause 9, and [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREME
 decomposes the Clause 5 processor obligations.
 [ISO-CORRIGENDA-MATRIX.md](ISO-CORRIGENDA-MATRIX.md) gives every published
 Corrigenda amendment cluster an executable, editorial, or superseded
-disposition. [ISO-PART2-PART3-SCOPE.md](ISO-PART2-PART3-SCOPE.md) records the
-separate normal-profile module/DCG compatibility boundary and known non-claims. Built-in rows may group closely related conditions only when the
+disposition. [ISO-PART2-AMENDMENT-2013.md](ISO-PART2-AMENDMENT-2013.md) maps the
+2013 module-amendment requirements to executable evidence, while
+[ISO-PART2-PART3-SCOPE.md](ISO-PART2-PART3-SCOPE.md) records the broader
+normal-profile module/DCG compatibility boundary and known non-claims. Built-in rows may group closely related conditions only when the
 row names every grouped condition and its executable evidence.
 The exit checklist is embedded in [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md). [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
@@ -92,6 +94,7 @@ npm run test:neumerkel            # the seven live upstream suites only
 npm run test:neumerkel:cached     # exact last fetched bytes; reproduction only
 npm run conformance:check:neumerkel # verify tracked report against last successful live snapshot
 npm run test:iso                  # Part 1 + Corrigenda strict-core processor gate
+npm run test:iso-part2-amendment  # 2013 Part 2 amendment module requirements
 npm run test:wg17                 # vendored reviewed WG17 syntax regression
 ```
 

package/test/run-all.mjs

@@ -6,6 +6,7 @@ import { runStandalone } from './test-style.mjs';
 import { runConformance } from './run-conformance.mjs';
 import { runRegression } from './run-regression.mjs';
 import { runIsoStrict } from './run-iso-strict.mjs';
+import { runIsoPart2Amendment } from './run-iso-part2-amendment.mjs';
 import { runPlayground } from './run-playground.mjs';
 import { runExamples } from './run-examples.mjs';
 import { runBookExamples } from './run-book-examples.mjs';
@@ -24,6 +25,7 @@ await runStandalone(async (reporter) => {
   if (!offline) await runNeumerkel(reporter);
   runConformance(reporter);
   runIsoStrict(reporter);
+  runIsoPart2Amendment(reporter);
   runWg17(reporter);
   runOpenRuleBenchChecks(reporter);
   runArchitecture(reporter);

package/test/run-conformance-all.mjs

@@ -4,6 +4,7 @@ import { runStandalone } from './test-style.mjs';
 import { runNeumerkel } from './run-neumerkel.mjs';
 import { runConformance } from './run-conformance.mjs';
 import { runIsoStrict } from './run-iso-strict.mjs';
+import { runIsoPart2Amendment } from './run-iso-part2-amendment.mjs';
 import { runWg17 } from './run-wg17.mjs';
 
 const offline = process.argv.includes('--offline');
@@ -12,5 +13,6 @@ await runStandalone(async (reporter) => {
   if (!offline) await runNeumerkel(reporter);
   runConformance(reporter);
   runIsoStrict(reporter);
+  runIsoPart2Amendment(reporter);
   runWg17(reporter);
 });

package/test/run-iso-part2-amendment.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { run } from '../src/index.js';
+import { Program } from '../src/program.js';
+import { TestReporter, assertEqual, isMainModule, runStandalone } from './test-style.mjs';
+
+function withModuleTree(files, test) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'eyeprolog-part2-amendment-'));
+  try {
+    for (const [name, source] of Object.entries(files)) {
+      fs.writeFileSync(path.join(directory, name), source);
+    }
+    return test(directory);
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+function programFrom(directory, source, filename = 'main.pl') {
+  return Program.parseSources([{ text: source, filename: path.join(directory, filename), baseDir: directory }]);
+}
+
+export function runIsoPart2Amendment(reporter = new TestReporter()) {
+  reporter.section('ISO/IEC 13211-2 amendment 2013');
+
+  reporter.test('module/2 exports are imported by use_module/1 while private predicates stay local', () => {
+    withModuleTree({
+      'colors.pl': [
+        ':- module(colors, [tone/1]).',
+        'tone(blue).',
+        'hidden(private).',
+        '',
+      ].join('\n'),
+    }, (directory) => {
+      const program = programFrom(directory, [
+        ":- use_module('colors.pl').",
+        'answer(X) :- tone(X).',
+        '',
+      ].join('\n'));
+      assertEqual(run(program, { goal: 'answer(X)' }).stdout, 'answer(blue).\n', 'use_module/1 export import');
+      assertEqual(program.findGroup('hidden', 1, 'user'), null, 'private predicate not imported');
+      assertEqual(program.findGroup('hidden', 1, 'colors')?.module, 'colors', 'private predicate remains in defining module');
+    });
+  });
+
+  reporter.test('use_module/2 selectively imports named exported predicates', () => {
+    withModuleTree({
+      'palette.pl': [
+        ':- module(palette, [red/0, blue/0]).',
+        'red.',
+        'blue.',
+        '',
+      ].join('\n'),
+    }, (directory) => {
+      const program = programFrom(directory, [
+        ":- use_module('palette.pl', [red/0]).",
+        'answer :- red.',
+        '',
+      ].join('\n'));
+      assertEqual(run(program, { goal: 'answer' }).stdout, 'answer.\n', 'selective import execution');
+      assertEqual(program.findGroup('red', 0, 'user')?.module, 'palette', 'selected export imported');
+      assertEqual(program.findGroup('blue', 0, 'user'), null, 'unselected export not imported');
+    });
+  });
+
+  reporter.test('ensure_loaded/1 imports public predicates from a module like use_module/1', () => {
+    withModuleTree({
+      'colors.pl': [
+        ':- module(colors, [tone/1]).',
+        'tone(blue).',
+        '',
+      ].join('\n'),
+    }, (directory) => {
+      const program = programFrom(directory, [
+        ":- ensure_loaded('colors.pl').",
+        'answer(X) :- tone(X).',
+        '',
+      ].join('\n'));
+      assertEqual(run(program, { goal: 'answer(X)' }).stdout, 'answer(blue).\n', 'ensure_loaded/1 module import');
+    });
+  });
+
+  reporter.test('repeated ensure_loaded/1 still imports an already loaded module into each caller', () => {
+    withModuleTree({
+      'colors.pl': [
+        ':- module(colors, [tone/1]).',
+        'tone(blue).',
+        '',
+      ].join('\n'),
+      'left.pl': [
+        ':- module(left, [answer/1]).',
+        ":- ensure_loaded('colors.pl').",
+        'answer(X) :- tone(X).',
+        '',
+      ].join('\n'),
+      'right.pl': [
+        ':- module(right, [answer/1]).',
+        ":- ensure_loaded('colors.pl').",
+        'answer(X) :- tone(X).',
+        '',
+      ].join('\n'),
+    }, (directory) => {
+      const program = programFrom(directory, [
+        ":- use_module('left.pl', [answer/1]).",
+        ":- use_module('right.pl', []).",
+        'both(X,Y) :- left:answer(X), right:answer(Y).',
+        '',
+      ].join('\n'));
+      assertEqual(run(program, { goal: 'both(X,Y)' }).stdout, 'both(blue, blue).\n', 'per-caller ensure_loaded import');
+    });
+  });
+
+  reporter.test('module source loaded by use_module/1 begins with module/2', () => {
+    withModuleTree({
+      'late.pl': [
+        'before_module.',
+        ':- module(late, [visible/0]).',
+        'visible.',
+        '',
+      ].join('\n'),
+    }, (directory) => {
+      let error = null;
+      try {
+        programFrom(directory, ":- use_module('late.pl').\n");
+      } catch (caught) {
+        error = caught;
+      }
+      assertEqual(error?.formal, 'existence_error(module)', 'late module directive rejection');
+    });
+  });
+
+  reporter.test('a second module/2 cannot restart a module body within the same Prolog text', () => {
+    let error = null;
+    try {
+      Program.parse([
+        ':- module(first, [one/0]).',
+        'one.',
+        ':- module(second, [two/0]).',
+        'two.',
+        '',
+      ].join('\n'));
+    } catch (caught) {
+      error = caught;
+    }
+    assertEqual(Boolean(error), true, 'second module directive rejected');
+  });
+
+  reporter.test('distinct Prolog texts may each begin and end their own module body', () => {
+    const program = Program.parseSources([
+      { text: ':- module(first, [value/1]).\nvalue(first).\n', filename: '<first>' },
+      { text: ':- module(second, [value/1]).\nvalue(second).\n', filename: '<second>' },
+    ]);
+    assertEqual(run(program, { goal: 'first:value(X)' }).stdout, 'first:value(first).\n', 'first text body');
+    assertEqual(run(program, { goal: 'second:value(X)' }).stdout, 'second:value(second).\n', 'second text body');
+  });
+
+  reporter.test('meta_predicate directive accepts the amendment operator spelling', () => {
+    const program = Program.parse([
+      ':- module(example, [capture/2]).',
+      ':- meta_predicate capture(:, *).',
+      'capture(Goal, Module) :- Goal = Module:_G.',
+      '',
+    ].join('\n'));
+    assertEqual(program.findGroup('capture', 2, 'example')?.metaArgumentModes?.[0]?.kind,
+      'context', 'colon meta mode registered');
+  });
+
+  reporter.test('colon meta-arguments are visibly prefixed with the calling source module', () => {
+    withModuleTree({
+      'trace.pl': [
+        ':- module(trace, [capture/2]).',
+        ':- meta_predicate capture(:, *).',
+        'capture(Goal, Module) :- Goal = Module:_G.',
+        '',
+      ].join('\n'),
+      'foo.pl': [
+        ':- module(foo, [seen/1]).',
+        ":- use_module('trace.pl').",
+        'seen(Module) :- capture(local_goal, Module).',
+        '',
+      ].join('\n'),
+    }, (directory) => {
+      const program = programFrom(directory, ":- use_module('foo.pl').\n");
+      assertEqual(run(program, { goal: 'foo:seen(Module)' }).stdout,
+        'foo:seen(foo).\n', 'visible caller module prefix');
+    });
+  });
+
+  reporter.test('colon meta-arguments preserve caller context when the argument is a variable', () => {
+    withModuleTree({
+      'trace.pl': [
+        ':- module(trace, [invoke/1]).',
+        ':- meta_predicate invoke(:).',
+        'invoke(Goal) :- call(Goal).',
+        '',
+      ].join('\n'),
+      'foo.pl': [
+        ':- module(foo, [answer/1]).',
+        ":- use_module('trace.pl').",
+        'answer(X) :- Goal = private(X), invoke(Goal).',
+        'private(ok).',
+        '',
+      ].join('\n'),
+    }, (directory) => {
+      const program = programFrom(directory, ":- use_module('foo.pl').\n");
+      assertEqual(run(program, { goal: 'foo:answer(X)' }).stdout,
+        'foo:answer(ok).\n', 'variable meta-argument caller context');
+    });
+  });
+
+  reporter.test('strict Part 1 does not predeclare the Part 2 colon operator', () => {
+    assertEqual(run('', { isoStrict: true, goal: "current_op(600,xfy,':')" }).stats.completed_goal_lists,
+      0, 'strict Part 1 colon current_op');
+    let error = null;
+    try {
+      Program.parse('p :- user:true.\n', { isoStrict: true });
+    } catch (caught) {
+      error = caught;
+    }
+    assertEqual(Boolean(error), true, 'strict Part 1 colon operator syntax rejected');
+  });
+
+  reporter.sectionTotal('ISO/IEC 13211-2 amendment 2013');
+}
+
+if (isMainModule(import.meta.url)) await runStandalone(runIsoPart2Amendment);

package/the-art-of-eyeprolog.md

@@ -2708,9 +2708,12 @@ whose conclusions remain auditable.
 
 EyeProlog supplies the Part 1 control, dynamic-database, operator, and I/O
 facilities together with its normal-profile module forms `module/2`,
-`use_module/1`, `use_module/2`, and `Module:Goal`. These forms are treated as a
-module compatibility surface, not as a claim of complete ISO/IEC 13211-2:2000
-conformance. Definite-clause grammar notation remains
+`use_module/1`, `use_module/2`, `meta_predicate/1`, and `Module:Goal`. The
+requirements clarified by the 2013 ISO/IEC 13211-2 module amendment are covered
+by a dedicated release-gated suite, including public imports through
+`ensure_loaded/1` and caller-module qualification of `:` meta-arguments. The
+unchanged remainder of Part 2 is still treated as a compatibility surface, not
+as a claim of complete ISO/IEC 13211-2:2000 conformance. Definite-clause grammar notation remains
 outside this profile. The examples still prefer explicit domain
 relations, state, and syntax trees where that makes assumptions easier to
 inspect.
@@ -5653,10 +5656,11 @@ semantics, such as #75's conditional power-underflow proposal, strict mode keeps
 the licensed baseline until the change is standardized or explicitly adopted as
 a compatibility extension. Normal EyeProlog additionally provides a practical
 module interface aligned with later WG17 module amendment work and a
-definite-clause-grammar profile following ISO/IEC TS 13211-3. Those
-normal-mode profiles are documented and tested compatibility surfaces; they are
-not currently claimed as complete clause-by-clause certifications of Part 2 or
-Part 3.
+definite-clause-grammar profile following ISO/IEC TS 13211-3. The requirements
+clarified by the 2013 Part 2 amendment have a dedicated executable coverage
+ledger; the unchanged remainder of Part 2 and the Part 3 profile are documented
+and tested compatibility surfaces rather than complete clause-by-clause
+certifications.
 
 Normal-mode Prolog source accepted by EyeProlog is UTF-8. `%` starts a line
 comment and `/* ... */` delimits a block comment. Plain atoms begin with a
@@ -5710,8 +5714,9 @@ denotes one literal double quote character.
 
 Graphic tokens use the characters `#$&*+-./<=>?@^~\`; `!` and `;` are solo
 atoms. A colon is the Part 2 module qualification operator in `Module:Goal`;
-quote an atom whose name itself contains a colon. Unquoted angle-bracket IRIs
-are not syntax.
+normal mode predeclares it, while `--iso-strict` does not include it in the
+Part 1 initial operator table. Quote an atom whose name itself contains a colon.
+Unquoted angle-bracket IRIs are not syntax.
 
 A `/*` sequence opens a block comment only when it begins a token; inside a
 maximal graphic token the slash and star remain atom characters. Graphic tokens
@@ -5756,6 +5761,10 @@ lowered to ordinary compound terms:
 
 - prefix: ISO `?-`, `\+`, unary `+`, unary `-`, and `\`;
 - control: `,`, `;`, and `->`;
+- normal Part 2 module profile: `:` at priority 600 (`xfy`) and
+  `meta_predicate` at priority 1150 (`fx`) so the amendment's directive spelling
+  such as `:- meta_predicate run(:).` parses directly; these are not predeclared
+  by `--iso-strict`;
 - quad syntax extension: `?-` is also a priority-1200 `xfx` operator so a
   label may precede a quad query;
 - grammar rules: `-->` and the Part 3 alternative `|`;