yukigo 0.2.3 → 0.3.2

package/dist/interpreter/components/evaluators/StatementEvaluator.js

@@ -0,0 +1,240 @@
+import { NamedArgument, Return, } from "yukigo-ast";
+import { BacktrackCommand, BindCommand, CatchCommand, EvalCommand, FailCommand, RaiseCommand, StepCommand, } from "../kernel/commands.js";
+import { LogicAnswer, LogicResult, RuntimeClass, RuntimeObject, YuBoolean, YuNil, YuString, } from "../../primitives/index.js";
+import { InterpreterError } from "../../errors.js";
+import { boolean, isTrue } from "../../utils.js";
+import { OOPCollector } from "../EnvBuilder.js";
+import { getClassFields, getClassInitializers, getLogicEngine } from "./utils.js";
+export function StatementEvaluator(Base) {
+    return class extends Base {
+        visitSequence(node) {
+            if (node.statements.length === 0)
+                return new StepCommand(YuNil.getInstance());
+            const evaluateNext = (index, lastResult) => {
+                if (index >= node.statements.length)
+                    return new StepCommand(lastResult);
+                const stmt = node.statements[index];
+                return new BindCommand(this.evaluate(stmt), (result) => {
+                    if (stmt instanceof Return)
+                        return new StepCommand(result);
+                    return evaluateNext(index + 1, result);
+                });
+            };
+            return evaluateNext(0, YuNil.getInstance());
+        }
+        visitSelf(node) {
+            try {
+                return new StepCommand(this.context.lookup("self"));
+            }
+            catch {
+                return new FailCommand(new InterpreterError("Self", "'self' is not defined in this context"));
+            }
+        }
+        visitSuper(node) {
+            let methodName;
+            try {
+                methodName = this.context.lookup("__METHOD_NAME__");
+            }
+            catch (e) {
+                return new FailCommand(new InterpreterError("Super", "'super' keyword used outside of a method context"));
+            }
+            const args = [];
+            const evaluateNextArg = (index) => {
+                if (index >= node.args.length) {
+                    return this.context.objRuntime.dispatchSuper(methodName.toJSON(), args);
+                }
+                return new BindCommand(this.evaluate(node.args[index]), (val) => {
+                    args.push(val);
+                    return evaluateNextArg(index + 1);
+                });
+            };
+            return evaluateNextArg(0);
+        }
+        visitIf(node) {
+            return new BindCommand(this.evaluate(node.condition), (condition) => {
+                if (!(condition instanceof YuBoolean))
+                    return new FailCommand(new InterpreterError("If", `Expected boolean in condition and got ${condition.getType()}`));
+                const isTrue = condition.value;
+                return isTrue ? this.evaluate(node.then) : this.evaluate(node.elseExpr);
+            });
+        }
+        visitReturn(node) {
+            if (!node.body)
+                return new StepCommand(YuNil.getInstance());
+            return this.evaluate(node.body);
+        }
+        visitFunction(node) {
+            return new StepCommand(YuNil.getInstance());
+        }
+        visitTry(node) {
+            const tryStartEnv = this.context.env;
+            // Comando que evaluará el cuerpo del Try (ej: block.apply())
+            const bodyCommand = new EvalCommand(node.body);
+            // Este handler es el que el Kernel llamará cuando reciba el RaiseCommand
+            const catchHandler = (errorObj) => {
+                this.context.env = tryStartEnv; // Restauramos entorno
+                // 1. Reificamos la excepción para Wollok
+                let exceptionObj;
+                if (errorObj instanceof InterpreterError) {
+                    const mappedErrors = this.context.dispatchHook("onInterpreterError", errorObj, this.context);
+                    exceptionObj = mappedErrors.find((res) => res !== undefined && res !== null);
+                }
+                if (!exceptionObj) {
+                    if (errorObj instanceof InterpreterError) {
+                        exceptionObj = new YuString(errorObj.message);
+                    }
+                    else {
+                        exceptionObj = errorObj;
+                    }
+                }
+                // 2. Buscamos si el Try tiene bloques catch
+                const catches = node.catchExpr;
+                if (catches.length > 0) {
+                    const catchBlock = catches[0];
+                    const pattern = catchBlock.patterns[0];
+                    const paramName = pattern.name?.value ?? pattern.identifier?.value ?? String(pattern);
+                    // Inyectamos la variable 'e' (excepción) en el scope
+                    this.context.pushEnv();
+                    this.context.define(paramName, exceptionObj);
+                    // Retornamos la evaluación del catchBlock
+                    return new BindCommand(new EvalCommand(catchBlock.body), (catchRes) => {
+                        this.context.env = tryStartEnv;
+                        // Si había bloque finally, podrías evaluarlo acá antes del StepCommand
+                        if (node.finallyExpr) {
+                            return new BindCommand(new EvalCommand(node.finallyExpr), () => new StepCommand(catchRes));
+                        }
+                        return new StepCommand(catchRes);
+                    });
+                }
+                // Si no había bloque catch (solo finally), relanzamos al Kernel superior
+                if (node.finallyExpr) {
+                    return new BindCommand(new EvalCommand(node.finallyExpr), () => new RaiseCommand(errorObj));
+                }
+                return new RaiseCommand(errorObj);
+            };
+            // Le entregamos el CatchCommand al Kernel para que lo apile ANTES de ejecutar el cuerpo
+            return new CatchCommand(catchHandler, bodyCommand);
+        }
+        visitRaise(node) {
+            return new BindCommand(this.evaluate(node.body), (msg) => {
+                if (msg instanceof RuntimeObject)
+                    return new RaiseCommand(msg);
+                const msgStr = msg.toJSON();
+                if (typeof msgStr !== "string") {
+                    return new RaiseCommand(new InterpreterError("Raise", msg.toString()));
+                }
+                return new RaiseCommand(new InterpreterError("Raise", msgStr));
+            });
+        }
+        visitPrint(node) {
+            return new BindCommand(this.evaluate(node.expression), (res) => {
+                console.log(res);
+                return new StepCommand(YuNil.getInstance());
+            });
+        }
+        visitVariable(node) {
+            const name = node.identifier.value;
+            return new BindCommand(this.evaluate(node.expression), (value) => {
+                this.context.define(name, value);
+                return boolean(true);
+            });
+        }
+        visitAssignment(node) {
+            if (!this.context.config.mutability) {
+                return new FailCommand(new InterpreterError("Assignment", `Cannot reassign variable '${node.identifier.value}': mutability is disabled`));
+            }
+            const name = node.identifier.value;
+            return new BindCommand(this.evaluate(node.expression), (value) => {
+                const onReplace = (scope) => {
+                    if (scope.has("self")) {
+                        const self = scope.get("self");
+                        if (self instanceof RuntimeObject && self.fields.has(name))
+                            self.fields.set(name, value);
+                    }
+                };
+                if (!this.context.replace(name, value, onReplace))
+                    return new FailCommand(new InterpreterError("Assignment", `Cannot assign to undefined variable: ${name}`));
+                return new StepCommand(value);
+            });
+        }
+        visitQuery(node) {
+            return getLogicEngine(this, this.context).solveQuery(node);
+        }
+        visitAttribute(node) {
+            const name = node.identifier.value;
+            return new BindCommand(this.evaluate(node.expression), (value) => {
+                this.context.define(name, value);
+                return boolean(true);
+            });
+        }
+        visitObject(node) {
+            const identifier = node.identifier.value;
+            const collector = new OOPCollector(this.context);
+            node.expression.accept(collector);
+            const fields = collector.collectedFields;
+            const methods = collector.collectedMethods;
+            const extendsSymbol = node.extendsSymbol?.value;
+            if (extendsSymbol) {
+                const classDef = this.context.lookup(extendsSymbol);
+                if (classDef && classDef instanceof RuntimeClass) {
+                    const classFields = getClassFields(classDef, this.context);
+                    for (const [k, v] of classFields.entries()) {
+                        if (!fields.has(k)) {
+                            fields.set(k, v);
+                        }
+                    }
+                }
+            }
+            const runtimeObject = new RuntimeObject(identifier, extendsSymbol || "", fields, methods);
+            const extendsArgs = node.extendsArgs || [];
+            const evaluateArgs = (index) => {
+                if (index >= extendsArgs.length) {
+                    this.context.define(identifier, runtimeObject);
+                    return new StepCommand(runtimeObject);
+                }
+                const arg = extendsArgs[index];
+                if (arg instanceof NamedArgument ||
+                    arg.constructor.name === "NamedArgument") {
+                    const fieldName = arg.identifier.value;
+                    return new BindCommand(this.evaluate(arg.expression), (val) => {
+                        runtimeObject.setField(fieldName, val);
+                        return evaluateArgs(index + 1);
+                    });
+                }
+                return evaluateArgs(index + 1);
+            };
+            const evaluateClassInitializers = (classDef, keys, keyIndex) => {
+                if (keyIndex >= keys.length) {
+                    return evaluateArgs(0);
+                }
+                const key = keys[keyIndex];
+                if (collector.fieldInitializers.has(key)) {
+                    return evaluateClassInitializers(classDef, keys, keyIndex + 1);
+                }
+                const expr = classInitializers.get(key);
+                return new BindCommand(this.evaluate(expr), (val) => {
+                    runtimeObject.setField(key, val);
+                    return evaluateClassInitializers(classDef, keys, keyIndex + 1);
+                });
+            };
+            let classInitializers = new Map();
+            let classInitializerKeys = [];
+            if (extendsSymbol) {
+                const classDef = this.context.lookup(extendsSymbol);
+                if (classDef && classDef instanceof RuntimeClass) {
+                    classInitializers = getClassInitializers(classDef, this.context);
+                    classInitializerKeys = Array.from(classInitializers.keys());
+                    return evaluateClassInitializers(classDef, classInitializerKeys, 0);
+                }
+            }
+            return evaluateArgs(0);
+        }
+        visitLogicConstraint(node) {
+            return new BindCommand(this.evaluate(node.expression), (val) => {
+                if (isTrue(val))
+                    return new StepCommand(new LogicResult([new LogicAnswer(true, new Map())]));
+                return new BacktrackCommand();
+            });
+        }
+    };
+}

package/dist/interpreter/components/evaluators/TestingEvaluator.d.ts

@@ -0,0 +1,15 @@
+import { Assert, Test, TestGroup } from "yukigo-ast";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { Constructor, EvaluatorBase } from "./BaseEvaluator.js";
+export declare function TestingEvaluator<TBase extends Constructor<EvaluatorBase>>(Base: TBase): {
+    new (...args: any[]): {
+        visitTestGroup(node: TestGroup): ExecutionCommand;
+        visitTest(node: Test): ExecutionCommand;
+        visitAssert(node: Assert): ExecutionCommand;
+        context: import("../RuntimeContext.js").RuntimeContext;
+        getContext(): import("../RuntimeContext.js").RuntimeContext;
+        evaluate(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: import("yukigo-ast").ASTNode): ExecutionCommand;
+    };
+} & TBase;

package/dist/interpreter/components/evaluators/TestingEvaluator.js

@@ -0,0 +1,14 @@
+import { TestRunner } from "../TestRunner.js";
+export function TestingEvaluator(Base) {
+    return class extends Base {
+        visitTestGroup(node) {
+            return new TestRunner(this, this.context.lazyRuntime).visitTestGroup(node);
+        }
+        visitTest(node) {
+            return new TestRunner(this, this.context.lazyRuntime).visitTest(node);
+        }
+        visitAssert(node) {
+            return new TestRunner(this, this.context.lazyRuntime).visitAssert(node);
+        }
+    };
+}

package/dist/interpreter/components/evaluators/index.d.ts

@@ -0,0 +1,110 @@
+import { ASTNode, Visitor } from "yukigo-ast";
+import { EvaluatorBase } from "./BaseEvaluator.js";
+import { ExecutionCommand } from "../kernel/commands.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { YuValue } from "../../primitives/index.js";
+declare const InterpreterVisitor_base: {
+    new (...args: any[]): {
+        visitTestGroup(node: import("yukigo-ast").TestGroup): ExecutionCommand;
+        visitTest(node: import("yukigo-ast").Test): ExecutionCommand;
+        visitAssert(node: import("yukigo-ast").Assert): ExecutionCommand;
+        context: RuntimeContext;
+        getContext(): RuntimeContext;
+        evaluate(node: ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: ASTNode): ExecutionCommand;
+    };
+} & {
+    new (...args: any[]): {
+        visitSequence(node: import("yukigo-ast").Sequence): ExecutionCommand;
+        visitSelf(node: import("yukigo-ast").Self): ExecutionCommand;
+        visitSuper(node: import("yukigo-ast").Super): ExecutionCommand;
+        visitIf(node: import("yukigo-ast").If): ExecutionCommand;
+        visitReturn(node: import("yukigo-ast").Return): ExecutionCommand;
+        visitFunction(node: import("yukigo-ast").Function): ExecutionCommand;
+        visitTry(node: import("yukigo-ast").Try): ExecutionCommand;
+        visitRaise(node: import("yukigo-ast").Raise): ExecutionCommand;
+        visitPrint(node: import("yukigo-ast").Print): ExecutionCommand;
+        visitVariable(node: import("yukigo-ast").Variable): ExecutionCommand;
+        visitAssignment(node: import("yukigo-ast").Assignment): ExecutionCommand;
+        visitQuery(node: import("yukigo-ast").Query): ExecutionCommand;
+        visitAttribute(node: import("yukigo-ast").Attribute): ExecutionCommand;
+        visitObject(node: import("yukigo-ast").Object): ExecutionCommand;
+        visitLogicConstraint(node: import("yukigo-ast").LogicConstraint): ExecutionCommand;
+        context: RuntimeContext;
+        getContext(): RuntimeContext;
+        evaluate(node: ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: ASTNode): ExecutionCommand;
+    };
+} & {
+    new (...args: any[]): {
+        visitTupleExpr(node: import("yukigo-ast").TupleExpression): ExecutionCommand;
+        visitFieldExpression(node: import("yukigo-ast").FieldExpression): ExecutionCommand;
+        visitDataExpr(node: import("yukigo-ast").DataExpression): ExecutionCommand;
+        visitConsExpr(node: import("yukigo-ast").ConsExpression): ExecutionCommand;
+        visitLetInExpr(node: import("yukigo-ast").LetInExpression): ExecutionCommand;
+        visitCall(node: import("yukigo-ast").Call): ExecutionCommand;
+        visitOtherwise(node: import("yukigo-ast").Otherwise): ExecutionCommand;
+        visitCompositionExpression(node: import("yukigo-ast").CompositionExpression): ExecutionCommand;
+        visitLambda(node: import("yukigo-ast").Lambda): ExecutionCommand;
+        visitGuardedExpression(expr: import("yukigo-ast").GuardedExpression): ExecutionCommand;
+        visitApplication(node: import("yukigo-ast").Application): ExecutionCommand;
+        visitExist(node: import("yukigo-ast").Exist): ExecutionCommand;
+        visitNot(node: import("yukigo-ast").Not): ExecutionCommand;
+        visitFindall(node: import("yukigo-ast").Findall): ExecutionCommand;
+        visitForall(node: import("yukigo-ast").Forall): ExecutionCommand;
+        visitGoal(node: import("yukigo-ast").Goal): ExecutionCommand;
+        visitSend(node: import("yukigo-ast").Send): ExecutionCommand;
+        visitNew(node: import("yukigo-ast").New): ExecutionCommand;
+        visitListComprehension(node: import("yukigo-ast").ListComprehension): ExecutionCommand;
+        visitGenerator(node: import("yukigo-ast").Generator): ExecutionCommand;
+        visitRangeExpression(node: import("yukigo-ast").RangeExpression): ExecutionCommand;
+        visitTypeCast(node: import("yukigo-ast").TypeCast): ExecutionCommand;
+        context: RuntimeContext;
+        getContext(): RuntimeContext;
+        evaluate(node: ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: ASTNode): ExecutionCommand;
+    };
+} & {
+    new (...args: any[]): {
+        visitArithmeticUnaryOperation(node: import("yukigo-ast").ArithmeticUnaryOperation): ExecutionCommand;
+        visitListUnaryOperation(node: import("yukigo-ast").ListUnaryOperation): ExecutionCommand;
+        visitListBinaryOperation(node: import("yukigo-ast").ListBinaryOperation): ExecutionCommand;
+        visitComparisonOperation(node: import("yukigo-ast").ComparisonOperation): ExecutionCommand;
+        visitLogicalBinaryOperation(node: import("yukigo-ast").LogicalBinaryOperation): ExecutionCommand;
+        visitLogicalUnaryOperation(node: import("yukigo-ast").LogicalUnaryOperation): ExecutionCommand;
+        visitBitwiseBinaryOperation(node: import("yukigo-ast").BitwiseBinaryOperation): ExecutionCommand;
+        visitBitwiseUnaryOperation(node: import("yukigo-ast").BitwiseUnaryOperation): ExecutionCommand;
+        visitStringOperation(node: import("yukigo-ast").StringOperation): ExecutionCommand;
+        visitUnifyOperation(node: import("yukigo-ast").UnifyOperation): ExecutionCommand;
+        visitAssignOperation(node: import("yukigo-ast").AssignOperation): ExecutionCommand;
+        visitArithmeticBinaryOperation(node: import("yukigo-ast").ArithmeticBinaryOperation): ExecutionCommand;
+        context: RuntimeContext;
+        getContext(): RuntimeContext;
+        evaluate(node: ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: ASTNode): ExecutionCommand;
+    };
+} & {
+    new (...args: any[]): {
+        visitStringPrimitive(node: import("yukigo-ast").StringPrimitive): ExecutionCommand;
+        visitListPrimitive(node: import("yukigo-ast").ListPrimitive): ExecutionCommand;
+        visitNilPrimitive(node: import("yukigo-ast").NilPrimitive): ExecutionCommand;
+        visitSymbolPrimitive(node: import("yukigo-ast").SymbolPrimitive): ExecutionCommand;
+        visitCharPrimitive(node: import("yukigo-ast").CharPrimitive): ExecutionCommand;
+        visitNumberPrimitive(node: import("yukigo-ast").NumberPrimitive): ExecutionCommand;
+        visitBooleanPrimitive(node: import("yukigo-ast").BooleanPrimitive): ExecutionCommand;
+        context: RuntimeContext;
+        getContext(): RuntimeContext;
+        evaluate(node: ASTNode): ExecutionCommand;
+        realizeList(val: any): ExecutionCommand;
+        fallback(node: ASTNode): ExecutionCommand;
+    };
+} & typeof EvaluatorBase;
+export declare class InterpreterVisitor extends InterpreterVisitor_base implements Visitor<ExecutionCommand> {
+    constructor(context: RuntimeContext);
+    static evaluateLiteral(node: ASTNode, ctx?: RuntimeContext): YuValue;
+}
+export {};

package/dist/interpreter/components/evaluators/index.js

@@ -0,0 +1,21 @@
+import { EvaluatorBase } from "./BaseEvaluator.js";
+import { ExpressionEvaluator } from "./ExpressionEvaluator.js";
+import { OperationEvaluator } from "./OperationEvaluator.js";
+import { PrimitiveEvaluator } from "./PrimitiveEvaluator.js";
+import { StatementEvaluator } from "./StatementEvaluator.js";
+import { TestingEvaluator } from "./TestingEvaluator.js";
+import { EvalCommand } from "../kernel/commands.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { YukigoKernel } from "../kernel/index.js";
+export class InterpreterVisitor extends TestingEvaluator(StatementEvaluator(ExpressionEvaluator(OperationEvaluator(PrimitiveEvaluator(EvaluatorBase))))) {
+    constructor(context) {
+        super(context);
+        this.context.evaluatorFactory = (ctx) => new InterpreterVisitor(ctx);
+    }
+    static evaluateLiteral(node, ctx) {
+        const targetCtx = ctx ?? new RuntimeContext();
+        const visitor = new InterpreterVisitor(targetCtx);
+        const kernel = new YukigoKernel(visitor);
+        return kernel.run(new EvalCommand(node));
+    }
+}

package/dist/interpreter/components/evaluators/utils.d.ts

@@ -0,0 +1,7 @@
+import { RuntimeClass, YuValue } from "../../primitives/index.js";
+import { LogicEngine } from "../logic/LogicEngine.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { EvaluatorBase } from "./BaseEvaluator.js";
+export declare const getLogicEngine: (evaluator: EvaluatorBase, ctx: RuntimeContext) => LogicEngine;
+export declare const getClassInitializers: (classDef: RuntimeClass, ctx: RuntimeContext) => Map<string, any>;
+export declare const getClassFields: (classDef: RuntimeClass, ctx: RuntimeContext) => Map<string, YuValue>;

package/dist/interpreter/components/evaluators/utils.js

@@ -0,0 +1,50 @@
+import { RuntimeClass } from "../../primitives/index.js";
+import { LogicEngine } from "../logic/LogicEngine.js";
+export const getLogicEngine = (evaluator, ctx) => new LogicEngine(evaluator, ctx);
+export const getClassInitializers = (classDef, ctx) => {
+    const initializers = new Map();
+    const collect = (c) => {
+        if (c.superclass) {
+            const superDef = ctx.lookup(c.superclass);
+            if (superDef && superDef instanceof RuntimeClass) {
+                collect(superDef);
+            }
+        }
+        for (const mixin of c.mixins) {
+            const mixinDef = ctx.lookup(mixin);
+            if (mixinDef && mixinDef instanceof RuntimeClass) {
+                collect(mixinDef);
+            }
+        }
+        const cInitializers = c.fieldInitializers;
+        if (cInitializers) {
+            for (const [k, v] of cInitializers.entries()) {
+                initializers.set(k, v);
+            }
+        }
+    };
+    collect(classDef);
+    return initializers;
+};
+export const getClassFields = (classDef, ctx) => {
+    const fields = new Map();
+    const collect = (c) => {
+        if (c.superclass) {
+            const superDef = ctx.lookup(c.superclass);
+            if (superDef && superDef instanceof RuntimeClass) {
+                collect(superDef);
+            }
+        }
+        for (const mixin of c.mixins) {
+            const mixinDef = ctx.lookup(mixin);
+            if (mixinDef && mixinDef instanceof RuntimeClass) {
+                collect(mixinDef);
+            }
+        }
+        for (const [k, v] of c.fields.entries()) {
+            fields.set(k, v);
+        }
+    };
+    collect(classDef);
+    return fields;
+};

package/dist/interpreter/components/hooks/YukigoHook.d.ts

@@ -0,0 +1,27 @@
+import { InterpreterError } from "../../errors.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { ASTNode, Test } from "yukigo-ast";
+import { YuValue } from "../../primitives/YuValue.js";
+import { Interpreter } from "../../index.js";
+export interface YukigoHook {
+    /**
+     * Executed when an InterpreterError is raised, allows languages to extends error handling.
+     */
+    onInterpreterError?: (error: InterpreterError, ctx: RuntimeContext) => Error | YuValue | void;
+    /**
+     * Executed before evaluating a node.
+     */
+    beforeNodeEvaluate?: (node: ASTNode, ctx: RuntimeContext) => void;
+    /**
+     * Executed after evaluating a nove.
+     */
+    afterNodeEvaluate?: (node: ASTNode, result: YuValue, ctx: RuntimeContext) => void;
+    /**
+     * Executed before dispatching a message to an object.
+     */
+    onMessageDispatch?: (receiver: YuValue, message: string, args: YuValue[], ctx: RuntimeContext) => void;
+    /** Executed before each individual Test */
+    beforeEachTest?: (interpreter: Interpreter, testNode: Test) => void;
+    /** Executed after each individual Test */
+    afterEachTest?: (interpreter: Interpreter, testNode: Test) => void;
+}

package/dist/interpreter/components/hooks/YukigoHook.js

@@ -0,0 +1 @@
+export {};

package/dist/interpreter/components/kernel/commands.d.ts

@@ -0,0 +1,122 @@
+import { ASTNode, Pattern } from "yukigo-ast";
+import { YukigoKernel } from "./index.js";
+import { ErrorFrame, InterpreterError } from "../../errors.js";
+import { LogicTranslator } from "../logic/LogicTranslator.js";
+import { Scope } from "../logic/LogicEngine.js";
+import { YuValue, Substitution } from "../../primitives/index.js";
+/**
+ * A Continuation is a function that receives a value and decides what is the next Command to execute
+ */
+export type Continuation = (result: YuValue) => ExecutionCommand;
+export type TraceEntry = {
+    frame: ErrorFrame;
+    key: string;
+};
+export interface ExecutionCommand {
+    readonly name: string;
+    execute(kernel: YukigoKernel): ExecutionCommand | void;
+    createTraceEntry(): TraceEntry | void;
+}
+/**
+ * Commands the Kernel to evaluate an AST node.
+ */
+export declare class EvalCommand implements ExecutionCommand {
+    readonly node: ASTNode;
+    readonly name = "EVAL";
+    constructor(node: ASTNode);
+    execute(kernel: YukigoKernel): ExecutionCommand;
+    createTraceEntry(): TraceEntry;
+}
+/**
+ * Commands the Kernel to move to the next step with a produced value.
+ * It triggers the popping of the continuation stack in the kernel.
+ */
+export declare class StepCommand implements ExecutionCommand {
+    readonly value: YuValue;
+    readonly name = "STEP";
+    constructor(value: YuValue);
+    execute(kernel: YukigoKernel): ExecutionCommand | void;
+    createTraceEntry(): void;
+}
+/**
+ * Commands the Kernel to bind a produced value to a continuation.
+ * It pushes the continuation to the kernel's stack and proceeds with the command.
+ */
+export declare class BindCommand implements ExecutionCommand {
+    readonly command: ExecutionCommand;
+    readonly next: Continuation;
+    readonly name = "BIND";
+    constructor(command: ExecutionCommand, next: Continuation);
+    execute(kernel: YukigoKernel): ExecutionCommand;
+    createTraceEntry(): void;
+}
+/**
+ * Commands the Kernel to handle multiple branches of execution (non-determinism).
+ * It will try the first one and save the others as choice points.
+ */
+export declare class ChoiceCommand implements ExecutionCommand {
+    readonly alternatives: ExecutionCommand[];
+    readonly name = "CHOICE";
+    constructor(alternatives: ExecutionCommand[]);
+    execute(kernel: YukigoKernel): ExecutionCommand | void;
+    createTraceEntry(): void;
+}
+/**
+ * Commands the Kernel to halt execution due to an error.
+ */
+export declare class FailCommand implements ExecutionCommand {
+    readonly error: Error;
+    readonly name = "FAIL";
+    constructor(error: Error);
+    execute(kernel: YukigoKernel): ExecutionCommand | void;
+    createTraceEntry(): void;
+}
+export declare class RaiseCommand implements ExecutionCommand {
+    readonly exceptionObj: YuValue | InterpreterError;
+    readonly name = "RAISE";
+    constructor(exceptionObj: YuValue | InterpreterError);
+    execute(kernel: YukigoKernel): ExecutionCommand | void;
+    createTraceEntry(): void;
+}
+/**
+ * A CatchHandler is a function that receives the raised exception (YuValue)
+ * and decides what Command to execute next (usually the catch block body).
+ */
+export type CatchHandler = (exception: YuValue | InterpreterError) => ExecutionCommand;
+export declare class CatchCommand implements ExecutionCommand {
+    readonly handler: CatchHandler;
+    readonly innerCommand: ExecutionCommand;
+    readonly name = "CATCH";
+    constructor(handler: CatchHandler, innerCommand: ExecutionCommand);
+    execute(kernel: YukigoKernel): ExecutionCommand;
+    createTraceEntry(): void;
+}
+/**
+ * Commands the Kernel to stop execution and backtrack due to logical failure.
+ */
+export declare class BacktrackCommand implements ExecutionCommand {
+    readonly name = "BACKTRACK";
+    constructor();
+    execute(kernel: YukigoKernel): ExecutionCommand | void;
+    createTraceEntry(): void;
+}
+export declare class NotCommand implements ExecutionCommand {
+    readonly innerGoalCmd: ExecutionCommand;
+    readonly currentSubsts: Substitution;
+    readonly name = "NOT";
+    constructor(innerGoalCmd: ExecutionCommand, currentSubsts: Substitution);
+    execute(kernel: YukigoKernel): ExecutionCommand;
+    createTraceEntry(): void;
+}
+export declare class FindallCommand implements ExecutionCommand {
+    readonly template: Pattern;
+    readonly bag: Pattern;
+    readonly innerGoalCmd: ExecutionCommand;
+    readonly currentSubsts: Substitution;
+    readonly scope: Scope;
+    readonly translator: LogicTranslator;
+    readonly name = "FINDALL";
+    constructor(template: Pattern, bag: Pattern, innerGoalCmd: ExecutionCommand, currentSubsts: Substitution, scope: Scope, translator: LogicTranslator);
+    execute(kernel: YukigoKernel): ExecutionCommand;
+    createTraceEntry(): void;
+}