eyeprolog 1.5.32 → 1.5.34

package/README.md

@@ -74,9 +74,9 @@ All 33 bundled modules that overlap Scryer's current `src/lib/` surface cover Sc
 - [Symbiotic Knowledge Graphs](https://eyereasoner.github.io/eyeprolog/examples/deck/symbiotic-knowledge-graphs) — RDF ↔ Prolog heatwave-response demo for human/AI/KG co-evolution
 - [rdf-prolog-roundtrip](https://github.com/eyereasoner/rdf-prolog-roundtrip) — standalone RDF 1.2 ↔ ISO Prolog bridge used by the RDF examples
 - [ISO conformance audit](test/conformance/ISO-COMPLIANCE.md) — supported Part 1 profile
-- [Conformance report](conformance-report.md) — generated executable conformance status and corpus summary
+- [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 and local corpus summary
 - [OpenRuleBench](openrulebench/README.md) — portable benchmark profile
-
 ## RDF, Prolog, and symbiotic knowledge graphs
 
 EyeProlog can sit behind an RDF knowledge graph without inventing a private graph representation. [`rdf-prolog-roundtrip`](https://github.com/eyereasoner/rdf-prolog-roundtrip) converts RDF 1.2 datasets to ordinary `rdf(Subject, Predicate, Object, Graph)` facts, EyeProlog applies portable rules, and ground `rdf/4` results can be converted back to RDF.
@@ -95,5 +95,5 @@ cd eyeprolog
 npm install
 npm test
 ```
-
+`npm test` is the release gate and fetches the latest seven Neumerkel conformity sources before the local gates; use `npm run test:offline` for a network-free pass, `npm run test:conformance` for all conformance layers, `npm run test:neumerkel` for live upstream only, and `npm run test:neumerkel:cached` only to reproduce the last fetch. Upstream counts are discovered dynamically. A stale tracked [latest Neumerkel report](test/conformance/NEUMERKEL-LATEST.md) produces a warning during normal tests. `npm run conformance:update:neumerkel` refreshes it from live upstream; `npm run conformance:sync:neumerkel` refreshes it from the exact successful snapshot already fetched by `npm test`; and `npm run conformance:check:neumerkel` verifies that snapshot without a second live fetch. npm's version lifecycle uses the sync path and stages the generated reports into the release commit. Exact bytes/hashes stay under Git-ignored `.cache/neumerkel/`. Benchmarks remain `npm run benchmark` and `npm run benchmark:lips`.
 EyeProlog is released under the [MIT License](LICENSE.md).

package/conformance-report.md

@@ -4,6 +4,13 @@ This report combines an executable external conformance gate with the file-based
 conformance corpus under `test/conformance/`. The executable result is measured
 when this report is generated; it is not inferred from fixture counts.
 
+## Latest Neumerkel evidence
+
+See the tracked [latest Neumerkel conformity report](test/conformance/NEUMERKEL-LATEST.md).
+`npm test` fetches all seven TU Wien sources once and executes the discovered inventory.
+The release workflow then synchronizes this tracked report from those exact successful
+cached source bytes, avoiding a second live fetch and its race window.
+
 ## Executable conformance status
 
 | Gate | Passed | Total | Status |

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.32",
+  "version": "1.5.34",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -46,31 +46,34 @@
   },
   "scripts": {
     "test": "node test/run-all.mjs",
-    "generate": "node tools/generate-library-autoload-index.mjs && node tools/generate-predicate-reference.mjs && node tools/extract-book-examples.mjs",
-    "generate:autoload": "node tools/generate-library-autoload-index.mjs",
-    "test:eyeprolog": "node test/run-all.mjs",
-    "test:conformance": "node test/run-conformance.mjs",
-    "test:iso-strict": "node test/run-iso-strict.mjs",
-    "test:interop": "node test/run-interop.mjs",
-    "test:openrulebench": "node test/run-openrulebench.mjs",
+    "test:offline": "node test/run-all.mjs --offline",
+    "test:conformance": "node test/run-conformance-all.mjs",
+    "test:conformance:offline": "node test/run-conformance-all.mjs --offline",
+    "test:neumerkel": "node test/run-neumerkel.mjs",
+    "test:neumerkel:cached": "node test/run-neumerkel.mjs --cached",
+    "test:neumerkel:harness": "node test/run-neumerkel-tests.mjs",
+    "test:iso": "node test/run-iso-strict.mjs",
     "test:wg17": "node test/run-wg17.mjs",
-    "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",
-    "test:regression:api": "node test/run-regression.mjs api",
-    "test:regression:core": "node test/run-regression.mjs regression",
-    "test:regression:docs": "node test/run-regression.mjs docs",
-    "test:regression:white-box": "node test/run-regression.mjs white-box",
+    "test:examples": "node test/run-examples.mjs",
+    "test:interop": "node test/run-interop.mjs",
     "test:playground": "node test/run-playground.mjs",
-    "wg17:upgrade": "node tools/upgrade-wg17.mjs",
-    "report:wg17": "node tools/report-wg17-syntax-coverage.mjs",
-    "report:wg17-syntax": "node tools/report-wg17-syntax-coverage.mjs",
-    "preversion": "npm test && node test/run-conformance-report.mjs conformance-report.md",
-    "postversion": "git push origin HEAD --follow-tags",
     "test:architecture": "node test/run-architecture.mjs",
+    "test:openrulebench": "node test/run-openrulebench.mjs",
+    "test:benchmark": "node test/run-benchmark-tests.mjs",
     "benchmark": "node test/benchmark.mjs",
+    "benchmark:lips": "node test/lips-benchmark.mjs",
     "benchmark:baseline": "node test/benchmark.mjs --save .benchmarks/baseline.json",
-    "test:benchmark": "node test/run-benchmark-tests.mjs",
+    "conformance:update": "npm run conformance:update:wg17 && npm run conformance:update:neumerkel",
+    "conformance:report": "node test/run-conformance-report.mjs conformance-report.md",
+    "generate": "node tools/generate-library-autoload-index.mjs && node tools/generate-predicate-reference.mjs && node tools/extract-book-examples.mjs",
+    "generate:autoload": "node tools/generate-library-autoload-index.mjs",
     "generate:reference": "node tools/generate-predicate-reference.mjs",
-    "benchmark:lips": "node test/lips-benchmark.mjs"
+    "preversion": "npm test && npm run conformance:sync:neumerkel && npm run conformance:report && git add test/conformance/NEUMERKEL-LATEST.md conformance-report.md",
+    "postversion": "git push origin HEAD --follow-tags",
+    "conformance:update:wg17": "node tools/upgrade-wg17.mjs",
+    "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"
   }
 }

package/src/parser.js

@@ -811,6 +811,14 @@ class Parser {
     let left = this.parsePrefixTerm(minPrecedence, allowBar, allowOperatorAtom);
     const leftIsBareOperatorAtom = initialWasCurrentOperator &&
       left.type === ATOM && left.name === initialOperatorName;
+    // Neumerkel syntax #379 (2026-09-03) pins a strict-ISO distinction for
+    // the processor-defined grammar-rule operator: `(-->)/2` is not an ISO
+    // predicate-indicator spelling.  Keep the ordinary profile permissive for
+    // existing DCG/module code; the moving ISO conformity gate runs strict.
+    if (this.strictIso && left.type === ATOM && left.name === '-->' &&
+        this.operatorTokenName() === '/') {
+      throw new Error(`parse line ${this.token.line}: operator atom --> is not permitted in a strict ISO predicate indicator`);
+    }
     let strictPostfixPrecedence = null;
     while (true) {
       const op = this.token.type === TOK.COMMA && allowComma

package/test/conformance/ISO-COMPLIANCE.md

@@ -270,17 +270,30 @@ requirement of ISO/IEC 13211-2:2000 or ISO/IEC TS 13211-3.
 
 ## Release gate
 
-A release intended to advance ISO conformance must pass all of:
+A release intended to advance ISO conformance uses one canonical command:
 
 ```sh
 npm test
-npm run test:iso-strict
+```
+
+That command first fetches and runs the **latest seven Neumerkel conformity
+sources**, then executes the deterministic local conformance, strict ISO,
+vendored WG17 regression, regression/API, examples, documentation and
+architecture gates. The upstream case counts are discovered dynamically.
+
+Useful focused commands are:
+
+```sh
 npm run test:conformance
+npm run test:neumerkel
+npm run test:iso
 npm run test:wg17
+npm run test:offline
 ```
 
-The unified `npm test` gate includes the strict-core suite. Expected conformance
-outputs are never auto-accepted.
+`test:offline` is a development/reproduction aid; it is not sufficient for a
+release claim that says EyeProlog passes the latest Neumerkel suites. Expected
+conformance outputs are never auto-accepted.
 
 ## Exit criteria for a full conformance claim
 
@@ -300,7 +313,7 @@ post-N289 STC drafts remain review input until standardized.
 | Implementation-specific strict/normal boundary is documented and tested | covered | all 5.5 hooks have explicit dispositions; the WG17 cross-profile gate verifies syntax-preservation for standard text accepted by the strict reader. |
 | Published Corrigenda 1-3 are incorporated | covered | `ISO-CORRIGENDA-MATRIX.md` inventories every published amendment cluster with executable, editorial, or superseded disposition |
 | Current post-N289 draft is tracked without silently changing the published baseline | covered | `STC-DRAFT-STATUS.md` tracks reviewed draft items separately from normative requirements |
-| Externally sourced syntax corpus is an offline release gate | covered | the vendored WG17 syntax matrix has 366 executable dispositions checked against its upstream expectations; this is external review evidence, not certification |
+| Latest Neumerkel conformity is a live release gate | covered | `npm test` fetches and executes the seven current TU Wien conformity sources with dynamic inventories; the vendored WG17 matrix remains an offline reviewed-outcome regression layer |
 | Third-party standard-core regression provenance is retained | covered | adapted Logtalk, Scryer, Trealla, and SWI-Prolog cases retain source identifiers and licenses in `THIRD_PARTY.md` |
 | No unexplained deviation remains in the release-facing ledger | covered | the release-facing ledger contains no remaining `audit` rows; documented variation points are implementation-defined/specific or draft-only rather than unexplained deviations. |
 

package/test/conformance/NEUMERKEL-LATEST.md

@@ -0,0 +1,38 @@
+# EyeProlog — latest Neumerkel conformity
+
+Status: **PASS** — **686/686** discovered upstream cases passed.
+
+This tracked report records the latest upstream inventory successfully checked by EyeProlog.
+`npm test` fetches the seven TU Wien sources again and executes the discovered cases.
+Release/report checks can additionally require these tracked counts to match the live suites.
+Counts are output from upstream, not hard-coded test constants.
+
+| Suite | Passed | Total |
+|---|---:|---:|
+| syntax | 379 | 379 |
+| number_chars/2 | 86 | 86 |
+| variable_names/1 | 75 | 75 |
+| dif/2 | 26 | 26 |
+| length/2 | 37 | 37 |
+| phrase/2,3 | 58 | 58 |
+| setup_call_cleanup/3 | 25 | 25 |
+| **Total** | **686** | **686** |
+
+## Upstream sources
+
+- [syntax](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/conformity_testing)
+- [number_chars](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/number_chars_cont_quad.pl)
+- [variable_names](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/variable_names_quad.pl)
+- [dif](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/dif)
+- [length](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/length_quad.pl)
+- [phrase](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/phrase_quad.pl)
+- [cleanup](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/cleanup)
+
+Exact fetched bytes, SHA-256 hashes, fetch timestamps, and HTTP validators remain under
+Git-ignored `.cache/neumerkel/` for local audit/reproduction and are intentionally not committed.
+A normal test run warns when this tracked report is stale. Refresh directly from live
+upstream with `npm run conformance:update:neumerkel`, or sync the exact successful
+snapshot already fetched by `npm test` with `npm run conformance:sync:neumerkel`.
+`npm run conformance:check:neumerkel` verifies the tracked report against that last
+successful live snapshot without fetching upstream a second time.
+

package/test/conformance/NEUMERKEL-LIVE.md

@@ -0,0 +1,73 @@
+# Live Neumerkel conformity gate
+
+EyeProlog treats Ulrich Neumerkel's current ISO/WG17 conformity material as a
+moving upstream release gate, not as a frozen snapshot with permanent case
+counts.
+
+`npm run test:neumerkel` fetches these seven TU Wien sources on every live run:
+
+1. `conformity_testing` — Part 1 syntax/reader/writer matrix;
+2. `number_chars_cont_quad.pl` — `number_chars/2` continuation corpus;
+3. `variable_names_quad.pl` — `variable_names/1` corpus;
+4. `dif` — `dif/2` comparison table;
+5. `length_quad.pl` — `length/2` corpus;
+6. `phrase_quad.pl` — `phrase/2,3` corpus;
+7. `cleanup` — `setup_call_cleanup/3` examples.
+
+The runner discovers the inventory at run time. A new upstream row is therefore
+executed automatically and a removed row disappears automatically. The syntax
+extractor keys the expected result from TU Wien's labelled `Codex` column rather
+than assuming a fixed cell position, and cross-checks the discovered inventory
+against the total declared by the live page so hand-edited HTML cannot silently
+reduce coverage.
+
+## Tracked GitHub evidence
+
+The latest successful discovered inventory is committed as
+[`NEUMERKEL-LATEST.md`](NEUMERKEL-LATEST.md). This is the stable report to link
+from GitHub, releases, or other documentation.
+
+A normal live run always executes the current upstream inventory. If the tracked
+Markdown no longer matches, the test still reflects engine conformance and prints a
+warning with the refresh command:
+
+```sh
+npm run conformance:update:neumerkel
+```
+
+Commit the resulting `test/conformance/NEUMERKEL-LATEST.md` after reviewing the
+change. After a successful `npm test`, `npm run conformance:sync:neumerkel` writes
+the tracked report from the exact cached source bytes that just passed, avoiding a
+second network fetch. `npm run conformance:check:neumerkel` verifies the tracked
+report against that same last successful snapshot. The npm version lifecycle
+uses this race-free sync path and stages the generated reports into the release
+commit. The tracked report intentionally omits fetch timestamps and HTTP validators,
+so repeated runs against unchanged upstream suites do not dirty the checkout.
+
+## Local audit cache
+
+Exact downloaded bytes, SHA-256 hashes, fetch timestamps, HTTP validators, and
+machine-readable results are kept under `.cache/neumerkel/`. `.cache/` remains
+Git-ignored: it is an audit/reproduction cache, not published project evidence.
+
+Use:
+
+```sh
+npm run test:neumerkel
+```
+
+for the canonical live check. For offline reproduction of the exact last live
+fetch, use:
+
+```sh
+npm run test:neumerkel:cached
+```
+
+The cached command never claims to check the latest upstream suites by itself.
+The release flow first performs the canonical live `npm test`, then uses those exact
+just-fetched bytes only to synchronize and verify the tracked evidence without
+contacting upstream twice.
+
+The vendored WG17 syntax matrix remains useful as a deterministic reviewed
+regression snapshot, but it is secondary to this live gate: passing the snapshot
+cannot mask a new or changed Neumerkel case.

package/test/conformance/README.md

@@ -69,68 +69,57 @@ Case names may be nested in category directories such as `arithmetic/`, `strings
 
 ## Running the suite
 
-Run all tests, including conformance, regression, documentation sync, API,
-examples, and book examples:
+The release gate is network-aware by design: it checks the current upstream
+Neumerkel conformity material before the deterministic local corpus.
 
 ```sh
 npm test
 ```
 
-Run only the conformance suite:
+For an offline-only development pass:
 
 ```sh
-node test/run-conformance.mjs
+npm run test:offline
 ```
 
-Run the Part 1 + Corrigenda strict-core processor gate:
+The conformance commands are:
 
 ```sh
-npm run test:iso-strict
+npm run test:conformance          # live Neumerkel + local ISO/conformance layers
+npm run test:conformance:offline  # same local layers, no network
+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:wg17                 # vendored reviewed WG17 syntax regression
 ```
 
-Run the vendored WG17 conformity matrix independently:
+`test:neumerkel` always fetches the current TU Wien sources. It does not skip a
+fetch because a cache exists. The runner discovers the number of active tests from those sources and fails on any newly introduced case EyeProlog does not pass. If the stable, tracked [NEUMERKEL-LATEST.md](NEUMERKEL-LATEST.md) is stale, normal tests warn rather than turning a passing engine run into a failure. `npm run conformance:update:neumerkel` performs a fresh live run and refreshes the report; after `npm test`, `npm run conformance:sync:neumerkel` refreshes it from the exact successful cached snapshot; and `npm run conformance:check:neumerkel` verifies that snapshot without a second network fetch. Exact bytes, SHA-256 hashes, timestamps, and HTTP validators stay under Git-ignored `.cache/neumerkel/` for audit/reproduction only. See [NEUMERKEL-LIVE.md](NEUMERKEL-LIVE.md).
 
-```sh
-npm run test:wg17
-```
-
-Refresh the WG17 snapshot from the TU Wien conformity tables before a release
-or whenever upstream changes:
+The vendored WG17 syntax snapshot is intentionally secondary. Update all upstream conformance evidence with `npm run conformance:update`, or use the focused commands:
 
 ```sh
-npm run wg17:upgrade
+npm run conformance:update:wg17
+npm run conformance:update:neumerkel
+npm run conformance:sync:neumerkel
 npm run test:wg17
 ```
 
-`wg17:upgrade` reconciles the upstream inventory by identifier: unchanged cases
-may keep their reviewed exact outcomes as an additional regression lock,
-removed cases disappear, and new or semantically changed cases initially have
-no local snapshot. **Every case is always checked independently against the
-upstream Codex expectation**, so a reviewed EyeProlog outcome can never make a
-non-conforming result pass (the failure mode that previously hid WG17 #227).
-The runner follows the upstream `read(G), G` input protocol, including the
-terminating newline, so stream-sensitive cases such as #270 and #271 exercise
-the characters left after `read/1`. Normal `npm test` remains offline and uses
-only the committed upstream snapshot.
+Every vendored syntax case is still checked against its upstream Codex
+expectation; reviewed exact outcomes are an additional regression lock rather
+than an alternative acceptance rule.
 
-Regenerate the public conformance report, including the executable WG17 syntax status and the file-based category inventory:
+Regenerate the top-level local-corpus report with `npm run conformance:report`. It links to [NEUMERKEL-LATEST.md](NEUMERKEL-LATEST.md) rather than duplicating live evidence. Counts in the tracked Neumerkel report are generated evidence, not permanent constants in project policy.
 
-```sh
-node test/run-conformance-report.mjs
-node test/run-conformance-report.mjs conformance-report.md
-```
-
-Run matching conformance cases by passing a filename or directory fragment:
+Run a matching local file-based conformance subset directly with:
 
 ```sh
 node test/run-conformance.mjs reusable
-node test/run-conformance.mjs 092_scalar_string_conversions
 node test/run-conformance.mjs variables/
 node test/run-conformance.mjs error/variables
 ```
 
-The runner executes normal programs with queries in-process through the public JavaScript API so small conformance cases avoid measuring Node startup overhead. Warning and proof cases intentionally use the CLI because warning output and `why/2` proof output are host-interface contracts.
-
 ## Scope
 
 The corpus covers accepted syntax, typed scalar identity and explicit scalar conversions, query answers,
@@ -147,12 +136,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 386 cases in `iso/` and 802 file-based conformance cases in
-total. Of those, 11 cases in `stc/` are explicitly labelled working-draft
-review evidence rather than normative ISO claims. The separate strict-reader WG17 matrix has 366 executable dispositions.
-The generated `conformance-report.md` is the authoritative source for the current
-executable WG17 syntax result and file-based category totals. Together with regression, documentation-sync, API, example,
-and book-example checks, `npm test` is the release gate.
+The corpus has 386 cases in `iso/` and 802 file-based conformance cases in total. Of those, 11 cases in `stc/` are explicitly labelled working-draft review evidence rather than normative ISO claims. The separate vendored strict-reader WG17 matrix is a deterministic regression snapshot; the live Neumerkel gate discovers the current upstream inventory at run time; release/report checks separately verify the tracked `NEUMERKEL-LATEST.md`. The generated `conformance-report.md` records local corpus totals and links to that live evidence. Together with regression, documentation-sync, API, example, and book-example checks, `npm test` is the release gate.
 
 ## Updating expected output
 

package/test/conformance/WG17-SYNTAX-STATUS.md

@@ -46,6 +46,6 @@ None.
 
 ## Maintenance
 
-1. Run `npm run wg17:upgrade` to reconcile the dated fixture with upstream.
+1. Run `npm run conformance:update` to reconcile the dated fixture with upstream.
 2. Review every new or changed ISO expectation before adding its expected outcome.
 3. Run `npm run test:wg17` and keep this generated status page synchronized.