eyeprolog 1.5.19 → 1.5.21

package/src/sockets-worker.js

@@ -0,0 +1,235 @@
+import net from 'node:net';
+import os from 'node:os';
+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();
+
+let nextServerId = 1;
+let nextConnectionId = 1;
+const servers = new Map();
+const connections = new Map();
+
+function errorRecord(error) {
+  return {
+    code: String(error?.code ?? 'EUNKNOWN'),
+    message: String(error?.message ?? error ?? 'socket 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: 'socket response 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 takeBuffered(state, maxBytes) {
+  if (state.chunks.length === 0) return null;
+  const first = state.chunks[0];
+  if (first.length <= maxBytes) {
+    state.chunks.shift();
+    return first;
+  }
+  const result = first.subarray(0, maxBytes);
+  state.chunks[0] = first.subarray(maxBytes);
+  return result;
+}
+
+function satisfyReaders(state) {
+  while (state.readers.length > 0) {
+    const waiter = state.readers[0];
+    if (state.error) {
+      state.readers.shift();
+      waiter.reject(state.error);
+      continue;
+    }
+    const chunk = takeBuffered(state, waiter.maxBytes);
+    if (chunk != null) {
+      state.readers.shift();
+      waiter.resolve(chunk);
+      continue;
+    }
+    if (state.ended) {
+      state.readers.shift();
+      waiter.resolve(null);
+      continue;
+    }
+    break;
+  }
+}
+
+function registerConnection(socket) {
+  const id = nextConnectionId++;
+  const state = { id, socket, chunks: [], readers: [], ended: false, error: null };
+  connections.set(id, state);
+  socket.on('data', (chunk) => {
+    state.chunks.push(Buffer.from(chunk));
+    satisfyReaders(state);
+  });
+  socket.on('end', () => {
+    state.ended = true;
+    satisfyReaders(state);
+  });
+  socket.on('close', () => {
+    state.ended = true;
+    satisfyReaders(state);
+  });
+  socket.on('error', (error) => {
+    state.error = error;
+    satisfyReaders(state);
+  });
+  return state;
+}
+
+function connectionClient(socket) {
+  const address = socket.remoteAddress ?? '';
+  const port = socket.remotePort ?? 0;
+  return address.includes(':') && !address.startsWith('[')
+    ? `[${address}]:${port}`
+    : `${address}:${port}`;
+}
+
+function queueAccepted(serverState, socket) {
+  const connection = registerConnection(socket);
+  const accepted = { connectionId: connection.id, client: connectionClient(socket) };
+  const waiter = serverState.acceptors.shift();
+  if (waiter) waiter.resolve(accepted);
+  else serverState.accepted.push(accepted);
+}
+
+async function serverOpen(host, port) {
+  const server = net.createServer();
+  const state = { id: nextServerId++, server, accepted: [], acceptors: [], closed: false };
+  server.on('connection', (socket) => queueAccepted(state, socket));
+  await new Promise((resolve, reject) => {
+    const onError = (error) => { server.off('listening', onListen); reject(error); };
+    const onListen = () => { server.off('error', onError); resolve(); };
+    server.once('error', onError);
+    server.once('listening', onListen);
+    server.listen({ host, port });
+  });
+  const address = server.address();
+  servers.set(state.id, state);
+  return { serverId: state.id, port: typeof address === 'object' && address ? address.port : port };
+}
+
+async function clientOpen(host, port) {
+  const socket = new net.Socket();
+  const state = registerConnection(socket);
+  try {
+    await new Promise((resolve, reject) => {
+      const onConnect = () => { socket.off('error', onError); resolve(); };
+      const onError = (error) => { socket.off('connect', onConnect); reject(error); };
+      socket.once('connect', onConnect);
+      socket.once('error', onError);
+      socket.connect({ host, port });
+    });
+  } catch (error) {
+    connections.delete(state.id);
+    socket.destroy();
+    throw error;
+  }
+  return { connectionId: state.id };
+}
+
+async function serverAccept(serverId) {
+  const state = servers.get(serverId);
+  if (!state || state.closed) throw Object.assign(new Error('server socket is closed'), { code: 'EBADF' });
+  if (state.accepted.length > 0) return state.accepted.shift();
+  return new Promise((resolve, reject) => state.acceptors.push({ resolve, reject }));
+}
+
+function serverClose(serverId) {
+  const state = servers.get(serverId);
+  if (!state || state.closed) throw Object.assign(new Error('server socket does not exist'), { code: 'EBADF' });
+  state.closed = true;
+  for (const waiter of state.acceptors.splice(0)) {
+    waiter.reject(Object.assign(new Error('server socket is closed'), { code: 'EBADF' }));
+  }
+  try { state.server.close(); } catch (_) { /* already closed */ }
+  servers.delete(serverId);
+  return {};
+}
+
+async function connectionRead(connectionId, maxBytes) {
+  const state = connections.get(connectionId);
+  if (!state) throw Object.assign(new Error('socket stream does not exist'), { code: 'EBADF' });
+  if (state.error) throw state.error;
+  const chunk = takeBuffered(state, maxBytes);
+  if (chunk != null) return { eof: false, data: chunk.toString('base64') };
+  if (state.ended) return { eof: true, data: '' };
+  const result = await new Promise((resolve, reject) => state.readers.push({ maxBytes, resolve, reject }));
+  return result == null ? { eof: true, data: '' } : { eof: false, data: result.toString('base64') };
+}
+
+async function connectionWrite(connectionId, base64) {
+  const state = connections.get(connectionId);
+  if (!state || state.ended) throw Object.assign(new Error('socket stream is closed'), { code: 'EBADF' });
+  const data = Buffer.from(base64, 'base64');
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const onError = (error) => {
+      if (settled) return;
+      settled = true;
+      state.socket.off('error', onError);
+      reject(error);
+    };
+    state.socket.once('error', onError);
+    state.socket.write(data, () => {
+      if (settled) return;
+      settled = true;
+      state.socket.off('error', onError);
+      resolve();
+    });
+  });
+  return {};
+}
+
+function connectionClose(connectionId) {
+  const state = connections.get(connectionId);
+  if (!state) return {};
+  state.ended = true;
+  satisfyReaders(state);
+  state.socket.destroy();
+  connections.delete(connectionId);
+  return {};
+}
+
+async function handle(request) {
+  switch (request.op) {
+    case 'hostname': return { hostname: os.hostname() };
+    case 'server_open': return serverOpen(request.host, request.port);
+    case 'server_accept': return serverAccept(request.serverId);
+    case 'server_close': return serverClose(request.serverId);
+    case 'client_open': return clientOpen(request.host, request.port);
+    case 'read': return connectionRead(request.connectionId, request.maxBytes);
+    case 'write': return connectionWrite(request.connectionId, request.data);
+    case 'close': return connectionClose(request.connectionId);
+    default: throw Object.assign(new Error(`unknown socket 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)));
+    writeResponse({ ok: true, result: await handle(request) });
+  } catch (error) {
+    writeResponse({ ok: false, error: errorRecord(error) });
+  }
+});
+
+Atomics.store(header, 0, -1);
+Atomics.notify(header, 0, 1);

package/src/standard-library.js

@@ -20,6 +20,7 @@ import { pioHostBuiltins } from './pio-host.js';
 import { randomHostBuiltins } from './random-host.js';
 import { tablingHostBuiltins } from './tabling-host.js';
 import { timeHostBuiltins } from './time-host.js';
+import { socketsHostBuiltins } from './sockets-host.js';
 import { fs, isNode, memoryStatistics } from './platform.js';
 import { ATOM, VAR, atom, deref, numberTerm, unify } from './term.js';
 import { eyePrologAmbiguousLibraryAutoload, eyePrologLibraryAutoload, eyePrologLibraryAutoloadModules } from './library-autoload-index.js';
@@ -59,6 +60,7 @@ const moduleFiles = Object.freeze({
   random: 'random.pl',
   reif: 'reif.pl',
   si: 'si.pl',
+  sockets: 'sockets.pl',
   strings: 'strings.pl',
   terms: 'terms.pl',
   tabling: 'tabling.pl',
@@ -98,6 +100,7 @@ export const eyePrologNativeLibraryIndicators = Object.freeze([
   'number_to_rational/2', 'number_to_rational/3', 'rational_numerator_denominator/3',
   'read_from_chars/2', 'read_term_from_chars/3', 'write_term_to_chars/3', 'chars_base64/3',
   'sleep/1',
+  'socket_client_open/3', 'socket_server_open/2', 'socket_server_accept/4', 'socket_server_close/1', 'current_hostname/1',
   'directory_files/2', 'file_size/2', 'file_exists/1', 'directory_exists/1',
   'delete_file/1', 'rename_file/2', 'file_copy/2', 'delete_directory/1',
   'make_directory/1', 'make_directory_path/1', 'working_directory/2', 'path_canonical/2',
@@ -274,6 +277,7 @@ const eyePrologSharedLibraryIndicators = [
   'ord_memberchk/2', 'ord_selectchk/3', 'ord_seteq/2', 'ord_subset/2',
   'ord_subtract/3', 'ord_symdiff/3', 'ord_union/2', 'ord_union/3', 'ord_union/4',
   'directory_files/2', 'delete_file/1', 'rename_file/2', 'make_directory/1', 'make_directory_path/1', 'working_directory/2',
+  'socket_client_open/3', 'socket_server_accept/4', 'socket_server_close/1',
   'phrase_from_file/2', 'phrase_from_file/3', 'phrase_to_file/2',
   'phrase_to_file/3', 'phrase_to_stream/2',
   'maybe/0', 'random/1', 'random_integer/3', 'set_random/1',
@@ -299,7 +303,7 @@ export const eyePrologInteropLibraryIndicators = Object.freeze([
 export const eyePrologInteropLibraryModules = Object.freeze([
   'arithmetic', 'assoc', 'atts', 'charsio', 'clpb', 'clpz', 'dcgs', 'debug', 'dif',
   'files', 'format', 'freeze', 'gensym', 'iso_ext', 'lambda', 'lists', 'ordsets', 'os', 'pio',
-  'random', 'reif', 'tabling', 'time', 'ugraphs', 'uuid', 'when',
+  'random', 'reif', 'sockets', 'tabling', 'time', 'ugraphs', 'uuid', 'when',
 ]);
 
 function* tabledNegationBuiltin({ solver, goal, env }) {
@@ -372,6 +376,7 @@ export function createEyePrologRegistry() {
   randomHostBuiltins.register(registry);
   tablingHostBuiltins.register(registry);
   timeHostBuiltins.register(registry);
+  socketsHostBuiltins.register(registry);
   cryptoHostBuiltins.register(registry);
   dcgsHostBuiltins.register(registry);
   registry.eyePrologLibrary = true;

package/test/run-regression.mjs

@@ -4792,15 +4792,15 @@ function documentationSyncCases() {
           encoding: 'utf8',
         });
         assertEqual(result.status, 0, 'exit status');
-        assertIncludes(result.stdout, 'predicate reference is up to date (518 predicates)', 'stdout');
+        assertIncludes(result.stdout, 'predicate reference is up to date (523 predicates)', 'stdout');
         assertEqual(result.stderr, '', 'stderr');
 
         const book = fs.readFileSync(path.join(packageRoot, 'the-art-of-eyeprolog.md'), 'utf8');
         const section = between(book, '<!-- eyeprolog-predicate-reference:start -->', '<!-- eyeprolog-predicate-reference:end -->');
         assertEqual(section.split('\n').some((line) => line.trimStart().startsWith('|')), false, 'predicate reference avoids wide table markup');
-        assertEqual((section.match(/^- \*\*`/gm) ?? []).length, 518, 'one reference entry per predicate');
-        assertEqual((section.match(/<a id="predicate-reference-\d{4}"><\/a>/g) ?? []).length, 518, 'one explicit anchor per predicate');
-        assertEqual((section.match(/\]\(#predicate-reference-\d{4}\)/g) ?? []).length, 518, 'one direct index link per predicate');
+        assertEqual((section.match(/^- \*\*`/gm) ?? []).length, 523, 'one reference entry per predicate');
+        assertEqual((section.match(/<a id="predicate-reference-\d{4}"><\/a>/g) ?? []).length, 523, 'one explicit anchor per predicate');
+        assertEqual((section.match(/\]\(#predicate-reference-\d{4}\)/g) ?? []).length, 523, 'one direct index link per predicate');
         assertNotIncludes(section, '[Symbols](#predicate-reference-symbols)', 'predicate index does not rely on renderer-generated group anchors');
 
         const chapter = between(book, '## 39. Predicate reference', '## 40. Running EyeProlog: command line and corpus');
@@ -5827,6 +5827,50 @@ answer(Status,Pid) :-
         assertEqual(fs.existsSync(nested), true, 'make_directory_path/1 created nested directories');
       },
     },
+    {
+      name: 'library(sockets) provides Scryer-compatible bidirectional TCP text streams',
+      run: () => {
+        const source = `:- use_module(library(sockets)).
+answer(Port,Client,Term,Mode,Alias,Host) :-
+  current_hostname(Host), atom(Host),
+  socket_server_open('127.0.0.1':Port,Server), Port > 0,
+  socket_client_open('127.0.0.1':Port,Out,[type(text),alias(client_socket),eof_action(eof_code)]),
+  socket_server_accept(Server,Client,In,[type(text)]),
+  stream_property(Out,input), stream_property(Out,output),
+  stream_property(Out,mode(Mode)), stream_property(Out,alias(Alias)),
+  stream_property(Out,position(0)), stream_property(Out,file_name(FileName)), atom(FileName),
+  socket_server_close(Server),
+  write(Out,ping), put_char(Out,'.'), nl(Out), flush_output(client_socket),
+  read(In,Term),
+  close(Out), close(In).
+`;
+        const result = run(source, { goal: 'answer(Port,Client,Term,Mode,Alias,Host)' });
+        assertIncludes(result.stdout, ', ping, read_append, client_socket, ', 'socket text stream result');
+        assertIncludes(result.stdout, "'127.0.0.1:", 'accepted peer address');
+      },
+    },
+    {
+      name: 'library(sockets) supports binary streams and rejects repositioning',
+      run: () => {
+        const source = `:- use_module(library(sockets)).
+answer(A,B) :-
+  socket_server_open(Port,Server),
+  socket_client_open('127.0.0.1':Port,Out,[type(binary)]),
+  socket_server_accept(Server,_,In,[type(binary)]),
+  put_byte(Out,65), put_byte(Out,255), flush_output(Out),
+  get_byte(In,A), get_byte(In,B),
+  close(Out), close(In), socket_server_close(Server).
+reject_reposition :-
+  socket_server_open(Port,Server),
+  catch(socket_client_open('127.0.0.1':Port,_,[reposition(true)]),
+        error(permission_error(reposition,stream,_),_),
+        true),
+  socket_server_close(Server).
+`;
+        assertEqual(run(source, { goal: 'answer(A,B)' }).stdout, 'answer(65, 255).\n', 'binary socket stream');
+        assertEqual(run(source, { goal: 'reject_reposition' }).stdout, 'reject_reposition.\n', 'socket reposition error');
+      },
+    },
     {
       name: 'completed Scryer arithmetic charsio dcgs and lists predicates compose',
       run: () => {
@@ -6573,13 +6617,15 @@ answer(ok) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 216, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
+        assertEqual(library.defs.size, 221, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS tnot/1, and generic library adapters');
         assertEqual(registry.get('eyeprolog__dynify', 1), null, 'Eyelet dynify adapter is absent from the ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__dynify', 1)), true, 'Eyelet dynify adapter is an internal EyeProlog library primitive');
         assertEqual(registry.get('eyeprolog__eyelet_emit', 2), null, 'Eyelet event adapter is absent from the ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__eyelet_emit', 2)), true, 'Eyelet event adapter is an internal EyeProlog library primitive');
         assertEqual(registry.get('eyeprolog__random_value', 1), null, 'native random helper is absent from the ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__random_value', 1)), true, 'native random helper is an internal EyeProlog library adapter');
+        assertEqual(registry.get('eyeprolog__socket_client_open', 4), null, 'socket adapter is absent from the ISO registry');
+        assertEqual(Boolean(library.get('eyeprolog__socket_client_open', 4)), true, 'socket client adapter is an internal EyeProlog library primitive');
         assertEqual(Boolean(registry.get('phrase', 2)), true, 'Part 3 phrase/2 exists');
         assertEqual(Boolean(registry.get('phrase', 3)), true, 'Part 3 phrase/3 exists');
         assertEqual(registry.get('statistics', 0), null, 'statistics/0 is absent from the ISO registry');
@@ -6596,10 +6642,10 @@ answer(ok) :-
         assertEqual(Boolean(library.get('call_cleanup', 2)), true, 'call_cleanup/2 is an EyeProlog cleanup control');
         assertEqual(registry.get('setup_call_cleanup', 3), null, 'setup_call_cleanup/3 is absent from the ISO registry');
         assertEqual(Boolean(library.get('setup_call_cleanup', 3)), true, 'setup_call_cleanup/3 is an EyeProlog cleanup control');
-        assertEqual(registeredNativeEyePrologLibraryNames().length, 109, 'public host-supported EyeProlog library count');
+        assertEqual(registeredNativeEyePrologLibraryNames().length, 114, 'public host-supported EyeProlog library count');
         assertEqual(eyePrologPortableLibraryIndicators.length, 280, 'portable Prolog library count');
-        assertEqual(eyePrologInteropLibraryIndicators.length, 218, 'cross-implementation interop profile count');
-        assertEqual(eyePrologInteropLibraryModules.length, 26, 'common explicit library module profile count');
+        assertEqual(eyePrologInteropLibraryIndicators.length, 221, 'cross-implementation interop profile count');
+        assertEqual(eyePrologInteropLibraryModules.length, 27, 'common explicit library module profile count');
         assertEqual(eyePrologInteropAutoload['member/2'], 'lists', 'member/2 canonical autoload');
         assertEqual(eyePrologInteropAutoload['between/3'], 'between', 'between/3 canonical internal autoload');
         assertEqual(eyePrologInteropAutoload['call_nth/2'], 'iso_ext', 'call_nth/2 canonical interop autoload');
@@ -6611,11 +6657,11 @@ answer(ok) :-
         assertEqual(eyePrologLibraryAutoload['pairs_keys_values/3'], 'pairs', 'complete library autoload includes library(pairs)');
         assertEqual(eyePrologLibraryAutoload['stable/1'], 'eyelet', 'complete library autoload includes Eyelet stable/1');
         assertEqual(eyePrologLibraryAutoload['becomes/2'], 'eyelet', 'complete library autoload includes Eyelet becomes/2');
-        assertEqual(eyePrologLibraryAutoloadModules.length, 39, 'all bundled src/lib modules are indexed for autoload');
-        assertEqual(eyePrologNativeLibraryIndicators.length, 109, 'host-supported library count');
+        assertEqual(eyePrologLibraryAutoloadModules.length, 40, 'all bundled src/lib modules are indexed for autoload');
+        assertEqual(eyePrologNativeLibraryIndicators.length, 114, 'host-supported library count');
         assertEqual(eyePrologNativeLibraryIndicators.includes('call_nth/2'), true, 'call_nth/2 remains classified as host-supported');
         assertEqual(eyePrologNativeLibraryIndicators.includes('random/1'), true, 'stateful random/1 is classified as host-supported');
-        assertEqual(eyePrologLibraryIndicators.length, 389, 'complete non-ISO EyeProlog library surface');
+        assertEqual(eyePrologLibraryIndicators.length, 394, 'complete non-ISO EyeProlog library surface');
         assertEqual(registry.get('eyeprolog__call_nth', 2), null, 'private call_nth adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__call_nth', 2)), true, 'private call_nth adapter is registered for EyeProlog');
         assertEqual(Boolean(library.get('eyeprolog__call_residue_vars', 2)), true, 'private call_residue_vars adapter is registered for EyeProlog');

package/test/scryer-library-exports.json

@@ -345,6 +345,13 @@
     "not_si/1",
     "when_si/2"
   ],
+  "sockets": [
+    "socket_client_open/3",
+    "socket_server_open/2",
+    "socket_server_accept/4",
+    "socket_server_close/1",
+    "current_hostname/1"
+  ],
   "tabling": [
     "start_tabling/2",
     "abolish_all_tables/0"