yukigo 0.1.1 → 0.2.0

package/dist/interpreter/components/FunctionRuntime.d.ts

@@ -1,8 +0,0 @@
-import { EquationRuntime, PrimitiveValue, EnvStack } from "yukigo-ast";
-import { ExpressionEvaluator } from "../utils.js";
-export declare class FunctionRuntime {
-    static apply(funcName: string, equations: EquationRuntime[], args: PrimitiveValue[], currentEnv: EnvStack, evaluatorFactory: (env: EnvStack) => ExpressionEvaluator): PrimitiveValue;
-    private static preloadDefinitions;
-    private static patternsMatch;
-    private static evaluateSequence;
-}

package/dist/interpreter/components/FunctionRuntime.js

@@ -1,81 +0,0 @@
-import { UnguardedBody, Sequence, Return, Function, } from "yukigo-ast";
-import { PatternMatcher } from "./PatternMatcher.js";
-import { pushEnv } from "../utils.js";
-import { InterpreterError } from "../errors.js";
-import { EnvBuilderVisitor } from "./EnvBuilder.js";
-class NonExhaustivePatterns extends InterpreterError {
-    constructor(funcName) {
-        super("PatternMatch", `Non-exhaustive patterns in '${funcName}'`);
-    }
-}
-export class FunctionRuntime {
-    static apply(funcName, equations, args, currentEnv, evaluatorFactory) {
-        for (const eq of equations) {
-            if (eq.patterns.length !== args.length)
-                continue;
-            const bindings = [];
-            if (!FunctionRuntime.patternsMatch(eq, args, bindings))
-                continue;
-            const localEnv = new Map(bindings);
-            const newStack = pushEnv(currentEnv, localEnv);
-            const scopeEvaluator = evaluatorFactory(newStack);
-            // UnguardedBody
-            if (eq.body instanceof UnguardedBody)
-                return this.evaluateSequence(eq.body.sequence, scopeEvaluator, newStack);
-            // GuardedBody
-            if (Array.isArray(eq.body) && eq.body.length > 0) {
-                const prototypeBody = eq.body[0].body;
-                if (prototypeBody instanceof Sequence)
-                    this.preloadDefinitions(prototypeBody, scopeEvaluator, newStack);
-            }
-            for (const guard of eq.body) {
-                const cond = scopeEvaluator.evaluate(guard.condition);
-                if (cond === true) {
-                    if (guard.body instanceof Sequence)
-                        return this.evaluateSequence(guard.body, scopeEvaluator, newStack);
-                    return scopeEvaluator.evaluate(guard.body);
-                }
-            }
-        }
-        throw new NonExhaustivePatterns(funcName);
-    }
-    static preloadDefinitions(seq, evaluator, env) {
-        const builder = new EnvBuilderVisitor(env);
-        for (const stmt of seq.statements) {
-            if (stmt instanceof Function)
-                stmt.accept(builder);
-        }
-        for (const stmt of seq.statements) {
-            if (stmt instanceof Function || stmt instanceof Return)
-                continue;
-            evaluator.evaluate(stmt);
-        }
-    }
-    static patternsMatch(eq, args, bindings) {
-        for (let i = 0; i < args.length; i++) {
-            const matcher = new PatternMatcher(args[i], bindings);
-            if (!eq.patterns[i].accept(matcher))
-                return false;
-        }
-        return true;
-    }
-    static evaluateSequence(seq, evaluator, env) {
-        let result = undefined;
-        const builder = new EnvBuilderVisitor(env);
-        for (const stmt of seq.statements) {
-            if (stmt instanceof Function)
-                stmt.accept(builder);
-        }
-        for (const stmt of seq.statements) {
-            if (stmt instanceof Function)
-                continue;
-            if (stmt instanceof Return) {
-                return evaluator.evaluate(stmt.body);
-            }
-            else {
-                result = evaluator.evaluate(stmt);
-            }
-        }
-        return result;
-    }
-}

package/dist/interpreter/components/LazyRuntime.d.ts

@@ -1,7 +0,0 @@
-import { PrimitiveValue, RangeExpression, ConsExpression } from "yukigo-ast";
-import { ExpressionEvaluator } from "../utils.js";
-export declare class LazyRuntime {
-    static realizeList(val: PrimitiveValue): PrimitiveValue[];
-    static evaluateRange(node: RangeExpression, evaluator: ExpressionEvaluator): PrimitiveValue;
-    static evaluateCons(node: ConsExpression, evaluator: ExpressionEvaluator, lazy: boolean): PrimitiveValue;
-}

package/dist/interpreter/components/LazyRuntime.js

@@ -1,94 +0,0 @@
-import { isLazyList, } from "yukigo-ast";
-import { createMemoizedStream, isMemoizedList } from "./PatternMatcher.js";
-export class LazyRuntime {
-    static realizeList(val) {
-        if (Array.isArray(val))
-            return val;
-        if (isLazyList(val)) {
-            const result = [];
-            const iter = val.generator();
-            let next = iter.next();
-            while (!next.done) {
-                if (next.value === undefined)
-                    throw new Error("LazyList yielded undefined");
-                result.push(next.value);
-                next = iter.next();
-            }
-            return result;
-        }
-        throw new Error(`Expected List or LazyList, got ${typeof val}`);
-    }
-    static evaluateRange(node, evaluator) {
-        const startVal = evaluator.evaluate(node.start);
-        if (typeof startVal !== "number")
-            throw new Error("Range start must be a number");
-        const hasEnd = node.end != null;
-        let step = 1;
-        if (node.step) {
-            const secondVal = evaluator.evaluate(node.step);
-            if (typeof secondVal !== "number")
-                throw new Error("Range step must be a number");
-            step = secondVal - startVal;
-            if (step === 0)
-                throw new Error("Range step cannot be zero");
-        }
-        if (!hasEnd) {
-            return createMemoizedStream(function* () {
-                let current = startVal;
-                while (true) {
-                    yield current;
-                    current += step;
-                }
-            });
-        }
-        // eager eval
-        const endVal = evaluator.evaluate(node.end);
-        if (typeof endVal !== "number")
-            throw new Error("Range end must be a number");
-        const result = [];
-        let current = startVal;
-        const cond = step > 0 ? () => current <= endVal : () => current >= endVal;
-        while (cond()) {
-            result.push(current);
-            current += step;
-        }
-        return result;
-    }
-    static evaluateCons(node, evaluator, lazy) {
-        const head = evaluator.evaluate(node.head);
-        if (lazy) {
-            return createMemoizedStream(function* () {
-                yield head;
-                const tail = evaluator.evaluate(node.tail);
-                if (Array.isArray(tail)) {
-                    for (const item of tail)
-                        yield item;
-                    return;
-                }
-                if (isLazyList(tail)) {
-                    if (isMemoizedList(tail)) {
-                        const seq = tail._sequence;
-                        let currentIdx = tail._offset;
-                        while (true) {
-                            const res = seq.get(currentIdx);
-                            if (res.done)
-                                break;
-                            yield res.value;
-                            currentIdx++;
-                        }
-                    }
-                    else {
-                        yield* tail.generator();
-                    }
-                    return;
-                }
-                throw new Error(`Invalid tail type for Cons: ${typeof tail}`);
-            });
-        }
-        // Eager behavior
-        const tail = evaluator.evaluate(node.tail);
-        if (isLazyList(tail) || !Array.isArray(tail))
-            throw new Error("Expected Array in eager Cons");
-        return [head, ...tail];
-    }
-}

package/dist/interpreter/components/LogicEngine.d.ts

@@ -1,24 +0,0 @@
-import { Exist, Expression, Findall, Forall, Goal, Not, PrimitiveValue, Query, EnvStack } from "yukigo-ast";
-import { InterpreterConfig } from "../index.js";
-import { ExpressionEvaluator } from "../utils.js";
-export declare class LogicEngine {
-    private env;
-    private config;
-    private evaluator;
-    constructor(env: EnvStack, config: InterpreterConfig, evaluator: ExpressionEvaluator);
-    unifyExpr(left: Expression, right: Expression): PrimitiveValue;
-    solveQuery(node: Query): PrimitiveValue;
-    solveGoal(node: Goal): PrimitiveValue;
-    solveNot(node: Not): PrimitiveValue;
-    solveFindall(node: Findall): PrimitiveValue;
-    solveForall(node: Forall): PrimitiveValue;
-    solveExist(node: Exist): PrimitiveValue;
-    private solveConjunction;
-    private expressionToPattern;
-    private primitiveToPattern;
-    private instantiateExpressionAsPattern;
-    private substitutePattern;
-    private instantiateTemplate;
-    private handleOutputMode;
-    private formatLogicResult;
-}

package/dist/interpreter/components/LogicEngine.js

@@ -1,173 +0,0 @@
-import { Exist, Goal, LiteralPattern, SymbolPrimitive, Variable, VariablePattern, } from "yukigo-ast";
-import { solveGoal, success, unify, } from "./LogicResolver.js";
-import { PatternResolver } from "./PatternMatcher.js";
-import { createStream, isDefined } from "../utils.js";
-import { InterpreterError } from "../errors.js";
-export class LogicEngine {
-    env;
-    config;
-    evaluator;
-    constructor(env, config, evaluator) {
-        this.env = env;
-        this.config = config;
-        this.evaluator = evaluator;
-    }
-    unifyExpr(left, right) {
-        const p1 = this.instantiateExpressionAsPattern(left, new Map());
-        const p2 = this.instantiateExpressionAsPattern(right, new Map());
-        const resultSubsts = unify(p1, p2, new Map());
-        return resultSubsts !== null;
-    }
-    solveQuery(node) {
-        const generator = this.solveConjunction(node.expressions, new Map());
-        return this.handleOutputMode(generator);
-    }
-    solveGoal(node) {
-        const patterns = node.args;
-        const generator = solveGoal(this.env, node.identifier.value, patterns, (body, substs) => this.solveConjunction(body, substs));
-        return this.handleOutputMode(generator);
-    }
-    solveNot(node) {
-        const generator = this.solveConjunction([node.expression], new Map());
-        const result = generator.next();
-        return result.done === true;
-    }
-    solveFindall(node) {
-        if (!(node.goal instanceof Goal))
-            throw new InterpreterError("solveFindall", "Findall expects a Goal");
-        const goalPatterns = node.goal.args;
-        const generator = solveGoal(this.env, node.goal.identifier.value, goalPatterns, (b, s) => this.solveConjunction(b, s));
-        const results = [];
-        for (const res of generator)
-            results.push(this.instantiateTemplate(node.template, res.substs));
-        return results;
-    }
-    solveForall(node) {
-        const conditionGenerator = this.solveConjunction([node.condition], new Map());
-        for (const condResult of conditionGenerator) {
-            const actionGenerator = this.solveConjunction([node.action], condResult.substs);
-            const actionResult = actionGenerator.next();
-            if (actionResult.done)
-                return false;
-        }
-        return true;
-    }
-    solveExist(node) {
-        const generator = solveGoal(this.env, node.identifier.value, node.patterns, (body, substs) => this.solveConjunction(body, substs));
-        return this.handleOutputMode(generator);
-    }
-    *solveConjunction(expressions, substs) {
-        if (expressions.length === 0) {
-            yield success(substs);
-            return;
-        }
-        const [head, ...tail] = expressions;
-        let headGen = null;
-        if (head instanceof Goal) {
-            const args = head.args.map((arg) => this.instantiateExpressionAsPattern(arg, substs));
-            headGen = solveGoal(this.env, head.identifier.value, args, (b, s) => this.solveConjunction(b, s));
-        }
-        else if (head instanceof Exist) {
-            const patterns = head.patterns.map((pat) => this.substitutePattern(pat, substs));
-            headGen = solveGoal(this.env, head.identifier.value, patterns, (b, s) => this.solveConjunction(b, s));
-        }
-        if (headGen) {
-            // backtracking
-            for (const headResult of headGen) {
-                const newSubsts = new Map([...substs, ...headResult.substs]);
-                yield* this.solveConjunction(tail, newSubsts);
-            }
-        }
-        else {
-            // imperative
-            const result = this.evaluator.evaluate(head);
-            if (result)
-                yield* this.solveConjunction(tail, substs);
-        }
-    }
-    expressionToPattern(expr) {
-        // 1. Si ya es explícitamente un patrón (ej. sintaxis especial si tuvieras), devolverlo.
-        if (expr instanceof VariablePattern)
-            return expr; // 2. Si es una variable, tenemos un dilema: ¿Es valor o incógnita?
-        if (expr instanceof Variable) {
-            const name = expr.identifier.value;
-            // A. ¿Existe definida en el entorno actual?
-            // Usamos una función auxiliar para no lanzar excepción
-            if (isDefined(this.env, name)) {
-                const val = this.evaluator.evaluate(expr);
-                return this.primitiveToPattern(val); // Es un VALOR (ej: 42)
-            }
-            // B. No existe en el entorno -> Es una INCÓGNITA LÓGICA nueva
-            return new VariablePattern(expr.identifier);
-        }
-        // 3. Cualquier otra expresión (números, strings, operaciones 1+1) se evalúa
-        const val = this.evaluator.evaluate(expr);
-        return this.primitiveToPattern(val);
-    }
-    primitiveToPattern(val) {
-        if (typeof val === "number" ||
-            typeof val === "string" ||
-            typeof val === "boolean")
-            return new LiteralPattern(new SymbolPrimitive(String(val)));
-        // TODO: Manejar arrays/listas complejas si es necesario
-        throw new InterpreterError("primitiveToPattern", `Cannot convert value ${val} to Logic Pattern`);
-    }
-    instantiateExpressionAsPattern(expr, substs) {
-        const patternBase = this.expressionToPattern(expr);
-        return this.substitutePattern(patternBase, substs);
-    }
-    substitutePattern(pat, substs, visited = new Set()) {
-        if (pat instanceof VariablePattern) {
-            const name = pat.name.value;
-            if (visited.has(name))
-                return pat;
-            const val = substs.get(name);
-            if (val) {
-                const newVisited = new Set(visited);
-                newVisited.add(name);
-                return this.substitutePattern(val, substs, newVisited);
-            }
-        }
-        return pat;
-    }
-    instantiateTemplate(template, substs) {
-        const pat = this.instantiateExpressionAsPattern(template, substs);
-        if (pat instanceof LiteralPattern)
-            return this.evaluator.evaluate(pat.name);
-        throw new Error("Complex template instantiation not fully implemented");
-    }
-    handleOutputMode(gen) {
-        const mode = this.config.outputMode || "first";
-        switch (mode) {
-            case "stream": {
-                const self = this;
-                return createStream(function* () {
-                    for (const res of gen)
-                        yield self.formatLogicResult(res.substs);
-                });
-            }
-            case "all": {
-                const res = [];
-                for (const r of gen)
-                    res.push(this.formatLogicResult(r.substs));
-                return res;
-            }
-            case "first": {
-                const next = gen.next();
-                if (next.done)
-                    return false;
-                return this.formatLogicResult(next.value.substs);
-            }
-            default:
-                throw new InterpreterError("handleOutputMode", `Unsupported mode: ${mode}. Supported modes: all | stream | first`);
-        }
-    }
-    formatLogicResult(substs) {
-        const solutions = new Map();
-        const resolver = new PatternResolver();
-        substs.forEach((pattern, key) => {
-            solutions.set(key, pattern.accept(resolver));
-        });
-        return { success: true, solutions };
-    }
-}

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

@@ -1,10 +0,0 @@
-import { Expression, Pattern, EnvStack } from "yukigo-ast";
-export type Substitution = Map<string, Pattern>;
-export type InternalLogicResult = {
-    success: true;
-    substs: Substitution;
-};
-export type BodySolver = (expressions: Expression[], env: Substitution) => Generator<InternalLogicResult>;
-export declare function success(substs: Substitution): InternalLogicResult;
-export declare function solveGoal(envs: EnvStack, predicateName: string, args: Pattern[], solveBody: BodySolver): Generator<InternalLogicResult>;
-export declare function unify(t1: Pattern, t2: Pattern, argEnv?: Substitution): Substitution | null;

package/dist/interpreter/components/LogicResolver.js

@@ -1,97 +0,0 @@
-import { Fact, FunctorPattern, ListPattern, LiteralPattern, Rule, VariablePattern, WildcardPattern, isRuntimePredicate, UnguardedBody, } from "yukigo-ast";
-import { lookup } from "../utils.js";
-import { InterpreterError } from "../errors.js";
-export function success(substs) {
-    return { success: true, substs };
-}
-function unifyParameters(patterns, args) {
-    const subst = new Map();
-    for (let i = 0; i < patterns.length; i++) {
-        const match = unify(patterns[i], args[i], subst);
-        if (!match)
-            return [, false];
-        match.forEach((v, k) => subst.set(k, v));
-    }
-    return [subst, true];
-}
-export function* solveGoal(envs, predicateName, args, solveBody) {
-    const pred = lookup(envs, predicateName);
-    if (!pred || !isRuntimePredicate(pred))
-        return;
-    for (const clause of pred.equations) {
-        const arity = clause instanceof Fact
-            ? clause.patterns.length
-            : clause.equations[0].patterns.length;
-        if (arity !== args.length)
-            continue;
-        if (clause instanceof Fact) {
-            const [substs, matches] = unifyParameters(clause.patterns, args);
-            if (!matches)
-                continue;
-            yield success(substs);
-            continue;
-        }
-        if (clause instanceof Rule) {
-            for (const eq of clause.equations) {
-                const [substs, matches] = unifyParameters(eq.patterns, args);
-                if (!matches)
-                    continue;
-                if (eq.body instanceof UnguardedBody) {
-                    const bodyGenerator = solveBody(eq.body.sequence.statements, substs);
-                    for (const finalResult of bodyGenerator)
-                        yield success(finalResult.substs);
-                }
-            }
-            continue;
-        }
-        throw new InterpreterError("*solveGoal", `Unexpected node: ${JSON.stringify(clause)}`);
-    }
-}
-function resolve(node, env) {
-    if (node instanceof VariablePattern) {
-        const name = node.name.toString();
-        if (env.has(name))
-            return resolve(env.get(name), env);
-    }
-    return node;
-}
-export function unify(t1, t2, argEnv) {
-    const env = argEnv ?? new Map();
-    const r1 = resolve(t1, env);
-    const r2 = resolve(t2, env);
-    if (r1 === r2)
-        return env;
-    if (r1 instanceof WildcardPattern || r2 instanceof WildcardPattern)
-        return env;
-    if (r1 instanceof VariablePattern) {
-        env.set(r1.name.value, r2);
-        return env;
-    }
-    if (r2 instanceof VariablePattern) {
-        env.set(r2.name.value, r1);
-        return env;
-    }
-    if (r1 instanceof LiteralPattern && r2 instanceof LiteralPattern)
-        return r1.name.equals(r2.name) ? env : null;
-    if (r1 instanceof FunctorPattern && r2 instanceof FunctorPattern) {
-        if (r1.identifier.value !== r2.identifier.value)
-            return null;
-        if (r1.args.length !== r2.args.length)
-            return null;
-        for (let i = 0; i < r1.args.length; i++) {
-            if (!unify(r1.args[i], r2.args[i], env))
-                return null;
-        }
-        return env;
-    }
-    if (r1 instanceof ListPattern && r2 instanceof ListPattern) {
-        if (r1.elements.length !== r2.elements.length)
-            return null;
-        for (let i = 0; i < r1.elements.length; i++) {
-            if (!unify(r1.elements[i], r2.elements[i], env))
-                return null;
-        }
-        return env;
-    }
-    return null;
-}

package/dist/interpreter/components/ObjectRuntime.d.ts

@@ -1,33 +0,0 @@
-import { PrimitiveValue, RuntimeFunction, RuntimeObject, EnvStack } from "yukigo-ast";
-import { ExpressionEvaluator } from "../utils.js";
-import { InterpreterConfig } from "../index.js";
-export declare class ObjectRuntime {
-    /**
-     * Creates a new instance of an Object.
-     * Typically called by visitNew()
-     */
-    static instantiate(className: string, identifier: string, fieldDefinitions: Map<string, PrimitiveValue>, methodDefinitions: Map<string, RuntimeFunction>): RuntimeObject;
-    /**
-     * Handles Method Calls (Message Passing).
-     * Reuses FunctionRuntime to execute the method body.
-     */
-    static dispatch(receiver: PrimitiveValue, methodName: string, args: PrimitiveValue[], env: EnvStack, evaluatorFactory: (env: EnvStack) => ExpressionEvaluator): PrimitiveValue;
-    /**
-     * Handles calls to super() or super.method()
-     */
-    static dispatchSuper(currentEnv: EnvStack, methodName: string, args: PrimitiveValue[], evaluatorFactory: (env: EnvStack) => ExpressionEvaluator): PrimitiveValue;
-    private static createDispatchScope;
-    private static getResolutionChain;
-    private static expandClassHierarchy;
-    private static findMethodInChain;
-    /**
-     * Field Access (Get)
-     * e.g. self.myField
-     */
-    static getField(receiver: PrimitiveValue, fieldName: string): PrimitiveValue;
-    /**
-     * Field Mutation (Set)
-     * e.g. self.myField = 10
-     */
-    static setField(receiver: PrimitiveValue, fieldName: string, value: PrimitiveValue, config: InterpreterConfig): PrimitiveValue;
-}

package/dist/interpreter/components/ObjectRuntime.js

@@ -1,123 +0,0 @@
-import { isRuntimeObject, isRuntimeClass, } from "yukigo-ast";
-import { FunctionRuntime } from "./FunctionRuntime.js";
-import { lookup, pushEnv } from "../utils.js";
-import { InterpreterError } from "../errors.js";
-export class ObjectRuntime {
-    /**
-     * Creates a new instance of an Object.
-     * Typically called by visitNew()
-     */
-    static instantiate(className, identifier, fieldDefinitions, methodDefinitions) {
-        return {
-            type: "Object",
-            className,
-            identifier,
-            fields: new Map(fieldDefinitions),
-            methods: methodDefinitions,
-        };
-    }
-    /**
-     * Handles Method Calls (Message Passing).
-     * Reuses FunctionRuntime to execute the method body.
-     */
-    static dispatch(receiver, methodName, args, env, evaluatorFactory) {
-        if (!isRuntimeObject(receiver))
-            throw new Error(`${receiver} is not an object`);
-        const chain = this.getResolutionChain(receiver, env);
-        const match = this.findMethodInChain(chain, methodName);
-        if (!match)
-            throw new InterpreterError("MethodDispatch", `${receiver.className} does not understand '${methodName}'.`);
-        const objectScope = this.createDispatchScope(receiver, match, methodName);
-        return FunctionRuntime.apply(methodName, match.method.equations, args, pushEnv(env, objectScope), evaluatorFactory);
-    }
-    /**
-     * Handles calls to super() or super.method()
-     */
-    static dispatchSuper(currentEnv, methodName, args, evaluatorFactory) {
-        const self = lookup(currentEnv, "self");
-        const currentHolder = lookup(currentEnv, "__CONTEXT_CLASS__");
-        const currentMethodName = lookup(currentEnv, "__METHOD_NAME__");
-        const targetMethodName = methodName || currentMethodName;
-        if (!self || !currentHolder)
-            throw new InterpreterError("SuperError", "'super' used outside of a method context");
-        const chain = this.getResolutionChain(self, currentEnv);
-        const currentIndex = chain.findIndex((c) => c === currentHolder);
-        if (currentIndex === -1)
-            throw new Error("Fatal: Execution context not found in hierarchy chain");
-        const remainingChain = chain.slice(currentIndex + 1);
-        const match = this.findMethodInChain(remainingChain, methodName);
-        if (!match)
-            throw new InterpreterError("Super", `Super method '${methodName}' not found`);
-        const objectScope = this.createDispatchScope(self, match, targetMethodName);
-        return FunctionRuntime.apply(methodName, match.method.equations, args, pushEnv(currentEnv, objectScope), evaluatorFactory);
-    }
-    static createDispatchScope(self, match, targetName) {
-        const objectScope = new Map();
-        objectScope.set("self", self);
-        objectScope.set("__CONTEXT_CLASS__", match.holder);
-        objectScope.set("__METHOD_NAME__", targetName);
-        for (const [key, val] of self.fields)
-            objectScope.set(key, val);
-        return objectScope;
-    }
-    static getResolutionChain(receiver, env) {
-        const chain = [];
-        chain.push(receiver);
-        if (receiver.className) {
-            this.expandClassHierarchy(receiver.className, env, chain);
-        }
-        return chain;
-    }
-    static expandClassHierarchy(className, env, chain) {
-        const classDef = lookup(env, className);
-        if (!isRuntimeClass(classDef))
-            throw new InterpreterError("expandClassHierarchy", "classDef was expected to be a RuntimeClass");
-        chain.push(classDef);
-        const classDefCopy = [...classDef.mixins];
-        if (classDef.mixins)
-            classDefCopy.reverse().forEach((mixinName) => {
-                this.expandClassHierarchy(mixinName, env, chain);
-            });
-        if (classDef.superclass)
-            this.expandClassHierarchy(classDef.superclass, env, chain);
-    }
-    static findMethodInChain(chain, methodName) {
-        for (const link of chain) {
-            if (link.methods.has(methodName))
-                return {
-                    method: link.methods.get(methodName),
-                    holder: link,
-                };
-        }
-        return undefined;
-    }
-    /**
-     * Field Access (Get)
-     * e.g. self.myField
-     */
-    static getField(receiver, fieldName) {
-        if (!isRuntimeObject(receiver))
-            throw new InterpreterError("FieldAccess", "Target is not an object");
-        if (!receiver.fields.has(fieldName)) {
-            if (receiver.methods.has(fieldName))
-                return receiver.methods.get(fieldName);
-            throw new InterpreterError("FieldAccess", `Field '${fieldName}' not found in ${receiver.className}`);
-        }
-        return receiver.fields.get(fieldName);
-    }
-    /**
-     * Field Mutation (Set)
-     * e.g. self.myField = 10
-     */
-    static setField(receiver, fieldName, value, config) {
-        if (!config.mutability) {
-            throw new InterpreterError("FieldAssignment", `Cannot mutate field '${fieldName}': mutability is disabled`);
-        }
-        if (!isRuntimeObject(receiver))
-            throw new InterpreterError("FieldAssignment", "Target is not an object");
-        if (!receiver.fields.has(fieldName))
-            throw new InterpreterError("FieldAssignment", `Cannot set unknown field '${fieldName}'`);
-        receiver.fields.set(fieldName, value);
-        return value;
-    }
-}