eyeprolog 1.5.39 → 1.5.40

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.40",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

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/term.js

@@ -1,6 +1,6 @@
 // Term model, environments, unification, readback, and ordering helpers.
 // Keep dependencies minimal because nearly every other module imports this file.
-import { sameNumberValue } from './number-value.js';
+import { compareIntegerValueText, sameNumberValue } from './number-value.js';
 
 export const VAR = 'var';
 export const ATOM = 'atom';
@@ -1009,13 +1009,22 @@ function occurs(variableName, term, env) {
   // as soon as a binding fans out.
   if (initial.length === 1) {
     let name = initial[0];
-    const seen = [];
+    const seenSmall = [];
+    let seenLarge = null;
     while (true) {
       if (name === variableName) return true;
-      for (let index = 0; index < seen.length; index++) {
-        if (seen[index] === name) return false;
+      let alreadySeen = seenLarge?.has(name) === true;
+      if (seenLarge == null) {
+        for (let index = 0; index < seenSmall.length; index++) {
+          if (seenSmall[index] === name) { alreadySeen = true; break; }
+        }
+      }
+      if (alreadySeen) return false;
+      if (seenLarge != null) seenLarge.add(name);
+      else {
+        seenSmall.push(name);
+        if (seenSmall.length === 8) seenLarge = new Set(seenSmall);
       }
-      seen.push(name);
       const binding = env?.get(name);
       if (binding === undefined) return false;
       const names = structuralVariableNames(binding);
@@ -1539,15 +1548,16 @@ export function variantTerms(left, leftEnv, right, rightEnv, pairs = new Map(),
 
 
 function compareCharacterText(left, right) {
-  const a = Array.from(left);
-  const b = Array.from(right);
-  const length = Math.min(a.length, b.length);
-  for (let i = 0; i < length; i++) {
-    const ac = a[i].codePointAt(0);
-    const bc = b[i].codePointAt(0);
+  let li = 0;
+  let ri = 0;
+  while (li < left.length && ri < right.length) {
+    const ac = left.codePointAt(li);
+    const bc = right.codePointAt(ri);
     if (ac !== bc) return ac < bc ? -1 : 1;
+    li += ac > 0xffff ? 2 : 1;
+    ri += bc > 0xffff ? 2 : 1;
   }
-  return a.length < b.length ? -1 : a.length > b.length ? 1 : 0;
+  return li < left.length ? 1 : ri < right.length ? -1 : 0;
 }
 
 export function compareTerms(left, right, variableRanks = null) {
@@ -1609,6 +1619,9 @@ export function isDecimalInteger(text) {
 }
 
 export function compareIntegerText(left, right) {
+  if (isDecimalInteger(left) && isDecimalInteger(right)) return compareIntegerValueText(left, right);
+  // Preserve the public helper's historical acceptance/error behavior for host
+  // BigInt spellings outside EyeProlog's decimal integer term syntax.
   const a = BigInt(left);
   const b = BigInt(right);
   return a < b ? -1 : a > b ? 1 : 0;

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

@@ -129,7 +129,9 @@ families; `--iso-strict` is intended to remove their Part 1 interpretation.
 Normal mode provides documented module and DCG compatibility profiles whose
 features overlap standardized Part 2 and Part 3 facilities. They are extensions
 relative to the Part 1 strict-core boundary and are tested separately; this
-ledger does not assert complete Part 2 or Part 3 conformance.
+ledger does not assert complete Part 2 or Part 3 conformance. The concrete
+compatibility boundary, including the normal-profile `phrase/2-3` terminal-sequence
+error choice, is recorded in `ISO-PART2-PART3-SCOPE.md`.
 
 ## Important implementation-dependent behavior (not the 5.4 mandatory table)
 

package/test/conformance/ISO-PART2-PART3-SCOPE.md

@@ -0,0 +1,52 @@
+# ISO Part 2 and Part 3 compatibility scope
+
+EyeProlog's release-facing `--iso-strict` claim is deliberately limited to
+ISO/IEC 13211-1:1995 together with Technical Corrigenda 1:2007, 2:2012, and
+3:2017. This note records the separate status of the normal-profile facilities
+that overlap ISO/IEC 13211-2:2000 (modules) and ISO/IEC TS 13211-3:2025 (definite
+clause grammar rules). It is a scope ledger, not an independent certification.
+
+## Part 2 modules
+
+Normal mode implements a procedure-oriented module compatibility layer:
+`module/2`, `use_module/1-2`, `meta_predicate/1`, explicit `Module:Goal`
+qualification, exports/imports, nonterminal indicators, and module-aware meta
+calls are covered by the regression and conformance corpora.
+
+This overlap is intentionally described as a compatibility profile rather than
+a complete Part 2 conformance claim. In particular, the Part 1 strict registry
+does not enable module directives, and the project does not infer full Part 2
+coverage from interoperability with Scryer, Trealla, or Logtalk. A future Part 2
+claim would require a clause-by-clause Part 2 processor and module-semantics
+ledger comparable to the existing Part 1 matrices.
+
+## Part 3 definite clause grammars
+
+Normal mode expands grammar rules to ordinary predicates and supports terminal
+sequences, sequencing, alternatives, semicontexts, embedded goals, cut,
+`call//1`, `phrase//1`, `phrase/2-3`, module-qualified nonterminals, and the
+implementation-dependent negation/if-then choices documented in the reference.
+`--iso-strict` leaves `-->/2` as ordinary Part 1 operator syntax and excludes
+Part 3 grammar expansion and `phrase/2-3` from the strict registry.
+
+One compatibility difference is explicit: EyeProlog currently reports
+`type_error(list)` when its `phrase/2-3` terminal-sequence validation rejects a
+non-list. The Part 3 terminal-sequence specification uses its own terminal
+sequence error category. EyeProlog retains the list-shaped error for its normal
+interoperability profile, so this behavior must not be presented as evidence of
+complete Part 3 conformance.
+
+The Part 3 implementation otherwise keeps sequence validation, grammar-body
+callability, variable-body instantiation errors, `phrase/3` steadfastness, and
+grammar expansion under focused executable tests. Changes intended to advance a
+formal Part 3 claim should update this ledger and the corresponding error cases
+rather than silently changing the compatibility profile.
+
+## Release boundary
+
+- Part 1 + Corrigenda 1-3: release-facing strict-core conformance target.
+- Part 2: normal-mode compatibility profile, tested but not certified complete.
+- Part 3: normal-mode compatibility profile, tested but not certified complete.
+
+This separation keeps Part 1 conformance evidence independent of useful module
+and DCG extensions while making known Part 2/Part 3 scope limits visible.

package/test/conformance/README.md

@@ -16,7 +16,8 @@ closes 7.9/Clause 9, and [ISO-PROCESSOR-REQUIREMENTS.md](ISO-PROCESSOR-REQUIREME
 decomposes the Clause 5 processor obligations.
 [ISO-CORRIGENDA-MATRIX.md](ISO-CORRIGENDA-MATRIX.md) gives every published
 Corrigenda amendment cluster an executable, editorial, or superseded
-disposition. Built-in rows may group closely related conditions only when the
+disposition. [ISO-PART2-PART3-SCOPE.md](ISO-PART2-PART3-SCOPE.md) records the
+separate normal-profile module/DCG compatibility boundary and known non-claims. Built-in rows may group closely related conditions only when the
 row names every grouped condition and its executable evidence.
 The exit checklist is embedded in [ISO-COMPLIANCE.md](ISO-COMPLIANCE.md). [WG17-SYNTAX-STATUS.md](WG17-SYNTAX-STATUS.md) records the
 complete one-to-one trace for the vendored active upstream WG17 syntax cases.

package/test/fixtures/http-test-server.mjs

@@ -1,6 +1,8 @@
 import http from 'node:http';
 import { parentPort } from 'node:worker_threads';
 
+const LARGE_BYTES = 9 * 1024 * 1024;
+
 const server = http.createServer((req, res) => {
   const chunks = [];
   req.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
@@ -11,8 +13,19 @@ const server = http.createServer((req, res) => {
       res.end();
       return;
     }
+    if (req.url === '/large') {
+      res.setHeader('content-type', 'text/plain');
+      res.setHeader('content-length', String(LARGE_BYTES));
+      res.end(Buffer.alloc(LARGE_BYTES, 120));
+      return;
+    }
     const body = Buffer.concat(chunks).toString('utf8');
-    const payload = JSON.stringify({ method: req.method, path: req.url, body, test: req.headers['x-test'] ?? null });
+    const payload = JSON.stringify({
+      method: req.method, path: req.url, body,
+      test: req.headers['x-test'] ?? null,
+      repeated: req.headers['x-repeat'] ?? null,
+      contentLength: req.headers['content-length'] ?? null,
+    });
     res.setHeader('content-type', 'application/json');
     res.setHeader('x-eyeprolog-test', 'yes');
     res.end(payload);

package/test/run-http-json.mjs

@@ -30,6 +30,29 @@ answer(Cs) :- once(phrase(json_chars(pairs([string("a")-number(2),string("ok")-b
       'answer("{\\"a\\":2,\\"ok\\":true}").\n', 'JSON generation');
   });
 
+  reporter.test('library(json) combines supplementary Unicode surrogate escapes', () => {
+    const source = String.raw`:- use_module(library(json)).
+:- use_module(library(dcgs)).
+answer(X) :- phrase(json_chars(X), "\"\\uD83D\\uDE00\"").`;
+    assertEqual(run(source, { goal: 'answer(X)' }).stdout,
+      'answer(string("😀")).\n', 'JSON surrogate-pair parse');
+  });
+
+  reporter.test('library(json) generates and validates supplementary Unicode escapes relationally', () => {
+    const source = String.raw`:- use_module(library(json)).
+:- use_module(library(dcgs)).
+answer :- phrase(json_chars(string("😀")), "\"\\uD83D\\uDE00\"").`;
+    assertEqual(run(source, { goal: 'answer' }).stdout, 'answer.\n', 'JSON surrogate-pair generation');
+  });
+
+  reporter.test('library(json) rejects unpaired UTF-16 surrogates', () => {
+    const source = String.raw`:- use_module(library(json)).
+:- use_module(library(dcgs)).
+answer :- \+ phrase(json_chars(_), "\"\\uD83D\""),
+          \+ phrase(json_chars(_), "\"\\uDE00\"").`;
+    assertEqual(run(source, { goal: 'answer' }).stdout, 'answer.\n', 'unpaired JSON surrogate rejection');
+  });
+
   reporter.test('http_request/5 parses request lines and lower-cases header names', () => {
     const source = `:- use_module(library(http)).
 answer(M,P,V,H) :- http_request(user_input,M,P,V,H).`;
@@ -79,6 +102,39 @@ answer(Data,Code,Size) :-
       assertIncludes(output, '\\"path\\":\\"/open\\"', 'http_open body');
       assertIncludes(output, ', 200, ', 'http_open status and size');
     });
+
+    reporter.test('GET omits an entity Content-Length unless data/1 is explicit', () => {
+      const source = `:- use_module(library(http)).
+answer(Data) :- http_get("http://127.0.0.1:${port}/headers", Data, []).`;
+      const output = run(source, { goal: 'answer(Data)' }).stdout;
+      assertIncludes(output, '\\"contentLength\\":null', 'GET content-length omission');
+    });
+
+    reporter.test('explicit empty POST data sends Content-Length zero', () => {
+      const source = `:- use_module(library(http)).
+answer(Data) :- http_post("http://127.0.0.1:${port}/post-empty", "", Data, []).`;
+      const output = run(source, { goal: 'answer(Data)' }).stdout;
+      assertIncludes(output, '\\"contentLength\\":\\"0\\"', 'empty POST content-length');
+    });
+
+    reporter.test('request_headers/1 preserves repeated header values', () => {
+      const source = `:- use_module(library(http)).
+answer(Data) :-
+  http_get("http://127.0.0.1:${port}/headers", Data,
+           [request_headers(['x-repeat'("one"),'x-repeat'("two")])]).`;
+      const output = run(source, { goal: 'answer(Data)' }).stdout;
+      assertIncludes(output, '\\"repeated\\":\\"one, two\\"', 'repeated request headers');
+    });
+
+    reporter.test('http_open/3 streams bodies larger than the host RPC buffer', () => {
+      const source = `:- use_module(library(http)).
+:- use_module(library(charsio)).
+answer(Prefix) :-
+  http_open("http://127.0.0.1:${port}/large", S, []),
+  get_n_chars(S,16,Prefix), close(S).`;
+      assertEqual(run(source, { goal: 'answer(Prefix)' }).stdout,
+        'answer("xxxxxxxxxxxxxxxx").\n', 'large HTTP response streaming');
+    });
   } finally {
     worker.postMessage('close');
     await worker.terminate();

package/test/run-regression.mjs

@@ -7217,6 +7217,30 @@ function whiteBoxCases() {
         assertEqual(String(compareTerms(right, left, ranks)), '1', 'shared order reverse direction');
       },
     },
+    {
+      name: 'numeric identity and term order handle noncanonical unbounded integers without host BigInts',
+      run: () => {
+        const env = new Env();
+        assertEqual(unify(numberTerm('000123'), numberTerm('123'), env), true, 'leading-zero integer identity');
+        assertEqual(unify(numberTerm('-000'), numberTerm('0'), env), true, 'negative-zero integer identity');
+        assertEqual(compareTerms(numberTerm('99999999999999999999999999999999999999'),
+          numberTerm('100000000000000000000000000000000000000')), -1, 'large positive integer order');
+        assertEqual(compareTerms(numberTerm('-100000000000000000000000000000000000000'),
+          numberTerm('-99999999999999999999999999999999999999')), -1, 'large negative integer order');
+        assertEqual(publicApi.compareIntegerText('+1', '1'), 0, 'public helper retains host BigInt spelling compatibility');
+        let invalidIntegerError = null;
+        try { publicApi.compareIntegerText('not-an-integer', '1'); } catch (error) { invalidIntegerError = error; }
+        assertEqual(invalidIntegerError?.name, 'SyntaxError', 'public helper retains invalid-spelling error');
+      },
+    },
+    {
+      name: 'character term order compares Unicode scalar values without materializing code-point arrays',
+      run: () => {
+        assertEqual(compareTerms(atom('a😀'), atom('a😁')), -1, 'supplementary scalar order');
+        assertEqual(compareTerms(atom('a😀'), atom('a😀x')), -1, 'supplementary prefix order');
+        assertEqual(compareTerms(atom('a😀x'), atom('a😀')), 1, 'supplementary reverse prefix order');
+      },
+    },
     {
       name: 'unification rejects direct and indirect cyclic bindings',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -5861,8 +5861,11 @@ look_ahead(X), [X] --> [X].
 `phrase(+Body,?Sequence)` accepts or generates a complete sequence.
 `phrase(+Body,?Sequence,?Rest)` leaves `Rest` unconsumed and is steadfast in
 that argument. A variable body raises `instantiation_error`; a non-callable
-body raises `type_error(callable)`. EyeProlog performs terminal-sequence checks
-and reports the portable ISO `type_error(list)` error term.
+body raises `type_error(callable)`. EyeProlog performs terminal-sequence checks and currently reports
+`type_error(list)` for a rejected non-list. This is a normal-profile
+interoperability choice, not a Part 3 conformance claim; Part 3 defines a
+dedicated terminal-sequence error category. See
+[`ISO-PART2-PART3-SCOPE.md`](test/conformance/ISO-PART2-PART3-SCOPE.md).
 
 #### A bidirectional expression grammar
 
@@ -6811,9 +6814,9 @@ library. Scryer uses `library(builtins)` as its fundamental system module, while
 Trealla's file is implementation support; EyeProlog keeps those procedures in
 the core registry instead of creating a second authority for them.
 
-`library(http)` combines the Scryer `http_open/3` option surface with Trealla's `http_get/3`, `http_post/4`, `http_patch/4`, `http_put/4`, `http_delete/3`, `http_server/2`, and `http_request/5`. HTTP and HTTPS client requests are performed by the module-owned Node adapter in `src/http-host.js`; response bodies are exposed as ordinary text streams for `http_open/3` and as complete character lists for the convenience predicates. The client follows redirects, supports Scryer request/response metadata options, Trealla `header(Name,Value)` request options, and Trealla's `host/path` address-list form. `http_request/5` parses a request line and headers from a stream. The compact `http_server/2` facade accepts one connection per call because EyeProlog does not provide Trealla's `fork` task primitive.
+`library(http)` combines the Scryer `http_open/3` option surface with Trealla's `http_get/3`, `http_post/4`, `http_patch/4`, `http_put/4`, `http_delete/3`, `http_server/2`, and `http_request/5`. HTTP and HTTPS client requests are performed by the module-owned Node adapter in `src/http-host.js`; response bodies are exposed as ordinary text streams for `http_open/3` and as complete character lists for the convenience predicates. The host stream pulls response bytes lazily in bounded chunks, so opening a large response no longer buffers the entire body through the fixed-size RPC message. An ordinary GET or HEAD has no request entity unless `data/1` is explicit, repeated request-header values are preserved, and an explicitly empty entity gets `Content-Length: 0`. The client follows redirects, supports Scryer request/response metadata options, Trealla `header(Name,Value)` request options, and Trealla's `host/path` address-list form. `http_request/5` parses a request line and headers from a stream. The compact `http_server/2` facade accepts one connection per call because EyeProlog does not provide Trealla's `fork` task primitive.
 
-`library(json)` is the BSD-licensed Scryer JSON DCG also distributed by Trealla. `json_chars//1` is bidirectional and represents JSON objects as `pairs/1`, arrays as `list/1`, strings as `string/1`, numbers as `number/1`, booleans as `boolean/1`, and JSON null as `null`. See `examples/json.pl` and `examples/http-client.pl`.
+`library(json)` is the BSD-licensed Scryer JSON DCG also distributed by Trealla. `json_chars//1` is bidirectional and represents JSON objects as `pairs/1`, arrays as `list/1`, strings as `string/1`, numbers as `number/1`, booleans as `boolean/1`, and JSON null as `null`. JSON `\u` escapes are UTF-16 code units: valid surrogate pairs are combined into one supplementary Unicode scalar while parsing and emitted as a pair when that escaped representation is requested during generation; unpaired surrogates are rejected. See `examples/json.pl` and `examples/http-client.pl`.
 
 `library(sockets)` follows Scryer's TCP stream interface. `socket_client_open/3`
 connects to `Host:Port`; `socket_server_open/2` accepts either a port or