eyeprolog 1.5.39 → 1.5.41

package/README.md

@@ -61,8 +61,8 @@ Normal mode executes top-level `Conclusion :+ Premise` rules through the bundled
 Bundled `src/lib/` predicates autoload in files, CLI/API goals, and the REPL; use `--no-autoload` to require explicit imports, and explicitly import libraries that introduce operators before using their syntax. See [*The Art of EyeProlog*](the-art-of-eyeprolog.md) for the full semantics.
 All 34 bundled modules that overlap Scryer's current library surface cover Scryer's exported predicates, and all 28 bundled modules with public-module counterparts in Trealla's current `library/` surface cover those Trealla exports as well. The stricter Trealla/Scryer intersection remains a separate portability profile. Runtime-dependent library primitives follow one ownership rule: `src/lib/<module>.pl` calls private adapters from `src/<module>-host.js`; pure Prolog libraries need no host file. This includes the full Scryer `library(files)` surface, Scryer character-list paths in `library(pio)` with atom-path compatibility, chars/UTF-8/term/Base64 helpers, the completed arithmetic/time/`iso_ext` surfaces, the full Scryer `library(crypto)`, Scryer-compatible TCP `library(sockets)`, the shared Scryer/Trealla `library(json)` DCG, and a merged Scryer/Trealla `library(http)` client/server facade. Filesystem, OS, TCP socket, and HTTP/HTTPS client side effects require Node; crypto uses Node's backend where needed, with Web Crypto also used for secure random bytes when available. Non-integral rational conversions remain structural `rdiv(Numerator,Denominator)` terms until rational numbers become processor numeric values.
 ## HTTP and JSON
-`library(http)` merges Scryer-style `http_open/3` options with Trealla's request helpers (`http_get/3`, `http_post/4`, `http_patch/4`, `http_put/4`, `http_delete/3`, `http_server/2`, `http_request/5`). HTTP/HTTPS clients use the Node-owned `src/http-host.js` bridge, follow up to five redirects, accept Trealla `header(Name,Value)` and `host/path` address-list forms, and expose response bodies as UTF-8 character lists or streams.
-`library(json)` provides the shared bidirectional `json_chars//1` DCG with `pairs/1`, `list/1`, `string/1`, `number/1`, `boolean/1`, and `null`. See `examples/json.pl`, `examples/http-client.pl`, `test/run-http-json.mjs`, and the full contracts in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
+`library(http)` merges Scryer-style `http_open/3` options with Trealla's request helpers (`http_get/3`, `http_post/4`, `http_patch/4`, `http_put/4`, `http_delete/3`, `http_server/2`, `http_request/5`). HTTP/HTTPS clients use the Node-owned `src/http-host.js` bridge, follow up to five redirects, preserve repeated request-header values, accept Trealla `header(Name,Value)` and `host/path` address-list forms, and expose response bodies as UTF-8 character lists or streams. `http_open/3` reads response bodies lazily in bounded chunks rather than buffering the whole response through the host RPC bridge; request metadata and `data/1` still pass through that bounded bridge.
+`library(json)` provides the shared bidirectional `json_chars//1` DCG with `pairs/1`, `list/1`, `string/1`, `number/1`, `boolean/1`, and `null`. JSON `\u` escapes combine and generate UTF-16 surrogate pairs for supplementary Unicode scalar values, while unpaired surrogates are rejected. See `examples/json.pl`, `examples/http-client.pl`, `test/run-http-json.mjs`, and the full contracts in [*The Art of EyeProlog*](the-art-of-eyeprolog.md).
 ## Links
 
 - [The Art of EyeProlog](https://eyereasoner.github.io/eyeprolog/the-art-of-eyeprolog) — complete reference

package/examples/json.pl

@@ -2,6 +2,7 @@
 %
 % Objects are pairs([...]), arrays are list([...]), strings are string(Chars),
 % numbers are number(N), booleans are boolean(true/false), and null is null.
+% Supplementary Unicode JSON escapes are combined from UTF-16 surrogate pairs.
 
 :- use_module(library(json)).
 :- use_module(library(dcgs)).
@@ -9,7 +10,7 @@
 %% goal: json_example(Mode, Value)
 
 json_example(parsed, JSON) :-
-    phrase(json_chars(JSON), "{\"name\":\"Ada\",\"active\":true,\"scores\":[3,5,8]}").
+    phrase(json_chars(JSON), "{\"name\":\"Ada\",\"active\":true,\"scores\":[3,5,8],\"emoji\":\"\\uD83D\\uDE00\"}").
 
 json_example(generated, Chars) :-
     once(phrase(json_chars(pairs([

package/examples/output/json.pl

@@ -1,2 +1,2 @@
-json_example(parsed, pairs([string("name") - string("Ada"), string("active") - boolean(true), string("scores") - list([number(3), number(5), number(8)])])).
+json_example(parsed, pairs([string("name") - string("Ada"), string("active") - boolean(true), string("scores") - list([number(3), number(5), number(8)]), string("emoji") - string("😀")])).
 json_example(generated, "{\"project\":\"EyeProlog\",\"ok\":true}").

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.39",
+  "version": "1.5.41",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -75,6 +75,7 @@
     "conformance:update:neumerkel": "node test/run-neumerkel.mjs --update-report",
     "conformance:check:neumerkel": "node test/run-neumerkel.mjs --cached --verify-report",
     "conformance:sync:neumerkel": "node test/run-neumerkel.mjs --cached --update-report",
-    "test:http-json": "node test/run-http-json.mjs"
+    "test:http-json": "node test/run-http-json.mjs",
+    "test:iso-part2-amendment": "node test/run-iso-part2-amendment.mjs"
   }
 }

package/src/ARCHITECTURE.md

@@ -105,4 +105,4 @@ and are intentionally not versioned.
 
 ## HTTP and JSON library ownership
 
-`src/lib/json.pl` is a pure Prolog DCG adapted from the BSD-licensed Scryer/Trealla JSON library. `src/lib/http.pl` owns HTTP option normalization, convenience predicates, request parsing, and the small server facade. Node HTTP/HTTPS client I/O is isolated in `src/http-host.js` and `src/http-worker.js`, following the same module-owned host-adapter convention as sockets, files, crypto, and other runtime-dependent libraries.
+`src/lib/json.pl` is a pure Prolog DCG adapted from the BSD-licensed Scryer/Trealla JSON library, with Unicode-scalar handling for JSON UTF-16 surrogate escapes. `src/lib/http.pl` owns HTTP option normalization, convenience predicates, request parsing, and the small server facade. Node HTTP/HTTPS client I/O is isolated in `src/http-host.js` and `src/http-worker.js`, following the same module-owned host-adapter convention as sockets, files, crypto, and other runtime-dependent libraries. The worker returns response metadata first and retains the response body behind a body id; the host stream pulls bounded chunks through the bridge on demand, so response size is no longer bounded by the RPC buffer and early `close/1` can discard the remaining transport body.

package/src/http-host.js

@@ -1,6 +1,6 @@
 // Node HTTP(S) bridge for library(http). The Prolog module owns option parsing,
-// response shaping, and server-side HTTP parsing; this host adapter only performs
-// the asynchronous client exchange and exposes the body as an EyeProlog stream.
+// response shaping, and server-side HTTP parsing; this host adapter performs the
+// asynchronous client exchange and exposes each response body as a lazy stream.
 
 import { isNode } from './platform.js';
 import { PrologError } from './errors.js';
@@ -14,6 +14,7 @@ let WorkerCtor = null;
 if (isNode) ({ Worker: WorkerCtor } = await import('node:worker_threads'));
 
 const RPC_BYTES = 8 * 1024 * 1024;
+const HTTP_READ_BYTES = 64 * 1024;
 const HEADER_WORDS = 4;
 let bridge = null;
 
@@ -75,6 +76,15 @@ function textValue(term, env, { allowNumber = false } = {}) {
   return characterListText(term, env);
 }
 
+function requestBodyValue(term, env) {
+  const value = deref(term, env);
+  if (value.type === ATOM && value.name === 'no_data') return null;
+  if (value.type === COMPOUND && value.name === 'data' && value.arity === 1) {
+    return textValue(value.args[0], env);
+  }
+  throw new PrologError('domain_error(http_data)', copyResolved(term, env));
+}
+
 function requestHeadersValue(term, env) {
   const items = properListItems(deref(term, env), env);
   if (items == null) throw new PrologError('type_error(list)', copyResolved(term, env));
@@ -89,11 +99,35 @@ function requestHeadersValue(term, env) {
 
 function streamHandle(id) { return compound('$stream', [numberTerm(id)]); }
 
-function addBodyStream(solver, body, finalUrl) {
+function bytesFromBase64(text) {
+  return Uint8Array.from(Buffer.from(text, 'base64'));
+}
+
+function addBodyStream(solver, bodyId, finalUrl) {
+  const worker = httpBridge();
+  // Buffer.toString('utf8'), used by the original eager bridge, replaced malformed
+  // input with U+FFFD. Keep that behavior while decoding incrementally.
+  const decoder = new TextDecoder('utf-8');
   const stream = {
-    id: solver.io.nextId++, alias: null, mode: 'read', type: 'text', content: String(body),
+    id: solver.io.nextId++, alias: null, mode: 'read', type: 'text', content: '',
     position: 0, reportedPosition: 0, path: String(finalUrl ?? ''), reposition: false,
     eofAction: 'eof_code', standard: false, pastEnd: false, readable: true, writable: false,
+    remoteEnded: false, continuousRefill: true, httpBodyId: bodyId,
+  };
+  stream.interactiveReadUnit = () => {
+    while (true) {
+      const result = worker.rpc({ op: 'body_read', bodyId, maxBytes: HTTP_READ_BYTES });
+      if (result.eof) {
+        stream.remoteEnded = true;
+        const tail = decoder.decode();
+        return tail || null;
+      }
+      const text = decoder.decode(bytesFromBase64(result.data), { stream: true });
+      if (text.length > 0) return text;
+    }
+  };
+  stream.closeTransport = () => {
+    worker.rpc({ op: 'body_close', bodyId });
   };
   solver.io.add(stream);
   return stream;
@@ -102,10 +136,10 @@ function addBodyStream(solver, body, finalUrl) {
 function* httpOpenBuiltin({ solver, goal, env }) {
   const url = textValue(goal.args[0], env);
   const method = textValue(goal.args[2], env);
-  const data = textValue(goal.args[3], env);
+  const data = requestBodyValue(goal.args[3], env);
   const requestHeaders = requestHeadersValue(goal.args[5], env);
   const result = httpBridge().rpc({ op: 'request', url, method, data, headers: requestHeaders, redirects: 5 });
-  const stream = addBodyStream(solver, result.body, result.finalUrl);
+  const stream = addBodyStream(solver, result.bodyId, result.finalUrl);
   const headerTerms = result.headers.map(([name, value]) => compound('header', [atom(name), chars(value)]));
   const next = env.clone();
   if (unify(goal.args[1], streamHandle(stream.id), next) &&

package/src/http-worker.js

@@ -7,6 +7,8 @@ const header = new Int32Array(workerData.shared, 0, HEADER_WORDS);
 const bytes = new Uint8Array(workerData.shared, HEADER_WORDS * Int32Array.BYTES_PER_ELEMENT);
 const decoder = new TextDecoder();
 const encoder = new TextEncoder();
+const bodies = new Map();
+let nextBodyId = 1;
 
 function errorRecord(error) {
   return { code: String(error?.code ?? 'EUNKNOWN'), message: String(error?.message ?? error ?? 'http error') };
@@ -15,7 +17,7 @@ function errorRecord(error) {
 function writeResponse(response) {
   const encoded = encoder.encode(JSON.stringify(response));
   if (encoded.length > bytes.length) {
-    const fallback = encoder.encode(JSON.stringify({ ok: false, error: { code: 'EMSGSIZE', message: 'HTTP response too large for bridge' } }));
+    const fallback = encoder.encode(JSON.stringify({ ok: false, error: { code: 'EMSGSIZE', message: 'HTTP bridge message too large' } }));
     bytes.set(fallback.subarray(0, bytes.length), 0);
     Atomics.store(header, 2, Math.min(fallback.length, bytes.length));
   } else {
@@ -26,6 +28,27 @@ function writeResponse(response) {
   Atomics.notify(header, 0, 1);
 }
 
+function headerObject(requestHeaders) {
+  const headers = Object.create(null);
+  for (const [rawName, rawValue] of requestHeaders) {
+    const name = String(rawName).toLowerCase();
+    const value = String(rawValue);
+    const previous = headers[name];
+    if (previous == null) headers[name] = value;
+    else if (Array.isArray(previous)) previous.push(value);
+    else headers[name] = [previous, value];
+  }
+  return headers;
+}
+
+function responseHeaders(res) {
+  const rawHeaders = [];
+  for (let i = 0; i < res.rawHeaders.length; i += 2) {
+    rawHeaders.push([String(res.rawHeaders[i]).toLowerCase(), String(res.rawHeaders[i + 1] ?? '')]);
+  }
+  return rawHeaders;
+}
+
 function requestOnce(url, method, data, requestHeaders) {
   return new Promise((resolve, reject) => {
     const target = new URL(url);
@@ -35,24 +58,14 @@ function requestOnce(url, method, data, requestHeaders) {
       return;
     }
     const body = data == null ? null : Buffer.from(data, 'utf8');
-    const headers = Object.fromEntries(requestHeaders);
-    if (body != null && !Object.keys(headers).some((name) => name.toLowerCase() === 'content-length')) {
-      headers['content-length'] = String(body.length);
-    }
+    const headers = headerObject(requestHeaders);
+    if (body != null && headers['content-length'] == null) headers['content-length'] = String(body.length);
     const req = transport.request(target, { method: method.toUpperCase(), headers }, (res) => {
-      const chunks = [];
-      res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-      res.on('end', () => {
-        const rawHeaders = [];
-        for (let i = 0; i < res.rawHeaders.length; i += 2) {
-          rawHeaders.push([String(res.rawHeaders[i]).toLowerCase(), String(res.rawHeaders[i + 1] ?? '')]);
-        }
-        resolve({
-          statusCode: Number(res.statusCode ?? 0),
-          headers: rawHeaders,
-          body: Buffer.concat(chunks).toString('utf8'),
-          location: res.headers.location == null ? null : String(res.headers.location),
-        });
+      resolve({
+        response: res,
+        statusCode: Number(res.statusCode ?? 0),
+        headers: responseHeaders(res),
+        location: res.headers.location == null ? null : String(res.headers.location),
       });
     });
     req.on('error', reject);
@@ -61,30 +74,92 @@ function requestOnce(url, method, data, requestHeaders) {
   });
 }
 
+function discardResponse(response) {
+  return new Promise((resolve) => {
+    response.on('error', resolve);
+    response.on('end', resolve);
+    response.resume();
+  });
+}
+
+function withoutContentLength(headers) {
+  return headers.filter(([name]) => String(name).toLowerCase() !== 'content-length');
+}
+
 async function requestFollowingRedirects(url, method, data, headers, redirects = 5) {
   let current = url;
   let currentMethod = method;
   let currentData = data;
+  let currentHeaders = headers;
   for (let count = 0; ; count++) {
-    const response = await requestOnce(current, currentMethod, currentData, headers);
-    if (![301, 302, 303, 307, 308].includes(response.statusCode) || response.location == null || count >= redirects) {
-      return { ...response, finalUrl: current };
+    const result = await requestOnce(current, currentMethod, currentData, currentHeaders);
+    if (![301, 302, 303, 307, 308].includes(result.statusCode) || result.location == null || count >= redirects) {
+      const bodyId = nextBodyId++;
+      bodies.set(bodyId, { response: result.response, iterator: result.response[Symbol.asyncIterator](), remainder: null });
+      return { statusCode: result.statusCode, headers: result.headers, bodyId, finalUrl: current };
     }
-    current = new URL(response.location, current).toString();
-    if (response.statusCode === 303 || ((response.statusCode === 301 || response.statusCode === 302) && currentMethod.toLowerCase() === 'post')) {
+    await discardResponse(result.response);
+    current = new URL(result.location, current).toString();
+    if (result.statusCode === 303 || ((result.statusCode === 301 || result.statusCode === 302) && currentMethod.toLowerCase() === 'post')) {
       currentMethod = 'get';
-      currentData = '';
+      currentData = null;
+      currentHeaders = withoutContentLength(currentHeaders);
     }
   }
 }
 
+function encodeBodyChunk(state, chunk, maxBytes) {
+  const data = Buffer.from(chunk);
+  if (data.length <= maxBytes) return { data, remainder: null };
+  return { data: data.subarray(0, maxBytes), remainder: data.subarray(maxBytes) };
+}
+
+async function readBody(bodyId, maxBytes) {
+  const state = bodies.get(bodyId);
+  if (state == null) return { eof: true, data: '' };
+  const limit = Math.max(1, Math.min(Number(maxBytes) || 65536, 1024 * 1024));
+  if (state.remainder?.length) {
+    const { data, remainder } = encodeBodyChunk(state, state.remainder, limit);
+    state.remainder = remainder;
+    return { eof: false, data: data.toString('base64') };
+  }
+  const next = await state.iterator.next();
+  if (next.done) {
+    bodies.delete(bodyId);
+    return { eof: true, data: '' };
+  }
+  const { data, remainder } = encodeBodyChunk(state, next.value, limit);
+  state.remainder = remainder;
+  return { eof: false, data: data.toString('base64') };
+}
+
+function closeBody(bodyId) {
+  const state = bodies.get(bodyId);
+  if (state == null) return { closed: false };
+  bodies.delete(bodyId);
+  state.response.destroy();
+  return { closed: true };
+}
+
+async function dispatch(request) {
+  switch (request.op) {
+    case 'request':
+      return requestFollowingRedirects(request.url, request.method, request.data, request.headers, request.redirects ?? 5);
+    case 'body_read':
+      return readBody(request.bodyId, request.maxBytes);
+    case 'body_close':
+      return closeBody(request.bodyId);
+    default:
+      throw Object.assign(new Error(`unknown HTTP operation: ${request.op}`), { code: 'EINVAL' });
+  }
+}
+
 parentPort.on('message', async () => {
   if (Atomics.load(header, 0) !== 1) return;
   try {
     const length = Atomics.load(header, 1);
     const request = JSON.parse(decoder.decode(bytes.subarray(0, length)));
-    if (request.op !== 'request') throw Object.assign(new Error(`unknown HTTP operation: ${request.op}`), { code: 'EINVAL' });
-    const result = await requestFollowingRedirects(request.url, request.method, request.data, request.headers, request.redirects ?? 5);
+    const result = await dispatch(request);
     writeResponse({ ok: true, result });
   } catch (error) {
     writeResponse({ ok: false, error: errorRecord(error) });

package/src/lib/http.pl

@@ -28,9 +28,9 @@ http_open(Address0, Response, Options0) :-
     must_be(list, Options0),
     http__normalize_address(Address0, Options0, Address, Options),
     http__method(Options, Method),
-    http__data(Options, Data),
+    http__data_spec(Options, DataSpec),
     http__request_headers(Options, RequestHeaders),
-    eyeprolog__http_open(Address, Response, Method, Data, Code, RequestHeaders, RawHeaders, FinalUrl),
+    eyeprolog__http_open(Address, Response, Method, DataSpec, Code, RequestHeaders, RawHeaders, FinalUrl),
     http__scryer_headers(RawHeaders, Headers),
     http__bind_option(status_code, Code, Options),
     http__bind_option(headers, Headers, Options),
@@ -70,26 +70,29 @@ http__ensure_slash(['/'|Rest], ['/'|Rest]) :- !.
 http__ensure_slash(Path, ['/'|Path]).
 
 http_get(Address, Data, Options) :-
-    http__request_data(Address, get, [], Data, Options).
+    http__request_data(Address, get, no_data, Data, Options).
 
 http_post(Address, PostData, Reply, Options) :-
-    http__request_data(Address, post, PostData, Reply, Options).
+    http__checked_data(PostData, DataSpec),
+    http__request_data(Address, post, DataSpec, Reply, Options).
 
 http_patch(Address, PostData, Reply, Options) :-
-    http__request_data(Address, patch, PostData, Reply, Options).
+    http__checked_data(PostData, DataSpec),
+    http__request_data(Address, patch, DataSpec, Reply, Options).
 
 http_put(Address, PostData, Reply, Options) :-
-    http__request_data(Address, put, PostData, Reply, Options).
+    http__checked_data(PostData, DataSpec),
+    http__request_data(Address, put, DataSpec, Reply, Options).
 
 http_delete(Address, Data, Options) :-
-    http__request_data(Address, delete, [], Data, Options).
+    http__request_data(Address, delete, no_data, Data, Options).
 
 http__request_data(Address, DefaultMethod, Payload, Data, Options) :-
     must_be(list, Options),
     ( memberchk(method(Method0), Options) -> http__valid_method(Method0), Method = Method0 ; Method = DefaultMethod ),
-    ( memberchk(data(Data0), Options) -> Payload0 = Data0 ; Payload0 = Payload ),
+    ( memberchk(data(Data0), Options) -> http__checked_data(Data0, DataSpec) ; DataSpec = Payload ),
     http__request_headers(Options, RequestHeaders),
-    eyeprolog__http_open(Address, Stream, Method, Payload0, Code, RequestHeaders, RawHeaders, FinalUrl),
+    eyeprolog__http_open(Address, Stream, Method, DataSpec, Code, RequestHeaders, RawHeaders, FinalUrl),
     get_n_chars(Stream, _, Data),
     close(Stream),
     http__trealla_headers(RawHeaders, Headers),
@@ -107,12 +110,14 @@ http__valid_method(Method) :-
     ; throw(error(domain_error(http_option, method(Method)), http_open/3))
     ).
 
-http__data(Options, Data) :-
-    ( memberchk(data(Data0), Options) ->
-        ( var(Data0) -> throw(error(instantiation_error, http_open/3)) ; Data = Data0 )
-    ; Data = []
+http__data_spec(Options, DataSpec) :-
+    ( memberchk(data(Data0), Options) -> http__checked_data(Data0, DataSpec)
+    ; DataSpec = no_data
     ).
 
+http__checked_data(Data, data(Data)) :-
+    ( var(Data) -> throw(error(instantiation_error, http_open/3)) ; true ).
+
 http__request_headers(Options, Headers) :-
     ( memberchk(request_headers(Input), Options) ->
         ( var(Input) -> throw(error(instantiation_error, http_open/3)) ; true ),

package/src/lib/json.pl

@@ -88,12 +88,45 @@ json_character(PrintChar) -->
     [PrintChar],
     { dif(PrintChar, '\\'), dif(PrintChar, '"'), char_code(PrintChar, Code), Code >= 32 }.
 json_character(EscapeChar) -->
-    "\\u", json_hex(H1), json_hex(H2), json_hex(H3), json_hex(H4),
+    "\\u",
+    ( parsing ->
+        json_hex4(Code),
+        json_unicode_parsed(Code, EscapeChar)
+    ; { char_code(EscapeChar, Code) },
+      json_unicode_generated(Code)
+    ).
+
+% JSON's \u escape syntax encodes UTF-16 code units. Combine a valid surrogate
+% pair while parsing and split supplementary Unicode scalar values while
+% generating. Lone surrogate code units are not Unicode scalar values and are
+% therefore rejected instead of being passed to char_code/2.
+json_unicode_parsed(Code, Char) -->
+    { Code >= 55296, Code =< 56319 }, !,
+    "\\u", json_hex4(Low),
+    { Low >= 56320, Low =< 57343,
+      Scalar is 65536 + (Code - 55296) * 1024 + (Low - 56320),
+      char_code(Char, Scalar) }.
+json_unicode_parsed(Code, _) -->
+    { Code >= 56320, Code =< 57343 }, !,
+    { fail }.
+json_unicode_parsed(Code, Char) -->
+    { char_code(Char, Code) }.
+
+json_unicode_generated(Code) -->
+    { Code > 65535 }, !,
+    { Scalar is Code - 65536,
+      High is 55296 + Scalar // 1024,
+      Low is 56320 + Scalar mod 1024 },
+    json_hex4(High), "\\u", json_hex4(Low).
+json_unicode_generated(Code) -->
+    { ( Code < 55296 ; Code > 57343 ) },
+    json_hex4(Code).
+
+json_hex4(Code) -->
+    json_hex(H1), json_hex(H2), json_hex(H3), json_hex(H4),
     { ( nonvar(H1) ->
-          Code is H1*4096 + H2*256 + H3*16 + H4,
-          char_code(EscapeChar, Code)
-      ; char_code(EscapeChar, Code),
-        H1 is (Code // 4096) mod 16,
+          Code is H1*4096 + H2*256 + H3*16 + H4
+      ; H1 is (Code // 4096) mod 16,
         H2 is (Code // 256) mod 16,
         H3 is (Code // 16) mod 16,
         H4 is Code mod 16

package/src/number-value.js

@@ -9,11 +9,51 @@ const finiteFloat = (text) => {
   return Number.isFinite(value) ? value : null;
 };
 
+// Compare decimal integer spellings without constructing host BigInts. This is
+// used on term-ordering and unification hot paths, including integers far beyond
+// JavaScript's safe-number range. Leading zeros and -0 remain value-equivalent.
+export function compareIntegerValueText(left, right) {
+  let li = left[0] === '-' ? 1 : 0;
+  let ri = right[0] === '-' ? 1 : 0;
+  while (li < left.length && left.charCodeAt(li) === 48) li++;
+  while (ri < right.length && right.charCodeAt(ri) === 48) ri++;
+
+  const leftZero = li === left.length;
+  const rightZero = ri === right.length;
+  const leftNegative = !leftZero && left[0] === '-';
+  const rightNegative = !rightZero && right[0] === '-';
+  if (leftNegative !== rightNegative) return leftNegative ? -1 : 1;
+  if (leftZero || rightZero) return leftZero ? (rightZero ? 0 : -1) : 1;
+
+  const leftDigits = left.length - li;
+  const rightDigits = right.length - ri;
+  if (leftDigits !== rightDigits) {
+    const cmp = leftDigits < rightDigits ? -1 : 1;
+    return leftNegative ? -cmp : cmp;
+  }
+  for (let offset = 0; offset < leftDigits; offset++) {
+    const a = left.charCodeAt(li + offset);
+    const b = right.charCodeAt(ri + offset);
+    if (a === b) continue;
+    const cmp = a < b ? -1 : 1;
+    return leftNegative ? -cmp : cmp;
+  }
+  return 0;
+}
+
+function canonicalIntegerText(text) {
+  let index = text[0] === '-' ? 1 : 0;
+  while (index < text.length && text.charCodeAt(index) === 48) index++;
+  if (index === text.length) return '0';
+  const digits = text.slice(index);
+  return text[0] === '-' ? `-${digits}` : digits;
+}
+
 export function sameNumberValue(left, right) {
   const leftInteger = decimalInteger(left);
   const rightInteger = decimalInteger(right);
   if (leftInteger || rightInteger) {
-    return leftInteger && rightInteger && BigInt(left) === BigInt(right);
+    return leftInteger && rightInteger && compareIntegerValueText(left, right) === 0;
   }
   const leftValue = finiteFloat(left);
   const rightValue = finiteFloat(right);
@@ -21,7 +61,7 @@ export function sameNumberValue(left, right) {
 }
 
 export function numberValueKey(text) {
-  if (decimalInteger(text)) return `integer:${BigInt(text)}`;
+  if (decimalInteger(text)) return `integer:${canonicalIntegerText(text)}`;
   const value = finiteFloat(text);
   if (value == null) return `invalid:${text}`;
   return `float:${Object.is(value, -0) ? 0 : value}`;

package/src/parser.js

@@ -112,7 +112,6 @@ const INFIX_OPERATORS = new Map([
   ['=<', { precedence: 501, associativity: 'none' }],
   ['>', { precedence: 501, associativity: 'none' }],
   ['>=', { precedence: 501, associativity: 'none' }],
-  [':', { precedence: 601, associativity: 'right' }],
   ['+', { precedence: 701, associativity: 'left' }],
   ['-', { precedence: 701, associativity: 'left' }],
   ['/\\', { precedence: 701, associativity: 'left' }],
@@ -142,13 +141,21 @@ export const ISO_OPERATOR_DEFINITIONS = [
   [900, 'fy', '\\+'],
   ...['=', '=..', '\\=', '==', '\\==', '@<', '@=<', '@>', '@>=', 'is',
     '=:=', '=\\=', '<', '=<', '>', '>='].map((name) => [700, 'xfx', name]),
-  [600, 'xfy', ':'],
   ...['+', '-', '/\\', '\\/'].map((name) => [500, 'yfx', name]),
   ...['*', '/', '//', 'div', 'mod', 'rem', '<<', '>>'].map((name) => [400, 'yfx', name]),
   [200, 'xfx', '**'], [200, 'xfy', '^'],
   [200, 'fy', '+'], [200, 'fy', '-'], [200, 'fy', '\\'],
 ];
 
+// ISO/IEC 13211-2 adds module qualification to the Part 1 operator table.
+// The 2013 amendment also writes meta_predicate/1 in directive operator form,
+// so normal module mode accepts that standard spelling while strict Part 1
+// keeps both additions out of its initial operator table.
+export const PART2_OPERATOR_DEFINITIONS = [
+  [600, 'xfy', ':'],
+  [1150, 'fx', 'meta_predicate'],
+];
+
 // The alternative operator belongs to the Part 3 grammar-rule profile. Part 1
 // reserves `|` as list punctuation but permits a program to declare it as an
 // infix operator at priority 1001 or greater (Corrigendum 2).
@@ -226,7 +233,7 @@ export function createParserOperatorState(definitions = [], includeDefaults = tr
     postfixOperators: new Map(),
   };
   if (includeDefaults && options.isoStrict !== true) {
-    for (const [priority, specifier, name] of [...PART3_OPERATOR_DEFINITIONS, ...QUAD_OPERATOR_DEFINITIONS]) {
+    for (const [priority, specifier, name] of [...PART2_OPERATOR_DEFINITIONS, ...PART3_OPERATOR_DEFINITIONS, ...QUAD_OPERATOR_DEFINITIONS]) {
       defineParserOperator(state, priority, specifier, name);
     }
   }