yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/logic/LogicEngine.js

@@ -1,259 +1,272 @@
-import { Exist, Findall, Goal, LogicConstraint, Sequence, SymbolPrimitive, VariablePattern, } from "yukigo-ast";
-import { solveFindallCPS, solveGoalCPS, unify, instantiate, } from "./LogicResolver.js";
-import { createStream } from "../../utils.js";
-import { InterpreterVisitor } from "../Visitor.js";
+import { Goal, Not, Sequence, } from "yukigo-ast";
+import { solveGoalKernel } from "./LogicResolver.js";
 import { LogicTranslator } from "./LogicTranslator.js";
-import { trampoline } from "../../trampoline.js";
-import { PatternResolver } from "../PatternMatcher.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { StepCommand, BindCommand, ChoiceCommand, NotCommand, FindallCommand, BacktrackCommand, } from "../kernel/commands.js";
+import { error, raise } from "../../utils.js";
+import { YuArray, LogicResult, LogicAnswer, isLogicTerm, YuBoolean, isLogicResult, YuNil, YuString, } from "../../primitives/index.js";
+import { InterpreterVisitor } from "../evaluators/index.js";
 export class LogicEngine {
     context;
     translator;
+    dispatch;
     constructor(evaluator, context) {
         this.context = context;
+        if (!this.context.logicState) {
+            this.context.logicState = {
+                variableCounter: 0,
+                idToName: new Map(),
+            };
+        }
         this.translator = new LogicTranslator(evaluator, this.context);
+        this.dispatch = this.buildDispatch();
+    }
+    buildDispatch() {
+        const goalKernel = (node, substs, scope) => new BindCommand(this.resolveTerms(node, substs, scope), (termsRes) => {
+            const terms = termsRes.asSequence;
+            if (!terms || !(terms instanceof YuArray))
+                return raise(error("LogicEngine", "Expected array of terms"));
+            return this.runKernel(node, terms.items, substs);
+        });
+        return new Map([
+            [
+                "Sequence",
+                (node, substs, scope) => this.solveConjunction(node.statements, substs, scope),
+            ],
+            [
+                "LogicConstraint",
+                (node, substs, scope) => this.solveConjunction([node.expression], substs, scope),
+            ],
+            [
+                "UnifyOperation",
+                (node, substs, scope) => {
+                    const op = node;
+                    return new BindCommand(this.unifyExpr(op.left, op.right, substs, scope), (res) => {
+                        const isMatch = res instanceof YuBoolean && res.value;
+                        if (isMatch)
+                            return new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
+                        return new BacktrackCommand();
+                    });
+                },
+            ],
+            [
+                "AssignOperation",
+                (node, substs, scope) => this.solveAssign(node, substs, scope),
+            ],
+            [
+                "Findall",
+                (node, substs, scope) => this.solveFindall(node, substs, scope),
+            ],
+            [
+                "Forall",
+                (node, substs, scope) => this.solveForall(node, substs, scope),
+            ],
+            ["Not", (node, substs, scope) => this.solveNot(node, substs, scope)],
+            ["Goal", (node, substs, scope) => goalKernel(node, substs, scope)],
+            [
+                "Exist",
+                (node, substs, scope) => goalKernel(node, substs, scope),
+            ],
+            ["If", (node, substs, scope) => this.solveIf(node, substs, scope)],
+            [
+                "Call",
+                (node, substs, scope) => {
+                    const callNode = node;
+                    return new BindCommand(this.translator.expressionToTerm(callNode.callee, scope), (calleeTermVal) => {
+                        const calleeTerm = calleeTermVal
+                            .instantiate(substs)
+                            .resolve(substs);
+                        return new BindCommand(this.resolveArgSequentially(callNode.args, substs, scope), (argsRes) => {
+                            const resolvedArgs = argsRes
+                                .items;
+                            let targetPredicate;
+                            let targetArgs;
+                            if (calleeTerm.logicTermType === "Compound") {
+                                const comp = calleeTerm;
+                                targetPredicate = comp.functor;
+                                targetArgs = [...comp.args, ...resolvedArgs];
+                            }
+                            else if (calleeTerm.logicTermType === "Constant") {
+                                const constTerm = calleeTerm;
+                                const val = constTerm.value;
+                                if (val instanceof YuString) {
+                                    targetPredicate = val.value;
+                                    targetArgs = resolvedArgs;
+                                }
+                                else {
+                                    return new BacktrackCommand();
+                                }
+                            }
+                            else {
+                                return new BacktrackCommand();
+                            }
+                            return solveGoalKernel(this.context, targetPredicate, targetArgs, (body, s, scp) => this.solveConjunction(body, s, scp), substs, this.translator);
+                        });
+                    });
+                },
+            ],
+        ]);
     }
-    unifyExpr(left, right, k) {
-        return this.translator.instantiateExpressionAsPattern(left, new Map(), (p1) => {
-            return () => this.translator.instantiateExpressionAsPattern(right, new Map(), (p2) => {
-                return k(unify(p1, p2, new Map()) !== null);
+    unifyExpr(left, right, substs = new Map(), scope) {
+        return new BindCommand(this.translator.expressionToTerm(left, scope), (leftTerm) => {
+            if (!isLogicTerm(leftTerm))
+                return new BacktrackCommand();
+            return new BindCommand(this.translator.expressionToTerm(right, scope), (rightTerm) => {
+                if (!isLogicTerm(rightTerm))
+                    return new BacktrackCommand();
+                return leftTerm.unify(rightTerm, substs);
             });
         });
     }
-    solveQuery(node, k, modeOverride) {
-        const mode = modeOverride || this.context.config.outputMode || "first";
-        if (mode === "all") {
-            return this.collectAllResults(node.expressions, new Map(), (results) => k(results.map((s) => this.formatLogicResult(s))));
-        }
-        else if (mode === "stream") {
-            return k(this.createLazyStream(node.expressions, new Map()));
-        }
-        // "first" mode
-        return this.solveConjunction(node.expressions, new Map(), (s) => k(this.formatLogicResult(s)), () => k(false));
+    solveQuery(node) {
+        const scope = new Map();
+        const compiled = this.solveConjunction(node.expressions, new Map(), scope);
+        return this.aggregateResults(compiled, scope);
     }
-    solveGoal(node, k, modeOverride) {
-        return this.prepareLogicTargetCPS(node, new Map(), ({ id, patterns }) => {
-            // Goals evaluated as expressions should usually default to "first"
-            // to avoid combinatorial explosion when they are part of a sequence.
-            const mode = modeOverride || this.context.config.outputMode || "first";
-            if (mode === "all") {
-                return this.collectAllResultsForGoal(id, patterns, new Map(), (results) => k(results.map((s) => this.formatLogicResult(s))));
-            }
-            else if (mode === "stream") {
-                return k(this.createLazyStreamForGoal(id, patterns, new Map()));
-            }
-            return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), new Map(), (s) => k(this.formatLogicResult(s)), () => k(false));
+    solveGoalLike(node, outerSubsts, outerScope) {
+        const scope = outerScope ?? new Map();
+        const substs = outerSubsts ?? new Map();
+        return new BindCommand(this.resolveTerms(node, substs, scope), (termsRes) => {
+            const termsSeq = termsRes.asSequence;
+            if (!(termsSeq instanceof YuArray))
+                return new BacktrackCommand();
+            const terms = termsSeq.items;
+            if (!terms.every(isLogicTerm))
+                return new BacktrackCommand();
+            return this.runKernel(node, terms, substs);
         });
     }
-    solveNot(node, k) {
-        return () => this.solveConjunction([node.expression], new Map(), () => k(false), () => k(true));
-    }
-    solveFindall(node, k) {
-        return solveFindallCPS(node, new Map(), (body, substs, onSuccess, onFailure) => this.solveConjunction(body, substs, onSuccess, onFailure), (finalSubsts) => {
-            const pat = finalSubsts.get(node.bag.name.value);
-            const val = this.translator.patternToPrimitive(pat);
-            return k(val);
-        }, () => k([]));
+    solveNot(node, substs = new Map(), scope = new Map()) {
+        const clonedSubsts = new Map(substs);
+        const innerGoalCmd = this.solveConjunction([node.expression], clonedSubsts, scope);
+        return new NotCommand(innerGoalCmd, substs);
     }
-    solveForall(node, k) {
-        return this.solveConjunction([node.condition], new Map(), (condSubsts, nextCond) => {
-            return this.solveConjunction([node.action], condSubsts, () => nextCond, () => k(false));
-        }, () => k(true));
+    solveFindall(node, substs = new Map(), scope = new Map()) {
+        const clonedSubsts = new Map(substs);
+        const innerGoalCmd = this.solveConjunction([node.goal], clonedSubsts, scope);
+        return new FindallCommand(node.template, node.bag, innerGoalCmd, substs, scope, this.translator);
     }
-    solveExist(node, k, modeOverride) {
-        return this.prepareLogicTargetCPS(node, new Map(), ({ id, patterns }) => {
-            // Exists evaluated as expressions should usually default to "first"
-            const mode = modeOverride || this.context.config.outputMode || "first";
-            if (mode === "all") {
-                return this.collectAllResultsForGoal(id, patterns, new Map(), (results) => k(results.map((s) => this.formatLogicResult(s))));
-            }
-            else if (mode === "stream") {
-                return k(this.createLazyStreamForGoal(id, patterns, new Map()));
-            }
-            return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), new Map(), (s) => k(this.formatLogicResult(s)), () => k(false));
+    solveAssign(op, substs, scope) {
+        const localEnv = this.createLocalEnv(substs);
+        const isolatedContext = new RuntimeContext(this.context.config);
+        isolatedContext.logicState = this.context.logicState;
+        isolatedContext.setEnv({ head: localEnv, tail: this.context.env });
+        const localEvaluator = new InterpreterVisitor(isolatedContext);
+        return new BindCommand(localEvaluator.evaluate(op.right), (val) => {
+            const resultTerm = this.translator.primitiveToTerm(val);
+            return new BindCommand(this.translator.expressionToTerm(op.left, scope), (leftTerm) => {
+                if (!isLogicTerm(leftTerm))
+                    return new BacktrackCommand();
+                if (leftTerm.unify(resultTerm, substs)) {
+                    return new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
+                }
+                return new BacktrackCommand();
+            });
         });
     }
-    solveConjunction(nodes, substs, onSuccess, onFailure) {
-        if (this.context.config.debug)
-            console.log(`[LogicEngine] Solving conjunction.`);
-        if (nodes.length === 0) {
-            if (this.context.config.debug)
-                console.log(`[LogicEngine] Nothing else to solve. Success.`);
-            return onSuccess(substs, onFailure);
-        }
-        const [head, ...tail] = nodes;
-        return () => this.solveSingle(head, substs, (newSubsts, next) => {
-            return this.solveConjunction(tail, newSubsts, onSuccess, next);
-        }, onFailure);
+    solveForall(node, substs = new Map(), scope = new Map()) {
+        // a forall(Cond, Action) is equivalent to \+ (Cond, \+ Action)
+        return this.solveNot(new Not(new Sequence([node.condition, new Not(node.action)])), substs, scope);
     }
-    solveSingle(node, substs, onSuccess, onFailure) {
-        if (this.isLogicGoal(node))
-            return () => this.solveLogicGoal(node, substs, onSuccess, onFailure);
-        return () => this.solveCondition(node, substs, onSuccess, onFailure);
+    aggregateResults(command, scope) {
+        return new BindCommand(command, (res) => {
+            if (!isLogicResult(res))
+                return new StepCommand(res);
+            const mappedAnswers = res.allAnswers.map((ans) => this.finalizeUserResult(ans, scope));
+            return new StepCommand(new LogicResult(mappedAnswers));
+        });
     }
-    solveLogicGoal(goal, substs, onSuccess, onFailure) {
-        if (goal instanceof LogicConstraint) {
-            return () => this.solveConjunction([goal.expression], substs, onSuccess, onFailure);
-        }
-        if (goal instanceof Sequence) {
-            return () => this.solveConjunction(goal.statements, substs, onSuccess, onFailure);
+    branchSolutions(solutions, tail, scope) {
+        if (solutions.length === 0)
+            return new BacktrackCommand();
+        if (solutions.length === 1) {
+            return this.solveConjunction(tail, solutions[0], scope);
         }
-        if (goal instanceof Findall) {
-            return solveFindallCPS(goal, substs, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), onSuccess, onFailure);
-        }
-        if (this.context.config.debug) {
-            console.log(`[LogicEngine] Solving logic goal: ${goal.identifier.value}.`);
+        return new ChoiceCommand(solutions.map((s) => this.solveConjunction(tail, s, scope)));
+    }
+    solveConjunction(nodes, substs, scope) {
+        if (nodes.length === 0) {
+            return new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
         }
-        return this.prepareLogicTargetCPS(goal, substs, ({ id, patterns }) => {
-            return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), substs, onSuccess, onFailure);
+        const [head, ...tail] = nodes;
+        const solver = this.dispatch.get(head.constructor.name) ??
+            ((node, s) => this.solveCondition(node, s));
+        const currentSubst = new Map(substs);
+        return new BindCommand(solver(head, currentSubst, scope), (res) => {
+            // fail if result not a LogicResult or if some conditionfail
+            if (!isLogicResult(res) || !res.allSuccessful())
+                return new BacktrackCommand();
+            return this.branchSolutions(res.getSuccessfulSolutions(), tail, scope);
         });
     }
-    solveCondition(expr, substs, onSuccess, onFailure) {
-        this.createLocalEnv(substs);
-        const localEvaluator = new InterpreterVisitor(this.context);
-        return localEvaluator.evaluate(expr, (result) => {
-            if (result !== undefined && result !== false) {
-                let currentSubsts = new Map(substs);
-                for (const [name, val] of this.context.env.head) {
-                    const pat = this.translator.primitiveToPattern(val);
-                    const unified = unify(new VariablePattern(new SymbolPrimitive(name)), pat, currentSubsts);
-                    if (unified) {
-                        currentSubsts = unified;
-                    }
-                    else {
-                        return onFailure();
-                    }
-                }
-                return onSuccess(currentSubsts, onFailure);
-            }
-            return onFailure();
+    solveCondition(expr, substs) {
+        const localEnv = this.createLocalEnv(substs);
+        const isolatedContext = new RuntimeContext(this.context.config);
+        isolatedContext.logicState = this.context.logicState;
+        isolatedContext.setEnv({ head: localEnv, tail: this.context.env });
+        const localEvaluator = new InterpreterVisitor(isolatedContext);
+        return new BindCommand(localEvaluator.evaluate(expr), (result) => {
+            // fail if result is falsy
+            const isTrue = (result instanceof YuBoolean && result.value) ||
+                (result instanceof LogicResult && result.success) ||
+                result instanceof YuNil;
+            if (!isTrue)
+                return new BacktrackCommand();
+            return new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
         });
     }
-    isLogicGoal(node) {
-        return (node instanceof Goal ||
-            node instanceof Exist ||
-            node instanceof Findall ||
-            node instanceof LogicConstraint ||
-            node instanceof Sequence);
-    }
     createLocalEnv(substs) {
-        this.context.pushEnv(new Map());
-        for (const [name, pattern] of substs) {
-            const resolvedPattern = instantiate(pattern, substs);
-            const value = this.translator.patternToPrimitive(resolvedPattern);
-            this.context.define(name, value);
-            // map base name if it was standardized apart ("X_1" -> "X")
-            const baseNameMatch = name.match(/^(.*)_\d+$/);
-            if (baseNameMatch) {
-                const baseName = baseNameMatch[1];
-                if (!this.context.env.head.has(baseName)) {
-                    this.context.define(baseName, value);
-                }
-            }
-        }
-    }
-    prepareLogicTargetCPS(node, substs, k) {
-        const id = node.identifier.value;
-        if (node instanceof Goal) {
-            const patterns = [];
-            const next = (index) => {
-                if (index >= node.args.length)
-                    return k({ id, patterns });
-                return this.translator.instantiateExpressionAsPattern(node.args[index], substs, (p) => {
-                    patterns.push(p);
-                    return () => next(index + 1);
-                });
-            };
-            return () => next(0);
-        }
-        else {
-            const patterns = node.patterns.map((pat) => instantiate(pat, substs));
-            return k({ id, patterns });
+        const env = new Map();
+        for (const [id, term] of substs) {
+            const name = typeof id === "string" ? id : this.translator.getName(id);
+            if (name)
+                env.set(name, term.instantiate(substs).toPrimitive(substs));
         }
+        return env;
     }
-    collectAllResults(nodes, substs, k) {
-        const results = [];
-        return this.solveConjunction(nodes, substs, (s, next) => {
-            if (this.context.config.debug)
-                console.log(`[LogicEngine] Pushing { ${Array.from(s).map(([k, pat]) => `${k} -> ${pat.accept(new PatternResolver())}`)} } to results`);
-            results.push(s);
-            if (this.context.config.debug)
-                console.log(`[LogicEngine] Collected results: ${results.map((s) => `{ ${Array.from(s).map(([k, pat]) => `${k} -> ${pat.accept(new PatternResolver())}`)} }`)}`);
-            return next;
-        }, () => k(results));
+    finalizeUserResult(ans, scope) {
+        const solution = ans.getSolution();
+        const fromScope = Array.from(scope.entries()).map(([name, term]) => [name, term.instantiate(solution)]);
+        const fromSolution = Array.from(solution.entries()).map(([id, term]) => [
+            typeof id === "number" ? this.translator.getName(id) : id,
+            term.instantiate(solution),
+        ]);
+        const userMapped = new Map([fromSolution, fromScope].flatMap((s) => [...s]));
+        return new LogicAnswer(ans.isSuccessful(), userMapped);
     }
-    collectAllResultsForGoal(id, patterns, substs, k) {
-        const results = [];
-        return solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), substs, (s, next) => {
-            results.push(s);
-            return next;
-        }, () => k(results));
+    resolveTerms(node, substs, scope) {
+        if (node.is(Goal))
+            return this.resolveArgSequentially(node.args, substs, scope);
+        const terms = node.patterns.map((pat) => this.translator.patternToTerm(pat, scope).instantiate(substs));
+        return new StepCommand(new YuArray(terms));
     }
-    createLazyStream(nodes, substs) {
-        let currentSubst = null;
-        let currentNext = null;
-        let thunk = this.solveConjunction(nodes, substs, (s, next) => {
-            currentSubst = s;
-            currentNext = next;
-            return null;
-        }, () => {
-            currentSubst = null;
-            return null;
-        });
-        return createStream(() => {
-            return {
-                next: () => {
-                    trampoline(thunk);
-                    if (currentSubst) {
-                        const res = this.formatLogicResult(currentSubst);
-                        thunk = currentNext();
-                        return { value: res, done: false };
-                    }
-                    return { value: undefined, done: true };
-                },
-            };
-        });
+    resolveArgSequentially(args, substs, scope) {
+        const terms = [];
+        const next = (index) => {
+            if (index >= args.length) {
+                return new StepCommand(new YuArray(terms));
+            }
+            return new BindCommand(this.translator.instantiateExpressionAsTerm(args[index], substs, scope), (t) => {
+                if (isLogicTerm(t))
+                    terms.push(t);
+                return next(index + 1);
+            });
+        };
+        return next(0);
     }
-    createLazyStreamForGoal(id, patterns, substs) {
-        let currentSubst = null;
-        let currentNext = null;
-        let thunk = solveGoalCPS(this.context, id, patterns, (body, s, onSucc, onFail) => this.solveConjunction(body, s, onSucc, onFail), substs, (s, next) => {
-            currentSubst = s;
-            currentNext = next;
-            return null;
-        }, () => {
-            currentSubst = null;
-            return null;
-        });
-        return createStream(() => {
-            return {
-                next: () => {
-                    trampoline(thunk);
-                    if (currentSubst) {
-                        const res = this.formatLogicResult(currentSubst);
-                        thunk = currentNext();
-                        return { value: res, done: false };
-                    }
-                    return { value: undefined, done: true };
-                },
-            };
-        });
+    runKernel(node, terms, substs) {
+        return solveGoalKernel(this.context, node.identifier.value, terms, (body, s, scp) => this.solveConjunction(body, s, scp), substs, this.translator);
     }
-    formatLogicResult(substs) {
-        const solutions = new Map();
-        substs.forEach((pattern, key) => {
-            const val = this.translator.patternToPrimitive(pattern);
-            if (val !== undefined) {
-                solutions.set(key, val);
-                // Also map base name if it was standardized apart (e.g., "X_1" -> "X")
-                const baseNameMatch = key.match(/^(.*)_\d+$/);
-                if (baseNameMatch) {
-                    const baseName = baseNameMatch[1];
-                    if (!solutions.has(baseName)) {
-                        solutions.set(baseName, val);
-                    }
+    solveIf(node, substs, scope) {
+        return new BindCommand(this.solveConjunction([node.condition], substs, scope), (res) => {
+            if (isLogicResult(res) && res.allSuccessful()) {
+                const solutions = res.getSuccessfulSolutions();
+                if (solutions.length === 1) {
+                    return this.solveConjunction([node.then], solutions[0], scope);
                 }
+                return new ChoiceCommand(solutions.map((s) => this.solveConjunction([node.then], s, scope)));
             }
+            return this.solveConjunction([node.elseExpr], substs, scope);
         });
-        return { success: true, solutions };
     }
 }

package/dist/interpreter/components/logic/LogicResolver.d.ts

@@ -1,53 +1,24 @@
-import { Fact, Pattern, Rule, Findall } from "yukigo-ast";
-import { Thunk } from "../../trampoline.js";
+import { Fact, Rule, Visitor, ASTNode } from "yukigo-ast";
 import { LogicExecutable } from "./LogicEngine.js";
 import { RuntimeContext } from "../RuntimeContext.js";
-/**
- * A Substitution maps variable names to their bound patterns.
- */
-export type Substitution = Map<string, Pattern>;
-/**
- * Internal result of a logic operation.
- */
-export type InternalLogicResult = {
-    success: true;
-    substs: Substitution;
-};
-/**
- * Backtracking continuations.
- */
-export type SuccessCont = (substs: Substitution, next: () => Thunk<any>) => Thunk<any>;
-export type FailureCont = () => Thunk<any>;
-/**
- * A function that can solve a sequence of logic goals/expressions in CPS.
- */
-export type BodySolverCPS = (expressions: LogicExecutable[], env: Substitution, onSuccess: SuccessCont, onFailure: FailureCont) => Thunk<any>;
-/**
- * Creates a successful logic result.
- */
-export declare function success(substs: Substitution): InternalLogicResult;
-/**
- * Unifies two patterns given an existing set of substitutions.
- * Returns the updated substitution map or null if unification fails.
- */
-export declare function unify(t1: Pattern, t2: Pattern, argEnv?: Substitution): Substitution | null;
-/**
- * Follows variable bindings in the substitution map until a non-variable or unbound variable is found.
- */
-export declare function resolve(node: Pattern, env: Substitution): Pattern;
-/**
- * Fully instantiates a pattern by replacing all bound variables with their values.
- */
-export declare function instantiate(pattern: Pattern, substs: Substitution, seen?: Set<string>): Pattern;
-/**
- * Renames all variables in a Rule or Fact to fresh names to avoid name clashes during unification.
- */
-export declare function renameVariables<T extends Rule | Fact>(clause: T): T;
-/**
- * Solves a single logic goal (predicate call) using CPS.
- */
-export declare function solveGoalCPS(ctx: RuntimeContext, predicateName: string, args: Pattern[], solveBody: BodySolverCPS, baseSubst: Substitution, onSuccess: SuccessCont, onFailure: FailureCont): Thunk<any>;
-/**
- * Solves a findall/3 goal using CPS.
- */
-export declare function solveFindallCPS(node: Findall, currentSubsts: Substitution, solveBody: BodySolverCPS, onSuccess: SuccessCont, onFailure: FailureCont): Thunk<any>;
+import { ExecutionCommand } from "../kernel/commands.js";
+import { LogicTranslator } from "./LogicTranslator.js";
+import { VariableTerm } from "./LogicTerm.js";
+import { LogicTerm, Substitution } from "../../primitives/index.js";
+type Solver = (expressions: LogicExecutable[], env: Substitution, scope?: Map<string, VariableTerm>) => ExecutionCommand;
+export declare class GoalKernelVisitor implements Visitor<ExecutionCommand> {
+    private readonly args;
+    private readonly baseSubst;
+    private readonly solveBody;
+    private readonly translator;
+    constructor(args: LogicTerm[], baseSubst: Substitution, solveBody: Solver, translator: LogicTranslator);
+    visitFact(fact: Fact): ExecutionCommand;
+    visitRule(rule: Rule): ExecutionCommand;
+    fallback(node: ASTNode): ExecutionCommand;
+}
+/**
+ * Solves a single logic goal (predicate call) using the Kernel.
+ * Returns a non-deterministic command. Aggregation should happen at top-level.
+ */
+export declare function solveGoalKernel(ctx: RuntimeContext, predicateName: string, args: LogicTerm[], solveBody: Solver, baseSubst: Substitution, translator: LogicTranslator): ExecutionCommand;
+export {};