eyeprolog 1.3.57 → 1.3.59

package/README.md

@@ -226,9 +226,22 @@ precedence for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`, and
 the complete Part 1 flag defaults/value domains/changeability rules. The
 ongoing issue #65 audit additionally tightens Prolog-text declaration ordering,
 initialization lifetime, stream/open/close behavior, character/byte stream
-errors, `keysort/2` error cases, and strict arithmetic-extension boundaries.
+errors, `keysort/2` error cases, the now-closed 5.5.6 side-effect and 5.5.10 evaluable-functor strict
+extension boundaries, and the standard's permitted arithmetic variation points: mixed-type Corrigendum 2
+`max/2`/`min/2` and signed Clause 9.4 bitwise/shift behavior.
 Those additions improve the Part 1 surface without turning the remaining audit
-rows into a blanket conformance claim.
+rows into a blanket conformance claim. The post-N289 WG17/STC working draft is
+reviewed separately rather than treated as a fourth Corrigendum. The
+2026-08-23 draft items #73-#76 are now pinned explicitly: float input limits for
+`read*` and `number_*` conversions, invalid-character term input, and the draft
+proposal that would make the two power-underflow rows depend on the processor's
+9.1.4.2 `resultF` choice. Strict mode retains the published Part 1 +
+Corrigenda 1-3 behavior where the draft has not been standardized.
+
+As an additional 5.5.1 extension-safety gate, every vendored WG17 syntax case
+that succeeds in the strict Part 1 reader is re-run in the normal profile and
+must retain the same observable outcome; normal mode may accept extra extension
+syntax, but it must not reinterpret text already accepted as standard syntax.
 
 The auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).

package/conformance-report.md

@@ -18,10 +18,10 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | proofs | 0 | 0 | 0 | 21 | 21 |
 | query | 8 | 2 | 0 | 0 | 10 |
 | rules | 13 | 3 | 0 | 0 | 16 |
-| stc | 5 | 4 | 0 | 0 | 9 |
+| stc | 5 | 6 | 0 | 0 | 11 |
 | strings | 40 | 0 | 0 | 0 | 40 |
 | syntax | 12 | 23 | 0 | 0 | 35 |
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 7 | 0 | 0 | 23 |
-| **Total** | **490** | **270** | **19** | **21** | **800** |
+| **Total** | **490** | **272** | **19** | **21** | **802** |

package/package.json

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

package/test/conformance/ISO-BUILTIN-MODE-ERROR-MATRIX.md

@@ -260,8 +260,8 @@ The Corrigendum 2 additions have the same shape.
 | --- | --- | --- | --- |
 | 8.14.1 `read_term/3`, `read_term/2`, `read/1-2` | read a term using the standardized read-option surface | covered | term-I/O corpus, Corrigendum 3 cases, strict success/error suite |
 | 8.14.1 option/argument errors | stream/option instantiation, non-list options, invalid read option | covered | strict 8.14.1 individual-condition assertions |
-| 8.14.1 stream/input errors | invalid/missing/output/binary stream, past-end state, invalid input character, syntax error | covered | strict and constructed-stream assertions |
-| 8.14.1 conditional finite-number/arity representation branches | limits tied to finite selected processor bounds | not applicable where bound is unbounded | EyeProlog selects unbounded integers/`max_arity`; finite binary64 input limits remain documented separately |
+| 8.14.1 stream/input errors | invalid/missing/output/binary stream, past-end state, invalid input character, syntax error | covered | strict and constructed-stream assertions; post-N289 STC #76 is pinned by invalid-character read regressions |
+| 8.14.1 conditional finite-number/arity representation branches | limits tied to finite selected processor bounds | not applicable where bound is unbounded | EyeProlog selects unbounded integers/`max_arity`; the implementation-defined finite binary64 input limits are pinned separately, including post-N289 STC #73 `max_float` / `min_float` coverage |
 | 8.14.1 Corrigendum options | `variables/1`, `variable_names/1`, `singletons/1` list traversal/unification behavior | covered | Corrigendum 3 metadata tests and STC #48 regression |
 | 8.14.2 `write_term/3`, `write_term/2`, `write/1-2`, `writeq/1-2` | write terms under standardized write options | covered | term-I/O/write-back corpus and strict writer suite |
 | 8.14.2 option/argument errors | stream/option instantiation, non-list options, invalid write option | covered | strict 8.14.2 assertions |

package/test/conformance/ISO-COMPLIANCE.md

@@ -27,24 +27,24 @@ relevant implementation-dependent overlap choice to an explicit audit outcome.
 | 5.1(d) document permitted variations | covered | The clause-by-clause [ISO 5.4 decision index](ISO-IMPLEMENTATION-DEFINED.md) records every explicit implementation-defined decision found in the Part 1 + Corrigenda baseline and separately inventories implementation-specific extension families. Rows marked `audit gap` remain conformance work, but the variation is no longer undocumented. |
 | 5.1(e) offer a strictly conforming mode | covered | `--iso-strict` and API option `isoStrict: true` restrict the processor to the Part 1 + Corrigenda 1-3 core language surface, remove EyeProlog-only registry/flag/operator features, disable automatic tabling/recursion guards, and reject the normal-profile host `stringTerm/1` term type at strict program/goal entry. |
 | 5.4 accompanying documentation | covered | *The Art of EyeProlog* remains the implementation reference; [ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md) is the closed clause-by-clause 5.4 decision index and points each decision to implementation evidence or an explicit audit gap. |
-| 5.5 extension boundaries | audit | [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) now splits 5.5 into its individual extension hooks. Operators, character conversion, the normal-profile host string type, directives, control constructs, flags, and reserved atoms have explicit decisions; exhaustive syntax-preservation, side-effect, built-in, and evaluable-functor dependency mapping remains open. |
+| 5.5 extension boundaries | audit | [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREMENTS.md) splits 5.5 into its individual extension hooks. Operators, character conversion, the normal-profile host string type, directives, control constructs, flags, built-ins, evaluable functors, and reserved atoms now have explicit decisions. The remaining open extension work is now concentrated in exhaustive syntax-preservation (5.5.1); the Prolog-visible additional-side-effect boundary (5.5.6) is explicitly filtered in strict mode and host instrumentation is documented as an embedding concern. |
 
 ## Normative language families
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, writer/read-back regressions, and Unicode-scalar PCS/collation boundary tests. The implementation-defined 6.5/6.6 character-model decisions are now closed; wider shall-by-shall lexical mapping remains open. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | Complete vendored WG17 syntax matrix, `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, quoted-layout/escape error cases, writer/read-back regressions, and Unicode-scalar PCS/collation boundary tests. A cross-profile gate now verifies that every WG17 case accepted by the strict Part 1 reader has the same observable outcome under normal-mode syntax extensions. The implementation-defined 6.5/6.6 character-model decisions are closed; the remaining work is the explicit production-by-production shall map. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates, plus strict checks for the required `variable < float < integer < atom < compound` type order, PCS-based atom collation, and the `max_arity=unbounded` compound-term model. The normal JavaScript API string term is now explicitly documented as a 5.5.4 extension and rejected at strict program/goal entry so it cannot add a sixth strict-core type. |
 | 7.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Preparation-time `char_conversion/2` affects later unquoted source text and respects `char_conversion=off`. Strict preparation now enforces declaration-before-clause ordering for `dynamic/1`, `multifile/1`, and `discontiguous/1`, cross-text `multifile/1`, discontiguous clause grouping, empty declared procedures, include textual-replacement behavior, and one-time initialization per prepared program. The remaining shall-by-shall mapping is still open. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access; focused strict checks cover the database built-ins and empty-procedure lifetime. Clause-body conversion now applies 7.6.2 both to prepared source clauses and runtime `asserta/1` / `assertz/1`: variables become `call/1`, `,/2`, `;/2`, and `->/2` are converted recursively, and head/body variable identity is preserved so `clause/2` and `retract/1` observe the converted term correctly. Runtime protection includes the solver-native conjunction control construct `','/2` and, following STC #56's accepted-direction action item, `(:-)/1-2` for database modification/private access while leaving their call behavior distinct. The remaining clause-conversion shall-by-shall mapping is still open. |
 | 7.7 — execution and backtracking | audit | Control/search suites. Strict mode disables EyeProlog automatic tabling, cycle guards, and recursive numeric shortcuts so core execution uses ordinary clause selection/backtracking. |
 | 7.8 — control constructs and exceptions | audit | call, cut, conjunction, disjunction (including failed branches after callee-local cuts), if-then, catch/throw, renamed-copy tests. The 8.15 built-in slice (`\+/1`, `once/1`, `repeat/0`, Corrigendum 2 `call/2..8`, `false/0`) is now row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md); the remaining general control-construct semantics ledger stays open. |
-| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Strict mode now pins direct-variable precedence, 7.9.2 non-evaluable `F/N` errors (including STC #69), arithmetic numeric/integer type errors, float-only rounding conversions, the Part 1 mixed integer/float comparison conversion rule, I->F overflow before floating evaluable functors (STC #42), explicit `exp/1`/power underflow, and prescribed negative/zero power errors before later conversion overflow. Unbounded integer powers/shifts no longer leak host `RangeError`; finite-host exhaustion is normalized to `resource_error(memory)` in line with the Part 1 resource-error note and STC #21. The remaining exceptional-value/error-precedence rows are still being exhaustively enumerated. |
+| 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Strict mode now pins direct-variable precedence, 7.9.2 non-evaluable `F/N` errors (including STC #69), arithmetic numeric/integer type errors, float-only rounding conversions, the Part 1 mixed integer/float comparison conversion rule, I->F overflow before floating evaluable functors (STC #42), the published `exp/1`/power underflow rows, and prescribed negative/zero power errors before later conversion overflow. Post-N289 STC #75's proposal to make the two power-underflow rows conditional on the 9.1.4.2 choice is tracked separately and is not silently substituted for the licensed baseline. Unbounded integer powers/shifts no longer leak host `RangeError`; finite-host exhaustion is normalized to `resource_error(memory)` in line with the Part 1 resource-error note and STC #21. The remaining exceptional-value/error-precedence rows are still being exhaustively enumerated. |
 | 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The complete 8.11-8.14 built-in mode/error family is now row-audited in [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md), including lifecycle/current-stream handling, stream positions, text/binary permissions, EOF actions, `force(true)`, input-code representation timing, term-I/O options, operators, and character conversion. `stream_property/2` now also distinguishes a malformed stream-term (domain error) from a valid stream-term whose stream is no longer open (ordinary failure). The higher-level 7.10 source/sink, buffering, positioning, and implementation-defined stream semantics remain under shall-by-shall audit. |
 | 7.11 — flags | covered | The complete Part 1 flag set, selected defaults, standard value domains, changeability, `current_prolog_flag/2`, and `set_prolog_flag/2` error behavior have dedicated strict tests. EyeProlog selects `bounded=false` and `integer_rounding_function=toward_zero`; valid alternative values of those fixed flags reach `permission_error(modify,flag,...)`, while `max_integer` and `min_integer` have no current value. STC #70 is recorded explicitly: EyeProlog has no separate finite procedure-arity ceiling, so the optional `max_procedure_arity` flag is absent while `max_arity` remains `unbounded`. Strict mode excludes the EyeProlog `occurs_check` extension. |
 | 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax/resource families and focused error cases. [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now gives explicit mode/error-condition outcomes across the complete 8.2-8.17 built-in family, including Corrigendum additions and not-applicable conditional branches. The audit records the 7.12 rule that simultaneous error conditions are implementation dependent: overlap regressions document stable EyeProlog choices rather than inventing a universal table-order requirement. Remaining work is concentrated in non-built-in Clause 7 semantics, Clause 9 exceptional interactions, and processor-level error conditions. |
 | 8.2-8.17 — built-in predicates | covered | [ISO-BUILTIN-MODE-ERROR-MATRIX.md](ISO-BUILTIN-MODE-ERROR-MATRIX.md) now records the complete Part 1 + Corrigenda built-in family at one row per prescribed mode, success/failure behavior, individual error condition, and conditional/not-applicable branch. The row audit exposed and fixed source/runtime 7.6.2 body conversion/variable sharing, strict host-string leakage, input-code error timing, `close/2` force handling, and closed-stream `stream_property/2` behavior. Simultaneous-error choices are documented as implementation dependent under 7.12 unless separately constrained. |
-| Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, reports unknown zero-arity evaluables with the required `F/0` culprit shape, distinguishes non-evaluable `F/N` errors from numeric/integer operand errors per 7.9.2 and STC #69, and enforces float-only rounding modes, performs I->F conversion before floating functors (including overflow), reports the explicit `exp/1`, `**/2`, and Corrigendum 2 `^/2` underflow conditions, preserves the power-specific undefined conditions ahead of conversion overflow, and uses the Part 1 integer-to-float rule for mixed arithmetic comparisons. Normal mode retains EyeProlog's exact mixed-type comparison and round-to-zero arithmetic behavior as extensions. Unbounded BigInt resource exhaustion is translated into the Prolog error model rather than leaking host exceptions. Host floating-point representation choices remain documented implementation-defined behavior; the remaining exceptional-value rows are still under audit. |
+| Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, reports unknown zero-arity evaluables with the required `F/0` culprit shape, distinguishes non-evaluable `F/N` errors from numeric/integer operand errors per 7.9.2 and STC #69, and enforces float-only rounding modes, performs I->F conversion before floating functors (including overflow), reports the published `exp/1`, `**/2`, and Corrigendum 2 `^/2` underflow conditions, tracks STC #75's proposed conditional power interpretation without adopting it as published text, preserves the power-specific undefined conditions ahead of conversion overflow, and uses the Part 1 integer-to-float rule for mixed arithmetic comparisons. Normal mode retains EyeProlog's exact mixed-type comparison and round-to-zero arithmetic behavior as extensions. Corrigendum 2 mixed-type `max/2`/`min/2` now have an explicit implementation-dependent decision: exact mathematical comparison selects one original operand and preserves its numeric type without mandatory integer-to-float conversion. Clause 9.4 signed bitwise operations and negative shift counts are likewise pinned to the documented BigInt infinite-two's-complement semantics. Unbounded BigInt resource exhaustion is translated into the Prolog error model rather than leaking host exceptions. Host floating-point representation choices remain documented implementation-defined behavior; the remaining exceptional-value rows are still under audit. |
 | Corrigendum 1 | covered | Double-quoted atom/operator-priority corrections have dedicated cases. |
 | Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
@@ -232,8 +232,18 @@ compound terms. EyeProlog therefore selects `unbounded` and does not invent a
 finite predicate/procedure ceiling merely to preserve the former 65535 value.
 STC #56, which became a WG17 action item, is implemented narrowly for database
 protection: `(:-)/1-2` are static/private for modification and `clause/2`
-access, while ordinary calls retain their separate existence behavior. Other
-draft/editorial or deliberately controversial proposals (for example deleting
+access, while ordinary calls retain their separate existence behavior. The 2026-08-23 post-N289 draft adds four more executable review points. STC
+#73 confirms the draft `max_float` / `min_float` representation-limit shape for
+`read/1-2` and `read_term/2-3`; STC #74 extends the same distinction to
+`number_chars/2` and `number_codes/2`; STC #76 proposes the
+`representation_error(character)` already exercised by EyeProlog's invalid-UTF-8
+read regressions. STC #75 is deliberately different: it proposes changing the
+published power-underflow conditions so that they depend on the 9.1.4.2
+`resultF` choice. Because that proposal is not a published Corrigendum, strict
+mode keeps the licensed Part 1/Corrigendum 2 power errors while the draft
+divergence is pinned and documented.
+
+Other draft/editorial or deliberately controversial proposals (for example deleting
 standalone if-then) remain outside the Part 1 + Corrigenda 1-3 strict baseline
 until standardized or adopted as an explicit compatibility extension.
 

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

@@ -73,11 +73,11 @@ Status values are:
 | 8.17.3 | Other effects of `halt/0` | Terminates EyeProlog execution and returns host/process status `0`; it produces no Prolog solution. | **defined** — `HaltSignal`, `haltBuiltin()`, CLI/runner handling. |
 | 8.17.4 | Meaning/effects of `halt(Status)` | Integer `Status` is converted to the host process/runner halt code; it produces no Prolog solution. | **defined** — `haltBuiltin()`, `src/execute.js`, `src/cli.js`. |
 | 9.1.4.1 | Floating-point rounding function `rndF` | Floating values and operations use ECMAScript `Number` (IEEE-754 binary64) and the host's specified binary64 arithmetic/conversions. | **defined** — `src/iso-arithmetic.js`, `src/number-value.js`. |
-| 9.1.4.2 | Floating-point result function for operations whose result is governed only by `resultF` | EyeProlog chooses `round(x)` rather than the optional exceptional value `underflow`. ECMAScript binary64 arithmetic therefore preserves a representable subnormal result and rounds a still-smaller generic arithmetic result to `0.0`, consistently with float-token and `number_chars/2` input. This implementation-defined choice does not suppress the explicit mandatory underflow conditions stated separately for Part 1 `**/2`, `exp/1`, and Corrigendum 2 `^/2`. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js` and parser/number conversion; strict exceptional-value regressions. |
+| 9.1.4.2 | Floating-point result function for operations whose result is governed only by `resultF` | EyeProlog chooses `round(x)` rather than the optional exceptional value `underflow`. ECMAScript binary64 arithmetic therefore preserves a representable subnormal result and rounds a still-smaller generic arithmetic result to `0.0`, consistently with float-token, `number_chars/2`, and `number_codes/2` input. The published Part 1 `**/2` and Corrigendum 2 `^/2` tables still contain separate unconditional underflow rows, which strict mode retains; post-N289 STC #75 proposes making those two power rows conditional on this `resultF` choice and is tracked separately as draft work. `exp/1` has its own published exceptional condition and is not the subject of STC #75. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js` and parser/number conversion; strict exceptional-value regressions. |
 | 9.1.4.3 | Approximate-addition function | ECMAScript binary64 addition is used; subtraction is implemented through the corresponding host operation and all finite results remain binary64 values. | **defined** — arithmetic evaluation in `src/iso-arithmetic.js`. |
-| 9.4 | Representation of negative integers for bitwise operations | BigInt's unbounded signed binary semantics are used, equivalent to an infinite two's-complement sign extension for bitwise operations. | **defined** — `src/iso-arithmetic.js` BigInt bitwise operators. |
-| 9.4.1 | Right shift of negative integers and unusual shift counts | `>>` is arithmetic/sign-propagating. A negative count reverses direction according to JavaScript BigInt shift semantics; there is no finite integer bit-size ceiling in the Prolog model. | **defined** — `a >> b` in `src/iso-arithmetic.js`. |
-| 9.4.2 | Left shift of negative integers and unusual shift counts | `<<` uses BigInt signed shift semantics; a negative count reverses direction. Resource exhaustion remains possible for very large results. | **defined** — `a << b` in `src/iso-arithmetic.js`. |
+| 9.4 | Representation of negative integers for bitwise operations | BigInt's unbounded signed binary semantics are used, equivalent to an infinite two's-complement sign extension for bitwise operations. | **defined** — `src/iso-arithmetic.js` BigInt bitwise operators and strict Clause 9.4 boundary regressions. |
+| 9.4.1 | Right shift of negative integers and unusual shift counts | `>>` is arithmetic/sign-propagating. A negative count reverses direction according to JavaScript BigInt shift semantics; there is no finite integer bit-size ceiling in the Prolog model. | **defined** — `a >> b` in `src/iso-arithmetic.js`; strict regressions pin negative operands/counts. |
+| 9.4.2 | Left shift of negative integers and unusual shift counts | `<<` uses BigInt signed shift semantics; a negative count reverses direction. Resource exhaustion remains possible for very large results. | **defined** — `a << b` in `src/iso-arithmetic.js`; strict regressions pin negative counts and resource exhaustion. |
 | 9.4.3 | Bitwise AND with negative operands | BigInt infinite-two's-complement semantics. | **defined** — `a & b`. |
 | 9.4.4 | Bitwise OR with negative operands | BigInt infinite-two's-complement semantics. | **defined** — `a \| b`. |
 | 9.4.5 | Bitwise complement | BigInt complement, i.e. `~N = -N-1`. | **defined** — `~a`. |
@@ -93,13 +93,16 @@ subnormal values remain non-zero and still-smaller generic results round to
 `0.0`. Float-token and `number_chars/2` input use the same finite-double
 rounding policy.
 
-That generic implementation-defined choice is distinct from evaluable functors
-whose own error clauses prescribe underflow. In strict mode, `exp/1`, Part 1
-`**/2`, and Corrigendum 2 `^/2` therefore raise
-`evaluation_error(underflow)` when their mathematical non-zero result falls
-below the representable range and the host would otherwise round it to zero.
-The regression suite pins both sides of this boundary, while
-`stc/float_underflow_input` covers the related input conversion policy.
+That generic implementation-defined choice is distinct from the currently
+published evaluable-functor error clauses. In the licensed Part 1 + Corrigenda
+baseline, `exp/1`, Part 1 `**/2`, and Corrigendum 2 `^/2` have explicit
+underflow conditions, so strict mode raises `evaluation_error(underflow)` when
+those published conditions are met. The 2026-08-23 post-N289 draft adds STC
+#75, proposing that the two *power* underflow rows apply only when the processor
+selects `underflow` in 9.1.4.2. EyeProlog records that proposal but does not
+silently replace the published strict baseline with it. The regression suite
+pins both the published power behavior and the generic round-to-zero choice;
+`stc/float_underflow_input` covers the separate input-conversion policy.
 
 ## Implementation-specific features required to be documented by 5.4
 
@@ -115,11 +118,11 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
 | 5.5.4 Types | The normal JavaScript API exposes an implementation-specific string term `stringTerm(Text)`. It is disjoint from the five Part 1 term types; normal term order places it after atoms and before compound terms, and normal `atomic/1` treats it as atomic. It has no Prolog source token syntax (double-quoted source still follows `double_quotes`), is non-callable for term-to-clause conversion, is not evaluable as an arithmetic expression, and writes as a double-quoted host string. | Strict mode rejects a programmatic string term at program/goal entry with `representation_error(term)`, so the additional type cannot enter the Part 1 execution domain. **defined** — `src/term.js`, `src/program.js`, `src/solver.js`; strict API-boundary regression. |
 | 5.5.5 Directives | `module/2`, `use_module/1-2`, `meta_predicate/1` and normal-profile library behavior | Rejected as implementation-specific Part 1 directives. |
-| 5.5.6 Side effects | Host output/statistics, library-specific state, proof/statistics collection | The strict registry excludes library adapters; ordinary Part 1 I/O/database/flag/operator side effects remain. |
+| 5.5.6 Side effects | Normal mode adds `statistics/0-2`, cleanup/library state, and optional proof/statistics host instrumentation. | The strict registry excludes Prolog-visible statistics/cleanup/library adapters; ordinary Part 1 I/O/database/flag/operator side effects remain. Host proof/statistics collection observes execution through the embedding API rather than adding a strict Prolog goal effect. **covered** — strict registry/execution regression. |
 | 5.5.7 Control constructs | `tnot/1` and normal-profile execution optimizations | `tnot/1` is absent; automatic tabling/recursion guards are disabled. |
 | 5.5.8 Flags | `occurs_check` | Absent in strict mode. |
 | 5.5.9 Built-in predicates | EyeProlog libraries, CLP(Z), statistics, Part 3 `phrase/2-3`, and interop autoloaded predicates | Strict registry contains only the Part 1 + Corrigenda core registry. |
-| 5.5.10 Evaluable functors | Library/runtime extensions when registered outside the strict core | Strict arithmetic registry is the Part 1 + Corrigenda set. |
+| 5.5.10 Evaluable functors | Normal mode additionally accepts the EyeProlog evaluable atom `e`; the remaining arithmetic functors accepted by strict mode are the Part 1 + Corrigenda set. | Strict mode rejects `e/0` as non-evaluable and retains the Corrigendum arithmetic additions. **covered** — strict extension-boundary regression plus `src/iso-arithmetic.js`. |
 | 5.5.11 Reserved atoms | None | None. |
 | Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Normal mode additionally accepts the EyeProlog `write_term/2-3` option `double_quotes(true|false)`. Strict core excludes that extension and accepts only the Part 1 plus Corrigendum 3 write-option surface; unknown extension options raise `domain_error(write_option,...)`. |
 
@@ -136,6 +139,7 @@ For portability work, EyeProlog also documents these choices even though the
 - distinct variables are ordered by first encounter within the operation that
   needs a stable ordering;
 - expression arguments are evaluated left-to-right by the JavaScript evaluator;
+- Corrigendum 2 mixed integer/float `max/2` and `min/2` use exact mathematical comparison and return one of the original operands without forcing integer-to-float conversion; equal values choose the left operand, so its original numeric type is preserved. EyeProlog does not elect the optional mixed-type `undefined` or `float_overflow` outcomes solely because the operand types differ;
 - generated variable names use EyeProlog's stable `_A`, `_B`, ... style within
   a write operation/top-level query;
 - resource and syntax-error detail atoms are EyeProlog implementation details;

package/test/conformance/ISO-MATRIX.md

@@ -8,7 +8,7 @@ compliance audit and the remaining work before a full conformance claim.
 
 | Standard area | Implementation | Representative executable coverage |
 | --- | --- | --- |
-| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, Unicode-scalar PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases |
+| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, Unicode-scalar PCS/collation | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, strict PCS/collation tests in `run-iso-strict.mjs`, syntax error cases, and a cross-profile check that all strict-success WG17 cases retain the same normal-profile outcome |
 | 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`, `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, and the one-row-per-mode/error 8.2-8.5 slice in `ISO-BUILTIN-MODE-ERROR-MATRIX.md`, including conditional finite-`max_arity` branches |
@@ -18,7 +18,7 @@ compliance audit and the remaining work before a full conformance claim.
 | 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin`, plus the complete 8.15 row-audit in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
 | 8.16 atomic processing | atoms, characters, codes and number conversion with prescribed errors | `atomic_term_processing`, focused forward/reverse cases, parenthesized-number rejection, Logtalk-derived cases, and the complete 8.16 mode/error slice in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
 | 8.17 flags and halt | complete required Part 1 flag set, selected defaults, standard value domains/changeability, and halt status handling | `exceptions_and_flags`, `remaining_builtins_and_directives`, the complete strict flag audit, halt cases, and explicit 8.17 rows in `ISO-BUILTIN-MODE-ERROR-MATRIX.md` |
-| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension, zero-arity unknown-evaluable checks, prescribed operand/type and power-error precedence, float-only rounding modes, I->F overflow before floating functors, explicit `exp/1`/`**/2`/`^/2` underflow, Part 1 mixed integer/float comparison conversion, and resource-error normalization for finite-host exhaustion of unbounded integer operations |
+| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension, zero-arity unknown-evaluable checks, prescribed operand/type and power-error precedence, float-only rounding modes, I->F overflow before floating functors, published `exp/1`/`**/2`/`^/2` underflow (with post-N289 STC #75 tracked separately), Part 1 mixed integer/float comparison conversion, the pinned Corrigendum 2 mixed-type `max/2`/`min/2` implementation-dependent choice, documented Clause 9.4 signed bitwise/negative-shift semantics, and resource-error normalization for finite-host exhaustion of unbounded integer operations |
 | Module compatibility profile (related to ISO/IEC 13211-2 and later WG17 amendment work) | module declarations, exports, imports, qualification, meta-predicate context | `modules/qualified_call`, `modules/selective_library_import`, `dcg_module_nonterminal_indicator` |
 | Part 3-oriented DCG compatibility profile | `-->`, terminal and partial sequences, grammar control constructs, semicontexts, nonterminal indicators, modules, `phrase/2-3`, steadfastness and errors | `dcg_terminals_and_remainder`, `dcg_control_constructs`, `dcg_partial_sequences`, `dcg_phrase_steadfastness`, `dcg_dynamic_nonterminal_indicator`, `logtalk_dcg_phrase_identity`, `logtalk_dcg_semicontexts`, DCG error and precedence cases |
 

package/test/conformance/ISO-PROCESSOR-REQUIREMENTS.md

@@ -35,16 +35,16 @@ certification claim.
 | Requirement | Status | EyeProlog decision / evidence |
 | --- | --- | --- |
 | 5.5 general extension rule | covered | normal mode may provide documented extensions; strict mode removes their Part 1 interpretation rather than changing implementation-defined choices |
-| 5.5.1 syntax extensions preserve standard token/text meaning | audit | WG17 syntax is a release gate and strict mode removes module/DCG/quad interpretation; a complete one-row preservation map for every Clause 6 production remains open |
+| 5.5.1 syntax extensions preserve standard token/text meaning | audit | WG17 syntax is a release gate and strict mode removes module/DCG/quad interpretation. Every vendored WG17 case that succeeds in the Part 1 strict reader now has an identical normal-profile observable outcome, directly checking that normal syntax extensions do not reinterpret accepted standard text. A complete one-row preservation map for every Clause 6 production remains open |
 | 5.5.2 additional predefined operators | covered | strict mode starts from the Part 1 predefined operator table; normal-profile extra operators are documented and filtered |
 | 5.5.3 initial character-conversion mapping | covered | identity initial mapping; user changes are exercised through preparation/execution `char_conversion/2` behavior |
 | 5.5.4 additional term types | covered | the normal JavaScript API's `stringTerm(Text)` is documented as an implementation-specific sixth term type, including disjointness, ordering, clause conversion, lack of source token syntax, expression behavior, and writing; strict program/goal entry rejects that type with `representation_error(term)` |
 | 5.5.5 additional directives | covered | normal module/library directives are documented implementation-specific features and are rejected by strict mode |
-| 5.5.6 additional side effects | audit | host/proof/statistics/library effects are outside the strict registry or documented normal-mode behavior; exhaustive side-effect preservation mapping remains part of the Clause 7.7/7.10 audit |
+| 5.5.6 additional side effects | covered | normal-profile `statistics/0-2`, cleanup/library state, proof/statistics host instrumentation, and other extension effects are documented outside the Part 1 core; strict registry tests exclude the Prolog-visible statistics/cleanup extensions. Host instrumentation is an embedding observation rather than an extra strict Prolog goal effect |
 | 5.5.7 additional control constructs | covered | `tnot/1` and implementation-specific execution optimizations are absent/disabled in strict mode; standard control constructs remain separately audited |
 | 5.5.8 additional flags | covered | normal `occurs_check` extension is absent from strict mode; the Part 1 flag family is fully audited |
 | 5.5.9 additional built-in predicates and error forms | covered | strict registry excludes normal-profile library/native additions; `ISO-BUILTIN-MODE-ERROR-MATRIX.md` closes the complete 8.2-8.17 family row-by-row; simultaneous-error choices are documented per 7.12 rather than treated as a global table-order mandate |
-| 5.5.10 additional evaluable functors/types | audit | strict mode excludes normal-profile arithmetic extensions such as evaluable `e`; Clause 9 exceptional-value and error-precedence rows remain under audit |
+| 5.5.10 additional evaluable functors/types | covered | strict mode rejects the normal-profile evaluable `e` extension while retaining the full Part 1 + Corrigenda arithmetic set. The 9.1.4.2 `resultF` choice, Corrigendum 2 mixed-type `max/2`/`min/2` choice, and Clause 9.4 signed bitwise/shift choices are documented and pinned by strict tests. Post-N289 STC #75 remains separate from the published baseline; the remaining Clause 9 semantic/error audit is tracked under 5.1(b)/5.3 rather than as an open extension-boundary decision |
 | 5.5.11 reserved atoms | not applicable | EyeProlog declares no reserved-atom extension; extension names remain ordinary atoms unless used in a documented syntactic/predicate/directive role |
 
 ## Exit-use rule

package/test/conformance/README.md

@@ -15,7 +15,7 @@ tracks the row-by-row built-in audit, while
 Clause 5 processor obligations. [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.
 [STC-DRAFT-STATUS.md](STC-DRAFT-STATUS.md) separately tracks executable
-implementation questions from the post-N289 working draft; those cases are
+implementation questions from the post-N289 working draft (reviewed through the 2026-08-23 items #73-#76); those cases are
 review evidence, not normative ISO claims.
 
 “Conformance” here means conformance to EyeProlog's documented ISO compatibility
@@ -141,8 +141,8 @@ 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 800 file-based conformance cases in
-total. Of those, 9 cases in `stc/` are explicitly labelled working-draft
+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 current
 category totals. Together with regression, documentation-sync, API, example,

package/test/conformance/STC-DRAFT-STATUS.md

@@ -39,7 +39,11 @@ regressions.
 | [#69](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#69) | arithmetic example culprit | **Found a #65 gap.** Strict expression evaluation now applies 7.9.2(c) to an atomic subexpression such as `foo`: it reports `type_error(evaluable,foo/0)` rather than the misleading `type_error(number,foo)` shown by the old 9.1.7 example. |
 | [#70](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#70) | optional `max_procedure_arity` | Reviewed after issue #66 corrected the earlier #71 pointer. EyeProlog has no declared procedure-arity limit smaller than its `max_arity=unbounded` term model, so the implementation-defined optional flag is intentionally absent. |
 | [#72](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#72) | tentative non-ground stream-term instances | Reviewed as a tentative post-2026 proposal. EyeProlog does not make this draft wording normative in `--iso-strict`; the published Part 1 stream-term/domain rules remain the baseline until WG17 settles the proposal. |
-| [issue #54](https://github.com/eyereasoner/eyeprolog/issues/54) | float-reading limits (historically discussed as a later STC item) | Positive/negative literal and `number_chars/2` overflow are kept as explicit draft-facing cases; underflow is tested separately. The current public STC page ends at #72, so this is no longer labelled as a current `stc#73` entry. See the note below. |
+| [#73](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73) | `read/1-2` and `read_term/2-3` representation limits | The 2026-08-23 post-N289 draft now explicitly proposes `max_float` / `min_float` alongside the existing representation-limit flags. EyeProlog already reports those errors while reading overflowing positive/negative float tokens; strict regression coverage now exercises both `read/1` and `read_term/2`, and the literal STC cases pin parser preparation. |
+| [#74](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#74) | `number_chars/2` and `number_codes/2` representation limits | Positive and negative overflow now have explicit draft-facing cases for both conversion predicates, reporting `representation_error(max_float)` / `representation_error(min_float)` rather than a syntax error. |
+| [#75](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#75) | power underflow versus the 9.1.4.2 `resultF` choice | The draft proposes making the Part 1 `**/2` and Corrigendum 2 `^/2` underflow rows conditional on the implementation-defined `resultF` underflow choice. EyeProlog's published-baseline strict mode intentionally retains the currently published unconditional power-underflow clauses; its separate 9.1.4.2 choice remains `round(x)`. This proposal is tracked, not silently adopted. |
+| [#76](https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#76) | `read/1-2` and `read_term/2-3` invalid input entity | Existing file-stream regressions already require `representation_error(character)` for invalid UTF-8 through all four read/read_term arities. The regression is now cross-referenced to the new draft item. |
+| [issue #54](https://github.com/eyereasoner/eyeprolog/issues/54) | float input range and underflow background | The earlier EyeProlog issue remains useful background for finite-double input overflow/underflow. Its overflow cases are now tracked by STC #73/#74; input underflow remains a separate implementation-profile check and must not be conflated with STC #75's power-underflow proposal. |
 
 ## Float-reading note from issue #54
 
@@ -54,13 +58,13 @@ record the behavior discussed in issue #54:
 - overflow produced by arithmetic evaluation remains
   `evaluation_error(float_overflow)`.
 
-These `max_float` / `min_float` names are treated as a **provisional draft
-extension**, not as a claim about the currently published ISO core standard.
+These `max_float` / `min_float` names are treated as a **draft-facing representation-limit extension**, now explicitly reflected by post-N289 STC #73/#74, not as a claim that the currently published ISO core standard already contains those flag names.
 The earlier WG17 float-update material also uses
-`representation_error(float_overflow)` for unsupported infinity input, while a
-separate reading-floats proposal discusses `max_float` for a finite value above
-the implementation's largest finite float. Those cases should remain distinct
-when WG17 settles the wording.
+`representation_error(float_overflow)` for unsupported infinity input, while
+STC #73/#74 use `max_float` / `min_float` for a finite numeric text that lies
+outside the implementation's finite float range. Those cases should remain
+distinct when WG17 settles the wording. STC #75 is independent again: it asks
+how power underflow relates to the implementation-defined `resultF` choice.
 
 Relevant background:
 

package/test/conformance/cases/stc/float_underflow_input.pl

@@ -1,6 +1,8 @@
-% Float-reading draft review associated with STC #73 / issue #54. EyeProlog's
-% finite-double profile permits input underflow to round to zero.
-% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+% Issue #54 input-underflow review. EyeProlog's finite-double profile permits
+% input underflow to round to zero. This is distinct from STC #75, which asks
+% whether the published power-underflow errors should depend on the 9.1.4.2
+% resultF choice.
+% https://github.com/eyereasoner/eyeprolog/issues/54
 %% goal: float_underflow_input
 
 float_underflow_input :-

package/test/conformance/errors/stc/float_overflow_negative_number_chars.pl

@@ -1,3 +1,3 @@
-% Draft float-reading limit review associated with STC #73 / issue #54.
-% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+% STC #74: number_chars/2 reports the draft floating representation limit.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#74
 %% goal: number_chars(_, "-1.0e99999")

package/test/conformance/errors/stc/float_overflow_negative_number_codes.pl

@@ -0,0 +1,4 @@
+% STC #74: number_codes/2 should report the same implementation-defined
+% floating representation limit as number_chars/2.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#74
+%% goal: number_codes(_, [45,49,46,48,101,57,57,57,57,57])

package/test/conformance/errors/stc/float_overflow_positive_number_chars.pl

@@ -1,3 +1,3 @@
-% Draft float-reading limit review associated with STC #73 / issue #54.
-% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#73
+% STC #74: number_chars/2 reports the draft floating representation limit.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#74
 %% goal: number_chars(_, "1.0e99999")

package/test/conformance/errors/stc/float_overflow_positive_number_codes.pl

@@ -0,0 +1,4 @@
+% STC #74: number_codes/2 should report the same implementation-defined
+% floating representation limit as number_chars/2.
+% https://www.complang.tuwien.ac.at/ulrich/iso-prolog/stc#74
+%% goal: number_codes(_, [49,46,48,101,57,57,57,57,57])

package/test/conformance/expected-errors/stc/float_overflow_negative_number_codes.txt

@@ -0,0 +1 @@
+error(representation_error(min_float))

package/test/conformance/expected-errors/stc/float_overflow_positive_number_codes.txt

@@ -0,0 +1 @@
+error(representation_error(max_float))

package/test/run-iso-strict.mjs

@@ -8,6 +8,7 @@ import {
   Env,
   compound,
   createStrictIsoRegistry,
+  getEyePrologRegistry,
   parseGoalText,
   parseProgramText,
   run,
@@ -614,6 +615,29 @@ export function runIsoStrict(reporter = new TestReporter()) {
     }
   });
 
+  reporter.test('tracks post-N289 STC draft items 73-76 without replacing the published baseline', () => {
+    for (const [goal, input, expected, label] of [
+      ['read(X)', '1.0e99999.\n', 'representation_error(max_float)', 'STC #73 read/1 max_float'],
+      ['read_term(X,[])', '-1.0e99999.\n', 'representation_error(min_float)', 'STC #73 read_term/2 min_float'],
+    ]) {
+      equal(capture(() => run('', { isoStrict: true, goal, ioOptions: { input } })).formal, expected, label);
+    }
+
+    for (const [goal, expected, label] of [
+      ["number_chars(N,['1','.','0',e,'9','9','9','9','9'])", 'representation_error(max_float)', 'STC #74 number_chars/2'],
+      ['number_codes(N,[45,49,46,48,101,57,57,57,57,57])', 'representation_error(min_float)', 'STC #74 number_codes/2'],
+    ]) equal(capture(() => run('', { isoStrict: true, goal })).formal, expected, label);
+
+    // STC #75 proposes conditioning the published **/2 and Corrigendum 2 ^/2
+    // underflow rows on the implementation-defined 9.1.4.2 resultF choice.
+    // Until that proposal is standardized, strict mode keeps the published
+    // unconditional error clauses; the draft divergence is documented.
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is 2.0 ** -1075.0' })).formal,
+      'evaluation_error(underflow)', 'published **/2 underflow baseline');
+    equal(capture(() => run('', { isoStrict: true, goal: 'X is 2.0 ^ -1075.0' })).formal,
+      'evaluation_error(underflow)', 'published ^/2 underflow baseline');
+  });
+
   reporter.test('reports explicit transcendental and power underflow in strict mode', () => {
     for (const [goal, label] of [
       ['X is exp(-1000.0)', 'exp/1 underflow'],
@@ -650,6 +674,72 @@ export function runIsoStrict(reporter = new TestReporter()) {
       'evaluation_error(undefined)', 'zero-negative power precedes exponent conversion overflow');
   });
 
+  reporter.test('closes the 5.5.6 additional side-effect extension boundary', () => {
+    const normalRegistry = getEyePrologRegistry();
+    const strictRegistry = createStrictIsoRegistry();
+    equal(Boolean(normalRegistry.get('statistics', 0)), true, 'normal statistics/0 side-effect extension');
+    equal(Boolean(strictRegistry.get('statistics', 0)), false, 'strict statistics/0 excluded');
+    equal(Boolean(strictRegistry.get('statistics', 2)), false, 'strict statistics/2 excluded');
+    equal(Boolean(strictRegistry.get('call_cleanup', 2)), false, 'strict cleanup extension excluded');
+    equal(Boolean(strictRegistry.get('setup_call_cleanup', 3)), false, 'strict setup/cleanup extension excluded');
+    equal(capture(() => run('', { isoStrict: true, goal: 'statistics' })).formal,
+      'existence_error(procedure)', 'strict execution cannot invoke statistics/0');
+  });
+
+  reporter.test('closes the 5.5.10 evaluable-functor extension boundary', () => {
+    const strictExtension = capture(() => run('', { isoStrict: true, goal: 'X is e' }));
+    equal(strictExtension.formal, 'type_error(evaluable)', 'normal-only e/0 is not evaluable in strict mode');
+    equal(run('', { goal: 'X is e' }).stats.completed_goal_lists, 1, 'normal e/0 extension remains available');
+
+    for (const goal of [
+      'X is +1',
+      'X is -7 div 3',
+      'X is max(2,3.0)',
+      'X is min(2.0,3)',
+      'X is 3^3',
+      'X is asin(0)',
+      'X is acos(1)',
+      'X is atan2(1,0)',
+      'X is tan(0)',
+      'X is pi',
+      'X is xor(10,12)',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, `Corrigendum evaluable ${goal}`);
+  });
+
+  reporter.test('pins Corrigendum 2 mixed-type max/min implementation-dependent behavior', () => {
+    for (const goal of [
+      'X is max(2.0,3), X == 3',
+      'X is max(2,3.0), X == 3.0',
+      'X is min(2.0,3), X == 2.0',
+      'X is min(2,3.0), X == 2',
+      'X is max(0,0.0), X == 0',
+      'X is max(0.0,0), X == 0.0',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
+
+    // Corrigendum 2 permits several mixed-type choices, including returning
+    // one of the original operands without converting the integer to float.
+    // EyeProlog compares the mathematical values exactly and preserves the
+    // selected operand's original type, so a huge integer does not create a
+    // float-overflow merely because the other operand is a float.
+    const huge = `1${'0'.repeat(400)}`;
+    equal(run('', { isoStrict: true, goal: `X is max(${huge},1.0), X == ${huge}` }).stats.completed_goal_lists,
+      1, 'mixed max/2 does not force integer-to-float conversion');
+    equal(run('', { isoStrict: true, goal: `X is min(${huge},1.0), X == 1.0` }).stats.completed_goal_lists,
+      1, 'mixed min/2 preserves selected float operand');
+  });
+
+  reporter.test('pins implementation-defined Clause 9.4 signed bitwise and shift behavior', () => {
+    for (const goal of [
+      'X is ((-16) >> 2), X == -4',
+      'X is (16 >> -2), X == 64',
+      'X is (16 << -2), X == 4',
+      'X is ((-1) /\\ 5), X == 5',
+      'X is ((-1) \\/ 5), X == -1',
+      'X is xor(-1,5), X == -6',
+      'X is \\ 5, X == -6',
+    ]) equal(run('', { isoStrict: true, goal }).stats.completed_goal_lists, 1, goal);
+  });
+
   reporter.test('uses the Part 1 mixed arithmetic comparison operations', () => {
     // 8.7 converts the integer operand to float in mixed comparisons.
     equal(run('', { isoStrict: true, goal: '18014398509481985 =:= 18014398509481984.0' }).stats.completed_goal_lists,

package/test/run-regression.mjs

@@ -845,6 +845,29 @@ c4 ?- call((!;1)).
         }
         assertEqual(readError?.formal, 'representation_error(max_float)', 'read/1 overflow');
 
+        let readTermError = null;
+        try {
+          runEyeProlog('', {
+            goal: 'read_term(X, [])',
+            ioOptions: { input: '-1.0e99999.\n' },
+          });
+        } catch (error) {
+          readTermError = error;
+        }
+        assertEqual(readTermError?.formal, 'representation_error(min_float)', 'read_term/2 overflow (STC #73)');
+
+        const numberCodes = createDefaultRegistry().get('number_codes', 2).handler;
+        let numberCodesError = null;
+        try {
+          numberCodes({
+            goal: compound('number_codes', [variable('N'), listFromItems(Array.from('1.0e99999', (c) => numberTerm(String(c.codePointAt(0))))) ]),
+            env: new Env(),
+          }).next();
+        } catch (error) {
+          numberCodesError = error;
+        }
+        assertEqual(numberCodesError?.formal, 'representation_error(max_float)', 'number_codes positive overflow (STC #74)');
+
         const isHandler = createDefaultRegistry().get('is', 2).handler;
         let hostTermError = null;
         try {
@@ -1222,21 +1245,34 @@ c4 ?- call((!;1)).
       run: () => {
         const filename = path.join(testRoot, 'fixtures', 'prologue_quad_runner.pl');
         const source = fs.readFileSync(filename, 'utf8');
-        const result = publicApi.runQuads(Program.parseSources([{
+        const program = Program.parseSources([{
           text: source,
           filename,
           baseDir: path.dirname(filename),
-        }]));
-        assertEqual(result.total, 33, 'quad total');
+        }]);
+        assertEqual(program.quads.length, 33, 'vendored quad total');
+        const maxIntegerQuads = program.quads.filter(({ query }) =>
+          termToString(query).includes('current_prolog_flag(max_integer, Max)'));
+        assertEqual(maxIntegerQuads.length, 1, 'max_integer quad count');
+
+        // This regression is about the one deliberate ISO divergence in the
+        // upstream Prologue fixture. Running all 33 records also explores two
+        // intentionally non-terminating STO examples and used to dominate the
+        // regression suite by several seconds, without adding evidence for
+        // max_integer. Keep the full vendored corpus intact, but execute only
+        // the relevant record here.
+        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.
-        assertEqual(result.passed, 32, 'quad passed');
+        assertEqual(result.total, 1, 'quad total');
+        assertEqual(result.passed, 0, 'quad passed');
         assertEqual(result.failed, 1, 'quad failed');
         assertIncludes(result.stdout, 'current_prolog_flag(max_integer, Max)', 'max_integer divergence');
-        assertIncludes(result.stdout, 'quads: 33 run, 32 passed, 1 failed.', 'quad report');
+        assertIncludes(result.stdout, 'quads: 1 run, 0 passed, 1 failed.', 'quad report');
       },
     },
     {
@@ -3323,7 +3359,7 @@ child.stdin.write(\`consult(${consultedAtom}).\\n\`);
       },
     },
     {
-      name: 'read and read_term report invalid UTF-8 as representation_error(character) (issue #64)',
+      name: 'read and read_term report invalid UTF-8 as representation_error(character) (issue #64, STC #76)',
       run: () => {
         const invalidPath = path.join(tmp, `read-invalid-utf8-${++tmpCounter}.bin`);
         fs.writeFileSync(invalidPath, Buffer.from([0xff]));
@@ -3508,6 +3544,21 @@ function documentationSyncCases() {
         );
       },
     },
+    {
+      name: 'normal syntax extensions preserve successful WG17 Part 1 outcomes',
+      run: () => {
+        const fixture = readWg17SyntaxFixture();
+        let checked = 0;
+        for (const item of fixture.cases) {
+          const strict = executeWg17Item(item);
+          if (strict.type !== 'success') continue;
+          const normal = executeWg17Item(item, { isoStrict: false });
+          assertEqual(JSON.stringify(normal), JSON.stringify(strict), `WG17 #${item.id} cross-profile outcome`);
+          checked++;
+        }
+        if (checked === 0) throw new Error('WG17 fixture has no successful Part 1 syntax cases');
+      },
+    },
     {
       name: 'WG17 stream-sensitive cases #270 and #271 follow the upstream input protocol',
       run: () => {

package/test/run-wg17.mjs

@@ -33,13 +33,13 @@ function capturedStages(stdout) {
     .map((match) => ({ output: match[2], variables: match[3] }));
 }
 
-function executeFinite(item) {
+function executeFinite(item, isoStrict = true) {
   try {
     // Match the upstream protocol: the Query cell plus its terminating newline
     // is input to read(G), G (and subsequent read/call stages when present).
     // This is essential for stream-sensitive cases such as #270 and #271.
     const result = run('', {
-      isoStrict: true,
+      isoStrict,
       goal: runnerStage(1, item.readCount ?? 16),
       ioOptions: { input: `${item.input}\n` },
     });
@@ -50,10 +50,10 @@ function executeFinite(item) {
   }
 }
 
-function executeWait(item) {
-  const program = Program.parse('', { isoStrict: true });
+function executeWait(item, isoStrict = true) {
+  const program = Program.parse('', { isoStrict });
   const solver = new Solver(program, {
-    isoStrict: true,
+    isoStrict,
     ioOptions: { input: `${item.input}\n` },
   });
   const stream = solver.io.resolve('user_input');
@@ -63,7 +63,7 @@ function executeWait(item) {
     return null;
   };
   const goal = parseGoalText('read_term(G, [])', {
-    isoStrict: true,
+    isoStrict,
     operatorDefinitions: [...program.operators.values()],
   });
   try {
@@ -310,10 +310,11 @@ export function wg17TestDescription(item) {
   return `#${item.id} ${query} -> ${expected}`;
 }
 
-export function executeWg17Item(item) {
+export function executeWg17Item(item, options = {}) {
+  const isoStrict = options.isoStrict ?? true;
   return usesWaitMatcher(item.expected) || item.outcome?.type === 'waits'
-    ? executeWait(item)
-    : executeFinite(item);
+    ? executeWait(item, isoStrict)
+    : executeFinite(item, isoStrict);
 }
 
 function assertOutcome(item) {

package/the-art-of-eyeprolog.md

@@ -5495,9 +5495,15 @@ The long catalogs are meant to be entered locally, not memorized linearly.
 ## 38. Language and ISO profile
 
 The normative strict-core baseline is ISO/IEC 13211-1:1995, as corrected by
-Technical Corrigenda 1:2007, 2:2012, and 3:2017. 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
+Technical Corrigenda 1:2007, 2:2012, and 3:2017. The post-N289 WG17/STC
+working draft is used as defect-discovery input, not as an unpublished fourth
+Corrigendum. The 2026-08-23 draft through items #73-#76 is tracked by
+`test/conformance/STC-DRAFT-STATUS.md`; where a proposal changes published
+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.
@@ -7590,8 +7596,14 @@ gaps without turning draft WG17/STC proposals into the licensed baseline.
 upstream syntax cases. Reviewed cases can pin exact strict-reader outcomes, while
 newly upgraded cases execute directly against the upstream Codex expectation.
 
+The syntax audit also cross-checks extension safety: each vendored WG17 case
+accepted by the strict Part 1 reader is executed through the normal profile and
+must preserve the same observable outcome. Additional normal-mode syntax may
+accept texts outside the strict grammar, but it may not reinterpret an accepted
+standard case.
+
 The complete suite must pass before release. The file-based conformance corpus
-contains 800 cases, including 386 focused ISO
+contains 802 cases, including 386 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 210 normal
@@ -7657,8 +7669,12 @@ strict boundary. The continuing issue #65 audit also enforces Part 1
 preparation constraints for `dynamic/1`, `multifile/1`, and `discontiguous/1`,
 keeps initialization tied to preparation of a program, tightens stream
 creation/position/EOF behavior and text-vs-binary permission errors, corrects
-Corrigendum 2 `keysort/2` error cases, and keeps the non-standard evaluable atom
-`e` outside strict mode. These are conformance improvements, while the
+Corrigendum 2 `keysort/2` error cases, closes the 5.5.6 Prolog-visible
+side-effect boundary by excluding statistics/cleanup extensions from strict
+mode, closes 5.5.10 by keeping the non-standard evaluable atom `e` outside
+strict mode, and pins the permitted arithmetic variation points for
+mixed-type Corrigendum 2 `max/2`/`min/2` plus signed Clause 9.4 bitwise and
+negative-shift behavior. These are conformance improvements, while the
 remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom

package/why-eyeprolog.md

@@ -19,13 +19,17 @@ syntax.
 
 EyeProlog targets the Part 1 core together with Technical Corrigenda 1, 2,
 and 3, and provides documented module and definite-clause-grammar compatibility
-profiles for normal-mode programs. The processor character model is explicitly
+profiles for normal-mode programs. The post-N289 WG17/STC working draft is
+tracked as audit input rather than silently treated as another published
+Corrigendum; the conformance ledger records where draft wording differs from
+the published strict baseline. The processor character model is explicitly
 implementation defined: EyeProlog uses Unicode scalar values as the PCS and as
 collating-sequence integers in both normal and strict profiles. Strict mode
 therefore rejects implementation-specific language extensions without changing
 that processor choice. Its executable conformance matrix and tests
 document the supported behavior, including an executable trace of the vendored
-active WG17 syntax cases. This is extensive implementation evidence, not a
+active WG17 syntax cases, cross-profile preservation of all strict-success WG17 syntax outcomes, closed strict side-effect and evaluable-functor extension boundaries, and explicit choices at standardized variation points such as mixed-type
+`max/2`/`min/2` and signed bitwise/shift operations. This is extensive implementation evidence, not a
 claim that every Part 1, Part 2, or Part 3 normative requirement has already
 been certified or closed.