eyeprolog 1.5.38 → 1.5.40

package/README.md

@@ -58,11 +58,11 @@ printf 'human(socrates).\nmortal(X) :- human(X).\n' |
 
 ## Eyelet forward rules (`:+`)
 Normal mode executes top-level `Conclusion :+ Premise` rules through the bundled Prolog `library(eyelet)` driver when no explicit `-g/--goal` is supplied. `true :+ Goal` prints answers and `false :+ Goal` emits a `fuse/1`; JavaScript `run()` follows the same rule. The module exports `:+`, `stable/1`, and `becomes/2`, and implements rule selection, fixed-point rounds, skolemization, state replacement, and duplicate suppression in Prolog. JavaScript retains only syntax recognition, static dependency/autoload planning, driver bootstrap, and private mutability/output adapters; it does not implement the fixed-point semantics. Strict ISO mode disables this extension.
-
 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 33 bundled modules that overlap Scryer's current `src/lib/` surface cover Scryer's exported predicates, and all 26 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)`, and Scryer-compatible TCP `library(sockets)`. Filesystem, OS, and TCP socket 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.
-
+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, 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/http-client.pl

@@ -0,0 +1,13 @@
+% HTTP/HTTPS client example. This file has no automatic golden query because it
+% intentionally depends on the network endpoint supplied by the caller.
+%
+% Example query:
+%   ?- fetch_json("https://example.org/api/status", JSON, Code).
+
+:- use_module(library(http)).
+:- use_module(library(json)).
+:- use_module(library(dcgs)).
+
+fetch_json(URL, JSON, Code) :-
+    http_get(URL, Body, [status_code(Code), header("accept", "application/json")]),
+    phrase(json_chars(JSON), Body).

package/examples/json.pl

@@ -0,0 +1,19 @@
+% JSON parsing and generation with the shared Scryer/Trealla representation.
+%
+% 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)).
+
+%% goal: json_example(Mode, Value)
+
+json_example(parsed, JSON) :-
+    phrase(json_chars(JSON), "{\"name\":\"Ada\",\"active\":true,\"scores\":[3,5,8],\"emoji\":\"\\uD83D\\uDE00\"}").
+
+json_example(generated, Chars) :-
+    once(phrase(json_chars(pairs([
+        string("project")-string("EyeProlog"),
+        string("ok")-boolean(true)
+    ])), Chars)).

package/examples/output/json.pl

@@ -0,0 +1,2 @@
+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.38",
+  "version": "1.5.40",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -74,6 +74,7 @@
     "conformance:update:wg17": "node tools/upgrade-wg17.mjs",
     "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"
+    "conformance:sync:neumerkel": "node test/run-neumerkel.mjs --cached --update-report",
+    "test:http-json": "node test/run-http-json.mjs"
   }
 }

package/playground.html

@@ -551,6 +551,7 @@
           "herbrand-semantics",
           "herbrand-witnesses",
           "heron-theorem",
+          "http-client",
           "ideal-gas-law",
           "illegitimate-reasoning",
           "integer-partitions",
@@ -567,6 +568,7 @@
           "iso-reflective-terms",
           "iso-term-io",
           "job-shop-scheduling",
+          "json",
           "knapsack-optimization",
           "knowledge-engineering-alignment-flow",
           "knuth-bendix-completion",

package/src/ARCHITECTURE.md

@@ -101,3 +101,8 @@ runs in its own Node process, warms the engine before measured parse+execute
 runs, reports the median, and verifies a committed output SHA-256 before its
 timing is accepted. Machine-specific timing baselines live under `.benchmarks/`
 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, 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

@@ -0,0 +1,159 @@
+// Node HTTP(S) bridge for library(http). The Prolog module owns option parsing,
+// 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';
+import {
+  ATOM, COMPOUND, NUMBER, STRING, VAR, atom, compound, copyResolved, deref,
+  listFromItems, numberTerm, properListItems, unify,
+} from './term.js';
+import { characterListText, chars } from './host-utils.js';
+
+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;
+
+class HttpBridge {
+  constructor() {
+    this.shared = new SharedArrayBuffer(HEADER_WORDS * Int32Array.BYTES_PER_ELEMENT + RPC_BYTES);
+    this.header = new Int32Array(this.shared, 0, HEADER_WORDS);
+    this.bytes = new Uint8Array(this.shared, HEADER_WORDS * Int32Array.BYTES_PER_ELEMENT);
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder();
+    this.worker = new WorkerCtor(new URL('./http-worker.js', import.meta.url), {
+      type: 'module', workerData: { shared: this.shared },
+      execArgv: typeof process !== 'undefined' ? process.execArgv.filter((arg) => !arg.startsWith('--input-type')) : [],
+    });
+    this.worker.unref();
+    const ready = Atomics.wait(this.header, 0, 0, 5000);
+    if (ready === 'timed-out' || Atomics.load(this.header, 0) !== -1) {
+      this.worker.terminate();
+      throw new PrologError('resource_error(http)');
+    }
+    Atomics.store(this.header, 0, 0);
+  }
+  rpc(request) {
+    const encoded = this.encoder.encode(JSON.stringify(request));
+    if (encoded.length > this.bytes.length) throw new PrologError('resource_error(http_message)');
+    this.bytes.set(encoded, 0);
+    Atomics.store(this.header, 1, encoded.length);
+    Atomics.store(this.header, 2, 0);
+    Atomics.store(this.header, 0, 1);
+    this.worker.postMessage(1);
+    Atomics.wait(this.header, 0, 1);
+    const responseLength = Atomics.load(this.header, 2);
+    const response = JSON.parse(this.decoder.decode(this.bytes.subarray(0, responseLength)));
+    Atomics.store(this.header, 0, 0);
+    if (!response.ok) {
+      if (response.error?.code === 'EPROTONOSUPPORT') throw new PrologError('domain_error(http_url_scheme)');
+      if (['ENOTFOUND', 'ECONNREFUSED', 'EHOSTUNREACH', 'ENETUNREACH'].includes(response.error?.code)) {
+        throw new PrologError('existence_error(source_sink)');
+      }
+      throw new PrologError('resource_error(http)');
+    }
+    return response.result;
+  }
+}
+
+function httpBridge() {
+  if (!isNode || WorkerCtor == null || typeof SharedArrayBuffer === 'undefined' || typeof Atomics?.wait !== 'function') {
+    throw new PrologError('resource_error(http)');
+  }
+  bridge ??= new HttpBridge();
+  return bridge;
+}
+
+function textValue(term, env, { allowNumber = false } = {}) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (value.type === ATOM && value.name === '[]') return '';
+  if (value.type === ATOM || value.type === STRING || (allowNumber && value.type === NUMBER)) return value.name;
+  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));
+  return items.map((entryTerm) => {
+    const entry = deref(entryTerm, env);
+    if (entry.type !== COMPOUND || entry.name !== 'header' || entry.arity !== 2) {
+      throw new PrologError('domain_error(http_header)', copyResolved(entry, env));
+    }
+    return [textValue(entry.args[0], env), textValue(entry.args[1], env, { allowNumber: true })];
+  });
+}
+
+function streamHandle(id) { return compound('$stream', [numberTerm(id)]); }
+
+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: '',
+    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;
+}
+
+function* httpOpenBuiltin({ solver, goal, env }) {
+  const url = textValue(goal.args[0], env);
+  const method = textValue(goal.args[2], 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.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) &&
+      unify(goal.args[4], numberTerm(result.statusCode), next) &&
+      unify(goal.args[6], listFromItems(headerTerms), next) &&
+      unify(goal.args[7], chars(result.finalUrl), next)) {
+    yield next;
+  } else {
+    solver.io.close(stream);
+  }
+}
+
+export const httpHostBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__http_open', 8, httpOpenBuiltin, { deterministic: true, eyePrologLibrary: true });
+  },
+};

package/src/http-worker.js

@@ -0,0 +1,170 @@
+import http from 'node:http';
+import https from 'node:https';
+import { parentPort, workerData } from 'node:worker_threads';
+
+const HEADER_WORDS = 4;
+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') };
+}
+
+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 bridge message too large' } }));
+    bytes.set(fallback.subarray(0, bytes.length), 0);
+    Atomics.store(header, 2, Math.min(fallback.length, bytes.length));
+  } else {
+    bytes.set(encoded, 0);
+    Atomics.store(header, 2, encoded.length);
+  }
+  Atomics.store(header, 0, 2);
+  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);
+    const transport = target.protocol === 'https:' ? https : target.protocol === 'http:' ? http : null;
+    if (transport == null) {
+      reject(Object.assign(new Error(`unsupported URL scheme: ${target.protocol}`), { code: 'EPROTONOSUPPORT' }));
+      return;
+    }
+    const body = data == null ? null : Buffer.from(data, 'utf8');
+    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) => {
+      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);
+    if (body != null && body.length > 0) req.write(body);
+    req.end();
+  });
+}
+
+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 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 };
+    }
+    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 = 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)));
+    const result = await dispatch(request);
+    writeResponse({ ok: true, result });
+  } catch (error) {
+    writeResponse({ ok: false, error: errorRecord(error) });
+  }
+});
+
+Atomics.store(header, 0, -1);
+Atomics.notify(header, 0, 1);

package/src/lib/http.pl

@@ -0,0 +1,220 @@
+/** HTTP/HTTPS client helpers and a small HTTP server facade.
+
+    The client API combines the Scryer http_open/3 option surface with the
+    Trealla convenience predicates. HTTP and HTTPS client exchanges are
+    performed by the matching src/http-host.js adapter; response bodies are
+    returned as ordinary EyeProlog text streams.
+*/
+
+:- module(http, [
+    http_open/3,
+    http_get/3,
+    http_post/4,
+    http_patch/4,
+    http_put/4,
+    http_delete/3,
+    http_server/2,
+    http_request/5
+]).
+
+:- use_module(library(charsio), [get_line_to_chars/3, get_n_chars/3]).
+:- use_module(library(error), [must_be/2]).
+:- use_module(library(lists), [append/3, member/2, memberchk/2, maplist/3]).
+:- use_module(library(sockets)).
+
+:- meta_predicate(http_server(1, '?')).
+
+http_open(Address0, Response, Options0) :-
+    must_be(list, Options0),
+    http__normalize_address(Address0, Options0, Address, Options),
+    http__method(Options, Method),
+    http__data_spec(Options, DataSpec),
+    http__request_headers(Options, RequestHeaders),
+    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),
+    http__bind_option(final_url, FinalUrl, Options),
+    http__bind_size(Options, RawHeaders).
+
+
+http__normalize_address(Address, Options, URL, Effective) :-
+    nonvar(Address),
+    memberchk(host(Host), Address),
+    memberchk(path(Path), Address), !,
+    append(Address, Options, Effective),
+    ( memberchk(scheme(Scheme0), Address) -> Scheme = Scheme0
+    ; memberchk(https(true), Address) -> Scheme = https
+    ; Scheme = http
+    ),
+    http__text_chars(Scheme, SchemeChars),
+    http__text_chars(Host, HostChars),
+    http__text_chars(Path, Path0),
+    http__ensure_slash(Path0, PathChars),
+    ( memberchk(port(Port), Address) ->
+        http__text_chars(Port, PortChars),
+        append(HostChars, [':'|PortChars], Authority)
+    ; Authority = HostChars
+    ),
+    append(SchemeChars, "://", A0),
+    append(A0, Authority, A1),
+    append(A1, PathChars, URL).
+http__normalize_address(Address, Options, Address, Options).
+
+http__text_chars(Text, Chars) :- atom(Text), !, atom_chars(Text, Chars).
+http__text_chars(Text, Chars) :- number(Text), !, number_chars(Text, Chars).
+http__text_chars(Text, Text).
+
+http__ensure_slash([], "/") :- !.
+http__ensure_slash(['/'|Rest], ['/'|Rest]) :- !.
+http__ensure_slash(Path, ['/'|Path]).
+
+http_get(Address, Data, Options) :-
+    http__request_data(Address, get, no_data, Data, Options).
+
+http_post(Address, PostData, Reply, Options) :-
+    http__checked_data(PostData, DataSpec),
+    http__request_data(Address, post, DataSpec, Reply, Options).
+
+http_patch(Address, PostData, Reply, Options) :-
+    http__checked_data(PostData, DataSpec),
+    http__request_data(Address, patch, DataSpec, Reply, Options).
+
+http_put(Address, 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, 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) -> http__checked_data(Data0, DataSpec) ; DataSpec = Payload ),
+    http__request_headers(Options, RequestHeaders),
+    eyeprolog__http_open(Address, Stream, Method, DataSpec, Code, RequestHeaders, RawHeaders, FinalUrl),
+    get_n_chars(Stream, _, Data),
+    close(Stream),
+    http__trealla_headers(RawHeaders, Headers),
+    http__bind_option(status_code, Code, Options),
+    http__bind_option(headers, Headers, Options),
+    http__bind_option(final_url, FinalUrl, Options),
+    http__bind_size(Options, RawHeaders).
+
+http__method(Options, Method) :-
+    ( memberchk(method(Method0), Options) -> http__valid_method(Method0), Method = Method0 ; Method = get ).
+
+http__valid_method(Method) :-
+    ( var(Method) -> throw(error(instantiation_error, http_open/3))
+    ; memberchk(Method, [get,post,put,delete,patch,head]) -> true
+    ; throw(error(domain_error(http_option, method(Method)), http_open/3))
+    ).
+
+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 ),
+        maplist(http__header_term, Input, Base)
+    ; Base = [header('user-agent', "EyeProlog")]
+    ),
+    http__trealla_request_headers(Options, Extra),
+    append(Base, Extra, Headers).
+
+http__trealla_request_headers([], []).
+http__trealla_request_headers([header(Name,Value)|Options], [header(Name,Value)|Headers]) :- !,
+    http__trealla_request_headers(Options, Headers).
+http__trealla_request_headers([_|Options], Headers) :-
+    http__trealla_request_headers(Options, Headers).
+
+http__header_term(header(Name,Value), header(Name,Value)) :- !.
+http__header_term(Name-Value, header(Name,Value)) :- !.
+http__header_term(Name:Value, header(Name,Value)) :- !.
+http__header_term(Term, header(Name,Value)) :-
+    Term =.. [Name,Value].
+
+http__scryer_headers([], []).
+http__scryer_headers([header(Name,Value)|Headers], [Term|Terms]) :-
+    Term =.. [Name,Value],
+    http__scryer_headers(Headers, Terms).
+
+http__trealla_headers([], []).
+http__trealla_headers([header(Name,Value)|Headers], [NameChars:Value|Terms]) :-
+    atom_chars(Name, NameChars),
+    http__trealla_headers(Headers, Terms).
+
+http__bind_option(Name, Value, Options) :-
+    ( member(Option, Options), Option =.. [Name,Target] -> Target = Value ; true ).
+
+http__bind_size(Options, RawHeaders) :-
+    ( memberchk(size(Size), Options) ->
+        ( memberchk(header('content-length',Chars), RawHeaders) -> number_chars(Size, Chars) ; fail )
+    ; true
+    ).
+
+% One accepted connection per call. This mirrors Trealla's compact facade while
+% keeping EyeProlog's synchronous execution model explicit.
+http_server(Goal, Options) :-
+    must_be(list, Options),
+    ( memberchk(port(Port), Options) -> true ; Port = 0 ),
+    socket_server_open(Port, Server),
+    socket_server_accept(Server, _Client, Stream, [type(text)]),
+    socket_server_close(Server),
+    call(Goal, Stream).
+
+http_request(Stream, Method, Path, Version, Headers) :-
+    http__read_line(Stream, RequestLine),
+    http__split_once(' ', RequestLine, Method0, Rest0),
+    http__split_once(' ', Rest0, Path, Version0),
+    http__uppercase(Method0, Method),
+    http__drop_http_prefix(Version0, Version),
+    http__read_headers(Stream, Headers).
+
+http__read_headers(Stream, Headers) :-
+    http__read_line(Stream, Line),
+    ( Line = [] -> Headers = []
+    ; http__split_once(':', Line, Name0, Value0),
+      http__lowercase(Name0, Name),
+      http__trim_left(Value0, Value),
+      Headers = [Name:Value|Rest],
+      http__read_headers(Stream, Rest)
+    ).
+
+http__read_line(Stream, Line) :-
+    get_line_to_chars(Stream, Raw, []),
+    http__strip_line_end(Raw, Line).
+
+http__strip_line_end(Raw, Line) :-
+    ( append(Line0, ['\r','\n'], Raw) -> Line = Line0
+    ; append(Line0, ['\n'], Raw) -> Line = Line0
+    ; Line = Raw
+    ).
+
+http__split_once(Sep, [Sep|Xs], [], Xs) :- !.
+http__split_once(Sep, [X|Xs], [X|Ys], Rest) :-
+    http__split_once(Sep, Xs, Ys, Rest).
+
+http__drop_http_prefix(['H','T','T','P','/'|Version], Version) :- !.
+http__drop_http_prefix(Version, Version).
+
+http__trim_left([' '|Xs], Ys) :- !, http__trim_left(Xs, Ys).
+http__trim_left(['\t'|Xs], Ys) :- !, http__trim_left(Xs, Ys).
+http__trim_left(Xs, Xs).
+
+http__uppercase([], []).
+http__uppercase([C|Cs], [U|Us]) :-
+    char_code(C, Code),
+    ( Code >= 97, Code =< 122 -> Upper is Code - 32, char_code(U, Upper) ; U = C ),
+    http__uppercase(Cs, Us).
+
+http__lowercase([], []).
+http__lowercase([C|Cs], [L|Ls]) :-
+    char_code(C, Code),
+    ( Code >= 65, Code =< 90 -> Lower is Code + 32, char_code(L, Lower) ; L = C ),
+    http__lowercase(Cs, Ls).