eyeprolog 1.5.19 → 1.5.20

package/README.md

@@ -61,7 +61,7 @@ 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 32 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, and the full Scryer `library(crypto)`. Filesystem and OS 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 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.
 
 ## Links
 

package/package.json

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

package/src/io.js

@@ -112,7 +112,8 @@ export class StreamManager {
     });
   }
   flush(stream) {
-    if (!stream || stream.standard || stream.mode === 'read') return;
+    if (!stream || stream.standard || (stream.mode === 'read' && stream.writable !== true)) return;
+    if (typeof stream.flush === 'function') { stream.flush(); return; }
     fs.writeFileSync(stream.path, stream.type === 'binary' ? BufferCtor.from(stream.content) : stream.content);
   }
   discard(stream) {
@@ -120,8 +121,33 @@ export class StreamManager {
     this.streams.delete(stream.id);
   }
   close(stream) {
-    this.flush(stream);
+    if (typeof stream.closeTransport !== 'function') {
+      this.flush(stream);
+      this.discard(stream);
+      return;
+    }
+    let error = null;
+    try { this.flush(stream); } catch (caught) { error = caught; }
+    try { stream.closeTransport(); } catch (caught) { error ??= caught; }
     this.discard(stream);
+    if (error != null) throw error;
+  }
+  refill(stream) {
+    if (typeof stream?.interactiveReadUnit !== 'function') return false;
+    if (stream.continuousRefill === true && stream.position >= stream.content.length && stream.position > 0) {
+      stream.content = stream.type === 'binary' ? [] : '';
+      stream.position = 0;
+    }
+    const value = stream.interactiveReadUnit();
+    if (value == null) return false;
+    if (stream.type === 'binary') {
+      const incoming = Array.isArray(value) ? value : [...value];
+      stream.content.push(...incoming);
+    } else {
+      stream.content += String(value);
+    }
+    stream.pastEnd = false;
+    return true;
   }
   readUnit(stream, peek = false) {
     if (stream.position >= stream.content.length) return null;
@@ -142,6 +168,10 @@ export class StreamManager {
     return value;
   }
   writeUnit(stream, value) {
+    if (typeof stream.writeUnit === 'function') {
+      stream.writeUnit(value);
+      return;
+    }
     if (stream.standard && stream.write) {
       stream.write(String(value));
       return;

package/src/iso.js

@@ -1154,8 +1154,12 @@ function requireStream(solver, term, env, mode = null) {
   const culprit = deref(term, env);
   const stream = solver.io.resolve(streamReference(term, env));
   if (!stream) throw new PrologError('existence_error(stream)', culprit);
-  if (mode && stream.mode !== mode && !(mode === 'write' && stream.mode === 'append')) {
-    throw new PrologError(`permission_error(${mode === 'read' ? 'input' : 'output'}, stream)`, culprit);
+  if (mode) {
+    const readable = stream.readable ?? stream.mode === 'read';
+    const writable = stream.writable ?? (stream.mode === 'write' || stream.mode === 'append');
+    if ((mode === 'read' && !readable) || (mode === 'write' && !writable)) {
+      throw new PrologError(`permission_error(${mode === 'read' ? 'input' : 'output'}, stream)`, culprit);
+    }
   }
   return stream;
 }
@@ -1358,18 +1362,27 @@ function* flushOutputBuiltin({ solver, goal, env }) {
   yield env;
 }
 
+function streamEndState(stream) {
+  if (stream.pastEnd) return 'past';
+  if (stream.position < stream.content.length) return 'not';
+  if (stream.remoteEnded === true) return 'at';
+  if (typeof stream.interactiveReadUnit === 'function') return 'not';
+  return 'at';
+}
+
 function streamProperties(stream) {
   const properties = [
     compound('mode', [atom(stream.mode)]),
     compound('type', [atom(stream.type)]),
     compound('reposition', [atom(stream.reposition ? 'true' : 'false')]),
     compound('eof_action', [atom(stream.eofAction)]),
-    compound('position', [numberTerm(stream.position)]),
+    compound('position', [numberTerm(stream.reportedPosition ?? stream.position)]),
   ];
-  properties.push(atom(stream.mode === 'read' ? 'input' : 'output'));
-  properties.push(compound('end_of_stream', [
-    atom(stream.pastEnd ? 'past' : stream.position >= stream.content.length ? 'at' : 'not'),
-  ]));
+  const readable = stream.readable ?? stream.mode === 'read';
+  const writable = stream.writable ?? (stream.mode === 'write' || stream.mode === 'append');
+  if (readable) properties.push(atom('input'));
+  if (writable) properties.push(atom('output'));
+  properties.push(compound('end_of_stream', [atom(streamEndState(stream))]));
   if (stream.alias) properties.push(compound('alias', [atom(stream.alias)]));
   if (stream.path) properties.push(compound('file_name', [atom(stream.path)]));
   return properties;
@@ -1461,7 +1474,7 @@ function* atEndBuiltin({ solver, goal, env }) {
   // stream property and therefore accepts any open stream-or-alias; it is not
   // an input-only operation.
   const stream = goal.arity === 0 ? solver.io.resolve(solver.io.currentInput) : requireStream(solver, goal.args[0], env);
-  if (stream.pastEnd || stream.position >= stream.content.length) yield env;
+  if (streamEndState(stream) !== 'not') yield env;
 }
 function validStrictInputCharacterCode(value, solver) {
   if (value.type !== NUMBER || !isDecimalInteger(value.name)) return false;
@@ -1521,11 +1534,7 @@ function inputUnitBuiltin(name) {
     }
     const peek = name.startsWith('peek');
     if (stream.position >= stream.content.length && typeof stream.interactiveReadUnit === 'function') {
-      const text = stream.interactiveReadUnit();
-      if (text != null) {
-        stream.content += String(text);
-        stream.pastEnd = false;
-      }
+      solver.io.refill(stream);
     }
     let unit;
     try {
@@ -1829,6 +1838,13 @@ function readTermFromStream(stream, solver) {
       throw error;
     }
 
+    // Streams backed by a synchronous refill hook (for example TCP sockets)
+    // may need more input before the current term becomes complete. Refill and
+    // rescan until a complete term is available or the underlying stream ends.
+    if (stream.continuousRefill === true && typeof stream.interactiveReadUnit === 'function' && stream.remoteEnded !== true) {
+      if (solver.io.refill(stream)) continue;
+    }
+
     // The interactive top level may attach a synchronous reader to the
     // standard user_input stream. Ask it for one complete read-term only when
     // this read operation actually reaches the end of buffered input. This is

package/src/lib/sockets.pl

@@ -0,0 +1,48 @@
+/** TCP sockets represented as ordinary Prolog streams. */
+
+:- module(sockets, [
+    socket_client_open/3,
+    socket_server_open/2,
+    socket_server_accept/4,
+    socket_server_close/1,
+    current_hostname/1
+]).
+
+:- use_module(library(error)).
+
+socket_client_open(Addr, Stream, Options) :-
+    ( var(Addr) ->
+        throw(error(instantiation_error, socket_client_open/3))
+    ; true
+    ),
+    must_be(var, Stream),
+    must_be(list, Options),
+    ( Addr = Address:Port,
+      atom(Address),
+      ( atom(Port) ; integer(Port) ) ->
+        true
+    ; throw(error(type_error(socket_address, Addr), socket_client_open/3))
+    ),
+    eyeprolog__socket_client_open(Address, Port, Stream, Options).
+
+socket_server_open(Addr, ServerSocket) :-
+    must_be(var, ServerSocket),
+    ( ( integer(Addr) ; var(Addr) ) ->
+        eyeprolog__socket_server_open([], Addr, ServerSocket)
+    ; Addr = Address:Port,
+      must_be(atom, Address),
+      can_be(integer, Port),
+      eyeprolog__socket_server_open(Address, Port, ServerSocket)
+    ).
+
+socket_server_accept(ServerSocket, Client, Stream, Options) :-
+    must_be(var, Client),
+    must_be(var, Stream),
+    must_be(list, Options),
+    eyeprolog__socket_server_accept(ServerSocket, Client, Stream, Options).
+
+socket_server_close(ServerSocket) :-
+    eyeprolog__socket_server_close(ServerSocket).
+
+current_hostname(HostName) :-
+    eyeprolog__current_hostname(HostName).

package/src/library-autoload-index.js

@@ -111,6 +111,7 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "crypto_password_hash/3": "crypto",
   "cumulative/1": "clpz",
   "cumulative/2": "clpz",
+  "current_hostname/1": "sockets",
   "current_time/1": "time",
   "curve25519_generator/1": "crypto",
   "curve25519_scalar_mult/3": "crypto",
@@ -339,6 +340,10 @@ export const eyePrologLibraryAutoload = Object.freeze({
   "sleep/1": "time",
   "slice/4": "lists",
   "smallest_divisor_from/3": "primes",
+  "socket_client_open/3": "sockets",
+  "socket_server_accept/4": "sockets",
+  "socket_server_close/1": "sockets",
+  "socket_server_open/2": "sockets",
   "split/3": "strings",
   "stable/1": "eyelet",
   "start_tabling/2": "tabling",
@@ -430,6 +435,7 @@ export const eyePrologLibraryAutoloadModules = Object.freeze([
   "random",
   "reif",
   "si",
+  "sockets",
   "strings",
   "tabling",
   "terms",

package/src/sockets-host.js

@@ -0,0 +1,298 @@
+// Node TCP services for Scryer-compatible library(sockets).
+// The public Prolog module stays synchronous; a worker owns Node's asynchronous
+// sockets and the host adapter bridges each operation into the existing stream API.
+
+import { isNode } from './platform.js';
+import { PrologError } from './errors.js';
+import {
+  ATOM, COMPOUND, NUMBER, VAR, atom, compound, copyResolved, deref, numberTerm,
+  properListItems, unify,
+} from './term.js';
+
+let WorkerCtor = null;
+if (isNode) ({ Worker: WorkerCtor } = await import('node:worker_threads'));
+
+const RPC_BYTES = 1024 * 1024;
+const HEADER_WORDS = 4;
+const WRITE_CHUNK_BYTES = 256 * 1024;
+let bridge = null;
+
+class SocketBridge {
+  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('./sockets-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(sockets)');
+    }
+    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(socket_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) {
+      const error = new Error(response.error?.message ?? 'socket error');
+      error.code = response.error?.code ?? 'EUNKNOWN';
+      throw error;
+    }
+    return response.result;
+  }
+}
+
+function socketBridge() {
+  if (!isNode || WorkerCtor == null || typeof SharedArrayBuffer === 'undefined' || typeof Atomics?.wait !== 'function') {
+    throw new PrologError('resource_error(sockets)');
+  }
+  bridge ??= new SocketBridge();
+  return bridge;
+}
+
+function socketSystemError(error, operation, culprit = null) {
+  if (error instanceof PrologError) return error;
+  if (error?.code === 'EACCES' || error?.code === 'EPERM') {
+    return new PrologError('permission_error(open, source_sink)', culprit);
+  }
+  if (error?.code === 'EBADF') return new PrologError('existence_error(socket)', culprit);
+  if (['ECONNREFUSED', 'EHOSTUNREACH', 'ENETUNREACH', 'ENOTFOUND', 'EADDRNOTAVAIL'].includes(error?.code)) {
+    return new PrologError('existence_error(source_sink)', culprit);
+  }
+  if (error?.code === 'EADDRINUSE') return new PrologError('permission_error(open, source_sink)', culprit);
+  return new PrologError(`resource_error(${operation})`, culprit);
+}
+
+function optionsList(term, env) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  const items = properListItems(value, env);
+  if (items == null) throw new PrologError('type_error(list)', copyResolved(value, env));
+  return items.map((item) => deref(item, env));
+}
+
+function parseSocketOptions(term, env) {
+  const result = { alias: null, eofAction: 'error', reposition: false, type: 'text' };
+  for (const option of optionsList(term, env)) {
+    if (option.type === VAR) throw new PrologError('instantiation_error');
+    if (option.type !== COMPOUND || option.arity !== 1) throw new PrologError('domain_error(stream_option)', copyResolved(option, env));
+    const value = deref(option.args[0], env);
+    if (value.type === VAR) throw new PrologError('instantiation_error');
+    if (option.name === 'alias') {
+      if (value.type !== ATOM) throw new PrologError('domain_error(stream_option)', copyResolved(option, env));
+      result.alias = value.name;
+    } else if (option.name === 'eof_action') {
+      if (value.type !== ATOM || !['error', 'eof_code', 'reset'].includes(value.name)) {
+        throw new PrologError('domain_error(stream_option)', copyResolved(option, env));
+      }
+      result.eofAction = value.name;
+    } else if (option.name === 'reposition') {
+      if (value.type !== ATOM || !['true', 'false'].includes(value.name)) {
+        throw new PrologError('domain_error(stream_option)', copyResolved(option, env));
+      }
+      result.reposition = value.name === 'true';
+    } else if (option.name === 'type') {
+      if (value.type !== ATOM || !['text', 'binary'].includes(value.name)) {
+        throw new PrologError('domain_error(stream_option)', copyResolved(option, env));
+      }
+      result.type = value.name;
+    } else {
+      throw new PrologError('domain_error(stream_option)', copyResolved(option, env));
+    }
+  }
+  return result;
+}
+
+function hostText(term, env, { allowEmptyList = false } = {}) {
+  const value = deref(term, env);
+  if (allowEmptyList && value.type === ATOM && value.name === '[]') return '127.0.0.1';
+  if (value.type !== ATOM) throw new PrologError('type_error(atom)', copyResolved(value, env));
+  return value.name;
+}
+
+function portValue(term, env, { allowVariable = false } = {}) {
+  const value = deref(term, env);
+  if (allowVariable && value.type === VAR) return { port: 0, variable: true };
+  if (value.type === NUMBER && /^\d+$/.test(value.name)) {
+    const port = Number(value.name);
+    if (Number.isInteger(port) && port >= 0 && port <= 65535) return { port, variable: false };
+  }
+  if (!allowVariable && value.type === ATOM && /^\d+$/.test(value.name)) {
+    const port = Number(value.name);
+    if (port <= 65535) return { port, variable: false };
+  }
+  throw new PrologError('type_error(integer)', copyResolved(value, env));
+}
+
+function serverHandle(id) {
+  return compound('$socket_server', [numberTerm(id)]);
+}
+
+function serverId(term, env) {
+  const value = deref(term, env);
+  if (value.type === VAR) throw new PrologError('instantiation_error');
+  if (value.type === COMPOUND && value.name === '$socket_server' && value.arity === 1) {
+    const id = deref(value.args[0], env);
+    if (id.type === NUMBER && /^\d+$/.test(id.name)) return Number(id.name);
+  }
+  throw new PrologError('type_error(socket)', copyResolved(value, env));
+}
+
+function base64(bytes) {
+  return Buffer.from(bytes).toString('base64');
+}
+
+function bytesFromBase64(text) {
+  return Uint8Array.from(Buffer.from(text, 'base64'));
+}
+
+function addSocketStream(solver, connectionId, options, fileName = '') {
+  if (options.reposition) throw new PrologError('permission_error(reposition, stream)');
+  if (options.alias && solver.io.resolve(options.alias)) {
+    throw new PrologError('permission_error(open, source_sink)', compound('alias', [atom(options.alias)]));
+  }
+  const worker = socketBridge();
+  const textDecoder = options.type === 'text' ? new TextDecoder('utf-8', { fatal: true }) : null;
+  const stream = {
+    id: solver.io.nextId++, alias: options.alias, mode: 'read_append', type: options.type,
+    content: options.type === 'binary' ? [] : '', position: 0, reportedPosition: 0, path: fileName,
+    reposition: false, eofAction: options.eofAction, standard: false, pastEnd: false,
+    readable: true, writable: true, remoteEnded: false, continuousRefill: true,
+    socketConnectionId: connectionId,
+    socketOutput: options.type === 'binary' ? [] : '',
+  };
+  stream.interactiveReadUnit = () => {
+    while (true) {
+      let result;
+      try { result = worker.rpc({ op: 'read', connectionId, maxBytes: 64 * 1024 }); }
+      catch (error) { throw socketSystemError(error, 'socket_read'); }
+      if (result.eof) {
+        stream.remoteEnded = true;
+        if (stream.type === 'text') {
+          try {
+            const tail = textDecoder.decode();
+            if (tail) return tail;
+          } catch (_) {
+            throw new PrologError('representation_error(character)');
+          }
+        }
+        return null;
+      }
+      const bytes = bytesFromBase64(result.data);
+      if (stream.type === 'binary') return [...bytes];
+      let text;
+      try { text = textDecoder.decode(bytes, { stream: true }); }
+      catch (_) { throw new PrologError('representation_error(character)'); }
+      if (text.length > 0) return text;
+    }
+  };
+  stream.writeUnit = (value) => {
+    if (stream.type === 'binary') stream.socketOutput.push(value);
+    else stream.socketOutput += String(value);
+  };
+  stream.flush = () => {
+    const data = stream.type === 'binary'
+      ? Uint8Array.from(stream.socketOutput)
+      : new TextEncoder().encode(stream.socketOutput);
+    if (data.length === 0) return;
+    for (let offset = 0; offset < data.length; offset += WRITE_CHUNK_BYTES) {
+      const chunk = data.subarray(offset, Math.min(data.length, offset + WRITE_CHUNK_BYTES));
+      try { worker.rpc({ op: 'write', connectionId, data: base64(chunk) }); }
+      catch (error) { throw socketSystemError(error, 'socket_write'); }
+    }
+    stream.socketOutput = stream.type === 'binary' ? [] : '';
+  };
+  stream.closeTransport = () => {
+    try { worker.rpc({ op: 'close', connectionId }); }
+    catch (error) { throw socketSystemError(error, 'socket_close'); }
+  };
+  solver.io.add(stream);
+  return stream;
+}
+
+function streamHandle(id) {
+  return compound('$stream', [numberTerm(id)]);
+}
+
+function* socketClientOpenBuiltin({ solver, goal, env }) {
+  const host = hostText(goal.args[0], env);
+  const { port } = portValue(goal.args[1], env);
+  const options = parseSocketOptions(goal.args[3], env);
+  if (options.reposition) throw new PrologError('permission_error(reposition, stream)', copyResolved(goal.args[3], env));
+  let result;
+  try { result = socketBridge().rpc({ op: 'client_open', host, port }); }
+  catch (error) { throw socketSystemError(error, 'socket_client_open', copyResolved(goal.args[0], env)); }
+  const stream = addSocketStream(solver, result.connectionId, options, `${host}:${port}`);
+  const next = env.clone();
+  if (unify(goal.args[2], streamHandle(stream.id), next)) yield next;
+  else solver.io.close(stream);
+}
+
+function* socketServerOpenBuiltin({ goal, env }) {
+  const host = hostText(goal.args[0], env, { allowEmptyList: true });
+  const { port, variable } = portValue(goal.args[1], env, { allowVariable: true });
+  let result;
+  try { result = socketBridge().rpc({ op: 'server_open', host, port }); }
+  catch (error) { throw socketSystemError(error, 'socket_server_open', copyResolved(goal.args[0], env)); }
+  const next = env.clone();
+  if (!unify(goal.args[2], serverHandle(result.serverId), next) ||
+      (variable && !unify(goal.args[1], numberTerm(result.port), next))) {
+    try { socketBridge().rpc({ op: 'server_close', serverId: result.serverId }); } catch (_) { /* best effort */ }
+    return;
+  }
+  yield next;
+}
+
+function* socketServerAcceptBuiltin({ solver, goal, env }) {
+  const id = serverId(goal.args[0], env);
+  const options = parseSocketOptions(goal.args[3], env);
+  if (options.reposition) throw new PrologError('permission_error(reposition, stream)', copyResolved(goal.args[3], env));
+  let result;
+  try { result = socketBridge().rpc({ op: 'server_accept', serverId: id }); }
+  catch (error) { throw socketSystemError(error, 'socket_server_accept', copyResolved(goal.args[0], env)); }
+  const stream = addSocketStream(solver, result.connectionId, options, result.client);
+  const next = env.clone();
+  if (unify(goal.args[1], atom(result.client), next) && unify(goal.args[2], streamHandle(stream.id), next)) yield next;
+  else solver.io.close(stream);
+}
+
+function* socketServerCloseBuiltin({ goal, env }) {
+  const id = serverId(goal.args[0], env);
+  try { socketBridge().rpc({ op: 'server_close', serverId: id }); }
+  catch (error) { throw socketSystemError(error, 'socket_server_close', copyResolved(goal.args[0], env)); }
+  yield env;
+}
+
+function* currentHostnameBuiltin({ goal, env }) {
+  let result;
+  try { result = socketBridge().rpc({ op: 'hostname' }); }
+  catch (error) { throw socketSystemError(error, 'current_hostname'); }
+  const next = env.clone();
+  if (unify(goal.args[0], atom(result.hostname), next)) yield next;
+}
+
+export const socketsHostBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__socket_client_open', 4, socketClientOpenBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__socket_server_open', 3, socketServerOpenBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__socket_server_accept', 4, socketServerAcceptBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__socket_server_close', 1, socketServerCloseBuiltin, { deterministic: true, eyePrologLibrary: true });
+    registry.add('eyeprolog__current_hostname', 1, currentHostnameBuiltin, { deterministic: true, eyePrologLibrary: true });
+  },
+};