eyeprolog 1.5.54 → 1.5.55

package/README.md

@@ -73,7 +73,6 @@ printf 'human(socrates).\nmortal(X) :- human(X).\n' |
 - [ISO conformance review](test/conformance/ISO-COMPLIANCE.md) — supported Part 1 profile
 - [Latest Neumerkel conformity](test/conformance/NEUMERKEL-LATEST.md) — tracked result from the current live upstream inventory
 - [Conformance report](conformance-report.md) — generated executable conformance status, local corpus summary, and known deviations
-- [Acknowledgements](ACKNOWLEDGEMENTS.md) — funding, standards consulted, and credits for vendored conformance corpora
 - [OpenRuleBench](openrulebench/README.md) — portable benchmark profile
 ## RDF, Prolog, and symbiotic knowledge graphs
 

package/conformance-report.md

@@ -70,3 +70,24 @@ runs that corpus live through the Neumerkel gate; the offline regression
 suite runs all 58 vendored quads. Neither expectations nor error matching
 are relaxed for quads 41-44.
 
+
+## Integer flag choice under `bounded=false`
+
+EyeProlog reports `bounded=false` and uses arbitrary-precision integers.
+It therefore associates no current value with `max_integer` or
+`min_integer`, so `current_prolog_flag/2` does not enumerate them and
+fails when either is named. Both flags stay registered, so
+`set_prolog_flag/2` still reaches the normal non-changeable-flag errors.
+
+This is an implementation choice, not a requirement of Part 1. Clause
+7.11.1.1 defines the `bounded` flag and does not govern
+`current_prolog_flag/2` outcomes, while 7.11.1.2 and 7.11.1.3 give both
+flags an implementation-defined default value unconditionally; the
+`bounded` condition constrains what that value *means*, not whether the
+flag exists. Two alternative readings are equally defensible: expose
+implementation-defined values so the flags enumerate, or treat them as
+unsupported and raise `domain_error(prolog_flag, Flag)` per 8.17.2.3 b.
+EyeProlog prefers silence over inventing a largest integer that its
+arithmetic does not have. The vendored Prologue corpus records the
+resulting single divergence rather than patching the upstream fixture.
+

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.54",
+  "version": "1.5.55",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -28,7 +28,6 @@
   "files": [
     "LICENSE.md",
     "README.md",
-    "ACKNOWLEDGEMENTS.md",
     "index.js",
     "index.d.ts",
     "playground.html",

package/src/datalog.js

@@ -32,7 +32,7 @@ function sameScalar(left, right) {
   return scalarKey(left) === scalarKey(right);
 }
 
-export class DatalogRelation {
+class DatalogRelation {
   constructor(arity) {
     this.arity = arity;
     this.rows = [];

package/src/expansion-builtins.js

@@ -66,7 +66,7 @@ function sourceTermList(term, env) {
   return null;
 }
 
-export function systemExpandTerm(term, module = 'user') {
+function systemExpandTerm(term, module = 'user') {
   const resolved = deref(term, new Env());
   if (resolved.type === COMPOUND && resolved.name === '-->' && resolved.arity === 2) {
     const expanded = expandDcgRuleClause({ head: resolved, body: [] }, module);

package/src/iso-character.js

@@ -23,13 +23,3 @@ export function isStrictIsoPcsCharacter(character) {
   if (typeof character !== 'string' || Array.from(character).length !== 1) return false;
   return isStrictIsoPcsCodePoint(character.codePointAt(0));
 }
-
-// EyeProlog chooses the Unicode scalar value as the collating-sequence integer.
-export function strictIsoCollatingInteger(character) {
-  return isStrictIsoPcsCharacter(character) ? character.codePointAt(0) : null;
-}
-
-export function assertStrictIsoPcsCharacter(character, formal = 'representation_error(character)') {
-  if (!isStrictIsoPcsCharacter(character)) throw new CharacterRepresentationError(formal);
-  return character;
-}

package/src/iso.js

@@ -35,7 +35,7 @@ class ThrownTerm extends Error {
 const succeed = function* ({ env }) { yield env; };
 const fail = function* () {};
 
-export const isoBuiltins = {
+const isoBuiltins = {
   register(registry) {
     registry.add('true', 0, succeed, { deterministic: true });
     registry.add('fail', 0, fail, { deterministic: true });
@@ -956,10 +956,15 @@ function* currentPrologFlagSolutions({ solver, goal, env }, state) {
     .filter(([name, definition]) => definition.value != null && (flag.type === VAR || flag.name === name));
   for (let index = 0; index < definitions.length; index++) {
     const [name, definition] = definitions[index];
-    // ISO 7.11.1.1: when bounded=false, max_integer and min_integer have no
-    // current value and current_prolog_flag/2 must therefore not enumerate
-    // them. The definitions remain registered so attempts to change these
-    // non-changeable flags still receive the normal flag error handling.
+    // Implementation choice: with bounded=false there is no largest integer to
+    // report, so max_integer and min_integer carry no current value and are not
+    // enumerated. ISO 7.11.1.1 defines the bounded flag and does not govern
+    // current_prolog_flag/2; 7.11.1.2 and 7.11.1.3 give both flags an
+    // implementation-defined default unconditionally, so the alternative
+    // reading (expose values, or raise domain_error(prolog_flag)) is equally
+    // available. See conformance-report.md. The definitions remain registered
+    // so attempts to change these non-changeable flags still receive the
+    // normal flag error handling.
     const next = env.clone();
     if (unify(goal.args[0], atom(name), next) && unify(goal.args[1], definition.value, next)) {
       state.pending = index + 1 < definitions.length;
@@ -1802,15 +1807,6 @@ function parseReadTermText(text, solver) {
   });
 }
 
-export function isCompleteReadTermText(text, solver) {
-  try {
-    parseReadTermText(text, solver);
-    return true;
-  } catch (_) {
-    return false;
-  }
-}
-
 function readTermFromStream(stream, solver) {
   if (stream.pastEnd && stream.eofAction === 'error') {
     throw new PrologError('permission_error(input, past_end_of_stream)', streamHandle(stream.id));

package/src/program-analysis.js

@@ -16,13 +16,13 @@ export function componentHasNegativeEdge(start, deps, negativeEdges) {
   return negativeEdges.some(([from, to]) => component.has(from) && component.has(to));
 }
 
-export function compactClauseIsDirectRecursive(clause, group) {
+function compactClauseIsDirectRecursive(clause, group) {
   return isCompactBinaryClause(clause) && clause.bodyName === group.name && group.arity === 2;
 }
 
 
 
-export function clauseIsDirectRecursive(clause, group) {
+function clauseIsDirectRecursive(clause, group) {
   if (isCompactBinaryClause(clause)) return compactClauseIsDirectRecursive(clause, group);
   return clause.body.some((goal) =>
     goal.type === COMPOUND && goal.name === group.name && goal.arity === group.arity
@@ -86,7 +86,7 @@ function reachableIndexesTransposed(target, deps, candidates) {
 }
 
 
-export function isFiniteDatalogArgument(term) {
+function isFiniteDatalogArgument(term) {
   return term?.type === VAR || term?.type === ATOM || term?.type === 'string' || term?.type === 'number';
 }
 
@@ -289,7 +289,7 @@ export function isFiniteWfsDatalogGroup(program, group, cache = new Map(), visit
   return finite;
 }
 
-export function collectVariables(term, output) {
+function collectVariables(term, output) {
   if (!term) return;
   if (term.type === VAR) {
     output.add(term.name);
@@ -420,12 +420,12 @@ export function isPortableBetweenGenerator(group) {
     group.clauses.every((clause) => clause.eyePrologLibraryPortable === true);
 }
 
-export function termContainsVariable(term, name) {
+function termContainsVariable(term, name) {
   if (term.type === 'var') return term.name === name;
   return term.args.some((arg) => termContainsVariable(arg, name));
 }
 
-export function sameClauseTerm(left, right) {
+function sameClauseTerm(left, right) {
   if (left.type !== right.type || left.name !== right.name || left.args.length !== right.args.length) return false;
   return left.args.every((arg, index) => sameClauseTerm(arg, right.args[index]));
 }
@@ -446,7 +446,7 @@ export function directGoalDependencyKey(goal) {
 }
 
 // ISO 13211-1, 7.1.6.3: `V1^V2^...^Goal` has the iterated goal Goal.
-export function iteratedGoal(goal) {
+function iteratedGoal(goal) {
   let current = goal;
   while (current?.type === COMPOUND && current.name === '^' && current.arity === 2) {
     current = current.args[1];

package/src/program-indexing.js

@@ -68,14 +68,6 @@ export function compactHeadArgName(clause, index) {
   return index === 0 ? clause.head0Name : clause.head1Name;
 }
 
-export function compactBodyArgType(clause, index) {
-  return index === 0 ? clause.body0Type : clause.body1Type;
-}
-
-export function compactBodyArgName(clause, index) {
-  return index === 0 ? clause.body0Name : clause.body1Name;
-}
-
 export function clauseBodyLength(clause) {
   return isCompactBinaryClause(clause) ? (clause.bodyName == null ? 0 : 1) : clause.body.length;
 }

package/src/program.js

@@ -1940,7 +1940,3 @@ function predicateIndicator(name, arity) {
 export function makeProgram(source, options = {}) {
   return Program.parse(source, options);
 }
-
-export function parseSourceClauses(source, options = {}) {
-  return parseClauses(source, options);
-}

package/test/conformance/ISO-COMPLIANCE.md

@@ -58,7 +58,9 @@ concrete mismatches that are now part of the closed Part 1 review:
 
 - `bounded=false` no longer exposes implementation-specific `unbounded` values
   for `max_integer` or `min_integer`; the corresponding
-  `current_prolog_flag/2` queries fail as specified by 7.11.1.1;
+  `current_prolog_flag/2` queries fail. Part 1 does not require that outcome
+  (7.11.1.1 defines the `bounded` flag and does not govern
+  `current_prolog_flag/2`), so it is recorded as an implementation choice;
 - preparation-time `char_conversion/2` now converts later unquoted source text
   when the `char_conversion` flag is `on`, leaves quoted characters unchanged,
   and feeds the same mapping into execution-time term input.

package/test/fixtures/README.md

@@ -32,7 +32,9 @@ included before its examples are run.
 
 The upstream Prologue snapshot contains one `max_integer` quad that accepts an
 implementation-specific `Max = unbounded` result. EyeProlog deliberately does
-not patch that vendored fixture: with its ISO `bounded=false` choice, Part 1
-7.11.1.1 requires `current_prolog_flag(max_integer, _)` to fail. The regression
-gate therefore records this single standards-driven divergence explicitly while
-requiring the other 32 quads to pass.
+not patch that vendored fixture: with `bounded=false` it reports no value for
+`max_integer`, so `current_prolog_flag(max_integer, _)` fails. Part 1 does not
+mandate that outcome -- 7.11.1.1 defines the `bounded` flag and says nothing
+about `current_prolog_flag/2` -- so this is an implementation choice, not a
+standards requirement. The regression gate records the single divergence
+explicitly while requiring the other 32 quads to pass.

package/test/run-conformance-report.mjs

@@ -120,6 +120,7 @@ export function formatConformanceReport(report = buildConformanceReport()) {
   lines.push(`| **Total** | **${report.total.positive}** | **${report.total.errors}** | **${report.total.warnings}** | **${report.total.proofs}** | **${report.total.total}** |`);
 
   lines.push(...dcgConformanceSection());
+  lines.push(...integerFlagChoiceSection());
 
   if (report.corpusIssues.length > 0) {
     lines.push('', '## Corpus issues', '');
@@ -163,6 +164,34 @@ function dcgConformanceSection() {
   ];
 }
 
+// Record the unbounded-integer flag choice as an explicit implementation
+// decision rather than leaving it implicit in the source comments.
+function integerFlagChoiceSection() {
+  return [
+    '',
+    '## Integer flag choice under `bounded=false`',
+    '',
+    'EyeProlog reports `bounded=false` and uses arbitrary-precision integers.',
+    'It therefore associates no current value with `max_integer` or',
+    '`min_integer`, so `current_prolog_flag/2` does not enumerate them and',
+    'fails when either is named. Both flags stay registered, so',
+    '`set_prolog_flag/2` still reaches the normal non-changeable-flag errors.',
+    '',
+    'This is an implementation choice, not a requirement of Part 1. Clause',
+    '7.11.1.1 defines the `bounded` flag and does not govern',
+    '`current_prolog_flag/2` outcomes, while 7.11.1.2 and 7.11.1.3 give both',
+    'flags an implementation-defined default value unconditionally; the',
+    '`bounded` condition constrains what that value *means*, not whether the',
+    'flag exists. Two alternative readings are equally defensible: expose',
+    'implementation-defined values so the flags enumerate, or treat them as',
+    'unsupported and raise `domain_error(prolog_flag, Flag)` per 8.17.2.3 b.',
+    'EyeProlog prefers silence over inventing a largest integer that its',
+    'arithmetic does not have. The vendored Prologue corpus records the',
+    'resulting single divergence rather than patching the upstream fixture.',
+    '',
+  ];
+}
+
 function executeGate(name, runSuite) {
   const failures = [];
   const reporter = {

package/test/run-iso-strict.mjs

@@ -95,6 +95,38 @@ export function runIsoStrict(reporter = new TestReporter()) {
   }
 });
 
+  // ISO 7.10.5 and 8.14.2: write_term/2 with quoted(true) shall emit text that
+  // reads back as the same term under the current operator table. Individual
+  // spellings are pinned elsewhere; this is the general property, over a corpus
+  // chosen to stress operator priority, prefix minus, and quoted atoms.
+  reporter.test('writeq output reads back as the identical term', () => {
+    const corpus = [
+      '-(1)', '- (-(1))', '-(a)', '- - 1', '1 - -1', 'f(-1)', '-(1)^2', '2^ -1',
+      '1*(2+3)', '(1*2)+3', '2** -3', 'a* -1', 'a- (-1)', '1 rem 2', 'a mod b',
+      '[a|b]', '[[]]', '[]', '[-]', '[-,+]', '[a,b,c]', '{}', '{a,b}',
+      "f(',')", "','(a,b)", 'f(;)', 'f(!)', 'f(-)', 'f(+)', 'f(*)',
+      'f(a,(b,c))', 'f((a,b))', 'f(g(h(1)))', '(a:-b,c)', '(a;b;c)', '(a->b;c)',
+      '*(1,2)', '+(1)', 'a=..b', "'ABC'", 'abc', "''", "' '", "'/*'", "'%'",
+      '1.0', '-1.0', '0.0', '1.0e-10', '1.5e300',
+      String.raw`'\n'`, String.raw`'\t'`, String.raw`'don''t'`,
+      String.raw`\+ a`, String.raw`f('|')`,
+    ];
+    for (const text of corpus) {
+      let written = '';
+      run('', {
+        isoStrict: true,
+        goal: `writeq(${text})`,
+        ioOptions: { write: (chunk) => { written += chunk; } },
+      });
+      const reread = run('', {
+        isoStrict: true,
+        goal: `read_term(X,[]), X == (${text})`,
+        ioOptions: { input: `${written}.` },
+      });
+      equal(reread.stats.completed_goal_lists, 1, `writeq round-trip ${text} -> ${written}`);
+    }
+  });
+
   reporter.test('keeps Corrigendum 2 core predicates and excludes Part 3 phrase', () => {
     const registry = createStrictIsoRegistry();
     equal(Boolean(registry.get('subsumes_term', 2)), true, 'subsumes_term/2');

package/test/run-regression.mjs

@@ -2325,10 +2325,11 @@ c4 ?- call((!;1)).
         program.quads = maxIntegerQuads;
         const result = publicApi.runQuads(program);
         // The upstream working-draft quad accepts either integer overflow or
-        // Max=unbounded. ISO/IEC 13211-1 7.11.1.1 instead says that when
-        // bounded=false, current_prolog_flag(max_integer, N) fails. Preserve
-        // the upstream fixture unchanged and make that one deliberate
-        // standards-driven divergence explicit in the regression gate.
+        // Max=unbounded. EyeProlog reports no value for max_integer when
+        // bounded=false, so current_prolog_flag(max_integer, N) fails. Part 1
+        // does not mandate that outcome, so this is an implementation choice
+        // rather than a standards requirement. Preserve the upstream fixture
+        // unchanged and make the one deliberate divergence explicit here.
         assertEqual(result.total, 1, 'quad total');
         assertEqual(result.passed, 0, 'quad passed');
         assertEqual(result.failed, 1, 'quad failed');
@@ -9070,7 +9071,9 @@ function declaredDefaultExportNames() {
 function missingDocumentedPackageScripts() {
   const docs = documentationFiles();
   const missing = [];
-  const nativeCommands = new Set(['exec', 'install', 'link']);
+  // Native npm subcommands are not package scripts, so documenting them must
+  // not require a matching entry in package.json.
+  const nativeCommands = new Set(['exec', 'install', 'link', 'pack', 'publish', 'version', 'ci']);
   for (const file of docs) {
     const text = fs.readFileSync(file, 'utf8');
     for (const line of text.split('\n')) {

package/the-art-of-eyeprolog.md

@@ -6194,8 +6194,15 @@ silently changing a static program.
 - **`occurs_check`** — **Default:** `true`; **Allowed:** `true`, `error`; **Mutable:** yes.
 
 Because `bounded=false`, `current_prolog_flag(max_integer, _)` and
-`current_prolog_flag(min_integer, _)` fail as required by ISO 7.11.1.1;
-EyeProlog does not expose an `unbounded` sentinel as either flag value.
+`current_prolog_flag(min_integer, _)` fail, and EyeProlog does not expose an
+`unbounded` sentinel as either flag value. This is a deliberate implementation
+choice rather than a requirement: ISO 7.11.1.1 defines the `bounded` flag and
+does not govern `current_prolog_flag/2` outcomes, and 7.11.1.2 and 7.11.1.3
+give `max_integer` and `min_integer` an implementation-defined default value
+unconditionally, making the `bounded` condition a constraint on what the value
+*means* rather than on whether the flag exists. A processor with unbounded
+integers has no largest integer to report, so EyeProlog declines to invent one.
+See `conformance-report.md` for the alternative reading.
 Preparation-time `char_conversion/2` mappings affect later unquoted source text
 and also initialize the execution-time conversion mapping; setting the
 `char_conversion` flag to `off` disables conversion for following source text.

package/ACKNOWLEDGEMENTS.md

@@ -1,36 +0,0 @@
-# Acknowledgements
-
-This work was carried out at [IDLab](https://idlab.ugent.be/), Ghent University
-– imec, within the [KNoWS](https://knows.idlab.ugent.be/) (Knowledge on Web
-Scale) research team, as part of the **Koreografeye** project.
-
-## Standards
-
-Conformance work on this repository targets the following standards.
-Licensed standards documents are not redistributed here:
-
-- ISO/IEC 13211-1:1995, *Information technology — Programming languages —
-  Prolog — Part 1: General core*
-- ISO/IEC 13211-1:1995/Cor.1:2007
-- ISO/IEC 13211-1:1995/Cor.2:2012
-- ISO/IEC 13211-1:1995/Cor.3:2017
-- ISO/IEC 13211-2:2000, *Part 2: Modules*, and its 2013 amendment
-- ISO/IEC TS 13211-3:2025, *Part 3: Definite clause grammar rules*
-
-## External conformance corpora
-
-The test suite executes third-party material that is vendored unmodified and
-credited in place:
-
-- Ulrich Neumerkel's ISO Prolog conformity corpora (TU Wien), including the
-  `phrase_quad.pl` and `variable_names_quad.pl` snapshots under
-  `test/fixtures/`.
-- The WG17 syntax conformity-testing matrix.
-- Test cases adapted from the Logtalk ISO conformance suite, marked as such in
-  the corpus files that use them.
-
-## Citation
-
-When referring to this work in a publication, please acknowledge the project as
-described above. A suggested sentence is available in the paper template used by
-the KNoWS team.