eyeprolog 1.3.42 → 1.3.44

package/README.md

@@ -210,6 +210,21 @@ expansion/`phrase/2-3`; it also removes the EyeProlog `occurs_check` flag,
 Normal mode is unchanged and continues to support modules, DCGs, quads,
 libraries, proofs, cleanup-aware control, and the other documented extensions.
 
+Strict mode also makes the Part 1 processor-character-set choice explicit: its
+PCS is 7-bit ASCII (U+0000..U+007F), C0 controls and DEL are classified as
+extended layout characters, and the collating-sequence integer of each
+character is its ASCII code. Characters or character codes outside that set
+raise representation errors in strict parsing and character operations. Normal
+mode retains Unicode scalar character data as an implementation-specific
+extension.
+
+Strict term I/O likewise keeps the standardized option boundary: `read_term/2-3`
+and `write_term/2-3` accept the Part 1 plus Corrigendum 3 options, while the
+normal-profile `write_term(...,[double_quotes(...)])` option remains an
+EyeProlog extension. The strict gate also checks the prescribed ISO error
+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 auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).
 The ISO 5.4 implementation-defined/implementation-specific decision index is

package/package.json

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

package/src/iso-character.js

@@ -0,0 +1,37 @@
+// ISO/IEC 13211-1 processor-character-set choices used by --iso-strict.
+//
+// EyeProlog's strict Part 1 profile deliberately chooses a finite PCS so every
+// accepted character has one documented lexical classification and one stable
+// collating-sequence integer. Normal mode keeps the broader Unicode surface as
+// an implementation-specific extension.
+
+export class CharacterRepresentationError extends Error {
+  constructor(formal = 'representation_error(character)') {
+    super(`error(${formal})`);
+    this.name = 'CharacterRepresentationError';
+    this.formal = formal;
+  }
+}
+
+// Strict PCS: the 128 ASCII characters U+0000..U+007F. Printable ASCII
+// carries the Part 1 lexical classes; the remaining C0 controls plus DEL are
+// implementation-defined extended layout characters. This lets every ISO
+// octal/hexadecimal character escape in the ASCII range denote a PCS member.
+// The collating-sequence integer is the Unicode/ASCII code point.
+export function isStrictIsoPcsCodePoint(code) {
+  return Number.isInteger(code) && code >= 0 && code <= 0x7f;
+}
+
+export function isStrictIsoPcsCharacter(character) {
+  if (typeof character !== 'string' || Array.from(character).length !== 1) return false;
+  return isStrictIsoPcsCodePoint(character.codePointAt(0));
+}
+
+export function strictIsoCollatingInteger(character) {
+  return isStrictIsoPcsCharacter(character) ? character.codePointAt(0) : null;
+}
+
+export function assertStrictIsoPcsCharacter(character, formal = 'representation_error(character)') {
+  if (!isStrictIsoPcsCharacter(character)) throw new CharacterRepresentationError(formal);
+  return character;
+}

package/src/iso.js

@@ -13,6 +13,7 @@ import {
 import { formatTermForWrite } from './write.js';
 import { emptyTerminalSequence, expandDcgBody, isListOrPartialList, validateDcgEmbeddedGoals } from './dcg.js';
 import { INVALID_UTF8_SENTINEL } from './io.js';
+import { CharacterRepresentationError, isStrictIsoPcsCharacter, isStrictIsoPcsCodePoint } from './iso-character.js';
 import {
   characterCodeConstantEnd, continuesGraphicToken, isTerminatingFullStop, quotedEscapeEnd,
 } from './syntax-scan.js';
@@ -689,44 +690,49 @@ function* setPrologFlagBuiltin({ solver, goal, env }) {
 
 const operatorSpecifiers = new Set(['fx', 'fy', 'xf', 'yf', 'xfx', 'xfy', 'yfx']);
 
-function operatorPriority(term, env) {
+function opListPreflight(term, env) {
   const value = deref(term, env);
   if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
-  const priority = BigInt(value.name);
-  if (priority < 0n || priority > 1200n) throw new PrologError('domain_error(operator_priority)', value);
-  return Number(priority);
+  if (value.type === ATOM) return { value, items: [value], proper: true, atom: true };
+  const { items, tail } = listElements(value, env);
+  if (tail.type === VAR || items.some((item) => item.type === VAR)) {
+    throw new PrologError('instantiation_error');
+  }
+  const proper = tail.type === ATOM && tail.name === '[]';
+  return { value, items, proper, atom: false };
 }
 
-function operatorSpecifier(term, env) {
-  const value = deref(term, env);
-  if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type !== ATOM) throw new PrologError('type_error(atom)', value);
-  if (!operatorSpecifiers.has(value.name)) throw new PrologError('domain_error(operator_specifier)', value);
-  return value.name;
-}
+function* opBuiltin({ solver, goal, env }) {
+  const priorityTerm = deref(goal.args[0], env);
+  const specifierTerm = deref(goal.args[1], env);
 
-function operatorNames(term, env) {
-  const value = deref(term, env);
-  if (value.type === VAR) throw new PrologError('instantiation_error');
-  if (value.type === ATOM) return [value];
-  const items = properListItems(value, env);
-  if (items == null) {
-    if (isPartialList(value, env)) throw new PrologError('instantiation_error');
-    throw new PrologError('type_error(list)', value);
+  // ISO 8.14.3.3 prescribes the ordering below.  In particular, all three
+  // instantiation cases precede type/domain errors, and Operator list-shape
+  // errors precede priority/specifier domain errors.
+  if (priorityTerm.type === VAR) throw new PrologError('instantiation_error');
+  if (specifierTerm.type === VAR) throw new PrologError('instantiation_error');
+  const operator = opListPreflight(goal.args[2], env);
+
+  if (priorityTerm.type !== NUMBER || !isDecimalInteger(priorityTerm.name)) {
+    throw new PrologError('type_error(integer)', priorityTerm);
   }
-  for (const item of items) {
-    const resolved = deref(item, env);
-    if (resolved.type === VAR) throw new PrologError('instantiation_error');
-    if (resolved.type !== ATOM) throw new PrologError('type_error(atom)', resolved);
+  if (specifierTerm.type !== ATOM) throw new PrologError('type_error(atom)', specifierTerm);
+  if (!operator.atom && !operator.proper) throw new PrologError('type_error(list)', operator.value);
+  for (const item of operator.items) {
+    if (item.type !== ATOM) throw new PrologError('type_error(atom)', item);
   }
-  return items.map((item) => deref(item, env));
-}
 
-function* opBuiltin({ solver, goal, env }) {
-  const priority = operatorPriority(goal.args[0], env);
-  const specifier = operatorSpecifier(goal.args[1], env);
-  for (const name of operatorNames(goal.args[2], env)) {
+  const priorityBig = BigInt(priorityTerm.name);
+  if (priorityBig < 0n || priorityBig > 1200n) {
+    throw new PrologError('domain_error(operator_priority)', priorityTerm);
+  }
+  if (!operatorSpecifiers.has(specifierTerm.name)) {
+    throw new PrologError('domain_error(operator_specifier)', specifierTerm);
+  }
+
+  const priority = Number(priorityBig);
+  const specifier = specifierTerm.name;
+  for (const name of operator.items) {
     if (name.name === ',') {
       throw new PrologError('permission_error(modify, operator)', name);
     }
@@ -754,19 +760,16 @@ function* currentOpBuiltin({ solver, goal, env }) {
   const priority = deref(goal.args[0], env);
   const specifier = deref(goal.args[1], env);
   const name = deref(goal.args[2], env);
-  if (priority.type !== VAR) {
-    if (priority.type !== NUMBER || !isDecimalInteger(priority.name)) {
-      throw new PrologError('type_error(integer)', priority);
-    }
-    if (BigInt(priority.name) < 0n || BigInt(priority.name) > 1200n) {
-      throw new PrologError('domain_error(operator_priority)', priority);
-    }
+  // ISO 8.14.4.3 defines the first two argument errors by domain, not by
+  // their underlying atom/integer representation type.
+  if (priority.type !== VAR &&
+      (priority.type !== NUMBER || !isDecimalInteger(priority.name) ||
+       BigInt(priority.name) < 0n || BigInt(priority.name) > 1200n)) {
+    throw new PrologError('domain_error(operator_priority)', priority);
   }
-  if (specifier.type !== VAR) {
-    if (specifier.type !== ATOM) throw new PrologError('type_error(atom)', specifier);
-    if (!operatorSpecifiers.has(specifier.name)) {
-      throw new PrologError('domain_error(operator_specifier)', specifier);
-    }
+  if (specifier.type !== VAR &&
+      (specifier.type !== ATOM || !operatorSpecifiers.has(specifier.name))) {
+    throw new PrologError('domain_error(operator_specifier)', specifier);
   }
   if (name.type !== VAR && name.type !== ATOM) throw new PrologError('type_error(atom)', name);
   for (const definition of solver.program.operators.values()) {
@@ -777,7 +780,7 @@ function* currentOpBuiltin({ solver, goal, env }) {
   }
 }
 
-function conversionCharacter(term, env, current = false) {
+function conversionCharacter(term, env, current = false, solver = null) {
   const value = deref(term, env);
   if (value.type === VAR) {
     if (current) return value;
@@ -787,18 +790,21 @@ function conversionCharacter(term, env, current = false) {
     if (current) throw new PrologError('type_error(character)', value);
     throw new PrologError('representation_error(character)');
   }
+  if (solver?.isoStrict && !isStrictIsoPcsCharacter(value.name)) {
+    throw new PrologError('representation_error(character)', value);
+  }
   return value;
 }
 function* charConversionBuiltin({ solver, goal, env }) {
-  const input = conversionCharacter(goal.args[0], env);
-  const output = conversionCharacter(goal.args[1], env);
+  const input = conversionCharacter(goal.args[0], env, false, solver);
+  const output = conversionCharacter(goal.args[1], env, false, solver);
   if (input.name === output.name) solver.charConversions.delete(input.name);
   else solver.charConversions.set(input.name, output.name);
   yield env;
 }
 function* currentCharConversionBuiltin({ solver, goal, env }) {
-  const input = conversionCharacter(goal.args[0], env, true);
-  const output = conversionCharacter(goal.args[1], env, true);
+  const input = conversionCharacter(goal.args[0], env, true, solver);
+  const output = conversionCharacter(goal.args[1], env, true, solver);
   for (const [from, to] of [...solver.charConversions]) {
     const next = env.clone();
     if (unify(input, atom(from), next) && unify(output, atom(to), next)) yield next;
@@ -845,6 +851,28 @@ function optionList(term, env) {
   return items.map((item) => deref(item, env));
 }
 
+// read_term/3 and write_term/3 have prescribed error ordering in ISO 8.14.
+// In particular, a partial option list (or a variable option element) is
+// diagnosed before several stream errors, while the relative order of a
+// non-list Options term and an invalid stream-or-alias differs between the
+// read and write predicates.  Split list-shape inspection from full option
+// validation so those predicates can follow the standard order exactly.
+function preflightOptionList(term, env) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  const { items, tail } = listElements(value, env);
+  if (tail.type === VAR || items.some((item) => item.type === VAR)) {
+    throw new PrologError('instantiation_error');
+  }
+  const proper = tail.type === ATOM && tail.name === '[]';
+  return { value, items, proper };
+}
+
+function requireProperOptionList(preflight) {
+  if (!preflight.proper) throw new PrologError('type_error(list)', preflight.value);
+  return preflight.items;
+}
+
 function optionAtom(option, name) {
   if (option.type !== COMPOUND || option.name !== name || option.arity !== 1) return null;
   return option.args[0];
@@ -1044,6 +1072,9 @@ function inputUnitBuiltin(name) {
       throw error;
     }
     if (unit == null && !peek) stream.pastEnd = true;
+    if (!binary && unit != null && solver.isoStrict && !isStrictIsoPcsCharacter(unit)) {
+      throw new PrologError('representation_error(character)');
+    }
     const result = unit == null ? (binary ? numberTerm(-1) : name.endsWith('code') ? numberTerm(-1) : atom('end_of_file'))
       : binary ? numberTerm(unit) : name.endsWith('code') ? numberTerm(unit.codePointAt(0)) : atom(unit);
     const target = goal.args[goal.arity - 1];
@@ -1059,6 +1090,9 @@ function outputUnitBuiltin(name) {
     if (name === 'put_char') {
       if (stream.type !== 'text') throw new PrologError('permission_error(output, binary_stream)', streamHandle(stream.id));
       if (!oneChar(value)) throw new PrologError('type_error(character)', value);
+      if (solver.isoStrict && !isStrictIsoPcsCharacter(value.name)) {
+        throw new PrologError('representation_error(character)', value);
+      }
       solver.io.writeUnit(stream, value.name);
     } else {
       if ((name === 'put_byte') !== (stream.type === 'binary')) {
@@ -1068,6 +1102,9 @@ function outputUnitBuiltin(name) {
       const code = BigInt(value.name);
       const max = name === 'put_byte' ? 255n : 0x10ffffn;
       if (code < 0n || code > max) throw new PrologError(name === 'put_byte' ? 'type_error(byte)' : 'representation_error(character_code)');
+      if (name === 'put_code' && solver.isoStrict && !isStrictIsoPcsCodePoint(Number(code))) {
+        throw new PrologError('representation_error(character_code)');
+      }
       solver.io.writeUnit(stream, name === 'put_byte' ? Number(code) : String.fromCodePoint(Number(code)));
     }
     yield env;
@@ -1095,6 +1132,9 @@ function* termTextCandidates(stream, solver) {
   let quote = null, lineComment = false, blockComment = false;
   for (let i = stream.position; i < source.length; i++) {
     const ch = source[i], next = source[i + 1];
+    if (solver.isoStrict && !isStrictIsoPcsCodePoint(ch.charCodeAt(0))) {
+      throw new PrologError('representation_error(character)');
+    }
     // Text streams preserve invalid UTF-8 bytes as an impossible Unicode
     // sentinel.  read/1-2 and read_term/2-3 must surface the same character
     // representation error as get_char/1-2 instead of misclassifying the
@@ -1106,7 +1146,7 @@ function* termTextCandidates(stream, solver) {
     if (blockComment) { if (ch === '*' && next === '/') { blockComment = false; i++; } continue; }
     if (quote) {
       if (ch === '\\') i = quotedEscapeEnd(source, i);
-      else if (ch !== ' ' && /^[\u0009-\u000d]$/.test(ch)) {
+      else if (ch !== ' ' && /^[\u0000-\u001f\u007f]$/.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.
@@ -1137,7 +1177,7 @@ function hasNonLayoutRemainder(source, start) {
   return lastNonLayoutIndex(source, start) >= start;
 }
 function lastNonLayoutIndex(source, start = 0) {
-  const ignored = /[\u0009-\u000d\u0020]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g;
+  const ignored = /[\u0000-\u0020\u007f]+|%[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\//g;
   ignored.lastIndex = start;
   let cursor = start;
   let last = -1;
@@ -1248,7 +1288,9 @@ function readTermFromStream(stream, solver) {
         stream.position = candidate.end;
         return scopeReadTerm(term);
       } catch (error) {
-        if (error instanceof NumberRepresentationError) throw new PrologError(error.formal);
+        if (error instanceof NumberRepresentationError || error instanceof CharacterRepresentationError) {
+          throw new PrologError(error.formal);
+        }
         // A dot inside a graphic operator, such as =.., is only a possible
         // terminator. Keep scanning until a complete term parses.
       }
@@ -1288,17 +1330,38 @@ function* readBuiltin({ solver, goal, env }) {
   const { term } = readTermFromStream(stream, solver);
   if (unify(goal.args[goal.arity - 1], term, next)) yield next;
 }
+function validateReadOptions(options) {
+  for (const option of options) {
+    if (option.type !== COMPOUND || option.arity !== 1 ||
+        !['variables', 'variable_names', 'singletons'].includes(option.name)) {
+      throw new PrologError('domain_error(read_option)', option);
+    }
+  }
+}
+
 function* readTermBuiltin({ solver, goal, env }) {
-  const stream = goal.arity === 2 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env, 'read');
+  const optionTerm = goal.args[goal.arity - 1];
+  const streamTerm = goal.arity === 3 ? deref(goal.args[0], env) : null;
+
+  // ISO 8.14.1.3 error order:
+  // a) variable stream; b) partial/options-variable; c) bad stream-or-alias;
+  // d) non-list options; e) invalid read option; then stream existence/mode.
+  if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
+  const preflight = preflightOptionList(optionTerm, env);
+  if (goal.arity === 3) streamReference(goal.args[0], env);
+  const options = requireProperOptionList(preflight);
+  validateReadOptions(options);
+
+  const stream = goal.arity === 2
+    ? solver.io.resolve(solver.io.currentInput)
+    : requireStream(solver, goal.args[0], env, 'read');
   if (stream.type !== 'text') throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
-  const options = optionList(goal.args[goal.arity - 1], env);
+
   const target = goal.args[goal.arity - 2];
   const { term, variables } = readTermFromStream(stream, solver);
   const next = env.clone();
   if (!unify(target, term, next)) return;
   for (const option of options) {
-    if (option.type === VAR) throw new PrologError('instantiation_error');
-    if (option.type !== COMPOUND || option.arity !== 1) throw new PrologError('domain_error(read_option)', option);
     let value;
     if (option.name === 'variables') {
       value = listFromItems(variables.map((item) => item.term));
@@ -1306,12 +1369,10 @@ function* readTermBuiltin({ solver, goal, env }) {
       value = listFromItems(variables
         .filter((item) => !item.anonymous)
         .map((item) => compound('=', [atom(item.sourceName), item.term])));
-    } else if (option.name === 'singletons') {
+    } else {
       value = listFromItems(variables
         .filter((item) => !item.anonymous && item.count === 1)
         .map((item) => compound('=', [atom(item.sourceName), item.term])));
-    } else {
-      throw new PrologError('domain_error(read_option)', option);
     }
     if (!unify(option.args[0], value, next)) return;
   }
@@ -1360,23 +1421,26 @@ function writeVariableNames(value, env, option) {
   return names;
 }
 
-function termWriteOptions(term, env, mode = 'write_term') {
+function termWriteOptionsFromItems(options, env, mode = 'write_term', solver = null) {
   const result = defaultTermWriteOptions(mode);
-  for (const option of optionList(term, env)) {
-    if (option.type === VAR) throw new PrologError('instantiation_error');
+  for (const option of options) {
     if (option.type !== COMPOUND || option.arity !== 1) {
       throw new PrologError('domain_error(write_option)', option);
     }
     if (option.name === 'quoted') result.quoted = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'ignore_ops') result.ignoreOps = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'numbervars') result.numbervars = writeOptionBoolean(option.args[0], env, option);
-    else if (option.name === 'double_quotes') result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
     else if (option.name === 'variable_names') result.variableNames = writeVariableNames(option.args[0], env, option);
-    else throw new PrologError('domain_error(write_option)', option);
+    else if (option.name === 'double_quotes' && !solver?.isoStrict) {
+      result.doubleQuotes = writeOptionBoolean(option.args[0], env, option);
+    } else {
+      throw new PrologError('domain_error(write_option)', option);
+    }
   }
   return result;
 }
 
+
 function writeBuiltin(mode) {
   return function* ({ solver, goal, env }) {
     const stream = outputStreamFor(solver, goal, env);
@@ -1392,9 +1456,22 @@ function writeBuiltin(mode) {
   };
 }
 function* writeTermBuiltin({ solver, goal, env }) {
-  const stream = goal.arity === 2 ? solver.io.resolve(solver.io.currentOutput) : requireStream(solver, goal.args[0], env, 'write');
+  const optionTerm = goal.args[goal.arity - 1];
+  const streamTerm = goal.arity === 3 ? deref(goal.args[0], env) : null;
+
+  // ISO 8.14.2.3 error order:
+  // a) variable stream; b) partial/options-variable; c) non-list options;
+  // d) bad stream-or-alias; e) invalid write option; then stream errors.
+  if (streamTerm?.type === VAR) throw new PrologError('instantiation_error');
+  const preflight = preflightOptionList(optionTerm, env);
+  const optionItems = requireProperOptionList(preflight);
+  if (goal.arity === 3) streamReference(goal.args[0], env);
+  const options = termWriteOptionsFromItems(optionItems, env, 'write_term', solver);
+
+  const stream = goal.arity === 2
+    ? solver.io.resolve(solver.io.currentOutput)
+    : requireStream(solver, goal.args[0], env, 'write');
   if (stream.type !== 'text') throw new PrologError('permission_error(output, binary_stream)', streamHandle(stream.id));
-  const options = termWriteOptions(goal.args[goal.arity - 1], env);
   if (options.doubleQuotes === true) {
     options.doubleQuotes = solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars';
   } else {
@@ -1510,30 +1587,35 @@ function oneChar(value) {
   return value.type === ATOM && characters(value.name).length === 1;
 }
 
-function validCharacterCode(value) {
+function validCharacterCode(value, solver = null) {
   if (value.type !== NUMBER || !isDecimalInteger(value.name)) return false;
   const code = BigInt(value.name);
-  return code >= 0n && code <= 0x10ffffn && !(code >= 0xd800n && code <= 0xdfffn);
+  if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return false;
+  return !solver?.isoStrict || isStrictIsoPcsCodePoint(Number(code));
 }
 
-function listToAtomInput(list, env, kind) {
+function listToAtomInput(list, env, kind, solver = null) {
   const { items, tail } = listElements(list, env);
   if (tail.type === VAR || items.some((item) => item.type === VAR)) throw new PrologError('instantiation_error');
   if (tail.type !== ATOM || tail.name !== '[]') throw new PrologError('type_error(list)', tail);
   if (kind === 'chars') {
     const invalid = items.find((item) => !oneChar(item));
     if (invalid) throw new PrologError('type_error(character)', invalid);
+    if (solver?.isoStrict) {
+      const outsidePcs = items.find((item) => !isStrictIsoPcsCharacter(item.name));
+      if (outsidePcs) throw new PrologError('representation_error(character)', outsidePcs);
+    }
     return items.map((item) => item.name).join('');
   }
   const nonInteger = items.find((item) => item.type !== NUMBER || !isDecimalInteger(item.name));
   if (nonInteger) throw new PrologError('type_error(integer)', nonInteger);
-  const invalid = items.find((item) => !validCharacterCode(item));
+  const invalid = items.find((item) => !validCharacterCode(item, solver));
   if (invalid) throw new PrologError('representation_error(character_code)');
   return items.map((item) => String.fromCodePoint(Number(item.name))).join('');
 }
 
 function atomListBuiltin(kind) {
-  return function* ({ goal, env }) {
+  return function* ({ solver, goal, env }) {
     const value = deref(goal.args[0], env);
     if (value.type !== VAR && value.type !== ATOM) throw new PrologError('type_error(atom)', value);
     const list = deref(goal.args[1], env);
@@ -1546,7 +1628,7 @@ function atomListBuiltin(kind) {
       }
       const invalid = supplied.find((item) => item.type !== VAR &&
         (kind === 'chars' ? !oneChar(item) :
-          item.type !== NUMBER || !isDecimalInteger(item.name) || !validCharacterCode(item)));
+          item.type !== NUMBER || !isDecimalInteger(item.name) || !validCharacterCode(item, solver)));
       if (invalid) {
         if (kind === 'chars') throw new PrologError('type_error(character)', invalid);
         if (invalid.type !== NUMBER || !isDecimalInteger(invalid.name)) {
@@ -1554,26 +1636,32 @@ function atomListBuiltin(kind) {
         }
         throw new PrologError('representation_error(character_code)');
       }
+      if (solver.isoStrict && characters(value.name).some((ch) => !isStrictIsoPcsCharacter(ch))) {
+        throw new PrologError('representation_error(character)', value);
+      }
       const items = characters(value.name).map((ch) =>
         kind === 'chars' ? atom(ch) : numberTerm(ch.codePointAt(0)));
       if (unify(goal.args[1], listFromItems(items), next)) yield next;
       return;
     }
-    if (unify(goal.args[0], atom(listToAtomInput(list, env, kind)), next)) yield next;
+    if (unify(goal.args[0], atom(listToAtomInput(list, env, kind, solver)), next)) yield next;
   };
 }
 const atomCharsBuiltin = atomListBuiltin('chars');
 const atomCodesBuiltin = atomListBuiltin('codes');
 
-function* charCodeBuiltin({ goal, env }) {
+function* charCodeBuiltin({ solver, goal, env }) {
   const char = deref(goal.args[0], env);
   const code = deref(goal.args[1], env);
   if (char.type === VAR && code.type === VAR) throw new PrologError('instantiation_error');
   if (char.type !== VAR && !oneChar(char)) throw new PrologError('type_error(character)', char);
+  if (char.type === ATOM && solver.isoStrict && !isStrictIsoPcsCharacter(char.name)) {
+    throw new PrologError('representation_error(character)', char);
+  }
   if (code.type !== VAR && (code.type !== NUMBER || !isDecimalInteger(code.name))) {
     throw new PrologError('type_error(integer)', code);
   }
-  if (code.type !== VAR && !validCharacterCode(code)) throw new PrologError('representation_error(character_code)');
+  if (code.type !== VAR && !validCharacterCode(code, solver)) throw new PrologError('representation_error(character_code)');
   const next = env.clone();
   if (char.type === ATOM) {
     if (unify(goal.args[1], numberTerm(char.name.codePointAt(0)), next)) yield next;
@@ -1583,7 +1671,7 @@ function* charCodeBuiltin({ goal, env }) {
 function skipNumberLayout(text, start) {
   let position = start;
   while (true) {
-    while (position < text.length && /[\u0009-\u000d\u0020]/.test(text[position])) {
+    while (position < text.length && /[\u0000-\u0020\u007f]/.test(text[position])) {
       position++;
     }
     if (text[position] === '%') {
@@ -1647,7 +1735,7 @@ function parseIsoNumber(text) {
     // there without separating layout: `/` *can* continue the graphic token,
     // and the eager-consumer rule therefore keeps `-/**/1` ill-formed (the
     // number_chars continuation corpus case 24).
-    if (/[\u0009-\u000d\u0020]/.test(next) || next === '%') {
+    if (/[\u0000-\u0020\u007f]/.test(next) || next === '%') {
       position = skipNumberLayout(text, position + 1);
       sign = '-';
     }

package/src/parser.js

@@ -2,6 +2,7 @@
 // It preserves the compact Prolog-like syntax while producing Term objects for the solver.
 import { ATOM, COMPOUND, atom, compound, cons, emptyList, numberTerm, variable } from './term.js';
 import { continuesGraphicToken, isTerminatingFullStop } from './syntax-scan.js';
+import { CharacterRepresentationError, isStrictIsoPcsCodePoint } from './iso-character.js';
 
 
 export class NumberRepresentationError extends Error {
@@ -33,7 +34,10 @@ const TOK = {
 };
 
 function isWhitespaceCode(code) {
-  return code === 32 || code === 9 || code === 10 || code === 13 || code === 12 || code === 11;
+  // EyeProlog classifies ASCII C0 controls and DEL as layout characters. In
+  // strict mode these are the implementation-defined extended-layout members
+  // of the ASCII processor character set.
+  return (code >= 0 && code <= 32) || code === 127;
 }
 
 function isDigitCode(code) {
@@ -232,7 +236,11 @@ class Parser {
     return this.parserFlagState.charConversions.get(character) ?? character;
   }
   rawPeek(offset = 0) {
-    return this.source[this.pos + offset] ?? '';
+    const ch = this.source[this.pos + offset] ?? '';
+    if (this.strictIso && ch && !isStrictIsoPcsCodePoint(ch.charCodeAt(0))) {
+      throw new CharacterRepresentationError();
+    }
+    return ch;
   }
   rawTake() {
     const ch = this.rawPeek();
@@ -410,6 +418,7 @@ class Parser {
       if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
         throw new Error(`parse line ${line}: character escape out of range`);
       }
+      if (this.strictIso && !isStrictIsoPcsCodePoint(code)) throw new CharacterRepresentationError();
       return String.fromCodePoint(code);
     }
     if (/^[0-7]$/.test(escaped)) {
@@ -420,6 +429,7 @@ class Parser {
       if (code > 0x10ffff || (code >= 0xd800 && code <= 0xdfff)) {
         throw new Error(`parse line ${line}: character escape out of range`);
       }
+      if (this.strictIso && !isStrictIsoPcsCodePoint(code)) throw new CharacterRepresentationError();
       return String.fromCodePoint(code);
     }
     // A backslash followed by a decimal digit is numeric-escape syntax, but

package/src/solver.js

@@ -951,12 +951,12 @@ const ISO_CORE_FLAG_NAMES = new Set([
 
 function defaultPrologFlags(unknown = 'error', strictIso = false) {
   const flags = new Map([
-    ['bounded', { value: compound('false', []), allowed: ['false'], changeable: false }],
-    ['integer_rounding_function', { value: compound('toward_zero', []), allowed: ['toward_zero'], changeable: false }],
+    ['bounded', { value: compound('false', []), allowed: ['true', 'false'], changeable: false }],
+    ['integer_rounding_function', { value: compound('toward_zero', []), allowed: ['down', 'toward_zero'], changeable: false }],
     ['char_conversion', { value: compound('on', []), allowed: ['on', 'off'], changeable: true }],
     ['debug', { value: compound('off', []), allowed: ['on', 'off'], changeable: true }],
-    ['max_integer', { value: null, allowed: ['unbounded'], changeable: false }],
-    ['min_integer', { value: null, allowed: ['unbounded'], changeable: false }],
+    ['max_integer', { value: null, allowed: [], changeable: false }],
+    ['min_integer', { value: null, allowed: [], changeable: false }],
     ['max_arity', { value: compound('unbounded', []), allowed: ['unbounded'], changeable: false }],
     ['unknown', { value: compound(unknown, []), allowed: ['error', 'fail', 'warning'], changeable: true }],
     ['double_quotes', { value: compound('chars', []), allowed: ['chars', 'codes', 'atom'], changeable: true }],

package/src/syntax-scan.js

@@ -46,7 +46,7 @@ export function isTerminatingFullStop(source, index, convert = null) {
   // token character accepted by continuesGraphicToken().
   if (continuesGraphicToken(source, index, convert)) return false;
   if (next === '' || next === '%' || next === '\n' || next === '\r') return true;
-  if (/^[\u0009\u000b\u000c\u0020]$/.test(next)) return true;
+  if (/^[\u0000-\u0020\u007f]$/.test(next)) return true;
   return false;
 }
 

package/test/conformance/ISO-COMPLIANCE.md

@@ -30,17 +30,17 @@ error-ordering alternative to an individual executable assertion.
 
 | 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, and 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. |
+| 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 strict ASCII 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. |
+| 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 and PCS-based atom collation. |
 | 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` now affects later unquoted source text and respects `char_conversion=off`. Cross-text `multifile/1` and ordering constraints still 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. |
 | 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. |
 | 7.9 — expression evaluation | audit | Arithmetic/evaluation/error suites, including Corrigenda. Exceptional-value/error-precedence matrix remains to be exhaustively enumerated. |
-| 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, Corrigendum 3 writer cases. Full option cross-product remains open. |
-| 7.11 — flags | audit | Required Part 1 flags implemented. Normal and strict modes use the ISO `unknown=error` default; strict mode excludes the EyeProlog `occurs_check` extension. With `bounded=false`, `max_integer` and `min_integer` correctly have no current value. |
-| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Complete prescribed-error ordering remains open. |
-| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. Mode/error matrix is not yet one-row-per-standard-row. |
+| 7.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The Part 1/Corrigendum 3 `read_term/2-3` and `write_term/2-3` option surfaces and ISO 8.14.1-8.14.2 prescribed error ordering now have dedicated strict tests; the wider stream/open/close option cross-product remains open. |
+| 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. Strict mode excludes the EyeProlog `occurs_check` extension. |
+| 7.12 — errors | audit | ISO `error(Error, Context)` envelope, type/domain/permission/representation/evaluation/syntax families and focused error cases. Exact ISO 8.14.1-8.14.4 error precedence is now covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; prescribed ordering for the remaining built-in families is still being mapped. |
+| 8.2-8.17 — built-in predicates | audit | Predicate-family coverage is mapped in ISO-MATRIX.md; Corrigendum 2 additions (`subsumes_term/2`, `term_variables/2`, `call/2..8`, `false/0`) are in the strict registry. The 8.14 term-I/O/operator subfamily now has dedicated strict option-surface and prescribed-error-order assertions, and 8.17 flag behavior is closed; the remaining mode/error matrix is not yet one-row-per-standard-row. |
 | Clause 9 — evaluable functors | audit | Integer/float/rounding/transcendental/bitwise suites and corrigendum cases. Host floating-point representation choices remain documented implementation-defined behavior. |
 | 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. |
@@ -59,10 +59,27 @@ conformance claims:
   when the `char_conversion` flag is `on`, leaves quoted characters unchanged,
   and feeds the same mapping into execution-time term input.
 
-The processor-character-set/collation rows in
-[ISO-IMPLEMENTATION-DEFINED.md](ISO-IMPLEMENTATION-DEFINED.md) remain explicit
-`audit gap`s. They were not papered over by narrowing strict mode without full
-WG17 and read/write/error validation.
+A follow-on audit closes the processor-character-set/collation choices rather
+than leaving them implicit. `--iso-strict` now selects the 128-character ASCII
+PCS U+0000..U+007F, classifies C0 controls and DEL as extended layout
+characters, and uses the code point itself as each collating-sequence integer.
+Characters/codes outside that PCS raise representation errors in strict
+parsing, term input, character conversion, and character-code predicates. The
+normal profile retains Unicode scalar character data as an explicit extension.
+The complete WG17 syntax matrix remains green under this narrower strict
+boundary.
+
+A further issue #65 audit closes the Part 1 flag family and tightens the 8.14
+term-I/O/operator error rules. The strict flag registry now distinguishes a
+standard value that is valid but not selectable from a value outside the
+standard domain: attempts to change fixed `bounded` or
+`integer_rounding_function` to another standard value therefore reach the
+required permission error. `read_term/3`, `write_term/3`, `op/3`, and
+`current_op/3` now follow their prescribed error precedence, including cases
+where more than one argument is erroneous. Strict `write_term/2-3` accepts only
+the Part 1 plus Corrigendum 3 option surface; the normal-profile
+`double_quotes/1` write option remains an explicitly documented EyeProlog
+extension.
 
 ## Strict-core boundary
 

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

@@ -19,21 +19,21 @@ Status values are:
 - **defined** — the current behavior is implemented and stated here;
 - **not applicable** — the standard decision is conditional and the condition
   is false for EyeProlog's selected profile;
-- **audit gap** — the current code behavior is stated, but strict-mode
-  conformance still needs a correction or a narrower profile before this row
-  can support a full conformance claim.
+- **audit gap** — retained for any future implementation-defined choice whose
+  code/documentation boundary is still unresolved. Open *normative* shall-by-
+  shall work is tracked separately in `ISO-COMPLIANCE.md`.
 
 ## Explicit implementation-defined decisions
 
 | Clause | Decision completed by ISO 5.4 documentation | EyeProlog choice | Status / implementation evidence |
 | --- | --- | --- | --- |
 | 5.5.11 | Reserved atoms and the effect of instantiating a variable to one | EyeProlog reserves no Prolog atom under 5.5.11. Atoms with implementation-looking names remain ordinary terms unless a particular predicate interprets them. | **defined** — term representation and built-ins in `src/term.js`, `src/iso.js`. |
-| 6.5 | Processor character set (PCS) | The unquoted ISO lexical classes are the Part 1 ASCII characters implemented by `src/parser.js`. Quoted character data additionally accepts Unicode scalar values. | **audit gap** — the Unicode quoted-character extension is currently also accepted by `--iso-strict`; strict extension rejection still needs a narrower PCS rule or a documented conforming classification. |
-| 6.5 | Classification of additional/extended PCS characters | Non-ASCII scalar values are not accepted as unquoted small-letter, capital-letter, graphic, solo, layout, or meta characters; they are accepted only inside quoted character data. | **audit gap** — same strict-mode boundary as the preceding row. |
-| 6.6 | Collating-sequence integers | Character codes are Unicode scalar values. Atom comparison uses ECMAScript string lexicographic order; on the ISO ASCII repertoire this is code-point order and satisfies the required monotonic ranges. | **defined** — `src/term.js` (`compareTerms`), `src/iso.js` character-code predicates. |
-| 6.6 | Collating values of control escapes and extended characters | Control escapes and character-code predicates use Unicode scalar values. Atom ordering is ECMAScript string order; for non-BMP one-char atoms that order is based on UTF-16 code units rather than scalar values. | **audit gap** — the ISO ASCII repertoire is conforming, but the extended-character collating rule still needs one coherent documented integer/order mapping in strict mode. |
+| 6.5 | Processor character set (PCS) | In `--iso-strict`, PCS is the 128-character 7-bit ASCII set U+0000..U+007F. Normal mode additionally accepts Unicode scalar values in character data as an implementation-specific extension. | **defined** — `src/iso-character.js`, strict parser/character-I/O guards, and strict-core/WG17 coverage. |
+| 6.5 | Classification of additional/extended PCS characters | Printable ASCII uses the lexical classes specified by Part 1. ASCII C0 controls U+0000..U+001F and DEL U+007F are EyeProlog's extended **layout** characters; they may therefore separate tokens, while quoted control values are written/read through the ISO escape forms. No non-ASCII character belongs to strict PCS. | **defined** — `src/parser.js`, `src/syntax-scan.js`, `src/iso-character.js`. |
+| 6.6 | Collating-sequence integers | In strict mode each PCS character's collating-sequence integer is its ASCII/Unicode code point, 0..127. Atom comparison is lexicographic by the same code-unit values, which coincide with those integers throughout strict PCS and satisfy the required capital-letter, small-letter, and decimal-digit constraints. | **defined** — `src/iso-character.js`, `src/term.js` (`compareTerms`), `src/iso.js` character-code predicates. |
+| 6.6 | Collating values of control escapes and extended characters | Strict control/extended-layout characters use their ASCII code point as collating integer, so octal/hexadecimal escapes and character-code constants map to the same 0..127 PCS. Normal-mode Unicode character codes use Unicode scalar values; that broader ordering is outside the strict Part 1 profile. | **defined** — `src/iso-character.js`, parser escape handling, `char_code/2`, `atom_codes/2`, and WG17 escape cases. |
 | 7.1.2.2 | Mapping between a character code and bytes | Text file streams decode and encode UTF-8. Binary streams expose bytes 0..255 directly. | **defined** — `src/io.js`. |
-| 7.1.4.1 | Set `C` of characters represented by one-char atoms | Character predicates accept Unicode scalar values U+0000..U+10FFFF excluding surrogate code points. | **defined** — `src/iso.js` character-code validation. |
+| 7.1.4.1 | Set `C` of characters represented by one-char atoms | In strict mode `C` is exactly the ASCII PCS U+0000..U+007F. Normal mode extends character predicates to Unicode scalar values U+0000..U+10FFFF excluding surrogates. | **defined** — `src/iso-character.js`, `src/iso.js` character-code validation. |
 | 7.4.2.4 | Whether `op/3` directives affect other Prolog texts or execution | An `op/3` directive changes parsing of subsequent text loaded into the same `Program`; the resulting operator table is also used by execution-time term I/O. Separately created `Program` objects are independent. | **defined** — `src/parser.js`, `src/program.js`, `src/iso.js`. |
 | 7.4.2.5 | Whether directive-created `Convc` affects other text/execution | Yes. A `char_conversion/2` directive updates preparation-time conversion for later unquoted source characters and the recorded mapping initializes execution-time term input. Quoted characters are not converted; `char_conversion=off` disables following preparation-time conversion. | **defined** — `src/parser.js`, `src/program.js`, `src/solver.js`; strict-core regression coverage. |
 | 7.4.2.6 | Order of `initialization/1` goals | Initialization goals run once, in source/inclusion order, before requested goals; each must obtain a first solution. | **defined** — `Program.initializations`, `Solver.runInitializations()`. |
@@ -58,18 +58,18 @@ Status values are:
 | 7.10.2.11 | Default `eof_action` | Newly opened file streams default to `error`. The predefined standard streams use `reset`. | **defined** — `src/io.js`. |
 | 7.10.2.13 | `eof_action(Action)` property when the stream uses its default action | Reports the same selected action: `error` for ordinary opened files and `reset` for the predefined standard streams. | **defined** — `streamProperties()` in `src/iso.js`, defaults in `src/io.js`. |
 | 7.10.2.11 | Whether `reposition(false)` streams may nevertheless be repositioned | No. `set_stream_position/2` raises a permission error unless the stream was created with `reposition(true)`. | **defined** — `src/iso.js`. |
-| 7.11.1.1 | Default `bounded` flag | `false`: EyeProlog's Prolog integer model uses arbitrary-precision `BigInt`, subject to host resources. | **defined** — `defaultPrologFlags()` in `src/solver.js`. |
+| 7.11.1.1 | Default `bounded` flag | `false`: EyeProlog's Prolog integer model uses arbitrary-precision `BigInt`, subject to host resources. The standard values remain `true` and `false`; because this flag is fixed, selecting either value through `set_prolog_flag/2` reaches the standard non-changeable-flag rule rather than narrowing the value domain to the current choice. | **defined** — `defaultPrologFlags()` in `src/solver.js`; strict flag tests. |
 | 7.11.1.2 | Default `max_integer` when `bounded=true` | Not applicable because EyeProlog selects `bounded=false`; consequently `current_prolog_flag(max_integer, _)` fails. | **not applicable** — `src/solver.js`, `current_prolog_flag/2`; strict-core regression coverage. |
 | 7.11.1.3 | Default `min_integer` when `bounded=true` | Not applicable because EyeProlog selects `bounded=false`; consequently `current_prolog_flag(min_integer, _)` fails. | **not applicable** — `src/solver.js`, `current_prolog_flag/2`; strict-core regression coverage. |
-| 7.11.1.4 | Default `integer_rounding_function` flag | `toward_zero`; `//` uses truncation toward zero. `div` is provided separately with downward/floor division semantics. | **defined** — `src/solver.js`, `src/iso-arithmetic.js`. |
+| 7.11.1.4 | Default `integer_rounding_function` flag | `toward_zero`; `//` uses truncation toward zero. The standard flag values are `down` and `toward_zero`, but the selected flag is non-changeable; an attempt to select the other valid value is therefore a permission error. `div` is provided separately with downward/floor division semantics. | **defined** — `src/solver.js`, `src/iso-arithmetic.js`; strict flag tests. |
 | 9.1.3.1 | Integer division rounding function `rndI` | Truncation toward zero, matching the `integer_rounding_function=toward_zero` flag. | **defined** — BigInt division for `//` in `src/iso-arithmetic.js`. |
 | 7.11.2.1 | Whether preparation-time `Convc` affects execution-time `Convc` | Yes: mappings created while Prolog text is prepared are retained and initialize the solver's execution-time conversion map. | **defined** — `src/parser.js`, `src/program.js`, `src/solver.js`. |
 | 7.11.2.2 | Effect when `debug=on` | The flag is accepted and stored; it does not change goal semantics or enable a debugger. | **defined** — `src/solver.js`; no semantic branch depends on `debug`. |
 | 7.11.2.3 | Default `max_arity` | `unbounded` in the Prolog model, subject to host memory and practical JavaScript array/index limits. | **defined** — `src/solver.js`; relevant guards report representation/resource errors. |
 | 7.11.2.5 | Default `double_quotes` | `chars`. | **defined** — `src/solver.js`, parser flag state. |
 | 7.12.1 | Second argument of `error/2` | The default context term is the atom `eyeprolog`. A few implementation-specific diagnostics may deliberately supply a more specific context term. | **defined** — `formalErrorTerm()` in `src/iso.js`. |
-| 7.12.2(f) | Implementation-defined representation limits | Character and character-code operations use Unicode scalar limits; arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |
-| 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` flag. With `bounded=false`, `max_integer` and `min_integer` have no current value and their `current_prolog_flag/2` queries fail. | **defined** — strict registry/flag filtering in `src/solver.js`. |
+| 7.12.2(f) | Implementation-defined representation limits | Strict character and character-code operations are limited to the selected ASCII PCS/collating integers 0..127. Normal mode extends characters to Unicode scalar values. Arity/integer values are modeled as unbounded but may hit host/resource limits. Float input overflow uses the implementation-specific `max_float`/`min_float` representation names documented by the STC-oriented tests. | **defined** — parser/ISO numeric and character guards. |
+| 8.17.1 | Implementation-defined flag value ranges | Strict mode exposes only Part 1 core flags and their standard value sets. Normal mode additionally exposes EyeProlog's `occurs_check` flag. With `bounded=false`, `max_integer` and `min_integer` have no current or selectable value and their `current_prolog_flag/2` queries fail. Valid alternative values of fixed standard flags are distinguished from invalid values so `set_prolog_flag/2` reports permission versus domain errors as prescribed. | **defined** — strict registry/flag filtering in `src/solver.js`; strict flag tests. |
 | 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`. |
@@ -105,7 +105,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 
 | Part 1 extension hook | EyeProlog normal-profile feature | Strict-core disposition |
 | --- | --- | --- |
-| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, and embedded quad syntax | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax is rejected. Unicode quoted-character handling is the open PCS audit item above. |
+| 5.5.1 Syntax | Part 2 modules, Part 3 grammar-rule expansion, embedded quad syntax, and normal-mode Unicode character data | Module directives are rejected; grammar rules remain ordinary `-->/2` terms rather than being expanded; quad syntax is rejected; strict character syntax/data is limited to the documented ASCII PCS. |
 | 5.5.2 Predefined operators | Part 3 `|` and EyeProlog's labelable infix `(?-)/2`; CLP(Z) operators when that library is imported | Only the Part 1 operator table is predefined; a conforming `op/3` may still add permitted operators. |
 | 5.5.3 Character-conversion mapping | No non-identity initial `Convc` extension | Identity initial mapping. |
 | 5.5.4 Types | No additional runtime Prolog term type is exposed by the core solver | Only variable, integer, float, atom, and compound term ordering participates in strict mode. |
@@ -116,7 +116,7 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 | 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.11 Reserved atoms | None | None. |
-| Cor.3 5.5.12 Options | Extra library/host options may exist outside core option lists | Strict core accepts the standard option names implemented for Part 1; invalid options follow Corrigendum 3 validation. |
+| 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,...)`. |
 
 Normal mode provides documented module and DCG compatibility profiles whose
 features overlap standardized Part 2 and Part 3 facilities. They are extensions

package/test/conformance/ISO-MATRIX.md

@@ -8,16 +8,16 @@ 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`, `wg17_unterminated_quoted_token`, `wg17_literal_newline_in_quote`, `wg17_non_iso_escape`, syntax error cases |
+| Clause 6 lexical and term syntax | tokenizer, operator parser, lists, curly terms, quotes, numeric syntax, comments, strict ASCII 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 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 |
 | 8.6-8.7 arithmetic predicates | `is/2` and all six arithmetic comparisons | `arithmetic`, comparison cases, isolated evaluation errors |
 | 8.8-8.10 database and solutions | logical update view, dynamic mutation, all-solutions grouping | `dynamic_database`, `trealla_logical_update_view`, `corrigenda_retractall`, `grouped_solutions_and_clauses` |
-| 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases |
+| 8.11-8.14 streams and term I/O | text/binary streams, properties, units, read/write options and operators | `streams_and_term_io`, `operators`, Corrigendum 3 option cases, stream error cases, plus strict 8.14.1-8.14.4 option-surface/error-precedence tests for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3` |
 | 8.15 logic and control | negation, once, repeat, `call/2` through `call/8`, `false/0` | `logtalk_once`, `corrigenda_call_closure`, `false_builtin` |
 | 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 error cases |
-| 8.17 flags and hooks | required flags, mutation permissions, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases |
+| 8.17 flags and hooks | complete required Part 1 flag set, selected defaults, standard value domains/changeability, halt and character conversion | `exceptions_and_flags`, `remaining_builtins_and_directives`, flag error cases, and the strict complete-flag audit in `run-iso-strict.mjs` |
 | Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power` |
 | 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/README.md

@@ -21,12 +21,17 @@ predicate indicators listed in Appendix B of the book across the Part 1 strict-c
 target and the normal-mode module/DCG compatibility families. [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md) is the explicit
 processor-requirement ledger for the Part 1 strict-core audit. This suite is
 still not an independent certification of every processor requirement, lexical
-edge, option combination, or prescribed error precedence. Cases under `iso/`
+edge, or option combination. Selected prescribed-error sequences are now
+checked exactly (including ISO 8.14.1-8.14.4), while the remaining built-in
+error-order matrix is tracked in the compliance ledger. Cases under `iso/`
 identify standards-derived behavior; other directories cover EyeProlog host
 contracts and extensions. EyeProlog-only execution features such as automatic
 tabling and `tnot/1` well-founded negation are outside the Part 1 strict-core
 claim. Their focused semantic coverage lives primarily in regression tests;
-`tnot/1` is absent from the strict ISO registry.
+`tnot/1` is absent from the strict ISO registry. The strict processor character
+set is the documented 7-bit ASCII PCS with ASCII-code collation; normal-mode
+Unicode character data is tested as an extension rather than folded into the
+Part 1 claim.
 
 All conformance files live under topic directories such as `arithmetic/`, `lists/`, `syntax/`, or `variables/`; new top-level numbered files should not be added. The report uses those directories as coverage categories.
 

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

@@ -1 +1 @@
-error(type_error(integer), 1.2)
+error(domain_error(operator_priority), 1.2)

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

@@ -1 +1 @@
-error(type_error(integer), x)
+error(domain_error(operator_priority), x)

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

@@ -1 +1 @@
-error(type_error(atom), 1)
+error(domain_error(operator_specifier), 1)

package/test/run-iso-strict.mjs

@@ -46,6 +46,41 @@ export function runIsoStrict(reporter = new TestReporter()) {
   });
 
 
+  reporter.test('covers the Part 1 flag defaults, value domains, and changeability', () => {
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true });
+    const answers = (text) => [...solver.solve([parseGoalText(text, { isoStrict: true })], new Env(), 0)].length;
+    for (const goalText of [
+      'current_prolog_flag(bounded,false)',
+      'current_prolog_flag(integer_rounding_function,toward_zero)',
+      'current_prolog_flag(char_conversion,on)',
+      'current_prolog_flag(debug,off)',
+      'current_prolog_flag(max_arity,unbounded)',
+      'current_prolog_flag(unknown,error)',
+      'current_prolog_flag(double_quotes,chars)',
+    ]) equal(answers(goalText), 1, goalText);
+
+    for (const goalText of [
+      'set_prolog_flag(char_conversion,off)',
+      'set_prolog_flag(debug,on)',
+      'set_prolog_flag(unknown,fail)',
+      'set_prolog_flag(double_quotes,codes)',
+    ]) run('', { isoStrict: true, goal: goalText });
+
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(bounded,true)' })).formal,
+      'permission_error(modify, flag)', 'bounded valid-but-fixed value');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(integer_rounding_function,down)' })).formal,
+      'permission_error(modify, flag)', 'rounding valid-but-fixed value');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_arity,unbounded)' })).formal,
+      'permission_error(modify, flag)', 'max_arity fixed value');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(max_integer,unbounded)' })).formal,
+      'domain_error(flag_value)', 'max_integer has no value when unbounded');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(unknown,maybe)' })).formal,
+      'domain_error(flag_value)', 'unknown value domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'set_prolog_flag(not_a_flag,on)' })).formal,
+      'domain_error(prolog_flag)', 'unsupported flag');
+  });
+
   reporter.test('preparation-time char_conversion affects later unquoted source only', () => {
     const program = Program.parse(
       ":- char_conversion(x,y).\np(x).\nquoted('x').\n:- set_prolog_flag(char_conversion,off).\nraw(x).\n",
@@ -56,6 +91,128 @@ export function runIsoStrict(reporter = new TestReporter()) {
     equal(Boolean(program.findGroup('raw', 1)?.clauses.some((clause) => clause.head.args[0]?.name === 'x')), true, 'conversion disabled');
   });
 
+
+  reporter.test('uses a documented 7-bit ASCII processor character set and collation', () => {
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true });
+    const answers = (text) => [...solver.solve([parseGoalText(text, { isoStrict: true })], new Env(), 0)].length;
+    equal(answers("char_code('\\0\\',0)"), 1, 'NUL collating integer');
+    equal(answers("char_code('A',65)"), 1, 'A collating integer');
+    equal(answers("char_code('\\177\\',127)"), 1, 'DEL collating integer');
+    equal(answers("'\\0\\' @< 'A'"), 1, 'control before capital');
+    equal(answers("'A' @< 'a'"), 1, 'capital before small letter');
+  });
+
+
+  reporter.test('follows the Part 1 standard term-type and atom ordering', () => {
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true });
+    const answers = (text) => [...solver.solve([parseGoalText(text, { isoStrict: true })], new Env(), 0)].length;
+    equal(answers("X @< 1.0"), 1, 'variable before float');
+    equal(answers("1.0 @< 1"), 1, 'float before integer');
+    equal(answers("1 @< a"), 1, 'integer before atom');
+    equal(answers("a @< f(a)"), 1, 'atom before compound');
+    equal(answers("'' @< 'A'"), 1, 'null atom first');
+    equal(answers("'A' @< 'B'"), 1, 'atom collation');
+  });
+
+  reporter.test('rejects characters outside the strict processor character set', () => {
+    const sourceError = capture(() => Program.parse("p('é').\n", { isoStrict: true }));
+    equal(sourceError.formal, 'representation_error(character)', 'source representation error');
+
+    const readError = capture(() => run('', {
+      isoStrict: true,
+      goal: 'read(X)',
+      ioOptions: { input: "'é'." },
+    }));
+    equal(readError.formal, 'representation_error(character)', 'read representation error');
+  });
+
+  reporter.test('restricts strict character codes to the processor character set', () => {
+    const charCodeError = capture(() => run('', { isoStrict: true, goal: 'char_code(_,128)' }));
+    equal(charCodeError.formal, 'representation_error(character_code)', 'char_code/2');
+    const atomCodesError = capture(() => run('', { isoStrict: true, goal: 'atom_codes(_, [128])' }));
+    equal(atomCodesError.formal, 'representation_error(character_code)', 'atom_codes/2');
+    const putCodeError = capture(() => run('', { isoStrict: true, goal: 'put_code(128)' }));
+    equal(putCodeError.formal, 'representation_error(character_code)', 'put_code/1');
+  });
+
+  reporter.test('keeps broader Unicode character handling as a normal-mode extension', () => {
+    const result = run('', { goal: "char_code('é',233)" });
+    equal(result.stdout, "char_code('é', 233).\n", 'normal Unicode char_code/2');
+  });
+
+  reporter.test('keeps the strict write-option surface to Part 1 plus Corrigendum 3', () => {
+    const strictError = capture(() => run('', {
+      isoStrict: true,
+      goal: 'write_term(a,[double_quotes(true)])',
+    }));
+    equal(strictError.formal, 'domain_error(write_option)', 'strict extension rejection');
+
+    const normal = run('', { goal: 'write_term("ab",[double_quotes(true)])' });
+    includes(normal.stdout, '"ab"', 'normal-profile extension remains available');
+  });
+
+  reporter.test('follows the ISO 8.14.1.3 read_term/3 error order', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'read_term(f(a),_,[X])' })).formal,
+      'instantiation_error', 'partial/variable option before stream domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'read_term(f(a),_,foo)' })).formal,
+      'domain_error(stream_or_alias)', 'stream domain before non-list options');
+    equal(capture(() => run('', { isoStrict: true, goal: 'read_term(user_output,_,foo)' })).formal,
+      'type_error(list)', 'non-list options before stream permission');
+    equal(capture(() => run('', { isoStrict: true, goal: 'read_term(user_output,_,[bogus])' })).formal,
+      'domain_error(read_option)', 'invalid option before stream permission');
+    equal(capture(() => run('', { isoStrict: true, goal: "read_term('$stream'(999),_,[bogus])" })).formal,
+      'domain_error(read_option)', 'invalid option before stream existence');
+
+    const program = Program.parse('', { isoStrict: true });
+    const solver = new Solver(program, { isoStrict: true, ioOptions: { input: 'a.' } });
+    const error = capture(() => [...solver.solve([
+      parseGoalText('read_term(user_input,_,[bogus])', { isoStrict: true }),
+    ], new Env(), 0)]);
+    equal(error.formal, 'domain_error(read_option)', 'invalid read option');
+    equal(solver.io.resolve('user_input').position, 0, 'invalid options are rejected before input');
+  });
+
+  reporter.test('follows the ISO 8.14.2.3 write_term/3 error order', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,[X])' })).formal,
+      'instantiation_error', 'partial/variable option before stream domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,foo)' })).formal,
+      'type_error(list)', 'non-list options before stream domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(f(a),a,[bogus])' })).formal,
+      'domain_error(stream_or_alias)', 'stream domain before invalid option');
+    equal(capture(() => run('', { isoStrict: true, goal: "write_term('$stream'(999),a,[bogus])" })).formal,
+      'domain_error(write_option)', 'invalid option before stream existence');
+    equal(capture(() => run('', { isoStrict: true, goal: 'write_term(user_input,a,[bogus])' })).formal,
+      'domain_error(write_option)', 'invalid option before stream permission');
+  });
+
+  reporter.test('follows the ISO 8.14.3.3 op/3 error order', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(a,X,0)' })).formal,
+      'instantiation_error', 'specifier variable before priority type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(a,xfy,[X])' })).formal,
+      'instantiation_error', 'operator variable element before priority type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(a,1,0)' })).formal,
+      'type_error(integer)', 'priority type before specifier type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(1,1,0)' })).formal,
+      'type_error(atom)', 'specifier type before operator-list type');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(1300,xfy,[1])' })).formal,
+      'type_error(atom)', 'operator element type before priority domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(1300,foo,a)' })).formal,
+      'domain_error(operator_priority)', 'priority domain before specifier domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'op(100,foo,a)' })).formal,
+      'domain_error(operator_specifier)', 'specifier domain');
+  });
+
+  reporter.test('uses ISO 8.14.4.3 domain errors for current_op/3 filters', () => {
+    equal(capture(() => run('', { isoStrict: true, goal: 'current_op(a,_,_)' })).formal,
+      'domain_error(operator_priority)', 'priority domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'current_op(1,1,_)' })).formal,
+      'domain_error(operator_specifier)', 'specifier domain');
+    equal(capture(() => run('', { isoStrict: true, goal: 'current_op(1,fx,1)' })).formal,
+      'type_error(atom)', 'operator type');
+  });
+
   reporter.test('uses the Part 1 predefined operator table', () => {
     const program = Program.parse('', { isoStrict: true });
     equal(program.operators.has('fx\u0000?-'), true, 'fx ?-');

package/the-art-of-eyeprolog.md

@@ -5119,8 +5119,13 @@ this part makes control, reflection, state, operators, and streams explicit.
 For Part 1 portability work, EyeProlog also provides a strict core mode:
 `--iso-strict` on the CLI or `isoStrict: true` in the JavaScript API restricts
 the language/runtime surface to ISO/IEC 13211-1:1995 plus Technical Corrigenda
-1–3. Isolated mode and error cases live in `test/conformance/cases/iso/`. The
-examples here compose those operations into programs worth changing and
+1–3. Its processor character set is the 128-character ASCII set U+0000..U+007F;
+C0 controls and DEL are implementation-defined extended layout characters, and
+collating-sequence integers are the corresponding ASCII codes. Character data
+outside that PCS is rejected with a representation error in strict mode. Normal
+mode keeps EyeProlog's broader Unicode scalar character support as an explicit
+extension. Isolated mode and error cases live in `test/conformance/cases/iso/`.
+The examples here compose those operations into programs worth changing and
 rerunning.
 
 These facilities do not all have the same declarative character. Term
@@ -5420,7 +5425,10 @@ emitted compactly when no lexical ambiguity would arise. For example,
 still retained where adjacent graphic tokens would otherwise merge, as in
 `a+ -b`.
 `write_term/2-3` supports `quoted/1`, `ignore_ops/1`, `numbervars/1`, and
-`variable_names/1`.
+`variable_names/1`. Normal mode additionally accepts the EyeProlog extension
+`double_quotes(true|false)`: `true` lets eligible character/code lists use the
+current `double_quotes` representation, while strict ISO mode rejects this
+non-standard write option.
 
 Character operations are `get_char`, `peek_char`, `put_char`, `get_code`,
 `peek_code`, and `put_code`; byte streams use the corresponding byte
@@ -5495,15 +5503,20 @@ 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.
 
-Prolog source accepted by EyeProlog is UTF-8. `%` starts a line comment and
-`/* ... */` delimits a block comment. Plain atoms begin with a
+Normal-mode Prolog source accepted by EyeProlog is UTF-8. `%` starts a line
+comment and `/* ... */` delimits a block comment. Plain atoms begin with a
 lowercase ASCII letter. Variables begin with uppercase or underscore. The bare
 `_` is fresh each time. Single quotes delimit quoted atoms; double quotes use
-ISO double-quoted-list notation. Integers, decimals, scientific notation, binary/octal/
-hexadecimal integers, and character-code constants are accepted.
+ISO double-quoted-list notation. Integers, decimals, scientific notation,
+binary/octal/hexadecimal integers, and character-code constants are accepted.
 
-Unquoted names deliberately use ASCII spelling. Unicode belongs inside quoted
-atoms and double-quoted lists:
+For `--iso-strict`, the processor character set is deliberately narrower and
+fully documented: U+0000..U+007F. Printable ASCII uses the Part 1 lexical
+classes; C0 controls and DEL are extended layout characters; character-code and
+collation values are the same ASCII integers 0..127. Non-ASCII input is a
+representation error. In normal mode, unquoted names still deliberately use
+ASCII spelling while Unicode scalar values may appear inside quoted atoms and
+double-quoted lists:
 
 ```eyeprolog
 
@@ -6036,8 +6049,8 @@ quoted_atom("ab").           % quoted_atom(ab)
 | `atom_length(+Atom,?Length)` | Counts Unicode code points, not UTF-16 code units. A supplied length must be a nonnegative integer. |
 | `atom_concat(?Prefix,?Suffix,?Whole)` | Concatenates two atoms, removes a supplied prefix or suffix, or enumerates every split when only `Whole` is bound. At least `Whole`, or both parts, must determine the operation. |
 | `sub_atom(+Atom,?Before,?Length,?After,?SubAtom)` | Enumerates substrings and their Unicode-code-point offsets. Supplied counts must be nonnegative integers. |
-| `atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)` | Convert between an atom and a proper list of one-character atoms or Unicode scalar codes. At least one side must be instantiated. |
-| `char_code(?Character,?Code)` | Converts one character atom and one Unicode scalar code. Surrogates and values outside `0..0x10ffff` raise a representation error. |
+| `atom_chars(?Atom,?Chars)`, `atom_codes(?Atom,?Codes)` | Convert between an atom and a proper list of one-character atoms or character codes. Strict mode uses its ASCII PCS/codes `0..127`; normal mode extends codes to Unicode scalar values. At least one side must be instantiated. |
+| `char_code(?Character,?Code)` | Converts one character atom and its collating/code value. Strict mode accepts only the ASCII PCS `0..127`; normal mode accepts Unicode scalar codes and rejects surrogates/out-of-range values. |
 | `number_chars(?Number,?Chars)`, `number_codes(?Number,?Codes)` | Convert finite numbers to canonical text or parse a proper character/code list using ISO number and negative-number syntax, including radix integers, character-code constants, and leading layout. The input is not parsed as a general term: grouping such as `(0)` is a syntax error. At least one side must be instantiated; malformed numeric input raises *syntax_error(number)*. |
 
 Conversions accept partial output lists when the atomic input is known, but
@@ -6078,12 +6091,12 @@ input or output.
 | `at_end_of_stream`, `at_end_of_stream(+Stream)` | Succeeds when the current or selected input position is at or beyond its content. |
 | `get_char(?Character)`, `get_char(+Stream,?Character)` | Reads one text character; end of input is `end_of_file`. |
 | `peek_char(?Character)`, `peek_char(+Stream,?Character)` | Observes the next text character without advancing. |
-| `get_code(?Code)`, `get_code(+Stream,?Code)` | Reads a Unicode code point; end of input is `-1`. |
-| `peek_code(?Code)`, `peek_code(+Stream,?Code)` | Observes the next Unicode code point without advancing. |
+| `get_code(?Code)`, `get_code(+Stream,?Code)` | Reads a character code; end of input is `-1`. Strict mode requires the ASCII PCS, while normal mode returns Unicode scalar codes. |
+| `peek_code(?Code)`, `peek_code(+Stream,?Code)` | Observes the next character code without advancing; strict mode requires the ASCII PCS. |
 | `get_byte(?Byte)`, `get_byte(+Stream,?Byte)` | Reads one unit from a binary stream; end of input is `-1`. |
 | `peek_byte(?Byte)`, `peek_byte(+Stream,?Byte)` | Observes the next binary unit without advancing. |
 | `put_char(+Character)`, `put_char(+Stream,+Character)` | Writes one character atom to a text stream. |
-| `put_code(+Code)`, `put_code(+Stream,+Code)` | Writes one Unicode scalar code to a text stream. |
+| `put_code(+Code)`, `put_code(+Stream,+Code)` | Writes one character code to a text stream. Strict mode accepts `0..127`; normal mode accepts Unicode scalar codes. |
 | `put_byte(+Byte)`, `put_byte(+Stream,+Byte)` | Writes an integer in `0..255` to a binary stream. |
 | `nl`, `nl(+Stream)` | Writes a newline to a text stream. |
 
@@ -7636,8 +7649,11 @@ conformance audit; it does **not** yet claim that every processor requirement
 has been independently certified. `test/conformance/ISO-COMPLIANCE.md` tracks
 the remaining normative audit work. The executable examples are mostly
 EyeProlog-profile programs using host-supplied goals, character lists, explicit
-integrity relations, automatic tabling, and the EyeProlog library. The
-remaining qualifications are:
+integrity relations, automatic tabling, and the EyeProlog library. The strict audit also exercises the complete Part 1 flag
+set and the prescribed 8.14 error precedence for `read_term/3`, `write_term/3`,
+`op/3`, and `current_op/3`; these checks distinguish invalid values from
+valid-but-fixed flag values and reject normal-profile write options at the
+strict boundary. The remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom
   `ready`;
@@ -7645,8 +7661,11 @@ remaining qualifications are:
 - variables cannot occupy functor or predicate position;
 - double-quoted text follows `double_quotes` exactly; the default `chars` value
   matches Trealla and Scryer and may be changed to `codes` or `atom`;
-- `write_term/2-3` implements `quoted/1`, `ignore_ops/1`, `numbervars/1`,
-  and `variable_names/1`, including Corrigendum 3 option validation and traversal rules;
+- `write_term/2-3` implements the Part 1 plus Corrigendum 3 `quoted/1`,
+  `ignore_ops/1`, `numbervars/1`, and `variable_names/1` option surface,
+  including option validation and traversal rules; normal mode also offers
+  `double_quotes(true|false)` as an explicitly non-standard extension, which
+  strict mode rejects;
 - unification consistently performs an occurs check, rejecting rational-tree
   bindings accepted as extensions by some systems.
 

package/why-eyeprolog.md

@@ -19,7 +19,10 @@ 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. Its executable conformance matrix and tests
+profiles for normal-mode programs. Strict mode makes its processor character
+model explicit: 7-bit ASCII is the PCS, ASCII code points are the collating
+integers, and normal-mode Unicode character data is an extension rather than an
+implicit part of the Part 1 claim. 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
 claim that every Part 1, Part 2, or Part 3 normative requirement has already