@mettascript/prolog 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MesTTo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+<!--
+SPDX-FileCopyrightText: 2026 MesTTo
+SPDX-License-Identifier: MIT
+-->
+
+# @mettascript/prolog
+
+`@mettascript/prolog` lets a MeTTa program call a host Prolog runtime through the
+PeTTa-compatible `Predicate`, `callPredicate`, `assertzPredicate`,
+`retractPredicate`, `prolog-call`, and `import_prolog_function` surface.
+
+The root package is runtime-agnostic. Pick the adapter subpath for the host you
+want to use.
+
+## Node SWI-Prolog
+
+`@mettascript/prolog/swi-node` talks to the `swipl` executable over a small JSON
+server. The CLI uses this when you pass `--prolog`.
+
+```ts
+import { MeTTa } from "@mettascript/hyperon";
+import { registerPrologInterop } from "@mettascript/prolog";
+import { swiPrologBridge } from "@mettascript/prolog/swi-node";
+
+const bridge = swiPrologBridge();
+const metta = new MeTTa();
+registerPrologInterop(metta, bridge);
+
+const out = await metta.runAsync(`
+  !(assertzPredicate (Predicate (edge alice bob)))
+  !(prolog-call (edge alice $x))
+`);
+
+await bridge.dispose();
+```
+
+## Browser SWI-Prolog WASM
+
+`@mettascript/prolog/swi-wasm` runs the same MeTTa surface over `swipl-wasm`.
+Files are loaded through the host text loader, written into SWI's virtual
+filesystem, and consulted with SWI's normal `consult/1`.
+
+```ts
+import { createBrowserRunner, createBrowserTextLoader } from "@mettascript/browser/host";
+import { createSwiWasmInterop } from "@mettascript/prolog/swi-wasm";
+
+const files = new Map([["facts.pl", "edge(alice, bob).\nedge(alice, mars).\n"]]);
+const loadText = createBrowserTextLoader({ files, baseUrl: import.meta.url });
+const prolog = await createSwiWasmInterop({ loadText });
+const runner = createBrowserRunner({ files, interops: [prolog] });
+
+const results = await runner.run(`
+  !(import! &self "facts.pl")
+  !(prolog-call (edge alice $x))
+`);
+
+await runner.dispose();
+```
+
+For browser bundlers, install `swipl-wasm` next to `@mettascript/prolog` and serve
+its WASM assets according to the `swipl-wasm` package documentation, or use its
+single-file bundle setup. For interactive pages, run the browser runner and
+SWI-WASM inside a Web Worker.
+
+## PeTTa Compatibility
+
+The interop surface follows PeTTa's Prolog bridge shape where it is independent
+of PeTTa's evaluator:
+
+```metta
+!(assertzPredicate (Predicate (edge alice bob)))
+!(callPredicate (Predicate (edge alice $x))) ; True
+!(import_prolog_function edge)
+!(edge alice)                                ; bob
+```
+
+MeTTaScript keeps Hyperon semantics. It does not switch into a PeTTa execution
+mode, and it does not compile all MeTTa rules to Prolog. A later
+PeTTa-compatibility layer can expose PeTTa's `process_metta_string` path
+explicitly, but normal `.pl` imports and predicate calls already work through
+the shared adapter contract.
+
+## Testing
+
+The default tests use mock bridges and do not need SWI installed.
+
+- `PROLOG_LIVE=1 pnpm vitest run packages/prolog/src/swi.test.ts` checks the
+  Node adapter against a local `swipl` executable.
+- `SWI_WASM_LIVE=1 pnpm vitest run packages/prolog/src/swi-wasm.test.ts` checks
+  `.pl` import, `prolog-call`, and `import_prolog_function` against real
+  `swipl-wasm`.

package/dist/chunk-DG3MQ2BR.js

@@ -0,0 +1,223 @@
+// src/prolog.ts
+import * as core from "@mettascript/core";
+import {
+  Atom,
+  E,
+  ExpressionAtom,
+  GroundedAtom,
+  S,
+  SymbolAtom,
+  ValueAtom,
+  VariableAtom,
+  asyncOperationReturnToReduceResult
+} from "@mettascript/hyperon";
+var TRUE = S("True");
+var FALSE = S("False");
+var SELF = S("&self");
+var SAFE_MIN = BigInt(Number.MIN_SAFE_INTEGER);
+var SAFE_MAX = BigInt(Number.MAX_SAFE_INTEGER);
+var PROLOG_METTA_SRC = `
+(: prolog-call (-> Atom Atom))
+(= (prolog-match $goal $template)
+   (let $answer (prolog-call $goal)
+        (let $goal $answer $template)))
+(: Predicate (-> Atom %Undefined%))
+(= (Predicate $goal) $goal)
+(: callPredicate (-> Atom Bool))
+(= (callPredicate $goal) (prolog-match $goal True))
+(: assertaPredicate (-> Atom Bool))
+(= (assertaPredicate $goal) (prolog-asserta $goal))
+(: assertzPredicate (-> Atom Bool))
+(= (assertzPredicate $goal) (prolog-assertz $goal))
+(: retractPredicate (-> Atom Bool))
+(= (retractPredicate $goal) (prolog-retract $goal))
+(: prolog-function (-> Atom Expression Atom))
+(: import_prolog_function (-> Atom Bool))
+(: prolog-consult (-> Atom Bool))
+(: import_prolog_functions_from_file (-> Atom Expression Bool))
+`;
+function atomName(atom, ctx) {
+  if (atom instanceof SymbolAtom) return atom.name();
+  if (atom instanceof GroundedAtom) {
+    const content = atom.object().content;
+    if (typeof content === "string") return content;
+  }
+  throw new Error(`${ctx}: expected a Symbol or String`);
+}
+function pathName(atom, ctx) {
+  if (atom instanceof ExpressionAtom) {
+    const children = atom.children();
+    if (children.length === 2 && children[0] instanceof SymbolAtom && children[0].name() === "library")
+      return atomName(children[1], ctx);
+  }
+  return atomName(atom, ctx);
+}
+function expressionItems(atom, ctx) {
+  if (atom instanceof ExpressionAtom) return atom.children();
+  throw new Error(`${ctx}: expected an expression`);
+}
+function bigintAtom(value) {
+  const n = BigInt(value);
+  if (n >= SAFE_MIN && n <= SAFE_MAX) return ValueAtom(Number(n));
+  return Atom.fromCAtom(core.gint(n));
+}
+function atomToPrologTerm(atom) {
+  if (atom instanceof VariableAtom) return { type: "var", name: atom.name() };
+  if (atom instanceof SymbolAtom) return { type: "atom", name: atom.name() };
+  if (atom instanceof GroundedAtom) {
+    const content = atom.object().content;
+    if (typeof content === "bigint") return { type: "int", value: String(content) };
+    if (typeof content === "number") {
+      return Number.isInteger(content) ? { type: "int", value: String(content) } : { type: "float", value: content };
+    }
+    if (typeof content === "string") return { type: "string", value: content };
+    if (typeof content === "boolean") return { type: "atom", name: content ? "true" : "false" };
+    if (content === void 0 || content === null) return { type: "atom", name: "[]" };
+    return { type: "atom", name: atom.toString() };
+  }
+  if (atom instanceof ExpressionAtom) {
+    const children = atom.children();
+    if (children.length === 0) return { type: "atom", name: "[]" };
+    const [head, ...args] = children;
+    if (head instanceof SymbolAtom && head.name() === "Predicate" && args.length === 1) {
+      return atomToPrologTerm(args[0]);
+    }
+    if (!(head instanceof SymbolAtom))
+      throw new Error(`prolog: compound head must be a Symbol, got ${head?.toString() ?? "()"}`);
+    return {
+      type: "compound",
+      functor: head.name(),
+      args: args.map((arg) => atomToPrologTerm(arg))
+    };
+  }
+  return { type: "atom", name: atom.toString() };
+}
+function prologTermToAtom(term) {
+  switch (term.type) {
+    case "atom":
+      return term.name === "[]" ? E() : S(term.name);
+    case "int":
+      return bigintAtom(term.value);
+    case "float":
+      return ValueAtom(term.value);
+    case "string":
+      return ValueAtom(term.value);
+    case "var":
+      return VariableAtom.parseName(term.name);
+    case "compound":
+      return E(S(term.functor), ...term.args.map(prologTermToAtom));
+  }
+}
+function functionRuleEffects(name, arities) {
+  const usable = [...new Set(arities)].filter((arity) => arity >= 1).sort((a, b) => a - b);
+  if (usable.length === 0)
+    throw new Error(`import_prolog_function: no predicate arity found for ${name}`);
+  const effects = [];
+  for (const arity of usable) {
+    const vars = Array.from(
+      { length: arity - 1 },
+      (_, i) => VariableAtom.parseName(`prolog_arg_${i}`)
+    );
+    effects.push({
+      kind: "addAtom",
+      space: SELF,
+      atom: E(S("="), E(S(name), ...vars), E(S("prolog-function"), S(name), E(...vars)))
+    });
+  }
+  return effects;
+}
+async function importFunctionEffects(bridge, name) {
+  return functionRuleEffects(name, await bridge.predicateArities(name));
+}
+function namesFromAtom(atom, ctx) {
+  if (atom instanceof ExpressionAtom) return atom.children().map((child) => atomName(child, ctx));
+  return [atomName(atom, ctx)];
+}
+async function callFunction(bridge, name, argsAtom) {
+  const args = expressionItems(argsAtom, "prolog-function");
+  const output = VariableAtom.parseName("prolog_result");
+  const goal = E(S(name), ...args, output);
+  const answers = await bridge.query(goal);
+  return answers.map((answer) => {
+    const children = expressionItems(answer, "prolog-function result");
+    const value = children[children.length - 1];
+    if (value === void 0) throw new Error(`prolog-function: ${name} returned an empty answer`);
+    return value;
+  });
+}
+function prologOps(bridge, opts = {}) {
+  const resolvePath = opts.resolvePath ?? ((path) => path);
+  return /* @__PURE__ */ new Map([
+    ["prolog-call", async (args) => await bridge.query(args[0] ?? E())],
+    [
+      "prolog-function",
+      async (args) => await callFunction(bridge, atomName(args[0], "prolog-function"), args[1] ?? E())
+    ],
+    [
+      "prolog-asserta",
+      async (args) => {
+        await bridge.asserta(args[0] ?? E());
+        return [TRUE];
+      }
+    ],
+    [
+      "prolog-assertz",
+      async (args) => {
+        await bridge.assertz(args[0] ?? E());
+        return [TRUE];
+      }
+    ],
+    ["prolog-retract", async (args) => [await bridge.retract(args[0] ?? E()) ? TRUE : FALSE]],
+    [
+      "prolog-consult",
+      async (args) => {
+        await bridge.consult(resolvePath(pathName(args[0], "prolog-consult")));
+        return [TRUE];
+      }
+    ],
+    [
+      "import_prolog_function",
+      async (args) => ({
+        results: [TRUE],
+        effects: await importFunctionEffects(bridge, atomName(args[0], "import_prolog_function"))
+      })
+    ],
+    [
+      "import_prolog_functions_from_file",
+      async (args) => {
+        await bridge.consult(resolvePath(pathName(args[0], "import_prolog_functions_from_file")));
+        const effects = [];
+        for (const name of namesFromAtom(args[1], "import_prolog_functions_from_file")) {
+          effects.push(...await importFunctionEffects(bridge, name));
+        }
+        return { results: [TRUE], effects };
+      }
+    ]
+  ]);
+}
+function registerPrologInterop(m, bridge, opts = {}) {
+  for (const [name, fn] of prologOps(bridge, opts)) m.registerAsyncOperation(name, fn);
+  m.run(PROLOG_METTA_SRC);
+}
+function prologCoreAsyncOps(bridge, opts = {}) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, fn] of prologOps(bridge, opts))
+    out.set(name, async (args) => {
+      try {
+        const raw = await fn(args.map((a) => Atom.fromCAtom(a)));
+        return asyncOperationReturnToReduceResult(raw);
+      } catch (e) {
+        return { tag: "runtimeError", msg: e instanceof Error ? e.message : String(e) };
+      }
+    });
+  return out;
+}
+
+export {
+  PROLOG_METTA_SRC,
+  atomToPrologTerm,
+  prologTermToAtom,
+  prologOps,
+  registerPrologInterop,
+  prologCoreAsyncOps
+};

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { P as PrologBridge } from './prolog-cLhN4SQh.js';
+export { a as PROLOG_METTA_SRC, b as PrologEffect, c as PrologInteropOptions, d as PrologOperationResult, e as PrologOperationReturn, f as PrologTermJson, g as atomToPrologTerm, p as prologCoreAsyncOps, h as prologOps, i as prologTermToAtom, r as registerPrologInterop } from './prolog-cLhN4SQh.js';
+import { Atom } from '@mettascript/hyperon';
+import '@mettascript/core';
+
+declare class MockPrologBridge implements PrologBridge {
+    readonly consulted: string[];
+    private readonly facts;
+    constructor(facts?: readonly Atom[]);
+    query(goal: Atom): Promise<Atom[]>;
+    asserta(term: Atom): Promise<void>;
+    assertz(term: Atom): Promise<void>;
+    retract(term: Atom): Promise<boolean>;
+    consult(path: string): Promise<void>;
+    predicateArities(name: string): Promise<number[]>;
+    dispose(): void;
+}
+
+export { MockPrologBridge, PrologBridge };

package/dist/index.js

@@ -0,0 +1,74 @@
+import {
+  PROLOG_METTA_SRC,
+  atomToPrologTerm,
+  prologCoreAsyncOps,
+  prologOps,
+  prologTermToAtom,
+  registerPrologInterop
+} from "./chunk-DG3MQ2BR.js";
+
+// src/mock.ts
+import * as core from "@mettascript/core";
+import { Atom, ExpressionAtom, SymbolAtom } from "@mettascript/hyperon";
+function predicateNameAndArity(atom) {
+  if (!(atom instanceof ExpressionAtom)) return void 0;
+  const children = atom.children();
+  const head = children[0];
+  if (!(head instanceof SymbolAtom)) return void 0;
+  return { name: head.name(), arity: children.length - 1 };
+}
+var MockPrologBridge = class {
+  consulted = [];
+  facts = [];
+  constructor(facts = []) {
+    this.facts.push(...facts);
+  }
+  query(goal) {
+    const out = [];
+    for (const fact of this.facts) {
+      for (const bindings of core.matchAtoms(goal.catom, fact.catom)) {
+        out.push(Atom.fromCAtom(core.instantiate(bindings, goal.catom)));
+      }
+    }
+    return Promise.resolve(out);
+  }
+  asserta(term) {
+    this.facts.unshift(term);
+    return Promise.resolve();
+  }
+  assertz(term) {
+    this.facts.push(term);
+    return Promise.resolve();
+  }
+  retract(term) {
+    const index = this.facts.findIndex(
+      (fact) => core.matchAtoms(term.catom, fact.catom).length > 0
+    );
+    if (index === -1) return Promise.resolve(false);
+    this.facts.splice(index, 1);
+    return Promise.resolve(true);
+  }
+  consult(path) {
+    this.consulted.push(path);
+    return Promise.resolve();
+  }
+  predicateArities(name) {
+    const arities = /* @__PURE__ */ new Set();
+    for (const fact of this.facts) {
+      const pred = predicateNameAndArity(fact);
+      if (pred?.name === name) arities.add(pred.arity);
+    }
+    return Promise.resolve([...arities].sort((a, b) => a - b));
+  }
+  dispose() {
+  }
+};
+export {
+  MockPrologBridge,
+  PROLOG_METTA_SRC,
+  atomToPrologTerm,
+  prologCoreAsyncOps,
+  prologOps,
+  prologTermToAtom,
+  registerPrologInterop
+};

package/dist/prolog-cLhN4SQh.d.ts

@@ -0,0 +1,46 @@
+import { AsyncGroundFn } from '@mettascript/core';
+import { Atom, AsyncOperationEffect, AsyncOperationResult, AsyncOperationReturn, MeTTa } from '@mettascript/hyperon';
+
+type PrologTermJson = {
+    readonly type: "atom";
+    readonly name: string;
+} | {
+    readonly type: "int";
+    readonly value: string;
+} | {
+    readonly type: "float";
+    readonly value: number;
+} | {
+    readonly type: "string";
+    readonly value: string;
+} | {
+    readonly type: "var";
+    readonly name: string;
+} | {
+    readonly type: "compound";
+    readonly functor: string;
+    readonly args: readonly PrologTermJson[];
+};
+interface PrologBridge {
+    query(goal: Atom): Promise<Atom[]>;
+    asserta(term: Atom): Promise<void>;
+    assertz(term: Atom): Promise<void>;
+    retract(term: Atom): Promise<boolean>;
+    consult(path: string): Promise<void>;
+    predicateArities(name: string): Promise<number[]>;
+    dispose(): Promise<void> | void;
+}
+interface PrologInteropOptions {
+    readonly resolvePath?: (path: string) => string;
+}
+type PrologEffect = AsyncOperationEffect;
+type PrologOperationResult = AsyncOperationResult;
+type PrologOperationReturn = AsyncOperationReturn;
+declare const PROLOG_METTA_SRC = "\n(: prolog-call (-> Atom Atom))\n(= (prolog-match $goal $template)\n   (let $answer (prolog-call $goal)\n        (let $goal $answer $template)))\n(: Predicate (-> Atom %Undefined%))\n(= (Predicate $goal) $goal)\n(: callPredicate (-> Atom Bool))\n(= (callPredicate $goal) (prolog-match $goal True))\n(: assertaPredicate (-> Atom Bool))\n(= (assertaPredicate $goal) (prolog-asserta $goal))\n(: assertzPredicate (-> Atom Bool))\n(= (assertzPredicate $goal) (prolog-assertz $goal))\n(: retractPredicate (-> Atom Bool))\n(= (retractPredicate $goal) (prolog-retract $goal))\n(: prolog-function (-> Atom Expression Atom))\n(: import_prolog_function (-> Atom Bool))\n(: prolog-consult (-> Atom Bool))\n(: import_prolog_functions_from_file (-> Atom Expression Bool))\n";
+declare function atomToPrologTerm(atom: Atom): PrologTermJson;
+declare function prologTermToAtom(term: PrologTermJson): Atom;
+declare function prologOps(bridge: PrologBridge, opts?: PrologInteropOptions): Map<string, (args: Atom[]) => Promise<PrologOperationReturn>>;
+declare function registerPrologInterop(m: MeTTa, bridge: PrologBridge, opts?: PrologInteropOptions): void;
+declare function prologCoreAsyncOps(bridge: PrologBridge, opts?: PrologInteropOptions): Map<string, AsyncGroundFn>;
+
+export { type PrologBridge as P, PROLOG_METTA_SRC as a, type PrologEffect as b, type PrologInteropOptions as c, type PrologOperationResult as d, type PrologOperationReturn as e, type PrologTermJson as f, atomToPrologTerm as g, prologOps as h, prologTermToAtom as i, prologCoreAsyncOps as p, registerPrologInterop as r };

package/dist/swi-node.d.ts

@@ -0,0 +1,31 @@
+import { Atom } from '@mettascript/hyperon';
+import { P as PrologBridge } from './prolog-cLhN4SQh.js';
+import '@mettascript/core';
+
+interface SwiPrologBridgeOptions {
+    readonly executable?: string;
+}
+declare class SwiPrologBridge implements PrologBridge {
+    private readonly dir;
+    private readonly proc;
+    private readonly pending;
+    private nextId;
+    private stdout;
+    private stderr;
+    private disposed;
+    constructor(opts?: SwiPrologBridgeOptions);
+    query(goal: Atom): Promise<Atom[]>;
+    asserta(term: Atom): Promise<void>;
+    assertz(term: Atom): Promise<void>;
+    retract(term: Atom): Promise<boolean>;
+    consult(path: string): Promise<void>;
+    predicateArities(name: string): Promise<number[]>;
+    dispose(): void;
+    private request;
+    private handleStdout;
+    private rejectAll;
+    private stderrText;
+}
+declare function swiPrologBridge(opts?: SwiPrologBridgeOptions): SwiPrologBridge;
+
+export { SwiPrologBridge, type SwiPrologBridgeOptions, swiPrologBridge };

package/dist/swi-node.js

@@ -0,0 +1,265 @@
+import {
+  atomToPrologTerm,
+  prologTermToAtom
+} from "./chunk-DG3MQ2BR.js";
+
+// src/swi.ts
+import { spawn, spawnSync } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+var SERVER_SRC = String.raw`
+:- use_module(library(http/json)).
+:- initialization(main, main).
+
+main :-
+    repeat,
+    read_line_to_string(user_input, Line),
+    ( Line == end_of_file
+    -> !
+    ;  handle_line(Line),
+       fail
+    ).
+
+handle_line(Line) :-
+    catch(
+        ( open_string(Line, Stream),
+          json_read_dict(Stream, Req),
+          close(Stream),
+          dispatch(Req, Resp0),
+          Resp = Resp0.put(id, Req.id)
+        ),
+        E,
+        ( message_to_string(E, Msg),
+          ( catch(open_string(Line, S2), _, fail),
+            catch(json_read_dict(S2, BadReq), _, fail),
+            catch(close(S2), _, true),
+            get_dict(id, BadReq, Id)
+          -> true
+          ;  Id = -1
+          ),
+          Resp = json{id:Id, ok:false, error:Msg}
+        )
+    ),
+    json_write_dict(current_output, Resp, [width(0)]),
+    nl,
+    flush_output(current_output).
+
+dispatch(Req, json{ok:true, answers:Answers}) :-
+    Req.cmd == "query",
+    !,
+    json_to_term(Req.goal, Goal),
+    findall(Answer, (call(Goal), term_to_json(Goal, Answer)), Answers).
+dispatch(Req, json{ok:true}) :-
+    Req.cmd == "asserta",
+    !,
+    json_to_term(Req.term, Term),
+    asserta(Term).
+dispatch(Req, json{ok:true}) :-
+    Req.cmd == "assertz",
+    !,
+    json_to_term(Req.term, Term),
+    assertz(Term).
+dispatch(Req, json{ok:true, value:Value}) :-
+    Req.cmd == "retract",
+    !,
+    json_to_term(Req.term, Term),
+    ( once(retract(Term)) -> Value = true ; Value = false ).
+dispatch(Req, json{ok:true}) :-
+    Req.cmd == "consult",
+    !,
+    consult(Req.path).
+dispatch(Req, json{ok:true, arities:Arities}) :-
+    Req.cmd == "arities",
+    !,
+    atom_string(Name, Req.name),
+    findall(A, current_predicate(Name/A), Raw),
+    sort(Raw, Arities).
+dispatch(Req, _) :-
+    throw(error(domain_error(prolog_bridge_command, Req.cmd), _)).
+
+json_to_term(Json, Term) :-
+    json_to_term(Json, Term, [], _).
+
+json_to_term(Json, Term, Vars0, Vars) :-
+    Type = Json.type,
+    ( Type == "var"
+    -> var_for_name(Json.name, Term, Vars0, Vars)
+    ; Type == "atom"
+    -> atom_string(Term, Json.name),
+       Vars = Vars0
+    ; Type == "int"
+    -> number_string(Term, Json.value),
+       Vars = Vars0
+    ; Type == "float"
+    -> Term = Json.value,
+       Vars = Vars0
+    ; Type == "string"
+    -> Term = Json.value,
+       Vars = Vars0
+    ; Type == "compound"
+    -> atom_string(Functor, Json.functor),
+       json_to_terms(Json.args, Args, Vars0, Vars),
+       Term =.. [Functor|Args]
+    ; throw(error(domain_error(prolog_term_json, Type), _))
+    ).
+
+json_to_terms([], [], Vars, Vars).
+json_to_terms([Json|Rest], [Term|Terms], Vars0, Vars) :-
+    json_to_term(Json, Term, Vars0, Vars1),
+    json_to_terms(Rest, Terms, Vars1, Vars).
+
+var_for_name(Name, Var, Vars, Vars) :-
+    memberchk(Name=Existing, Vars),
+    !,
+    Var = Existing.
+var_for_name(Name, Var, Vars, [Name=Var|Vars]).
+
+term_to_json(Term, Json) :-
+    ( var(Term)
+    -> Json = json{type:"var", name:"_"}
+    ; integer(Term)
+    -> number_string(Term, Value),
+       Json = json{type:"int", value:Value}
+    ; float(Term)
+    -> Json = json{type:"float", value:Term}
+    ; string(Term)
+    -> Json = json{type:"string", value:Term}
+    ; atom(Term)
+    -> atom_string(Term, Name),
+       Json = json{type:"atom", name:Name}
+    ; Term =.. [Functor|Args],
+      atom_string(Functor, FunctorString),
+      terms_to_json(Args, JsonArgs),
+      Json = json{type:"compound", functor:FunctorString, args:JsonArgs}
+    ).
+
+terms_to_json([], []).
+terms_to_json([Term|Rest], [Json|JsonRest]) :-
+    term_to_json(Term, Json),
+    terms_to_json(Rest, JsonRest).
+`;
+var SwiPrologBridge = class {
+  dir;
+  proc;
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  stdout = "";
+  stderr = "";
+  disposed = false;
+  constructor(opts = {}) {
+    const executable = opts.executable ?? "swipl";
+    const version = spawnSync(executable, ["--version"], { encoding: "utf8" });
+    if (version.error !== void 0) {
+      throw new Error(`--prolog needs SWI-Prolog on PATH (${version.error.message})`);
+    }
+    this.dir = mkdtempSync(join(tmpdir(), "metta-ts-prolog-"));
+    const server = join(this.dir, "server.pl");
+    writeFileSync(server, SERVER_SRC);
+    this.proc = spawn(executable, ["-q", "-f", "none", server]);
+    this.proc.stdout.setEncoding("utf8");
+    this.proc.stderr.setEncoding("utf8");
+    this.proc.stdout.on("data", (chunk) => this.handleStdout(chunk));
+    this.proc.stderr.on("data", (chunk) => {
+      this.stderr += chunk;
+    });
+    this.proc.on("error", (error) => this.rejectAll(error));
+    this.proc.on("exit", (code, signal) => {
+      if (!this.disposed) {
+        this.rejectAll(
+          new Error(
+            `SWI-Prolog bridge exited (${signal ?? code ?? "unknown"})${this.stderrText()}`
+          )
+        );
+      }
+    });
+  }
+  async query(goal) {
+    const response = await this.request({ cmd: "query", goal: atomToPrologTerm(goal) });
+    if (!("answers" in response)) throw new Error("SWI-Prolog bridge query returned no answers");
+    return response.answers.map(prologTermToAtom);
+  }
+  async asserta(term) {
+    await this.request({ cmd: "asserta", term: atomToPrologTerm(term) });
+  }
+  async assertz(term) {
+    await this.request({ cmd: "assertz", term: atomToPrologTerm(term) });
+  }
+  async retract(term) {
+    const response = await this.request({ cmd: "retract", term: atomToPrologTerm(term) });
+    if (!("value" in response)) throw new Error("SWI-Prolog bridge retract returned no value");
+    return response.value;
+  }
+  async consult(path) {
+    await this.request({ cmd: "consult", path });
+  }
+  async predicateArities(name) {
+    const response = await this.request({ cmd: "arities", name });
+    if (!("arities" in response)) throw new Error("SWI-Prolog bridge arities returned no value");
+    return [...response.arities];
+  }
+  dispose() {
+    this.disposed = true;
+    for (const pending of this.pending.values())
+      pending.reject(new Error("SWI-Prolog bridge closed"));
+    this.pending.clear();
+    this.proc.kill();
+    rmSync(this.dir, { recursive: true, force: true });
+  }
+  request(payload) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, {
+        resolve: (response) => {
+          if (!response.ok) reject(new Error(response.error));
+          else resolve(response);
+        },
+        reject
+      });
+      this.proc.stdin.write(JSON.stringify({ ...payload, id }) + "\n", (error) => {
+        if (error !== null && error !== void 0) {
+          this.pending.delete(id);
+          reject(error);
+        }
+      });
+    });
+  }
+  handleStdout(chunk) {
+    this.stdout += chunk;
+    for (; ; ) {
+      const index = this.stdout.indexOf("\n");
+      if (index === -1) return;
+      const line = this.stdout.slice(0, index).trim();
+      this.stdout = this.stdout.slice(index + 1);
+      if (line === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch (e) {
+        this.rejectAll(new Error(`SWI-Prolog bridge emitted invalid JSON: ${String(e)}`));
+        continue;
+      }
+      const id = parsed.id;
+      if (id === void 0) continue;
+      const pending = this.pending.get(id);
+      if (pending === void 0) continue;
+      this.pending.delete(id);
+      pending.resolve(parsed);
+    }
+  }
+  rejectAll(error) {
+    for (const pending of this.pending.values()) pending.reject(error);
+    this.pending.clear();
+  }
+  stderrText() {
+    const text = this.stderr.trim();
+    return text === "" ? "" : `: ${text}`;
+  }
+};
+function swiPrologBridge(opts = {}) {
+  return new SwiPrologBridge(opts);
+}
+export {
+  SwiPrologBridge,
+  swiPrologBridge
+};

package/dist/swi-wasm.d.ts

@@ -0,0 +1,61 @@
+import { HostTextLoader, HostInterop } from '@mettascript/core/host';
+import { Atom } from '@mettascript/hyperon';
+import { P as PrologBridge } from './prolog-cLhN4SQh.js';
+import '@mettascript/core';
+
+interface SwiWasmFs {
+    writeFile(path: string, data: string, opts?: {
+        readonly encoding?: "utf8";
+    }): void;
+    mkdirTree?(path: string): void;
+    analyzePath?(path: string): {
+        readonly exists: boolean;
+    };
+    mkdir?(path: string): void;
+}
+interface SwiWasmQuery {
+    next(): unknown;
+    once(): unknown;
+}
+interface SwiWasmProlog {
+    query(goal: string, input?: Record<string, unknown>): SwiWasmQuery;
+}
+interface SwiWasmRuntime {
+    readonly FS: SwiWasmFs;
+    readonly prolog: SwiWasmProlog;
+}
+interface SwiWasmLoadOptions {
+    readonly arguments?: readonly string[];
+    readonly locateFile?: (path: string, prefix?: string) => string;
+}
+type SwiWasmLoader = (options?: SwiWasmLoadOptions) => Promise<SwiWasmRuntime>;
+interface SwiWasmBridgeOptions {
+    readonly loadText?: HostTextLoader;
+    readonly baseUrl?: string | URL;
+    readonly files?: ReadonlyMap<string, string>;
+}
+interface SwiWasmInteropOptions extends SwiWasmBridgeOptions {
+    readonly prolog?: SwiWasmRuntime;
+    readonly loadSwipl?: SwiWasmLoader;
+    readonly locateFile?: (path: string, prefix?: string) => string;
+    readonly arguments?: readonly string[];
+    readonly preload?: readonly string[];
+}
+declare class SwiWasmBridge implements PrologBridge {
+    private readonly runtime;
+    private readonly loadText;
+    private readonly consulted;
+    constructor(runtime: SwiWasmRuntime, options?: SwiWasmBridgeOptions);
+    query(goal: Atom): Promise<Atom[]>;
+    asserta(term: Atom): Promise<void>;
+    assertz(term: Atom): Promise<void>;
+    retract(term: Atom): Promise<boolean>;
+    consult(path: string): Promise<void>;
+    predicateArities(name: string): Promise<number[]>;
+    dispose(): void;
+    private runOnce;
+}
+declare function swiWasmBridge(runtime: SwiWasmRuntime, options?: SwiWasmBridgeOptions): SwiWasmBridge;
+declare function createSwiWasmInterop(options?: SwiWasmInteropOptions): Promise<HostInterop>;
+
+export { SwiWasmBridge, type SwiWasmBridgeOptions, type SwiWasmFs, type SwiWasmInteropOptions, type SwiWasmLoadOptions, type SwiWasmLoader, type SwiWasmProlog, type SwiWasmQuery, type SwiWasmRuntime, createSwiWasmInterop, swiWasmBridge };

package/dist/swi-wasm.js

@@ -0,0 +1,295 @@
+import {
+  PROLOG_METTA_SRC,
+  atomToPrologTerm,
+  prologCoreAsyncOps
+} from "./chunk-DG3MQ2BR.js";
+
+// src/swi-wasm.ts
+import * as core from "@mettascript/core";
+import { emptyExpr } from "@mettascript/core";
+import "@mettascript/core/host";
+import { Atom, E, ExpressionAtom, S, ValueAtom, VariableAtom } from "@mettascript/hyperon";
+import defaultLoadSwipl from "swipl-wasm";
+var SAFE_MIN = BigInt(Number.MIN_SAFE_INTEGER);
+var SAFE_MAX = BigInt(Number.MAX_SAFE_INTEGER);
+var SourceVariables = class {
+  sourceToOriginal = /* @__PURE__ */ new Map();
+  originalToSource = /* @__PURE__ */ new Map();
+  sourceName(original) {
+    let source = this.originalToSource.get(original);
+    if (source === void 0) {
+      source = `V${this.originalToSource.size}`;
+      this.originalToSource.set(original, source);
+      this.sourceToOriginal.set(source, original);
+    }
+    return source;
+  }
+};
+function fileCandidates(path) {
+  if (path.endsWith(".pl")) return [path, path.slice(0, -".pl".length)];
+  return [path, `${path}.pl`];
+}
+function globalBaseUrl() {
+  const location = globalThis.location;
+  return typeof location?.href === "string" ? location.href : void 0;
+}
+function createDefaultTextLoader(options) {
+  const files = options.files ?? /* @__PURE__ */ new Map();
+  return async (path, from) => {
+    for (const candidate of fileCandidates(path)) {
+      const text = files.get(candidate);
+      if (text !== void 0) return text;
+    }
+    const base = from ?? options.baseUrl ?? globalBaseUrl();
+    if (base === void 0) throw new Error(`swi-wasm import: ${path}: no base URL`);
+    const url = new URL(path, base);
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`swi-wasm import: ${path}: ${response.status} ${url.href}`);
+    return response.text();
+  };
+}
+var toPosix = (path) => path.replaceAll("\\", "/");
+function virtualPath(path) {
+  const normalized = toPosix(path).replace(/^\.\/+/, "");
+  return normalized.startsWith("/") ? normalized : `/metta-ts-prolog/${normalized}`;
+}
+function dirname(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? "/" : path.slice(0, i);
+}
+function ensureDir(fs, dir) {
+  if (dir === "" || dir === "/") return;
+  if (fs.mkdirTree !== void 0) {
+    fs.mkdirTree(dir);
+    return;
+  }
+  let current = "";
+  for (const part of dir.split("/")) {
+    if (part === "") continue;
+    current += `/${part}`;
+    if (fs.analyzePath?.(current).exists === true) continue;
+    fs.mkdir?.(current);
+  }
+}
+function quoteAtom(value) {
+  return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "''")}'`;
+}
+function quoteString(value) {
+  return JSON.stringify(value);
+}
+function termToSource(term, vars) {
+  switch (term.type) {
+    case "atom":
+      return term.name === "[]" ? "[]" : quoteAtom(term.name);
+    case "int":
+      return term.value;
+    case "float":
+      return String(term.value);
+    case "string":
+      return quoteString(term.value);
+    case "var":
+      return vars.sourceName(term.name);
+    case "compound":
+      if (term.args.length === 0) return quoteAtom(term.functor);
+      return `${quoteAtom(term.functor)}(${term.args.map((arg) => termToSource(arg, vars)).join(",")})`;
+  }
+}
+function goalSource(term, vars = new SourceVariables()) {
+  return `${termToSource(term, vars)}.`;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringProperty(value, key) {
+  const out = value[key];
+  return typeof out === "string" ? out : void 0;
+}
+function booleanProperty(value, key) {
+  const out = value[key];
+  return typeof out === "boolean" ? out : void 0;
+}
+function messageFrom(error) {
+  return error instanceof Error && error.message !== "" ? error.message : String(error);
+}
+function throwIfError(value) {
+  if (!isObject(value)) return;
+  if (booleanProperty(value, "error") === true) {
+    throw new Error(stringProperty(value, "message") ?? "SWI-Prolog WASM error");
+  }
+}
+function queryStep(value) {
+  if (!isObject(value)) return {};
+  const out = {};
+  const done = booleanProperty(value, "done");
+  if (done !== void 0) out.done = done;
+  if (value.value !== void 0) out.value = value.value;
+  const error = booleanProperty(value, "error");
+  if (error !== void 0) out.error = error;
+  const message = stringProperty(value, "message");
+  if (message !== void 0) out.message = message;
+  return out;
+}
+function isSuccess(value) {
+  if (!isObject(value)) return false;
+  if (booleanProperty(value, "success") === false) return false;
+  return booleanProperty(value, "success") === true || value["$tag"] === "bindings";
+}
+function bigintAtom(value) {
+  if (value >= SAFE_MIN && value <= SAFE_MAX) return ValueAtom(Number(value));
+  return Atom.fromCAtom(core.gint(value));
+}
+function numberAtom(value) {
+  return Number.isInteger(value) && value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER ? ValueAtom(value) : ValueAtom(value);
+}
+function prologValueToAtom(value) {
+  if (typeof value === "string") return S(value);
+  if (typeof value === "number") return numberAtom(value);
+  if (typeof value === "bigint") return bigintAtom(value);
+  if (typeof value === "boolean") return S(value ? "true" : "false");
+  if (value === null || value === void 0) return VariableAtom.parseName("_");
+  if (Array.isArray(value)) return E(...value.map(prologValueToAtom));
+  if (!isObject(value)) return S(String(value));
+  if (value["$t"] === "s") {
+    const text = stringProperty(value, "v");
+    return text === void 0 ? ValueAtom("") : ValueAtom(text);
+  }
+  if (value["$t"] === "v") return VariableAtom.parseName("_");
+  if (value["$t"] === "t") {
+    const functor = stringProperty(value, "functor");
+    if (functor === void 0) return S(String(value));
+    const rawArgs = value[functor];
+    const args = Array.isArray(rawArgs) && Array.isArray(rawArgs[0]) ? rawArgs[0].map(prologValueToAtom) : [];
+    return E(S(functor), ...args);
+  }
+  return S(String(value));
+}
+function instantiate(atom, bindings) {
+  if (atom instanceof VariableAtom) return bindings.get(atom.name()) ?? atom;
+  if (atom instanceof ExpressionAtom)
+    return E(...atom.children().map((child) => instantiate(child, bindings)));
+  return atom;
+}
+function bindingsFromAnswer(answer, sourceToOriginal) {
+  const out = /* @__PURE__ */ new Map();
+  if (!isObject(answer)) return out;
+  for (const [source, original] of sourceToOriginal) {
+    if (Object.hasOwn(answer, source)) out.set(original, prologValueToAtom(answer[source]));
+  }
+  return out;
+}
+function importAtomName(atom) {
+  if (atom?.kind === "sym") return atom.name;
+  if (atom?.kind === "gnd" && atom.value.g === "str") return atom.value.s;
+  if (atom?.kind === "expr" && atom.items.length === 2 && atom.items[0]?.kind === "sym" && atom.items[0].name === "library")
+    return importAtomName(atom.items[1]);
+  return void 0;
+}
+function collectAnswers(query) {
+  const out = [];
+  for (; ; ) {
+    const step = queryStep(query.next());
+    if (step.error === true) throw new Error(step.message ?? "SWI-Prolog WASM query error");
+    if (step.value !== void 0) {
+      throwIfError(step.value);
+      out.push(step.value);
+    }
+    if (step.done === true) break;
+  }
+  return out;
+}
+var SwiWasmBridge = class {
+  constructor(runtime, options = {}) {
+    this.runtime = runtime;
+    this.loadText = options.loadText ?? createDefaultTextLoader(options);
+  }
+  runtime;
+  loadText;
+  consulted = /* @__PURE__ */ new Set();
+  async query(goal) {
+    const vars = new SourceVariables();
+    const source = goalSource(atomToPrologTerm(goal), vars);
+    const answers = collectAnswers(this.runtime.prolog.query(source));
+    return answers.map(
+      (answer) => instantiate(goal, bindingsFromAnswer(answer, vars.sourceToOriginal))
+    );
+  }
+  async asserta(term) {
+    this.runOnce(
+      goalSource({ type: "compound", functor: "asserta", args: [atomToPrologTerm(term)] })
+    );
+  }
+  async assertz(term) {
+    this.runOnce(
+      goalSource({ type: "compound", functor: "assertz", args: [atomToPrologTerm(term)] })
+    );
+  }
+  async retract(term) {
+    return this.runOnce(
+      goalSource({ type: "compound", functor: "retract", args: [atomToPrologTerm(term)] })
+    );
+  }
+  async consult(path) {
+    if (this.consulted.has(path)) return;
+    try {
+      const source = await this.loadText(path);
+      const target = virtualPath(path);
+      ensureDir(this.runtime.FS, dirname(target));
+      this.runtime.FS.writeFile(target, source, { encoding: "utf8" });
+      this.runOnce(`consult(${quoteAtom(target)}).`);
+      this.consulted.add(path);
+    } catch (error) {
+      throw new Error(`swi-wasm consult: ${path}: ${messageFrom(error)}`);
+    }
+  }
+  async predicateArities(name) {
+    const query = this.runtime.prolog.query(`current_predicate(${quoteAtom(name)}/A).`);
+    const arities = /* @__PURE__ */ new Set();
+    for (const answer of collectAnswers(query)) {
+      if (!isObject(answer)) continue;
+      const arity = answer.A;
+      if (typeof arity === "number" && Number.isInteger(arity)) arities.add(arity);
+    }
+    return [...arities].sort((a, b) => a - b);
+  }
+  dispose() {
+    this.consulted.clear();
+  }
+  runOnce(goal) {
+    const result = this.runtime.prolog.query(goal).once();
+    throwIfError(result);
+    return isSuccess(result);
+  }
+};
+function swiWasmBridge(runtime, options = {}) {
+  return new SwiWasmBridge(runtime, options);
+}
+async function createSwiWasmInterop(options = {}) {
+  const loadSwipl = options.loadSwipl ?? defaultLoadSwipl;
+  const runtime = options.prolog ?? await loadSwipl({
+    arguments: [...options.arguments ?? ["-q"]],
+    ...options.locateFile !== void 0 ? { locateFile: options.locateFile } : {}
+  });
+  const bridge = swiWasmBridge(runtime, options);
+  for (const path of options.preload ?? []) await bridge.consult(path);
+  return {
+    name: "swi-wasm",
+    prelude: PROLOG_METTA_SRC,
+    asyncOps: prologCoreAsyncOps(bridge),
+    hostImport: async (_space, target) => {
+      const name = importAtomName(target);
+      if (!name?.endsWith(".pl")) return { tag: "noReduce" };
+      try {
+        await bridge.consult(name);
+        return { tag: "ok", results: [emptyExpr] };
+      } catch (error) {
+        return { tag: "runtimeError", msg: `import!: ${name}: ${messageFrom(error)}` };
+      }
+    },
+    dispose: () => bridge.dispose()
+  };
+}
+export {
+  SwiWasmBridge,
+  createSwiWasmInterop,
+  swiWasmBridge
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@mettascript/prolog",
+  "version": "2.0.0",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./swi-node": {
+      "types": "./dist/swi-node.d.ts",
+      "default": "./dist/swi-node.js"
+    },
+    "./swi-wasm": {
+      "types": "./dist/swi-wasm.d.ts",
+      "default": "./dist/swi-wasm.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@mettascript/core": "2.0.0",
+    "@mettascript/hyperon": "2.0.0"
+  },
+  "author": "MesTTo",
+  "engines": {
+    "node": ">=20"
+  },
+  "sideEffects": false,
+  "module": "./dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Prolog interop for MeTTaScript: PeTTa-compatible Predicate/callPredicate/prolog-call/import_prolog_function over SWI-Prolog or SWI-WASM.",
+  "keywords": [
+    "metta",
+    "hyperon",
+    "prolog",
+    "swi-prolog",
+    "interop",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MesTTo/MeTTaScript.git",
+    "directory": "packages/prolog"
+  },
+  "homepage": "https://github.com/MesTTo/MeTTaScript#readme",
+  "bugs": {
+    "url": "https://github.com/MesTTo/MeTTaScript/issues"
+  },
+  "devDependencies": {
+    "swipl-wasm": "8.0.3"
+  },
+  "peerDependencies": {
+    "swipl-wasm": "8.0.3"
+  },
+  "peerDependenciesMeta": {
+    "swipl-wasm": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/swi-node.ts src/swi-wasm.ts --format esm --dts --clean"
+  }
+}