eyeprolog 1.3.44 → 1.3.45

package/README.md

@@ -223,7 +223,12 @@ 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 complete Part 1 flag defaults/value domains/changeability rules. The
+ongoing issue #65 audit additionally tightens Prolog-text declaration ordering,
+initialization lifetime, stream/open/close behavior, character/byte stream
+errors, `keysort/2` error cases, and strict arithmetic-extension boundaries.
+Those additions improve the Part 1 surface without turning the remaining audit
+rows into a blanket conformance claim.
 
 The auditable processor-requirement checklist lives in
 [`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).

package/package.json

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

package/src/io.js

@@ -88,8 +88,13 @@ export class StreamManager {
       const raw = fs.readFileSync(path);
       if (type === 'binary') content = raw;
       else { content = decodeUtf8ForTextStream(raw); strictUtf8 = true; }
-    } else if (mode === 'append' && fs.existsSync(path)) {
-      content = fs.readFileSync(path, type === 'binary' ? null : 'utf8');
+    } else if (mode === 'write') {
+      // ISO 7.10.1.1: opening an existing sink in write mode empties it,
+      // while a missing sink is created at open time (not deferred to close).
+      fs.writeFileSync(path, type === 'binary' ? BufferCtor.from([]) : '');
+    } else if (mode === 'append') {
+      if (fs.existsSync(path)) content = fs.readFileSync(path, type === 'binary' ? null : 'utf8');
+      else fs.writeFileSync(path, type === 'binary' ? BufferCtor.from([]) : '');
     }
     if (BufferCtor?.isBuffer(content)) content = [...content];
     return this.add({
@@ -100,13 +105,18 @@ export class StreamManager {
       pastEnd: false,
     });
   }
-  close(stream) {
-    if (!stream.standard && stream.mode !== 'read') {
-      fs.writeFileSync(stream.path, stream.type === 'binary' ? BufferCtor.from(stream.content) : stream.content);
-    }
+  flush(stream) {
+    if (!stream || stream.standard || stream.mode === 'read') return;
+    fs.writeFileSync(stream.path, stream.type === 'binary' ? BufferCtor.from(stream.content) : stream.content);
+  }
+  discard(stream) {
     if (stream.alias) this.aliases.delete(stream.alias);
     this.streams.delete(stream.id);
   }
+  close(stream) {
+    this.flush(stream);
+    this.discard(stream);
+  }
   readUnit(stream, peek = false) {
     if (stream.position >= stream.content.length) return null;
     if (stream.type === 'binary') {
@@ -126,9 +136,22 @@ export class StreamManager {
     return value;
   }
   writeUnit(stream, value) {
-    if (stream.standard && stream.write) stream.write(String(value));
-    else if (stream.type === 'binary') stream.content.push(value);
-    else stream.content += value;
-    stream.position = stream.content.length;
+    if (stream.standard && stream.write) {
+      stream.write(String(value));
+      return;
+    }
+    // 7.10.2.8: output after repositioning overwrites the existing sink
+    // contents at the selected stream position rather than always appending.
+    if (stream.type === 'binary') {
+      if (stream.position < stream.content.length) stream.content[stream.position] = value;
+      else stream.content.push(value);
+      stream.position++;
+      return;
+    }
+    const text = String(value);
+    const content = String(stream.content);
+    const end = Math.min(content.length, stream.position + text.length);
+    stream.content = `${content.slice(0, stream.position)}${text}${content.slice(end)}`;
+    stream.position += text.length;
   }
 }

package/src/iso-arithmetic.js

@@ -5,7 +5,7 @@ import {
 } from './term.js';
 import { PrologError } from './errors.js';
 
-function evaluate(term, env) {
+function evaluate(term, env, options = {}) {
   term = deref(term, env);
   if (term.type === VAR) throw new PrologError('instantiation_error');
   if (term.type === NUMBER) {
@@ -16,10 +16,11 @@ function evaluate(term, env) {
   }
   if (term.type === ATOM) {
     if (term.name === 'pi') return { integer: false, value: Math.PI };
-    if (term.name === 'e') return { integer: false, value: Math.E };
+    if (term.name === 'e' && options.isoStrict !== true) return { integer: false, value: Math.E };
+    throw new PrologError('type_error(evaluable)', compound('/', [atom(term.name), numberTerm(0)]));
   }
   if (term.type !== COMPOUND) throw new PrologError('type_error(evaluable)', term);
-  const args = term.args.map((arg) => evaluate(arg, env));
+  const args = term.args.map((arg) => evaluate(arg, env, options));
   return evaluateOperation(term, args);
 }
 function evaluateOperation(term, args) {
@@ -120,8 +121,8 @@ export function arithmeticValueTerm(value) {
 function numericTerm(value) {
   return arithmeticValueTerm(value);
 }
-export function evaluateArithmetic(term, env) {
-  return evaluate(term, env);
+export function evaluateArithmetic(term, env, options = {}) {
+  return evaluate(term, env, options);
 }
 function compareIntegerToFloat(integerValue, floatValue) {
   if (!Number.isFinite(floatValue)) throw new PrologError('evaluation_error(float_overflow)');
@@ -151,15 +152,16 @@ export function compareArithmeticValues(left, right) {
   if (right.integer) return -compareIntegerToFloat(b, a);
   return a < b ? -1 : a > b ? 1 : 0;
 }
-export function* isBuiltin({ goal, env }) {
-  const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env));
+export function* isBuiltin({ solver, goal, env }) {
+  const result = arithmeticValueTerm(evaluateArithmetic(goal.args[1], env, { isoStrict: solver?.isoStrict === true }));
   const next = env.clone();
   if (unify(goal.args[0], result, next)) yield next;
 }
 export function arithmeticComparison(test) {
-  return function* ({ goal, env }) {
-    const left = evaluateArithmetic(goal.args[0], env);
-    const right = evaluateArithmetic(goal.args[1], env);
+  return function* ({ solver, goal, env }) {
+    const options = { isoStrict: solver?.isoStrict === true };
+    const left = evaluateArithmetic(goal.args[0], env, options);
+    const right = evaluateArithmetic(goal.args[1], env, options);
     const cmp = compareArithmeticValues(left, right);
     if (test(cmp)) yield env;
   };

package/src/iso.js

@@ -96,7 +96,7 @@ export const isoBuiltins = {
     registry.add('current_output', 1, currentOutputBuiltin, { deterministic: true });
     registry.add('set_input', 1, setCurrentStreamBuiltin('read'), { deterministic: true });
     registry.add('set_output', 1, setCurrentStreamBuiltin('write'), { deterministic: true });
-    registry.add('flush_output', 0, succeed, { deterministic: true });
+    registry.add('flush_output', 0, flushOutputBuiltin, { deterministic: true });
     registry.add('flush_output', 1, flushOutputBuiltin, { deterministic: true });
     registry.add('stream_property', 2, streamPropertyBuiltin);
     registry.add('set_stream_position', 2, setStreamPositionBuiltin, { deterministic: true });
@@ -346,10 +346,18 @@ function* keysortBuiltin({ goal, env }) {
   validateListOutput(goal.args[1], env);
   for (const item of items) {
     const resolved = deref(item, env);
+    if (resolved.type === VAR) throw new PrologError('instantiation_error');
     if (resolved.type !== COMPOUND || resolved.name !== '-' || resolved.arity !== 2) {
       throw new PrologError('type_error(pair)', resolved);
     }
   }
+  const { items: outputPrefix } = listElements(goal.args[1], env);
+  for (const item of outputPrefix) {
+    if (item.type === VAR) continue;
+    if (item.type !== COMPOUND || item.name !== '-' || item.arity !== 2) {
+      throw new PrologError('type_error(pair)', item);
+    }
+  }
   // Modern ECMAScript specifies a stable Array#sort, as required by keysort/2.
   // Keep one implementation-dependent variable order for this whole sorting
   // operation, as required by ISO 7.2.1.
@@ -830,6 +838,16 @@ function streamReference(term, env) {
   throw new PrologError('domain_error(stream_or_alias)', value);
 }
 
+function streamTermReference(term, env) {
+  const value = deref(term, env);
+  if (value.type === VAR) return null;
+  if (value.type === COMPOUND && value.name === '$stream' && value.arity === 1 &&
+      value.args[0].type === NUMBER && isDecimalInteger(value.args[0].name)) {
+    return Number(value.args[0].name);
+  }
+  throw new PrologError('domain_error(stream)', value);
+}
+
 function requireStream(solver, term, env, mode = null) {
   const culprit = deref(term, env);
   const stream = solver.io.resolve(streamReference(term, env));
@@ -886,13 +904,14 @@ function openOptions(term, env) {
     if ((value = optionAtom(option, 'type'))) {
       value = deref(value, env);
       if (value.type === VAR) throw new PrologError('instantiation_error');
-      if (value.type !== ATOM) throw new PrologError('type_error(atom)', value);
-      if (!['text', 'binary'].includes(value.name)) throw new PrologError('domain_error(stream_option)', option);
+      if (value.type !== ATOM || !['text', 'binary'].includes(value.name)) {
+        throw new PrologError('domain_error(stream_option)', option);
+      }
       result.type = value.name;
     } else if ((value = optionAtom(option, 'alias'))) {
       value = deref(value, env);
       if (value.type === VAR) throw new PrologError('instantiation_error');
-      if (value.type !== ATOM) throw new PrologError('type_error(atom)', value);
+      if (value.type !== ATOM) throw new PrologError('domain_error(stream_option)', option);
       result.alias = value.name;
     } else if ((value = optionAtom(option, 'reposition'))) {
       value = deref(value, env);
@@ -911,19 +930,45 @@ function openOptions(term, env) {
   return result;
 }
 
+function streamOptionHasRequiredVariable(option, env) {
+  option = deref(option, env);
+  if (option.type !== COMPOUND || option.arity !== 1 ||
+      !['type', 'alias', 'reposition', 'eof_action'].includes(option.name)) return false;
+  return deref(option.args[0], env).type === VAR;
+}
+
 function* openBuiltin({ solver, goal, env }) {
-  const path = requireAtom(goal.args[0], env);
-  const mode = requireAtom(goal.args[1], env);
-  if (!['read', 'write', 'append'].includes(mode.name)) throw new PrologError('domain_error(io_mode)', mode);
+  const source = deref(goal.args[0], env);
+  const mode = deref(goal.args[1], env);
   const streamTarget = deref(goal.args[2], env);
+  const optionTerm = goal.arity === 3 ? emptyList() : goal.args[3];
+
+  // ISO 8.11.5.3 + Corrigenda 2/3.  Keep each prescribed condition
+  // observable on its own and apply the published ordering for deterministic
+  // diagnostics when several arguments are erroneous.
+  if (source.type === VAR) throw new PrologError('instantiation_error');
+  if (mode.type === VAR) throw new PrologError('instantiation_error');
+  const preflight = preflightOptionList(optionTerm, env);
+  if (preflight.items.some((option) => streamOptionHasRequiredVariable(option, env))) {
+    throw new PrologError('instantiation_error');
+  }
+  if (mode.type !== ATOM) throw new PrologError('type_error(atom)', mode);
+  const optionItems = requireProperOptionList(preflight);
   if (streamTarget.type !== VAR) throw new PrologError('uninstantiation_error', streamTarget);
-  const options = goal.arity === 3 ? {} : openOptions(goal.args[3], env);
-  if (options.alias && solver.io.resolve(options.alias)) throw new PrologError('permission_error(open, source_sink)', atom(options.alias));
+  if (source.type !== ATOM) throw new PrologError('domain_error(source_sink)', source);
+  if (!['read', 'write', 'append'].includes(mode.name)) throw new PrologError('domain_error(io_mode)', mode);
+  const options = goal.arity === 3 ? {} : openOptions(optionTerm, env);
+  if (options.alias && solver.io.resolve(options.alias)) {
+    throw new PrologError('permission_error(open, source_sink)', atom(options.alias));
+  }
   let stream;
   try {
-    stream = solver.io.open(path.name, mode.name, options);
-  } catch (_) {
-    throw new PrologError('existence_error(source_sink)', path);
+    stream = solver.io.open(source.name, mode.name, options);
+  } catch (error) {
+    if (error?.code === 'ENOENT' && mode.name === 'read') {
+      throw new PrologError('existence_error(source_sink)', source);
+    }
+    throw new PrologError('permission_error(open, source_sink)', source);
   }
   const next = env.clone();
   if (unify(goal.args[2], streamHandle(stream.id), next)) yield next;
@@ -931,22 +976,35 @@ function* openBuiltin({ solver, goal, env }) {
 }
 
 function* closeBuiltin({ solver, goal, env }) {
-  if (goal.arity === 2) {
-    for (const option of optionList(goal.args[1], env)) {
-      if (option.type === VAR) throw new PrologError('instantiation_error');
-      const force = optionAtom(option, 'force');
-      const value = force && deref(force, env);
-      if (value?.type === VAR) throw new PrologError('instantiation_error');
-      if (!value || value.type !== ATOM || !['true', 'false'].includes(value.name)) {
-        throw new PrologError('domain_error(close_option)', option);
-      }
+  const reference = deref(goal.args[0], env);
+  if (reference.type === VAR) throw new PrologError('instantiation_error');
+  const optionTerm = goal.arity === 2 ? goal.args[1] : emptyList();
+  const preflight = preflightOptionList(optionTerm, env);
+  if (preflight.items.some((option) => {
+    const force = optionAtom(option, 'force');
+    return force != null && deref(force, env).type === VAR;
+  })) throw new PrologError('instantiation_error');
+  const options = requireProperOptionList(preflight);
+  streamReference(goal.args[0], env);
+  let forceClose = false;
+  for (const option of options) {
+    const force = optionAtom(option, 'force');
+    const value = force && deref(force, env);
+    if (!value || value.type !== ATOM || !['true', 'false'].includes(value.name)) {
+      throw new PrologError('domain_error(close_option)', option);
     }
+    forceClose = value.name === 'true'; // rightmost contradictory option applies
   }
   const stream = requireStream(solver, goal.args[0], env);
   if (!stream.standard) {
+    try {
+      solver.io.close(stream);
+    } catch (_) {
+      if (!forceClose) throw new PrologError('system_error');
+      solver.io.discard(stream);
+    }
     if (solver.io.currentInput === stream.id) solver.io.currentInput = 0;
     if (solver.io.currentOutput === stream.id) solver.io.currentOutput = 1;
-    solver.io.close(stream);
   }
   yield env;
 }
@@ -954,7 +1012,8 @@ function* closeBuiltin({ solver, goal, env }) {
 function* currentInputBuiltin({ solver, goal, env }) {
   const value = deref(goal.args[0], env);
   if (value.type !== VAR) {
-    const stream = solver.io.resolve(streamReference(goal.args[0], env));
+    const id = streamTermReference(goal.args[0], env);
+    const stream = solver.io.resolve(id);
     if (!stream) throw new PrologError('domain_error(stream)', value);
     if (stream.id === solver.io.currentInput) yield env;
     return;
@@ -965,7 +1024,8 @@ function* currentInputBuiltin({ solver, goal, env }) {
 function* currentOutputBuiltin({ solver, goal, env }) {
   const value = deref(goal.args[0], env);
   if (value.type !== VAR) {
-    const stream = solver.io.resolve(streamReference(goal.args[0], env));
+    const id = streamTermReference(goal.args[0], env);
+    const stream = solver.io.resolve(id);
     if (!stream) throw new PrologError('domain_error(stream)', value);
     if (stream.id === solver.io.currentOutput) yield env;
     return;
@@ -973,6 +1033,7 @@ function* currentOutputBuiltin({ solver, goal, env }) {
   const next = env.clone();
   if (unify(goal.args[0], streamHandle(solver.io.currentOutput), next)) yield next;
 }
+
 function setCurrentStreamBuiltin(mode) {
   return function* ({ solver, goal, env }) {
     const stream = requireStream(solver, goal.args[0], env, mode);
@@ -982,7 +1043,14 @@ function setCurrentStreamBuiltin(mode) {
   };
 }
 function* flushOutputBuiltin({ solver, goal, env }) {
-  requireStream(solver, goal.args[0], env, 'write');
+  const stream = goal.arity === 0
+    ? solver.io.resolve(solver.io.currentOutput)
+    : requireStream(solver, goal.args[0], env, 'write');
+  try {
+    solver.io.flush(stream);
+  } catch (_) {
+    throw new PrologError('system_error');
+  }
   yield env;
 }
 
@@ -1003,23 +1071,51 @@ function streamProperties(stream) {
   return properties;
 }
 function* setStreamPositionBuiltin({ solver, goal, env }) {
-  const stream = requireStream(solver, goal.args[0], env);
-  if (!stream.reposition) throw new PrologError('permission_error(reposition, stream)', deref(goal.args[0], env));
+  const reference = deref(goal.args[0], env);
+  if (reference.type === VAR) throw new PrologError('instantiation_error');
   let position = deref(goal.args[1], env);
-  if (position.type === COMPOUND && position.name === 'position' && position.arity === 1) {
+  if (position.type === VAR) throw new PrologError('instantiation_error');
+  streamReference(goal.args[0], env);
+  if (!solver.isoStrict && position.type === COMPOUND && position.name === 'position' && position.arity === 1) {
+    // Historical EyeProlog convenience form.  Strict Part 1 mode uses only
+    // the implementation-defined integer stream-position terms returned by
+    // stream_property/2.
     position = deref(position.args[0], env);
   }
-  if (position.type === VAR) throw new PrologError('instantiation_error');
-  if (position.type !== NUMBER || !isDecimalInteger(position.name)) throw new PrologError('domain_error(stream_position)', position);
+  if (position.type === VAR || position.type !== NUMBER || !isDecimalInteger(position.name)) {
+    throw new PrologError('domain_error(stream_position)', position);
+  }
   const offset = BigInt(position.name);
-  if (offset < 0n || offset > BigInt(stream.content.length)) throw new PrologError('domain_error(stream_position)', position);
+  if (offset < 0n) throw new PrologError('domain_error(stream_position)', position);
+  const stream = requireStream(solver, goal.args[0], env);
+  if (!stream.reposition) throw new PrologError('permission_error(reposition, stream)', reference);
+  if (offset > BigInt(stream.content.length)) throw new PrologError('domain_error(stream_position)', position);
   stream.position = Number(offset);
   stream.pastEnd = false;
   yield env;
 }
+
+function isStreamPropertyPattern(value) {
+  if (value.type === VAR) return true;
+  if (value.type === ATOM) return value.name === 'input' || value.name === 'output';
+  return value.type === COMPOUND && value.arity === 1 && [
+    'file_name', 'mode', 'alias', 'position', 'end_of_stream', 'eof_action', 'reposition', 'type',
+  ].includes(value.name);
+}
+
 function* streamPropertyBuiltin({ solver, goal, env }) {
   const reference = deref(goal.args[0], env);
-  const streams = reference.type === VAR ? [...solver.io.streams.values()] : [requireStream(solver, goal.args[0], env)];
+  const propertyPattern = deref(goal.args[1], env);
+  if (reference.type !== VAR) {
+    const id = streamTermReference(goal.args[0], env);
+    if (!solver.io.resolve(id)) throw new PrologError('domain_error(stream)', reference);
+  }
+  if (!isStreamPropertyPattern(propertyPattern)) {
+    throw new PrologError('domain_error(stream_property)', propertyPattern);
+  }
+  const streams = reference.type === VAR
+    ? [...solver.io.streams.values()]
+    : [solver.io.resolve(streamTermReference(goal.args[0], env))];
   for (const stream of streams) {
     for (const property of streamProperties(stream)) {
       const next = env.clone();
@@ -1035,27 +1131,69 @@ function outputStreamFor(solver, goal, env) {
   return goal.arity === 1 ? solver.io.resolve(solver.io.currentOutput) : requireStream(solver, goal.args[0], env, 'write');
 }
 function* atEndBuiltin({ solver, goal, env }) {
-  const stream = goal.arity === 0 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env, 'read');
-  if (stream.position >= stream.content.length) yield env;
+  // at_end_of_stream/1 is bootstrapped in Part 1 from the end_of_stream/1
+  // stream property and therefore accepts any open stream-or-alias; it is not
+  // an input-only operation.
+  const stream = goal.arity === 0 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env);
+  if (stream.pastEnd || stream.position >= stream.content.length) yield env;
+}
+function validStrictInputCharacterCode(value, solver) {
+  if (value.type !== NUMBER || !isDecimalInteger(value.name)) return false;
+  const code = BigInt(value.name);
+  if (code === -1n) return true;
+  if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) return false;
+  return !solver.isoStrict || isStrictIsoPcsCodePoint(Number(code));
 }
+
+function preflightInputUnitTarget(name, target, env, solver) {
+  const value = deref(target, env);
+  if (name.endsWith('char')) {
+    if (value.type !== VAR && !(oneChar(value) || (value.type === ATOM && value.name === 'end_of_file'))) {
+      throw new PrologError('type_error(in_character)', value);
+    }
+    if (value.type === ATOM && oneChar(value) && solver.isoStrict && !isStrictIsoPcsCharacter(value.name)) {
+      throw new PrologError('type_error(in_character)', value);
+    }
+  } else if (name.endsWith('code')) {
+    if (value.type !== VAR && (value.type !== NUMBER || !isDecimalInteger(value.name))) {
+      throw new PrologError('type_error(integer)', value);
+    }
+    if (value.type !== VAR && !validStrictInputCharacterCode(value, solver)) {
+      throw new PrologError('representation_error(in_character_code)');
+    }
+  } else {
+    if (value.type !== VAR) {
+      if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(in_byte)', value);
+      const byte = BigInt(value.name);
+      if (byte !== -1n && (byte < 0n || byte > 255n)) throw new PrologError('type_error(in_byte)', value);
+    }
+  }
+  return value;
+}
+
 function inputUnitBuiltin(name) {
   return function* ({ solver, goal, env }) {
+    const explicit = goal.arity === 2;
+    if (explicit && deref(goal.args[0], env).type === VAR) throw new PrologError('instantiation_error');
+    const target = goal.args[goal.arity - 1];
+    preflightInputUnitTarget(name, target, env, solver);
     const stream = inputStreamFor(solver, goal, env);
     const binary = name.endsWith('byte');
-    if (binary !== (stream.type === 'binary')) throw new PrologError('permission_error(input, stream)', streamHandle(stream.id));
+    if (binary && stream.type !== 'binary') {
+      throw new PrologError('permission_error(input, text_stream)', streamHandle(stream.id));
+    }
+    if (!binary && stream.type !== 'text') {
+      throw new PrologError('permission_error(input, binary_stream)', streamHandle(stream.id));
+    }
     if (stream.pastEnd && stream.eofAction === 'error') {
       throw new PrologError('permission_error(input, past_end_of_stream)', streamHandle(stream.id));
     }
     if (stream.pastEnd && stream.eofAction === 'reset') {
-      // A terminal EOF (Ctrl-D) is local to one input operation. The next
-      // operation should wait for fresh terminal input rather than rewinding
-      // and replaying the already-consumed interactive buffer.
       if (typeof stream.interactiveReadUnit !== 'function') stream.position = 0;
       stream.pastEnd = false;
     }
     const peek = name.startsWith('peek');
-    if (stream.position >= stream.content.length &&
-        typeof stream.interactiveReadUnit === 'function') {
+    if (stream.position >= stream.content.length && typeof stream.interactiveReadUnit === 'function') {
       const text = stream.interactiveReadUnit();
       if (text != null) {
         stream.content += String(text);
@@ -1066,50 +1204,68 @@ function inputUnitBuiltin(name) {
     try {
       unit = solver.io.readUnit(stream, peek);
     } catch (error) {
-      if (error?.name === 'InvalidCharacterEncodingError') {
-        throw new PrologError('representation_error(character)');
-      }
+      if (error?.name === 'InvalidCharacterEncodingError') throw new PrologError('representation_error(character)');
       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'))
+    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];
     const next = env.clone();
     if (unify(target, result, next)) yield next;
   };
 }
+
+function preflightOutputUnitValue(name, target, env) {
+  const value = deref(target, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (name === 'put_char') {
+    if (!oneChar(value)) throw new PrologError('type_error(character)', value);
+    return value;
+  }
+  if (name === 'put_byte') {
+    if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(byte)', value);
+    const byte = BigInt(value.name);
+    if (byte < 0n || byte > 255n) throw new PrologError('type_error(byte)', value);
+    return value;
+  }
+  if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
+  return value;
+}
+
 function outputUnitBuiltin(name) {
   return function* ({ solver, goal, env }) {
+    const explicit = goal.arity === 2;
+    if (explicit && deref(goal.args[0], env).type === VAR) throw new PrologError('instantiation_error');
+    const value = preflightOutputUnitValue(name, goal.args[goal.arity - 1], env);
     const stream = outputStreamFor(solver, goal, env);
-    const value = deref(goal.args[goal.arity - 1], env);
-    if (value.type === VAR) throw new PrologError('instantiation_error');
     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') {
+      if (stream.type !== 'binary') throw new PrologError('permission_error(output, text_stream)', streamHandle(stream.id));
+      solver.io.writeUnit(stream, Number(value.name));
     } else {
-      if ((name === 'put_byte') !== (stream.type === 'binary')) {
-        throw new PrologError('permission_error(output, stream)', streamHandle(stream.id));
-      }
-      if (value.type !== NUMBER || !isDecimalInteger(value.name)) throw new PrologError('type_error(integer)', value);
+      if (stream.type !== 'text') throw new PrologError('permission_error(output, binary_stream)', streamHandle(stream.id));
       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))) {
+      if (code < 0n || code > 0x10ffffn || (code >= 0xd800n && code <= 0xdfffn)) {
+        throw new PrologError('representation_error(character_code)');
+      }
+      if (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)));
+      solver.io.writeUnit(stream, String.fromCodePoint(Number(code)));
     }
     yield env;
   };
 }
+
 function* nlBuiltin({ solver, goal, env }) {
   const stream = goal.arity === 0
     ? solver.io.resolve(solver.io.currentOutput)
@@ -1274,6 +1430,13 @@ export function isCompleteReadTermText(text, solver) {
 }
 
 function readTermFromStream(stream, solver) {
+  if (stream.pastEnd && stream.eofAction === 'error') {
+    throw new PrologError('permission_error(input, past_end_of_stream)', streamHandle(stream.id));
+  }
+  if (stream.pastEnd && stream.eofAction === 'reset') {
+    if (typeof stream.interactiveReadTerm !== 'function') stream.position = 0;
+    stream.pastEnd = false;
+  }
   let requestedInteractiveTerm = false;
   while (true) {
     let sawCandidate = false;
@@ -1317,6 +1480,7 @@ function readTermFromStream(stream, solver) {
     stream.position = source.length;
     if (!sawCandidate) {
       if (hasNonLayoutRemainder(source, remainderStart)) throw new PrologError('syntax_error(read_term)');
+      stream.pastEnd = true;
       return { term: atom('end_of_file'), variables: [] };
     }
     throw new PrologError('syntax_error(read_term)');
@@ -1789,14 +1953,14 @@ function canonicalNumberText(value) {
   return text;
 }
 
-function numberListText(list, env, kind, valueIsBound) {
+function numberListText(list, env, kind, valueIsBound, solver = null) {
   const whole = deref(list, env);
   const { items, tail } = listElements(list, env);
   const proper = tail.type === ATOM && tail.name === '[]';
   if (tail.type !== VAR && !proper) throw new PrologError('type_error(list)', whole);
 
   const invalid = items.find((item) => item.type !== VAR &&
-    (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item)));
+    (kind === 'chars' ? !oneChar(item) : !validCharacterCode(item, solver)));
   if (invalid) {
     if (kind === 'chars') throw new PrologError('type_error(character)', invalid);
     if (invalid.type !== NUMBER || !isDecimalInteger(invalid.name)) {
@@ -1816,12 +1980,12 @@ function numberListText(list, env, kind, valueIsBound) {
 const numberSyntaxError = new PrologError('syntax_error(number)');
 
 function numberListBuiltin(kind) {
-  return function* ({ goal, env }) {
+  return function* ({ solver, goal, env }) {
     const value = deref(goal.args[0], env);
     if (value.type !== VAR && value.type !== NUMBER) throw new PrologError('type_error(number)', value);
     const list = deref(goal.args[1], env);
     if (value.type === VAR && list.type === VAR) throw new PrologError('instantiation_error');
-    const text = numberListText(list, env, kind, value.type === NUMBER);
+    const text = numberListText(list, env, kind, value.type === NUMBER, solver);
     if (value.type === NUMBER) {
       if (text != null) {
         const parsed = parseIsoNumber(text);

package/src/program.js

@@ -44,6 +44,8 @@ export class Program {
     this.libraryImports = [];
     this.interopPortabilityWarnings = [];
     this.dynamicPredicates = new Set();
+    this.multifilePredicates = new Set();
+    this.discontiguousPredicates = new Set();
     this.strictIso = options.isoStrict === true;
     this.operators = new Map();
     const predefinedOperatorSets = this.strictIso
@@ -55,6 +57,7 @@ export class Program {
       }
     }
     this.initializations = [];
+    this._initializationsExecuted = false;
     this.quads = [];
     this.prologFlagDirectives = [];
     this.charConversionDirectives = [];
@@ -476,11 +479,94 @@ class ProgramBuilder {
     this.options = options;
     this.program = program ?? new Program([], { ...options, [DEFER_PROGRAM_BUILD]: true });
     this.declaredDynamicIndicators = new Map();
+    this.declaredMultifileIndicators = new Map();
+    this.declaredDiscontiguousIndicators = new Map();
+    this.directiveDeclarationsByText = new Map();
+    this.clauseTextUnitsByKey = new Map();
+    this.lastPredicateByText = new Map();
     this.lastGroupKey = null;
     this.lastGroup = null;
     this.finished = false;
   }
 
+  declarationSet(textUnit, kind) {
+    const unit = textUnit ?? '<input>';
+    let declarations = this.directiveDeclarationsByText.get(unit);
+    if (!declarations) {
+      declarations = { dynamic: new Set(), multifile: new Set(), discontiguous: new Set() };
+      this.directiveDeclarationsByText.set(unit, declarations);
+    }
+    return declarations[kind];
+  }
+
+  noteProcedureClause(key, textUnit) {
+    if (!this.program.strictIso) return;
+    const unit = textUnit ?? '<input>';
+    const declarations = this.directiveDeclarationsByText.get(unit);
+    const units = this.clauseTextUnitsByKey.get(key) ?? new Set();
+
+    if (this.program.dynamicPredicates.has(key) && !declarations?.dynamic.has(key)) {
+      throw new Error(`ISO preparation error: dynamic(${key}) must precede clauses for ${key} in every Prolog text`);
+    }
+
+    if (units.size > 0 && !units.has(unit)) {
+      if (!declarations?.multifile.has(key)) {
+        throw new Error(`ISO preparation error: multifile(${key}) is required before clauses for ${key} in this Prolog text`);
+      }
+      for (const prior of units) {
+        if (!this.directiveDeclarationsByText.get(prior)?.multifile.has(key)) {
+          throw new Error(`ISO preparation error: multifile(${key}) is required in every Prolog text containing clauses for ${key}`);
+        }
+      }
+    }
+
+    const last = this.lastPredicateByText.get(unit);
+    if (last != null && last !== key && units.has(unit) && !declarations?.discontiguous.has(key)) {
+      throw new Error(`ISO preparation error: discontiguous(${key}) must precede non-consecutive clauses for ${key}`);
+    }
+    units.add(unit);
+    this.clauseTextUnitsByKey.set(key, units);
+    this.lastPredicateByText.set(unit, key);
+  }
+
+  addProcedureDirective(clause, kind, targetSet, declaredMap) {
+    const program = this.program;
+    const indicators = procedureDirectiveIndicators(clause, kind, program.strictIso);
+    if (indicators == null) return false;
+    const textUnit = clause.textUnit ?? '<input>';
+    const local = this.declarationSet(textUnit, kind);
+    for (const indicator of indicators) {
+      assertDynamicIndicatorIsDefinable(indicator, program.strictIso);
+      const module = clause.module ?? 'user';
+      const key = modulePredicateKey(module, indicator.name, indicator.arity);
+      if (program.strictIso && this.clauseTextUnitsByKey.get(key)?.has(textUnit)) {
+        throw new Error(`ISO preparation error: ${kind}(${indicator.key}) must precede all clauses for ${indicator.key}`);
+      }
+      if (program.strictIso && kind === 'dynamic') {
+        for (const prior of this.clauseTextUnitsByKey.get(key) ?? []) {
+          if (prior !== textUnit && !this.directiveDeclarationsByText.get(prior)?.dynamic.has(key)) {
+            throw new Error(`ISO preparation error: dynamic(${indicator.key}) is required in every Prolog text containing clauses for ${indicator.key}`);
+          }
+        }
+      }
+      if (program.strictIso && kind === 'multifile') {
+        for (const prior of this.clauseTextUnitsByKey.get(key) ?? []) {
+          if (prior !== textUnit && !this.directiveDeclarationsByText.get(prior)?.multifile.has(key)) {
+            throw new Error(`ISO preparation error: multifile(${indicator.key}) is required in every Prolog text containing clauses for ${indicator.key}`);
+          }
+        }
+      }
+      local.add(key);
+      targetSet.add(key);
+      declaredMap.set(`${textUnit}\u0000${key}`, { ...indicator, key, module, textUnit });
+      if (kind === 'dynamic') {
+        const existing = program.groups.get(key);
+        if (existing) existing.dynamic = true;
+      }
+    }
+    return true;
+  }
+
   addClauses(clauses) {
     if (this.finished) throw new Error('program builder is already finalized');
     const program = this.program;
@@ -501,6 +587,7 @@ class ProgramBuilder {
         assertPredicateIsDefinable(clause.headName, 2, program.strictIso);
         const module = clause.module ?? 'user';
         const key = modulePredicateKey(module, clause.headName, 2);
+        this.noteProcedureClause(key, clause.textUnit);
         let group = key === lastGroupKey ? lastGroup : program.groups.get(key);
         if (!group) {
           group = program.makeGroup(clause.headName, 2, module);
@@ -524,6 +611,7 @@ class ProgramBuilder {
         if (head.type !== ATOM && head.type !== COMPOUND) continue;
         const module = clause.module ?? 'user';
         const key = modulePredicateKey(module, head.name, head.arity);
+        this.noteProcedureClause(key, clause.textUnit);
         let group = key === lastGroupKey ? lastGroup : program.groups.get(key);
         if (!group) {
           group = program.makeGroup(head.name, head.arity, module);
@@ -553,14 +641,10 @@ class ProgramBuilder {
   addDirectiveClause(clause) {
     const program = this.program;
     const module = clause.module ?? 'user';
-    for (const indicator of dynamicDirectiveIndicators(clause)) {
-      assertDynamicIndicatorIsDefinable(indicator, program.strictIso);
-      const key = modulePredicateKey(module, indicator.name, indicator.arity);
-      program.dynamicPredicates.add(key);
-      this.declaredDynamicIndicators.set(key, { ...indicator, key, module });
-      const existing = program.groups.get(key);
-      if (existing) existing.dynamic = true;
-    }
+    const textUnit = clause.textUnit ?? '<input>';
+    this.addProcedureDirective(clause, 'dynamic', program.dynamicPredicates, this.declaredDynamicIndicators);
+    this.addProcedureDirective(clause, 'multifile', program.multifilePredicates, this.declaredMultifileIndicators);
+    this.addProcedureDirective(clause, 'discontiguous', program.discontiguousPredicates, this.declaredDiscontiguousIndicators);
 
     const operator = operatorDirective(clause);
     if (operator) {
@@ -586,6 +670,7 @@ class ProgramBuilder {
     } else if (directive?.type === COMPOUND && directive.name === 'char_conversion' && directive.arity === 2) {
       program.charConversionDirectives.push(directive.args);
     }
+    if (program.strictIso) this.lastPredicateByText.set(textUnit, '@directive');
   }
 
   finish() {
@@ -596,9 +681,13 @@ class ProgramBuilder {
     // A dynamic declaration creates a procedure even when it has no clauses.
     // Calls to that procedure fail normally instead of being treated as calls
     // to an unknown predicate.
-    for (const indicator of this.declaredDynamicIndicators.values()) {
-      if (!program.groups.has(indicator.key)) {
-        program.groups.set(indicator.key, program.makeGroup(indicator.name, indicator.arity, indicator.module));
+    for (const declarations of [
+      this.declaredDynamicIndicators, this.declaredMultifileIndicators, this.declaredDiscontiguousIndicators,
+    ]) {
+      for (const indicator of declarations.values()) {
+        if (!program.groups.has(indicator.key)) {
+          program.groups.set(indicator.key, program.makeGroup(indicator.name, indicator.arity, indicator.module));
+        }
       }
     }
     program.mutable = program.dynamicPredicates.size > 0;
@@ -694,11 +783,14 @@ function loadSourcesIntoBuilder(builder, sources, options, fast) {
     if (filename) ensured.add(filename);
   }
   try {
-    for (const item of prepared) {
+    for (const [sourceIndex, item] of prepared.entries()) {
       const text = typeof item.source === 'string'
         ? item.source
         : item.source?.text ?? item.source?.source ?? '';
-      const context = { module: 'user' };
+      const context = {
+        module: 'user',
+        textUnit: sourcePath(item.options) ?? `<input:${sourceIndex}>`,
+      };
       if (!loadSourceIntoBuilder(builder, text, item.options, ensured, loadedModules, fast, context)) return false;
     }
     const autoloadGoals = parseInteropGoalInputs(options.autoloadGoals, {
@@ -964,6 +1056,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     if (moduleDeclaration) {
       flush();
       clause.module = moduleDeclaration.name;
+      clause.textUnit = context.textUnit;
       clause.moduleFilename = options.filename ?? '<input>';
       builder.addClauses([clause]);
       context.module = moduleDeclaration.name;
@@ -974,6 +1067,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     if (use) {
       flush();
       clause.module = context.module;
+      clause.textUnit = context.textUnit;
       builder.addClauses([clause]);
       const libraryName = libraryDesignationName(use.designation);
       if (libraryName != null) {
@@ -996,6 +1090,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
     const include = includeDirective(clause);
     if (!include) {
       clause.module ??= context.module;
+      clause.textUnit ??= context.textUnit;
       if (!isDirectiveClause(clause)) {
         for (const goal of clause.body) annotateGoalModule(goal, clause.module);
       }
@@ -1004,9 +1099,15 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       return;
     }
     flush();
+    if (builder.program.strictIso && include.name === 'ensure_loaded') {
+      builder.lastPredicateByText.set(context.textUnit ?? '<input>', '@directive');
+    }
     const child = readIncludedSource(include, options, ensured);
     if (!child) return;
-    if (!loadSourceIntoBuilder(builder, child.text, child.options, ensured, loadedModules, fast, context)) {
+    const childContext = include.name === 'include'
+      ? context
+      : { module: context.module, textUnit: sourcePath(child.options) ?? context.textUnit };
+    if (!loadSourceIntoBuilder(builder, child.text, child.options, ensured, loadedModules, fast, childContext)) {
       throw FAST_PARSE_ABORT;
     }
   };
@@ -1019,6 +1120,7 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
         bodyName, body0Type, body0Name, body1Type, body1Name,
       ));
       batch[batch.length - 1].module = context.module;
+      batch[batch.length - 1].textUnit = context.textUnit;
       if (batch.length >= PROGRAM_BUILD_BATCH_SIZE) flush();
     };
     const parsed = tryParseClausesFastInto(source, accept, acceptBinary, options);
@@ -1148,16 +1250,25 @@ function isDirectiveClause(clause) {
     clause.head.name === ':-' && clause.head.arity === 1;
 }
 
-function dynamicDirectiveIndicators(clause) {
-  if (!isDirectiveClause(clause)) return [];
+function procedureDirectiveIndicators(clause, name, strictIso = false) {
+  if (!isDirectiveClause(clause)) return null;
   const directive = clause.head.args[0];
-  if (directive.type !== COMPOUND || directive.name !== 'dynamic' || directive.arity !== 1) return [];
+  if (directive.type !== COMPOUND || directive.name !== name || directive.arity !== 1) return null;
   const terms = properListItems(directive.args[0], new Env()) ?? flattenDirectiveSequence(directive.args[0]);
-  return terms.map((indicator) =>
+  const indicators = terms.map((indicator) =>
     indicator.type === COMPOUND && ['/', '//'].includes(indicator.name) && indicator.arity === 2
       ? nonterminalOrPredicateIndicator(indicator)
       : null
-  ).filter(Boolean);
+  );
+  if (indicators.some((indicator) => indicator == null)) {
+    if (strictIso) throw new Error(`ISO preparation error: invalid ${name}/1 predicate indicator`);
+    return [];
+  }
+  return indicators;
+}
+
+function dynamicDirectiveIndicators(clause) {
+  return procedureDirectiveIndicators(clause, 'dynamic', false) ?? [];
 }
 
 function nonterminalOrPredicateIndicator(term) {

package/src/solver.js

@@ -283,6 +283,7 @@ export class Solver {
   }
 
   runInitializations() {
+    if (this.program._initializationsExecuted) return;
     for (const goal of this.program.initializations ?? []) {
       let succeeded = false;
       for (const _ of this.solve([goal], new Env(), 0)) {
@@ -291,6 +292,9 @@ export class Solver {
       }
       if (!succeeded) throw new PrologError('initialization_error');
     }
+    // 7.4.2.6 attaches initialization to preparation of the Prolog text, not
+    // to each later Solver instance created for the same prepared Program.
+    this.program._initializationsExecuted = true;
   }
 
   *solve(goals, env = new Env(), depth = 0) {

package/test/conformance/ISO-COMPLIANCE.md

@@ -32,16 +32,16 @@ error-ordering alternative to an individual executable assertion.
 | --- | --- | --- |
 | 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.4 — Prolog text and directives | audit | All Part 1 directive indicators are parsed; include/ensure-loaded/operator/flag/character-conversion behavior has executable coverage. Preparation-time `char_conversion/2` affects later unquoted source text and respects `char_conversion=off`. Strict preparation now enforces declaration-before-clause ordering for `dynamic/1`, `multifile/1`, and `discontiguous/1`, cross-text `multifile/1`, discontiguous clause grouping, empty declared procedures, include textual-replacement behavior, and one-time initialization per prepared program. The remaining shall-by-shall mapping is still open. |
 | 7.5-7.6 — database and term/clause conversion | audit | Dynamic database and logical-update-view suites. Strict mode restores Part 1 private-static/public-dynamic `clause/2` access. 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, 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.10 — input/output concepts | audit | Stream, character/byte I/O, read/write options, operator-sensitive write-back, and Corrigendum 3 writer cases. The audit now also covers write-mode creation/truncation, append creation, repositioned overwrite, flushing, EOF actions, close/current-stream handling, strict stream-position terms, stream-property validation, stream-term requirements, and text-vs-binary permission errors. The full option/mode cross-product is still being mapped. |
 | 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. |
+| 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 covered for `read_term/3`, `write_term/3`, `op/3`, and `current_op/3`; the continuing audit has corrected additional 8.11-8.13 stream/character/byte errors, Corrigendum 2 `keysort/2` errors, and arithmetic culprit reporting. A complete one-row-per-prescribed-error ordering map 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. The audit now includes corrected `keysort/2` variable/non-pair errors, stricter 8.11-8.13 stream and character/byte modes/errors, the 8.14 option/error-order subfamily, and closed 8.17 flags. 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. Strict mode excludes the EyeProlog-only evaluable atom `e`, retains Corrigendum 2 arithmetic additions, and reports unknown zero-arity evaluables with the required `F/0` culprit shape. Host floating-point representation choices remain documented implementation-defined behavior; exhaustive exceptional-value precedence remains open. |
 | Corrigendum 1 | covered | Double-quoted atom/operator-priority corrections have dedicated cases. |
 | Corrigendum 2 | covered | Added predicates/functors, catch corrections, bar/operator and uninstantiation corrections have dedicated cases. |
 | Corrigendum 3 | covered | Writer options, `variable_names/1`, canonical list output and negative-power corrections have dedicated cases. |
@@ -81,6 +81,20 @@ the Part 1 plus Corrigendum 3 option surface; the normal-profile
 `double_quotes/1` write option remains an explicitly documented EyeProlog
 extension.
 
+
+The current continuation of issue #65 expands that audit into Prolog-text,
+stream, atomic-conversion, sorting, and arithmetic edge cases. Strict
+preparation now enforces the Part 1 declaration constraints for `dynamic/1`,
+`multifile/1`, and `discontiguous/1`, including cross-text multifile use and
+one-time initialization per prepared program. Stream handling now distinguishes
+text and binary permission errors, validates stream properties and stream-term
+requirements, and tightens creation, truncation/append, repositioning, flush,
+EOF, close, and current-stream behavior. Corrigendum 2 `keysort/2` variable and
+non-pair errors are corrected. Strict arithmetic no longer exposes the
+EyeProlog-only evaluable atom `e`, while the Corrigendum arithmetic additions
+remain available. These corrections narrow the remaining `audit` rows but do
+not by themselves close the full shall-by-shall/error-order exit criteria.
+
 ## Strict-core boundary
 
 `isoStrict: true` is intentionally a **Part 1 + Corrigenda 1-3** mode. It does

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

@@ -36,7 +36,7 @@ Status values are:
 | 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()`. |
+| 7.4.2.6 | Order of `initialization/1` goals | Initialization goals run once per prepared `Program`, in source/inclusion order, before requested goals; each must obtain a first solution. Reusing the same prepared program in another solver does not execute its initialization goals again. | **defined** — `Program.initializations`, preparation state, `Solver.runInitializations()`. |
 | 7.4.2.7 | Ground term designating a Prolog text for `include/1` | A source designation is an atom interpreted as a file path; relative paths resolve from the including file's directory (or the current working directory for unanchored input). | **defined** — `src/program.js` (`readIncludedSource`). |
 | 7.4.2.8 | Ground term designating a Prolog text for `ensure_loaded/1` | Same atom/file-path designation as `include/1`. | **defined** — `src/program.js`. |
 | 7.4.2.8 | Position at which an ensured text is included | The first `ensure_loaded/1` expands the text in place at the directive; later requests for the same resolved path are ignored. | **defined** — `src/program.js` (`ensured` set and in-place builder loading). |

package/test/conformance/ISO-MATRIX.md

@@ -11,14 +11,14 @@ compliance audit and the remaining work before a full conformance claim.
 | 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.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, including Corrigendum 2 `keysort/2` variable/non-pair errors |
 | 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, 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.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, strict 8.14.1-8.14.4 option/error-order tests, and issue #65 checks for stream-term/property validation, text-vs-binary permissions, EOF/flush/position, and open/close semantics |
 | 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 | 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` |
+| Clause 9 evaluable functors | integer, float, rounding, transcendental and bitwise operations | `arithmetic`, `corrigenda_arithmetic`, `corrigenda_atan2_zero`, `corrigenda_integer_negative_power`, strict exclusion of the normal-mode `e` evaluable extension and zero-arity unknown-evaluable error checks |
 | 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/expected-errors/iso/get_byte_text_stream.txt

@@ -1 +1 @@
-error(permission_error(input, stream), '$stream'(0))
+error(permission_error(input, text_stream), '$stream'(0))

package/the-art-of-eyeprolog.md

@@ -7653,7 +7653,13 @@ integrity relations, automatic tabling, and the EyeProlog library. The strict au
 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:
+strict boundary. The continuing issue #65 audit also enforces Part 1
+preparation constraints for `dynamic/1`, `multifile/1`, and `discontiguous/1`,
+keeps initialization tied to preparation of a program, tightens stream
+creation/position/EOF behavior and text-vs-binary permission errors, corrects
+Corrigendum 2 `keysort/2` error cases, and keeps the non-standard evaluable atom
+`e` outside strict mode. These are conformance improvements, while the
+remaining qualifications are:
 
 - zero-arity compound syntax such as `ready()` is represented by the atom
   `ready`;