eyeprolog 1.1.18 → 1.1.20

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 | 164 | 209 | 0 | 0 | 373 |
+| iso | 165 | 209 | 0 | 0 | 374 |
 | 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** | **479** | **260** | **19** | **21** | **779** |
+| **Total** | **480** | **260** | **19** | **21** | **780** |

package/examples/clpz-sudoku-9x9.pl

@@ -0,0 +1,64 @@
+:- use_module(library(clpz)).
+
+% AI Escargot is a well-known difficult 9-by-9 Sudoku. The model is entirely
+% declarative: every row, column, and 3-by-3 block is all-distinct, while
+% first-fail labeling chooses among the remaining finite-domain cells.
+
+%% goal: sudoku9_solution(X0)
+
+sudoku9_solution(Rows) :-
+  Rows = [
+    [1, _, _, _, _, 7, _, 9, _],
+    [_, 3, _, _, 2, _, _, _, 8],
+    [_, _, 9, 6, _, _, 5, _, _],
+    [_, _, 5, 3, _, _, 9, _, _],
+    [_, 1, _, _, 8, _, _, _, 2],
+    [6, _, _, _, _, 4, _, _, _],
+    [3, _, _, _, _, _, _, 1, _],
+    [_, 4, _, _, _, _, _, _, 7],
+    [_, _, 7, _, _, _, 3, _, _]
+  ],
+  sudoku9_rows(Rows),
+  sudoku9_transpose(Rows, Columns),
+  sudoku9_rows_distinct(Columns),
+  sudoku9_blocks(Rows),
+  sudoku9_flatten(Rows, Cells),
+  labeling([ff], Cells).
+
+sudoku9_rows([]).
+sudoku9_rows([Row|Rows]) :-
+  Row ins 1..9,
+  all_distinct(Row),
+  sudoku9_rows(Rows).
+
+sudoku9_rows_distinct([]).
+sudoku9_rows_distinct([Row|Rows]) :-
+  all_distinct(Row),
+  sudoku9_rows_distinct(Rows).
+
+sudoku9_transpose([[]|_], []).
+sudoku9_transpose(Rows, [Column|Columns]) :-
+  sudoku9_heads_tails(Rows, Column, Tails),
+  sudoku9_transpose(Tails, Columns).
+
+sudoku9_heads_tails([], [], []).
+sudoku9_heads_tails([[Head|Tail]|Rows], [Head|Heads], [Tail|Tails]) :-
+  sudoku9_heads_tails(Rows, Heads, Tails).
+
+sudoku9_blocks([]).
+sudoku9_blocks([A, B, C|Rows]) :-
+  sudoku9_block_row(A, B, C),
+  sudoku9_blocks(Rows).
+
+sudoku9_block_row([], [], []).
+sudoku9_block_row([A, B, C|As], [D, E, F|Bs], [G, H, I|Cs]) :-
+  all_distinct([A, B, C, D, E, F, G, H, I]),
+  sudoku9_block_row(As, Bs, Cs).
+
+sudoku9_flatten([], []).
+sudoku9_flatten([Row|Rows], Cells) :-
+  sudoku9_append(Row, Rest, Cells),
+  sudoku9_flatten(Rows, Rest).
+
+sudoku9_append([], Ys, Ys).
+sudoku9_append([X|Xs], Ys, [X|Zs]) :- sudoku9_append(Xs, Ys, Zs).

package/examples/output/clpz-sudoku-9x9.pl

@@ -0,0 +1 @@
+sudoku9_solution([[1, 6, 2, 8, 5, 7, 4, 9, 3], [5, 3, 4, 1, 2, 9, 6, 7, 8], [7, 8, 9, 6, 4, 3, 5, 2, 1], [4, 7, 5, 3, 1, 2, 9, 8, 6], [9, 1, 3, 5, 8, 6, 7, 4, 2], [6, 2, 8, 7, 9, 4, 1, 3, 5], [3, 5, 6, 4, 7, 8, 2, 1, 9], [2, 4, 1, 9, 3, 5, 8, 6, 7], [8, 9, 7, 2, 6, 1, 3, 5, 4]]).

package/package.json

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

package/playground.html

@@ -468,6 +468,7 @@
           "clpz-global-constraints",
           "clpz-n-queens",
           "clpz-resource-allocation",
+          "clpz-sudoku-9x9",
           "collatz-1000",
           "combinatorics-findall-sort",
           "competitive-enzyme-kinetics",

package/src/clpz.js

@@ -12,6 +12,8 @@ import {
 import { PrologError } from './iso.js';
 
 const MAX_ENUMERATED_DOMAIN = 100000;
+const domainCacheByState = new WeakMap();
+const mutableDomainEnvs = new WeakSet();
 
 export const clpzBuiltins = {
   register(registry) {
@@ -193,23 +195,28 @@ function rootVariableName(term, env) {
   return term.type === VAR ? term.name : null;
 }
 
-function domainsForRoot(root, env) {
-  const domains = [];
-  for (const [name, values] of storeOf(env).domains) {
-    if (rootVariableName(variable(name), env) === root) domains.push(values);
+function domainsByRoot(env) {
+  const store = storeOf(env);
+  const cached = domainCacheByState.get(env._state);
+  if (cached?.domains === store.domains) return cached.roots;
+  const roots = new Map();
+  for (const [name, values] of store.domains) {
+    const resolvedRoot = rootVariableName(variable(name), env);
+    if (resolvedRoot == null) continue;
+    const current = roots.get(resolvedRoot);
+    roots.set(resolvedRoot, current == null ? values : intersectValues(current, values));
   }
-  return domains;
+  domainCacheByState.set(env._state, { domains: store.domains, roots });
+  return roots;
 }
 
 function intersectValues(left, right) {
-  const allowed = new Set(right.map(String));
-  return left.filter((value) => allowed.has(String(value)));
+  const allowed = new Set(right);
+  return left.filter((value) => allowed.has(value));
 }
 
 function domainForRoot(root, env) {
-  const domains = domainsForRoot(root, env);
-  if (domains.length === 0) return null;
-  return domains.slice(1).reduce(intersectValues, domains[0]);
+  return domainsByRoot(env).get(root) ?? null;
 }
 
 function constrainTermDomain(next, term, values) {
@@ -230,9 +237,14 @@ function narrowTermDomain(next, term, values) {
   const changed = existing == null || existing.length !== narrowed.length ||
     existing.some((value, index) => value !== narrowed[index]);
   if (!changed) return { ok: true, changed: false };
-  const domains = new Map(storeOf(next).domains);
-  domains.set(resolved.name, narrowed);
-  updateStore(next, { domains });
+  if (mutableDomainEnvs.has(next)) {
+    storeOf(next).domains.set(resolved.name, narrowed);
+    domainCacheByState.delete(next._state);
+  } else {
+    const domains = new Map(storeOf(next).domains);
+    domains.set(resolved.name, narrowed);
+    updateStore(next, { domains });
+  }
   if (narrowed.length === 1 && !unify(resolved, numberTerm(narrowed[0].toString()), next)) {
     return { ok: false, changed: false };
   }
@@ -650,9 +662,143 @@ function bindLinearEquality(left, right, env) {
   return { ok: unify(variable(name), numberTerm(value.toString()), env), changed: true };
 }
 
+function hasDistinctMatching(domains, forcedIndex = -1, forcedValue = null) {
+  const matchedByValue = new Map();
+  if (forcedIndex >= 0) {
+    if (!domains[forcedIndex].some((value) => value === forcedValue)) return false;
+    matchedByValue.set(forcedValue, forcedIndex);
+  }
+  const indices = domains
+    .map((_, index) => index)
+    .filter((index) => index !== forcedIndex)
+    .sort((left, right) => domains[left].length - domains[right].length);
+
+  function augment(index, seen) {
+    for (const value of domains[index]) {
+      if (seen.has(value)) continue;
+      seen.add(value);
+      const previous = matchedByValue.get(value);
+      if (previous == null ||
+          (previous !== forcedIndex && augment(previous, seen))) {
+        matchedByValue.set(value, index);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  return indices.every((index) => augment(index, new Set()));
+}
+
+function popcount32(value) {
+  value >>>= 0;
+  value -= (value >>> 1) & 0x55555555;
+  value = (value & 0x33333333) + ((value >>> 2) & 0x33333333);
+  return (((value + (value >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+}
+
+function hallSetDomains(domains) {
+  const valueIndices = new Map();
+  for (const domain of domains) {
+    for (const value of domain) {
+      if (!valueIndices.has(value)) valueIndices.set(value, valueIndices.size);
+      if (valueIndices.size > 30) return null;
+    }
+  }
+  const masks = domains.map((domain) => domain.reduce(
+    (mask, value) => mask | (1 << valueIndices.get(value)), 0));
+  const removed = new Array(domains.length).fill(0);
+  const subsetLimit = 2 ** domains.length;
+  for (let subset = 1; subset < subsetLimit; subset++) {
+    let union = 0;
+    for (let index = 0; index < domains.length; index++) {
+      if (subset & (1 << index)) union |= masks[index];
+    }
+    const variableCount = popcount32(subset);
+    const valueCount = popcount32(union);
+    if (valueCount < variableCount) return false;
+    if (valueCount !== variableCount) continue;
+    for (let index = 0; index < domains.length; index++) {
+      if (!(subset & (1 << index))) removed[index] |= union;
+    }
+  }
+  return domains.map((domain, index) => domain.filter(
+    (value) => !(removed[index] & (1 << valueIndices.get(value)))));
+}
+
+function propagateAllDistinct(global, env) {
+  const bound = new Set();
+  const variables = new Set();
+  for (const term of global.terms) {
+    const resolved = deref(term, env);
+    if (resolved.type === VAR) {
+      if (variables.has(resolved.name)) return { ok: false, changed: false };
+      variables.add(resolved.name);
+      continue;
+    }
+    const value = integerValue(resolved, env);
+    if (bound.has(value)) return { ok: false, changed: false };
+    bound.add(value);
+  }
+
+  let changed = false;
+  for (const term of global.terms) {
+    const resolved = deref(term, env);
+    if (resolved.type !== VAR) continue;
+    const domain = domainForRoot(resolved.name, env);
+    if (domain == null) continue;
+    const result = narrowTermDomain(env, term, domain.filter((value) => !bound.has(value)));
+    if (!result.ok) return { ok: false, changed: false };
+    changed ||= result.changed;
+  }
+
+  // Exhaustive Hall-set filtering is allocation-free in its inner loop for the
+  // small all_distinct/1 groups common in puzzles. Fall back to matching-based
+  // support when the compact bit-set representation is not applicable.
+  if (global.terms.length <= 16) {
+    const domains = global.terms.map((term) => {
+      const resolved = deref(term, env);
+      if (resolved.type === NUMBER) return [integerValue(resolved, env)];
+      if (resolved.type !== VAR) return null;
+      return domainForRoot(resolved.name, env);
+    });
+    if (domains.every((domain) => domain != null)) {
+      const hallDomains = global.terms.length <= 12 ? hallSetDomains(domains) : null;
+      if (hallDomains === false || (hallDomains == null && !hasDistinctMatching(domains))) {
+        return { ok: false, changed: false };
+      }
+      for (let index = 0; index < global.terms.length; index++) {
+        const resolved = deref(global.terms[index], env);
+        if (resolved.type !== VAR) continue;
+        const supported = hallDomains == null
+          ? domains[index].filter((value) => hasDistinctMatching(domains, index, value))
+          : hallDomains[index];
+        const result = narrowTermDomain(env, global.terms[index], supported);
+        if (!result.ok) return { ok: false, changed: false };
+        changed ||= result.changed;
+        domains[index] = supported;
+      }
+    }
+  }
+  return { ok: true, changed };
+}
+
 function propagate(env) {
   const store = env._clpz;
   if (!store) return true;
+  // A propagation pass owns one domain-map copy. Individual narrowings can
+  // then update that private copy instead of cloning the whole map each time.
+  updateStore(env, { domains: new Map(store.domains) });
+  mutableDomainEnvs.add(env);
+  try {
+    return propagateMutable(env);
+  } finally {
+    mutableDomainEnvs.delete(env);
+  }
+}
+
+function propagateMutable(env) {
+  const store = env._clpz;
   let changed;
   do {
     changed = false;
@@ -665,7 +811,11 @@ function propagate(env) {
       }
     }
     for (const global of store.globals) {
-      if (global.kind === 'nvalue') {
+      if (global.kind === 'allDistinct') {
+        const result = propagateAllDistinct(global, env);
+        if (!result.ok) return false;
+        changed ||= result.changed;
+      } else if (global.kind === 'nvalue') {
         const values = global.terms.map((term) => expressionValue(term, env));
         const known = new Set(values.filter((value) => value != null).map(String));
         const unresolved = values.filter((value) => value == null).length;

package/src/iso.js

@@ -1814,7 +1814,7 @@ function* catchBuiltin({ solver, goal, env }) {
     const ball = error instanceof ThrownTerm
       ? error.term
       : error instanceof PrologError
-        ? formalErrorTerm(error)
+        ? freshCopy(formalErrorTerm(error), new Env())
         : null;
     if (ball == null) throw error;
     const recovered = env.clone();
@@ -1827,7 +1827,9 @@ function* catchBuiltin({ solver, goal, env }) {
 function* throwBuiltin({ goal, env }) {
   const ball = deref(goal.args[0], env);
   if (ball.type === VAR) throw new PrologError('instantiation_error');
-  throw new ThrownTerm(copyResolved(ball, env));
+  // ISO throw/1 copies the thrown term before control unwinds. Freshen
+  // variables so the catcher cannot retain aliases to the protected goal.
+  throw new ThrownTerm(freshCopy(ball, env));
 }
 function* onceBuiltin({ solver, goal, env }) {
   const child = solver.cloneForInnerGoal(1);

package/src/repl.js

@@ -57,7 +57,7 @@ export async function runRepl(engine, options = {}) {
           exitCode = error.code;
           break;
         }
-        output.write(`   ${formatError(error)}\n`);
+        output.write(`   ${formatError(engine, state, error)}\n`);
       }
     }
   } catch (error) {
@@ -368,13 +368,15 @@ function queryVariables(goal) {
 
 function formatAnswer(engine, state, variables, env) {
   const bindings = [];
+  const queryVariableNames = new Set(variables.map((variable) => variable.name));
   const names = new Map(variables.map((variable) => [variable.name, variable.name]));
   let generated = 0;
 
   for (const variable of variables) collectUnboundVariables(engine, variable, env, names, () => `_${letterName(generated++)}`);
   for (const variable of variables) {
     const value = engine.deref(variable, env);
-    if (value.type === 'var' && value.name === variable.name) continue;
+    if (value.type === 'var' &&
+        (value.name === variable.name || !queryVariableNames.has(value.name))) continue;
     bindings.push(`${variable.name} = ${engine.formatTermForWrite(value, env, {
       quoted: true,
       operators: [...state.program.operators.values()],
@@ -406,7 +408,21 @@ function letterName(index) {
   return suffix === 0 ? letter : `${letter}${suffix}`;
 }
 
-function formatError(error) {
+function formatError(engine, state, error) {
+  if (error?.name === 'PrologError') {
+    const env = new engine.Env();
+    const variableNames = new Map();
+    let generated = 0;
+    if (error.culprit != null) {
+      collectUnboundVariables(engine, error.culprit, env, variableNames, () => `_${letterName(generated++)}`);
+    }
+    const culprit = error.culprit == null ? '' : `, ${engine.formatTermForWrite(error.culprit, env, {
+      quoted: true,
+      operators: [...state.program.operators.values()],
+      variableNames,
+    })}`;
+    return `error(${error.formal}${culprit}).`;
+  }
   const message = error?.message ?? String(error);
   return message.endsWith('.') ? message : `${message}.`;
 }

package/test/conformance/ISO-MATRIX.md

@@ -9,7 +9,7 @@ case totals.
 | --- | --- | --- |
 | Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, syntax error cases |
 | Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
-| Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability` |
+| Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `throw_copies_ball` |
 | 8.2-8.5 term predicates | unification, Corrigendum 2 tests, comparison, sorting, creation and decomposition | `corrigenda_term_predicates`, `corrigenda_sort_keysort`, `logtalk_arg_unification`, `logtalk_univ`, associated error cases |
 | 8.6-8.7 arithmetic predicates | `is/2` and all six arithmetic comparisons | `arithmetic`, comparison cases, isolated evaluation errors |
 | 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses` |

package/test/conformance/README.md

@@ -94,7 +94,7 @@ 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 373 cases in `iso/` and 779 file-based conformance cases in
+The corpus has 374 cases in `iso/` and 780 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.

package/test/conformance/cases/iso/throw_copies_ball.pl

@@ -0,0 +1,17 @@
+% ISO 7.12.1: throw/1 copies the ball before searching for a catcher.
+%% goal: user_throw_copy
+%% goal: error_throw_copy
+
+user_throw_copy :-
+    catch(throw(g(X)), g(V), true),
+    X = protected,
+    V = caught.
+
+error_throw_copy :-
+    catch(
+        number_chars(_, [1, [], X|2]),
+        error(type_error(list, Culprit), _),
+        true
+    ),
+    X = protected,
+    Culprit = [1, [], caught|2].

package/test/conformance/expected/iso/throw_copies_ball.pl

@@ -0,0 +1,2 @@
+user_throw_copy.
+error_throw_copy.

package/test/run-regression.mjs

@@ -496,6 +496,32 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL hides aliases to fresh throw variables while preserving query aliases',
+      run: () => {
+        const result = runCli([], {
+          input: 'catch(throw(g(X)),g(V),true).\nX = Y.\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, '?-    true.\n?-    X = Y.\n?- ', 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'REPL freshens variables displayed in uncaught ISO errors',
+      run: () => {
+        const result = runCli([], {
+          input: 'number_chars(V,[1,[],X|2]).\nnumber_chars(V,[1,[],Xx|2]).\nhalt.\n',
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    error(type_error(list), [1, [], _A | 2]).\n' +
+          '?-    error(type_error(list), [1, [], _A | 2]).\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL enumerates and stops answers like the Scryer top level',
       run: () => {
@@ -1540,10 +1566,13 @@ answer(X, Y, B) :-
   B #<==> X #= 1,
   labeling([ff, down], [X, Y, B]).
 contradiction :- Z in 1..3, Z = 4.
+pruned(Domain) :- [X, Y] ins 1..3, all_distinct([X, Y]), X #= 2, fd_dom(Y, Domain).
+hall(Domain) :- [X, Y] ins 1..2, Z in 1..3, all_distinct([X, Y, Z]), fd_dom(Z, Domain).
+repeated(X) :- X in 1..3, all_distinct([X, X]).
 `);
         assertEqual(program.findGroup('labeling', 2)?.module, 'clpz', 'labeling/2 module');
-        assertEqual(run(program, { goals: ['answer(X, Y, B)', 'contradiction'] }).stdout,
-          'answer(1, 4, 1).\nanswer(2, 3, 0).\n', 'CLP(Z) constrained answers');
+        assertEqual(run(program, { goals: ['answer(X, Y, B)', 'contradiction', 'pruned(Domain)', 'hall(Domain)', 'repeated(X)'] }).stdout,
+          'answer(1, 4, 1).\nanswer(2, 3, 0).\npruned(1 \\/ 3).\nhall(3).\n', 'CLP(Z) constrained answers');
       },
     },
     {

package/the-art-of-eyeprolog.md

@@ -5749,8 +5749,14 @@ instances whose message contains the corresponding Prolog error term.
 | *syntax_error(number)*, *syntax_error(read_term)* | Lexical number conversion or streamed term parsing failed. |
 
 `catch/3` converts a `PrologError` into a catchable
-`error(Formal,eyeprolog)` term. A user ball from `throw/1` is delivered as-is.
-An unmatched ball or error continues outward.
+`error(Formal,eyeprolog)` term. `throw/1` copies its ball before unwinding: bound
+parts are preserved, repeated variables remain shared within the copied ball,
+and unbound variables are fresh with respect to the protected goal and catcher.
+Catchable error terms follow the same variable-freshening rule. At the interactive
+top level, variables that occur in an uncaught ISO error are rendered with fresh
+answer names such as `_A` rather than reusing query-variable spellings such as
+`X` or `Xx`; this keeps the displayed error consistent with the copied exception
+term. An unmatched ball or error continues outward.
 
 Streams belong to one solver run and are shared by nested calls, exceptions,
 and solution collectors. `user_input` and `user_output` are always present.
@@ -6365,7 +6371,7 @@ Review questions:
 </figure>
 
 The [examples directory](https://github.com/eyereasoner/eyeprolog/tree/main/examples/) is the book's executable companion. The
-top-level directory contains **210 self-contained runnable programs**. Every
+top-level directory contains **211 self-contained runnable programs**. Every
 source program has an exact answer file under
 [examples/output](https://github.com/eyereasoner/eyeprolog/tree/main/examples/output/), and **61 selected programs** have a checked
 explanation under [examples/proof](https://github.com/eyereasoner/eyeprolog/tree/main/examples/proof/). The thematic tables below link every top-level program and open the program
@@ -6417,6 +6423,7 @@ mode at a time.
 | [CLP(Z) global constraints](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-global-constraints.pl) | Compatibility tables, lexicographic and serialized schedules, global cardinality with costs, circuits, value counting, and integer comparison. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-global-constraints.pl) |
 | [CLP(Z) N-queens](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-n-queens.pl) | Six-queens using finite domains, delayed diagonal constraints, `all_distinct/1`, and first-fail labeling. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-n-queens.pl) |
 | [CLP(Z) resource allocation](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-resource-allocation.pl) | Resource assignment using `element/3`, `sum/3`, `scalar_product/4`, reification, labeling options, and domain reflection. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-resource-allocation.pl) |
+| [CLP(Z) Sudoku 9×9](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-sudoku-9x9.pl) | The difficult AI Escargot puzzle modeled with finite domains, 27 all-distinct constraints, and first-fail labeling. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-sudoku-9x9.pl) |
 | [Combinatorics Findall Sort](https://github.com/eyereasoner/eyeprolog/blob/main/examples/combinatorics-findall-sort.pl) | Eyelet-inspired combinations example using `findall/3` and ISO `sort/2`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/combinatorics-findall-sort.pl) |
 | [Floating Point](https://github.com/eyereasoner/eyeprolog/blob/main/examples/floating-point.pl) | Floating-point arithmetic and comparisons. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/floating-point.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/floating-point.pl) |
 | [Atomic conversion](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-atomic-conversion.pl) | Atom splitting, character atoms, Unicode codes, and numeric parsing. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-atomic-conversion.pl) |
@@ -6814,7 +6821,7 @@ node test/run-conformance-report.mjs
 ```
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 779 cases, including 373 focused ISO
+contains 780 cases, including 374 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 189 normal