eyeprolog 1.2.7 → 1.2.9

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 167 | 210 | 0 | 0 | 377 |
+| iso | 167 | 216 | 0 | 0 | 383 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **482** | **261** | **19** | **21** | **783** |
+| **Total** | **482** | **267** | **19** | **21** | **789** |

package/package.json

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

package/src/iso.js

@@ -1067,6 +1067,11 @@ function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;
 
+  // A quoted-token continuation escape consumes its newline. Accept CRLF as
+  // the host representation of the same line boundary.
+  if (escaped === '\n') return index + 1;
+  if (escaped === '\r' && source[index + 2] === '\n') return index + 2;
+
   // ISO 6.4.2.1 numeric escapes include a terminating backslash.  Consume
   // that delimiter as part of the quoted character so stream scanning does
   // not mistake it for an escape of the quote which follows.
@@ -1096,6 +1101,13 @@ function* termTextCandidates(stream) {
     if (blockComment) { if (ch === '*' && next === '/') { blockComment = false; i++; } continue; }
     if (quote) {
       if (ch === '\\') i = quotedEscapeEnd(source, i);
+      else if (ch !== ' ' && /^[\u0009-\u000d]$/.test(ch)) {
+        // Literal layout characters are not quoted characters (6.4.2.1).
+        // Surface the lexical error immediately even when there is no later
+        // full stop; otherwise read/1 would misreport malformed input as EOF.
+        yield { text: source.slice(stream.position, i + 1), end: i + 1, lexicalError: true };
+        return;
+      }
       else if (ch === quote && next === quote) i++;
       else if (ch === quote) quote = null;
       continue;
@@ -1140,6 +1152,10 @@ function readTermFromStream(stream, solver) {
     let sawCandidate = false;
     for (const candidate of termTextCandidates(stream)) {
       sawCandidate = true;
+      if (candidate.lexicalError) {
+        stream.position = candidate.end;
+        throw new PrologError('syntax_error(read_term)');
+      }
       try {
         const operatorState = createParserOperatorState(solver.program.operators.values(), false);
         const clauses = parseClauses(convertedTermText(candidate.text, solver), {

package/src/parser.js

@@ -285,29 +285,58 @@ class Parser {
       break;
     }
   }
-  readEscape(line) {
+  readEscape(line, options = {}) {
     const escaped = this.take();
     if (!escaped) throw new Error(`parse line ${line}: unterminated escape sequence`);
-    if (escaped === '\n') return '';
+
+    // ISO 6.4.2 permits a continuation escape only inside quoted tokens: a
+    // backslash immediately followed by a newline. Character-code constants
+    // use a single quoted character and therefore cannot use continuation.
+    if (escaped === '\n') {
+      if (options.allowContinuation !== false) return '';
+      throw new Error(`parse line ${line}: bad escape sequence`);
+    }
+    if (escaped === '\r' && this.peek() === '\n') {
+      if (options.allowContinuation !== false) {
+        this.take();
+        return '';
+      }
+      throw new Error(`parse line ${line}: bad escape sequence`);
+    }
+
     const controls = { a: '\x07', b: '\b', r: '\r', f: '\f', t: '\t', n: '\n', v: '\v' };
     if (controls[escaped] != null) return controls[escaped];
+
     if (escaped === 'x') {
       let digits = '';
       while (/^[0-9A-Fa-f]$/.test(this.peek())) digits += this.take();
       if (!digits || this.take() !== '\\') throw new Error(`parse line ${line}: bad hexadecimal escape`);
-      return String.fromCodePoint(Number.parseInt(digits, 16));
+      const code = Number.parseInt(digits, 16);
+      if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
+        throw new Error(`parse line ${line}: character escape out of range`);
+      }
+      return String.fromCodePoint(code);
     }
     if (/^[0-7]$/.test(escaped)) {
       let digits = escaped;
       while (/^[0-7]$/.test(this.peek())) digits += this.take();
       if (this.take() !== '\\') throw new Error(`parse line ${line}: bad octal escape`);
-      return String.fromCodePoint(Number.parseInt(digits, 8));
+      const code = Number.parseInt(digits, 8);
+      if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
+        throw new Error(`parse line ${line}: character escape out of range`);
+      }
+      return String.fromCodePoint(code);
     }
     // A backslash followed by a decimal digit is numeric-escape syntax, but
     // ISO octal digits are limited to 0..7.  Do not reinterpret \8 or \9 as
     // implementation-specific one-character escapes.
     if (/^[0-9]$/.test(escaped)) throw new Error(`parse line ${line}: bad octal escape`);
-    return escaped;
+
+    // The only remaining ISO meta escapes are the four meta characters from
+    // 6.5.5.  Forms such as \c, \d, \e, \u or \. are not quoted
+    // characters in ISO syntax and must not be silently accepted.
+    if (escaped === '\\' || escaped === "'" || escaped === '"' || escaped === '`') return escaped;
+    throw new Error(`parse line ${line}: bad escape sequence`);
   }
   nextToken() {
     // The tokenizer keeps just enough state for useful parse-line errors and
@@ -373,6 +402,11 @@ class Parser {
           }
         } else if (value === '\\' && this.peek()) {
           value = this.readEscape(line);
+        } else if (value !== ' ' && isWhitespaceCode(value.charCodeAt(0))) {
+          // ISO 6.4.2.1 allows an ordinary space in a quoted character, but
+          // not literal layout characters such as tab or newline. Newlines
+          // are permitted only through the continuation escape handled above.
+          throw new Error(`parse line ${line}: layout character in quoted term`);
         }
         text += value;
       }
@@ -398,8 +432,10 @@ class Parser {
         this.take();
         this.take();
         let value = this.take();
-        if (!value || value === '\n') throw new Error(`parse line ${line}: bad character code constant`);
-        if (value === '\\') value = this.readEscape(line);
+        if (!value || (value !== ' ' && isWhitespaceCode(value.charCodeAt(0)))) {
+          throw new Error(`parse line ${line}: bad character code constant`);
+        }
+        if (value === '\\') value = this.readEscape(line, { allowContinuation: false });
         const code = value.codePointAt(0);
         return { type: TOK.NUMBER, text: String(negative ? -code : code), line };
       }

package/src/repl.js

@@ -338,6 +338,12 @@ function quotedEscapeEnd(source, index) {
   const escaped = source[index + 1] ?? '';
   if (!escaped) return index;
 
+  // A backslash-newline pair is a continuation escape (6.4.2), so the
+  // newline is not a literal quoted character. Accept CRLF as the host text
+  // representation of the same continuation boundary.
+  if (escaped === '\n') return index + 1;
+  if (escaped === '\r' && source[index + 2] === '\n') return index + 2;
+
   // ISO 6.4.2.1 octal and hexadecimal escapes are terminated by a
   // backslash.  Consume that terminator as part of the escape so the REPL
   // scanner does not mistake it for an escape of the following quote.
@@ -383,6 +389,12 @@ function terminalFullStop(source) {
     if (quote != null) {
       if (ch === '\\') {
         i = quotedEscapeEnd(source, i);
+      } else if (ch === '\n' || ch === '\r') {
+        // A literal newline can never be repaired by a later line: ISO
+        // 6.4.2.1 excludes it from quoted characters. Return this boundary
+        // immediately so the parser reports a syntax error instead of the
+        // top level prompting forever for a closing quote.
+        return i;
       } else if (ch === quote) {
         if (next === quote) i++;
         else quote = null;

package/src/solver.js

@@ -47,7 +47,10 @@ export class Solver {
     this.maxInferences = options.maxInferences ?? Infinity;
     this.inferences = 0;
     this.inferenceLimitExceeded = false;
-    this.solutionLimit = options.solutionLimit ?? 10000000;
+    // Do not impose an implicit answer cap. Infinite and very large searches are
+    // part of normal Prolog semantics; callers that need a resource bound can
+    // still supply solutionLimit explicitly.
+    this.solutionLimit = options.solutionLimit ?? Infinity;
     this.solutionsSeen = 0;
     this.prologFlags = options.prologFlags ?? defaultPrologFlags('error', this.isoStrict);
     if (this.isoStrict) {

package/src/write.js

@@ -7,6 +7,23 @@ import {
 const graphicAtomCharacters = new Set('!#$&*+-/<=>@^~\\'.split(''));
 const compactInfixOperators = new Set([':', '..']);
 
+function quotedControlEscape(ch) {
+  if (ch === '\x00') return '\\0\\';
+  if (ch === '\x07') return '\\a';
+  if (ch === '\b') return '\\b';
+  if (ch === '\r') return '\\r';
+  if (ch === '\f') return '\\f';
+  if (ch === '\t') return '\\t';
+  if (ch === '\n') return '\\n';
+  if (ch === '\v') return '\\v';
+  const code = ch.codePointAt(0);
+  // Other C0 controls and DEL have no ISO symbolic-control escape. Emit an
+  // octal escape so quoted output remains valid read-back syntax instead of
+  // leaking a raw control character into the output stream.
+  if (code < 0x20 || code === 0x7f) return `\\${code.toString(8)}\\`;
+  return null;
+}
+
 function atomNeedsQuotes(name) {
   if (!name) return true;
   if (name === '[]' || name === '{}') return false;
@@ -22,15 +39,7 @@ function quoteAtom(name) {
   for (const ch of name) {
     if (ch === "'") out += "''";
     else if (ch === '\\') out += '\\\\';
-    else if (ch === '\x00') out += '\\0\\';
-    else if (ch === '\x07') out += '\\a';
-    else if (ch === '\b') out += '\\b';
-    else if (ch === '\r') out += '\\r';
-    else if (ch === '\f') out += '\\f';
-    else if (ch === '\t') out += '\\t';
-    else if (ch === '\n') out += '\\n';
-    else if (ch === '\v') out += '\\v';
-    else out += ch;
+    else out += quotedControlEscape(ch) ?? ch;
   }
   return out + "'";
 }
@@ -60,15 +69,7 @@ function writeString(value) {
   let out = '"';
   for (const ch of value) {
     if (ch === '"' || ch === '\\') out += `\\${ch}`;
-    else if (ch === '\x00') out += '\\0\\';
-    else if (ch === '\x07') out += '\\a';
-    else if (ch === '\b') out += '\\b';
-    else if (ch === '\r') out += '\\r';
-    else if (ch === '\f') out += '\\f';
-    else if (ch === '\t') out += '\\t';
-    else if (ch === '\n') out += '\\n';
-    else if (ch === '\v') out += '\\v';
-    else out += ch;
+    else out += quotedControlEscape(ch) ?? ch;
   }
   return out + '"';
 }

package/test/conformance/ISO-COMPLIANCE.md

@@ -30,7 +30,7 @@ error-ordering alternative to an individual executable assertion.
 
 | Standard area | Status | Current evidence |
 | --- | --- | --- |
-| Clause 6 — tokens, terms, lists, operators, quoted text | audit | `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, `wg17_syntax_high_risk`, writer/read-back regressions. |
+| Clause 6 — tokens, terms, lists, operators, quoted text | audit | `lexical_and_curly_terms`, `scryer_lexical_terms`, operator suites, syntax-error cases, `wg17_syntax_high_risk`, quoted-layout/escape error cases, writer/read-back regressions. |
 | 7.1-7.3 — term types, term order, unification | audit | Standard-order, identity, finite-tree and occurs-check suites, Corrigendum 2 term predicates. |
 | 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. Cross-text `multifile/1` and ordering constraints require explicit shall-by-shall audit. |
 | 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. Public/private and multi-text requirements still need complete mapping. |

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 | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, syntax error cases |
+| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments | `scryer_lexical_terms`, `lexical_and_curly_terms`, `double_quoted_lists`, `corrigendum1_double_quote_operator`, `wg17_syntax_high_risk`, `wg17_invalid_octal_escape`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, syntax error cases |
 | Clause 7 term order and unification | finite-tree unification, identity, standard order, errors | `unification_control_information`, `swipl_occurs_check`, `term_modes_and_ordering`, `logtalk_compare_standard_order` |
 | Clause 7 control and exceptions | call, cut, conjunction, disjunction, if-then-else, catch and throw | `cut_control`, `control_and_terms`, `exceptions_and_flags`, `corrigenda_catch_callability`, `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 |

package/test/conformance/README.md

@@ -102,7 +102,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 377 cases in `iso/` and 783 file-based conformance cases in
+The corpus has 383 cases in `iso/` and 789 file-based conformance cases in
 total. The generated `conformance-report.md` is the authoritative source for
 current category totals. Together with regression, documentation-sync, API,
 example, and book-example checks, `npm test` is the release gate.

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

@@ -85,3 +85,14 @@ numeric_escape_term_input(ok) :-
     A == '\a',
     B == '\a'.
 
+
+%% goal: malformed_quoted_term_input(ok)
+
+malformed_quoted_term_input(ok) :-
+    open('/tmp/eyeprolog-iso-bad-quoted-term.txt', write, Output, []),
+    put_code(Output, 39), nl(Output),
+    close(Output),
+    open('/tmp/eyeprolog-iso-bad-quoted-term.txt', read, Input, []),
+    catch(read(Input, _), error(syntax_error(read_term), _), Caught = yes),
+    close(Input),
+    Caught == yes.

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

@@ -1,6 +1,6 @@
 % High-risk ISO syntax/write regressions, independently derived from
 % ISO/IEC 13211-1 clauses 6.3, 6.4 and 7.10 and cross-checked against the
-% public WG17 conformity-testing syntax cases (#1, #14-15, #28-31, #33-34, #301).
+% public WG17 conformity-testing syntax cases (#1, #7-10, #14-15, #18, #28-31, #33-34, #301, #315-316).
 
 %% goal: wg17_numeric_escape
 wg17_numeric_escape :-
@@ -28,3 +28,18 @@ wg17_canonical_list :-
 %% goal: wg17_zero_character_escape
 wg17_zero_character_escape :-
     writeq('\0\'), nl.
+
+%% goal: wg17_continuation_escapes
+wg17_continuation_escapes :-
+    writeq('\
+'), nl,
+    writeq('\
+a'), nl,
+    writeq('a\
+b'), nl,
+    writeq('a\
+ b'), nl.
+
+%% goal: wg17_non_symbolic_control_write
+wg17_non_symbolic_control_write :-
+    writeq('\033\'), nl.

package/test/conformance/cases/strings/trim_tabs_and_spaces.pl

@@ -1,4 +1,3 @@
 %% goal: answer(X0)
 
-answer(X) :- trim('	 hello 
-', X).
+answer(X) :- trim('\t hello \n', X).

package/test/conformance/cases/syntax/quoted_atom_with_newline_escape.pl

@@ -1,4 +1,3 @@
 %% goal: answer(X0)
 
-answer('line
-break').
+answer('line\nbreak').

package/test/conformance/cases/syntax/string_with_tab_escape.pl

@@ -1,3 +1,3 @@
 %% goal: answer(X0)
 
-answer("a	b").
+answer("a\tb").

package/test/conformance/errors/iso/wg17_bad_character_code_escape.pl

@@ -0,0 +1 @@
+bad :- X = 0'\..

package/test/conformance/errors/iso/wg17_literal_newline_in_quote.pl

@@ -0,0 +1,2 @@
+writeq('
+').

package/test/conformance/errors/iso/wg17_literal_tab_in_quote.pl

@@ -0,0 +1 @@
+writeq('	').

package/test/conformance/errors/iso/wg17_non_iso_escape.pl

@@ -0,0 +1 @@
+writeq('\e').

package/test/conformance/errors/iso/wg17_non_iso_unicode_escape.pl

@@ -0,0 +1 @@
+writeq('\u0021').

package/test/conformance/errors/iso/wg17_unterminated_quoted_token.pl

@@ -0,0 +1 @@
+'

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

@@ -5,3 +5,4 @@ default_streams(ok).
 io_marker
 standard_write(ok).
 numeric_escape_term_input(ok).
+malformed_quoted_term_input(ok).

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

@@ -13,3 +13,10 @@ wg17_operator_precedence.
 wg17_canonical_list.
 '\0\'
 wg17_zero_character_escape.
+''
+a
+ab
+'a b'
+wg17_continuation_escapes.
+'\33\'
+wg17_non_symbolic_control_write.

package/test/conformance/expected-errors/iso/wg17_bad_character_code_escape.txt

@@ -0,0 +1 @@
+parse line 1: bad escape sequence

package/test/conformance/expected-errors/iso/wg17_literal_newline_in_quote.txt

@@ -0,0 +1 @@
+parse line 1: layout character in quoted term

package/test/conformance/expected-errors/iso/wg17_literal_tab_in_quote.txt

@@ -0,0 +1 @@
+parse line 1: layout character in quoted term

package/test/conformance/expected-errors/iso/wg17_non_iso_escape.txt

@@ -0,0 +1 @@
+parse line 1: bad escape sequence

package/test/conformance/expected-errors/iso/wg17_non_iso_unicode_escape.txt

@@ -0,0 +1 @@
+parse line 1: bad escape sequence

package/test/conformance/expected-errors/iso/wg17_unterminated_quoted_token.txt

@@ -0,0 +1 @@
+parse line 1: layout character in quoted term

package/test/conformance/expected-errors/syntax/unclosed_quoted_atom.txt

@@ -1 +1 @@
-parse line 1: unterminated quoted term
+parse line 1: layout character in quoted term

package/test/conformance/expected-errors/syntax/unclosed_quoted_atom_rejected.txt

@@ -1 +1 @@
-parse line 1: unterminated quoted term
+parse line 1: layout character in quoted term

package/test/conformance/expected-errors/syntax/unclosed_string.txt

@@ -1 +1 @@
-parse line 1: unterminated quoted term
+parse line 1: layout character in quoted term

package/test/run-regression.mjs

@@ -696,6 +696,127 @@ c4 ?- call((!;1)).
         assertEqual(result.stderr, '', 'stderr');
       },
     },
+    {
+      name: 'REPL rejects an unterminated quote at the line boundary instead of waiting',
+      run: () => {
+        const result = runCli([], {
+          input: "'\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    parse line 1: unterminated quoted term.\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'REPL rejects a literal newline in a quoted token immediately',
+      run: () => {
+        const result = runCli([], {
+          // The first input line ends while a quote is open. ISO 6.4.2.1
+          // makes that newline a lexical error unless it is escaped by the
+          // immediately preceding backslash. The following true/0 proves
+          // that the top level did not consume another line as continuation.
+          input: "writeq('\ntrue.\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout,
+          '?-    parse line 1: unterminated quoted term.\n' +
+          '?-    true.\n' +
+          '?- ',
+          'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
+    {
+      name: 'parser matches WG17 quoted-character and escape syntax cluster',
+      run: () => {
+        const invalid = [
+          ['#2 lone quote', "'\n"],
+          ['#5 literal horizontal tab', "writeq('\t')"],
+          ['#6 literal newline', "writeq('\n')"],
+          ['#11 backslash-space', String.raw`writeq('\ ')`],
+          ['#12 backslash-horizontal-tab', "writeq('\\\t')"],
+          ['#16 non-ISO c escape', String.raw`writeq('\ca')`],
+          ['#241 non-ISO d escape', String.raw`writeq('\d')`],
+          ['#17 non-ISO e escape', String.raw`writeq('\e')`],
+          ['#19 non-ISO e in char_code/2', String.raw`char_code('\e', C)`],
+          ['#21 non-ISO d in char_code/2', String.raw`char_code('\d', C)`],
+          ['#22 non-ISO u escape', String.raw`writeq('\u1')`],
+          ['#312 non-ISO Unicode escape', String.raw`writeq('\u0021')`],
+          ['#314 non-ISO Unicode double-quote escape', String.raw`writeq("\u0021")`],
+          ['#23 non-ISO character-code escape', String.raw`X = 0'\u1`],
+          ['#24 unterminated quoted argument', "writeq('\n"],
+          ['#26 continuation followed by unterminated quote', "'\\\n''"],
+          ['#210 escaped dot character code', String.raw`X = 0'\.`],
+          ['#211 escaped dot character code before layout', String.raw`X = 0'\. `],
+        ];
+        for (const [label, source] of invalid) {
+          let error = null;
+          try {
+            parseGoalText(source);
+          } catch (caught) {
+            error = caught;
+          }
+          if (error == null) throw new Error(`${label} unexpectedly parsed`);
+        }
+
+        const valid = [
+          ['#7 empty continuation', "writeq('\\\n')"],
+          ['#8 leading continuation', "writeq('\\\na')"],
+          ['#9 embedded continuation', "writeq('a\\\nb')"],
+          ['#10 continuation before space', "writeq('a\\\n b')"],
+          ['#13 symbolic tab', String.raw`writeq('\t')`],
+          ['#14 symbolic alert', String.raw`writeq('\a')`],
+          ['#15 octal alert', String.raw`writeq('\7\')`],
+          ['#18 octal escape', String.raw`writeq('\033\')`],
+          ['#301 NUL escape', String.raw`writeq('\0\')`],
+          ['#315 hexadecimal escape', String.raw`writeq('\x21\')`],
+          ['#316 padded hexadecimal escape', String.raw`writeq('\x0021\')`],
+          ['#38 double-quoted meta escapes', "\"\\'\\`\\\"\" = \"'`\"\"\""],
+          ['#39 single-quoted meta escapes', "'\\'\\`\\\"' = '''`\"'"],
+          ['#40 writeq meta escapes', "writeq('\\'\\`\\\"\\\"')"],
+          ['#41 meta backslash escape', String.raw`('\\') = (\)`],
+        ];
+        for (const [label, source] of valid) {
+          try {
+            parseGoalText(source);
+          } catch (error) {
+            throw new Error(`${label} should parse: ${error?.message ?? error}`);
+          }
+        }
+      },
+    },
+    {
+      name: 'stream term input reports malformed quoted layout as syntax_error',
+      run: () => {
+        for (const [label, input] of [
+          ['lone quote', "'\n"],
+          ['literal newline', "writeq('\n').\n"],
+          ['literal tab', "writeq('\t').\n"],
+        ]) {
+          let error = null;
+          try {
+            runEyeProlog('', { goal: 'read(X)', ioOptions: { input } });
+          } catch (caught) {
+            error = caught;
+          }
+          assertEqual(error?.message, 'error(syntax_error(read_term))', `${label} read error`);
+        }
+      },
+    },
+    {
+      name: 'writeq uses ISO numeric escapes for non-symbolic control characters',
+      run: () => {
+        const result = runCli([], {
+          input: "writeq('\\033\\').\nhalt.\n",
+        });
+        assertEqual(result.status, 0, 'exit status');
+        assertEqual(result.stdout, "?- '\\33\\'   true.\n?- ", 'stdout');
+        assertEqual(result.stderr, '', 'stderr');
+      },
+    },
     {
       name: 'REPL read predicates consume following interactive term input',
       run: () => {
@@ -1942,6 +2063,21 @@ open(X) :- candidate(X), \\+ closed(X).
         assertEqual(answers.join('\n'), 'p(a)\np(b)', 'answers');
       },
     },
+    {
+      name: 'solver has no implicit solution limit',
+      run: () => {
+        const program = Program.parse('p(a).\n');
+        const solver = new Solver(program);
+        assertEqual(String(solver.solutionLimit), 'Infinity', 'default solution limit');
+        // Crossing the former 10,000,000-answer ceiling must not make an
+        // otherwise available answer disappear. This exercises the boundary
+        // without making the regression suite enumerate ten million answers.
+        solver.solutionsSeen = 10_000_000;
+        const goal = parseGoalText('p(X)');
+        const answers = [...solver.solve([goal], new Env(), 0)].map((env) => termToString(goal, env, true));
+        assertEqual(answers.join('\n'), 'p(a)', 'answer beyond former default ceiling');
+      },
+    },
     {
       name: 'solver honors solution limits',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -1805,7 +1805,13 @@ const solver = new Solver(program, {
 ```
 
 The limits are safety ceilings, not logical declarations. Reaching one may
-truncate search; it does not prove that no further answer exists.
+truncate search; it does not prove that no further answer exists. At the `Solver`
+API boundary, `solutionLimit` is opt-in: if it is omitted, ordinary solving and
+child searches that inherit the solver limit do not stop after a fixed number of
+solutions. This matters for re-executable goals such as `repeat/0` and for
+library relations such as `call_nth/2`; an implementation safety threshold must
+not turn a still re-executable search into logical failure. Embedders that need
+a finite answer budget should pass `solutionLimit` explicitly.
 
 ### Implementation boundary
 
@@ -5276,17 +5282,27 @@ city('München').
 message("café").
 ```
 
-Inside a quoted atom, a single quote is doubled: `'don''t'`. Quoted characters
-support the ISO symbolic control escapes such as `\a`, `\n`, and `\t`, and numeric
-octal or hexadecimal escapes are terminated by a backslash; for example, `'\7\'`
-and `'\x7\'` both denote the alert character. The NUL character, when present in
-the processor character set, is written readably as `'\0\'`; digits `8` and `9`
-are not octal digits, so forms such as `'\8\'` are syntax errors rather than
-continuation input. Double-quoted lists use the same
-quoted-character escapes. Whitespace is insignificant
-between tokens, and a `%` comment continues to the end of its line. Doubling
-the active delimiter is also accepted inside either quoted form, so `""`
-inside double-quoted notation denotes one literal double quote character.
+Inside a quoted atom, a single quote is doubled: `'don''t'`. EyeProlog follows
+the ISO quoted-character grammar rather than accepting arbitrary backslash
+escapes. The symbolic control escapes are `\a`, `\b`, `\r`, `\f`, `\t`,
+`\n`, and `\v`; the meta characters backslash, single quote, double quote, and
+back quote may be escaped after a backslash; and numeric octal or hexadecimal
+escapes are terminated by a backslash. For example, `'\7\'` and `'\x7\'`
+both denote the alert character. Forms such as `\c`, `\d`, `\e`, `\u`, `\.`
+and `\ ` are not ISO quoted-character escapes and are syntax errors.
+
+A literal layout character other than ordinary space is not a quoted
+character. In particular, a literal tab or newline inside quotes is a syntax
+error. A quoted token can cross a line boundary only through a continuation
+escape: a backslash immediately followed by the newline, which contributes no
+character to the atom. The NUL character is written readably as `'\0\'`;
+digits `8` and `9` are not octal digits, so forms such as `'\8\'` are syntax
+errors. `writeq/1` uses octal escapes for other non-symbolic control characters,
+for example ESC is written as `'\33\'`. Double-quoted lists use the same
+quoted-character rules. Whitespace is insignificant between tokens, and a `%`
+comment continues to the end of its line. Doubling the active delimiter is
+also accepted inside either quoted form, so `""` inside double-quoted notation
+denotes one literal double quote character.
 
 Graphic atoms may contain `#$&*+-/<=>@^~\;`. A colon is the Part 2 module
 qualification operator in `Module:Goal`; quote an atom whose name itself
@@ -6959,7 +6975,7 @@ precedence still need one-by-one closure. `test/conformance/ISO-MATRIX.md`
 maps language families to representative executable cases.
 
 The complete suite must pass before release. The file-based conformance corpus
-contains 783 cases, including 377 focused ISO
+contains 789 cases, including 383 focused ISO
 cases derived from the success, failure, mode, and error behavior in
 ISO/IEC 13211-1 clauses 7 and 8, Part 2 modules, and Part 3 grammar rules.
 Separate exact-output suites check 189 normal