@polintpro/proposit-core 0.8.6 → 0.8.8

package/dist/lib/core/argument-engine.js

@@ -1,13 +1,10 @@
-import { Value } from "typebox/value";
-import { CoreArgumentSchema, isClaimBound, isPremiseBound, } from "../schemata/index.js";
+import { isClaimBound, isPremiseBound, } from "../schemata/index.js";
 import { DEFAULT_GRAMMAR_CONFIG, PERMISSIVE_GRAMMAR_CONFIG, } from "../types/grammar.js";
-import { ARG_SCHEMA_INVALID, ARG_OWNERSHIP_MISMATCH, ARG_CLAIM_REF_NOT_FOUND, ARG_PREMISE_REF_NOT_FOUND, ARG_CIRCULARITY_DETECTED, ARG_CONCLUSION_NOT_FOUND, ARG_CHECKSUM_MISMATCH, } from "../types/validation.js";
 import { DEFAULT_CHECKSUM_CONFIG, normalizeChecksumConfig, serializeChecksumConfig, } from "../consts.js";
-import { getOrCreate, sortedUnique } from "../utils/collections.js";
 import { ChangeCollector } from "./change-collector.js";
 import { canonicalSerialize, computeHash, entityChecksum } from "./checksum.js";
-import { kleeneAnd, kleeneNot, kleeneOr, kleeneImplies, kleeneIff, } from "./evaluation/kleene.js";
-import { makeErrorIssue, makeValidationResult, } from "./evaluation/validation.js";
+import { evaluateArgument as evaluateArgumentStandalone, checkArgumentValidity as checkArgumentValidityStandalone, } from "./evaluation/argument-evaluation.js";
+import { validateArgument as validateArgumentStandalone, validateArgumentAfterPremiseMutation as validateAfterPremiseMutationStandalone, validateArgumentEvaluability as validateArgumentEvaluabilityStandalone, collectArgumentReferencedVariables as collectArgumentReferencedVariablesStandalone, } from "./argument-validation.js";
 import { InvariantViolationError } from "./invariant-violation-error.js";
 import { PremiseEngine } from "./premise-engine.js";
 import { VariableManager } from "./variable-manager.js";
@@ -1181,833 +1178,63 @@ export class ArgumentEngine {
         };
     }
     collectReferencedVariables() {
-        const byIdTmp = new Map();
-        const bySymbolTmp = new Map();
-        for (const premise of this.listPremises()) {
-            const premiseId = premise.getId();
-            const varsById = new Map(premise.getVariables().map((v) => [v.id, v]));
-            for (const expr of premise.getExpressions()) {
-                if (expr.type !== "variable")
-                    continue;
-                const variable = varsById.get(expr.variableId);
-                if (!variable)
-                    continue;
-                const byIdEntry = getOrCreate(byIdTmp, variable.id, () => ({
-                    symbols: new Set(),
-                    premiseIds: new Set(),
-                }));
-                byIdEntry.symbols.add(variable.symbol);
-                byIdEntry.premiseIds.add(premiseId);
-                const bySymbolEntry = getOrCreate(bySymbolTmp, variable.symbol, () => ({
-                    variableIds: new Set(),
-                    premiseIds: new Set(),
-                }));
-                bySymbolEntry.variableIds.add(variable.id);
-                bySymbolEntry.premiseIds.add(premiseId);
-            }
-        }
-        const byId = {};
-        for (const [variableId, entry] of Array.from(byIdTmp.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
-            byId[variableId] = {
-                symbol: sortedUnique(entry.symbols)[0] ?? "",
-                premiseIds: sortedUnique(entry.premiseIds),
-            };
-        }
-        const bySymbol = {};
-        for (const [symbol, entry] of Array.from(bySymbolTmp.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
-            bySymbol[symbol] = {
-                variableIds: sortedUnique(entry.variableIds),
-                premiseIds: sortedUnique(entry.premiseIds),
-            };
-        }
-        return {
-            variableIds: sortedUnique(byIdTmp.keys()),
-            byId,
-            bySymbol,
-        };
+        return collectArgumentReferencedVariablesStandalone(this.asValidationContext());
     }
-    /**
-     * Validates after a PremiseEngine mutation. Identical to `validate()` but
-     * clears cached argument-level checksums first so the checksum-stability
-     * check is skipped (checksums are known to be dirty after a premise
-     * mutation).
-     */
-    /**
-     * Lightweight validation triggered after a PremiseEngine mutation.
-     * Skips per-premise deep validation (which is O(n) over all premises)
-     * and argument-level checksum stability checks (checksums are known to
-     * be dirty). Only checks argument-level cross-references that a
-     * PremiseEngine mutation could affect.
-     */
     validateAfterPremiseMutation() {
-        const violations = [];
-        // Variable references: ensure all variable expressions in the
-        // mutated premise still reference known variables (this is the main
-        // cross-cutting invariant a premise mutation can break).
-        for (const v of this.variables.toArray()) {
-            const base = v;
-            if (isPremiseBound(base)) {
-                const pb = base;
-                if (pb.boundArgumentId === this.argument.id) {
-                    if (!this.premises.has(pb.boundPremiseId)) {
-                        violations.push({
-                            code: ARG_PREMISE_REF_NOT_FOUND,
-                            message: `Premise-bound variable "${pb.id}" references non-existent premise "${pb.boundPremiseId}".`,
-                            entityType: "variable",
-                            entityId: pb.id,
-                        });
-                    }
-                }
-            }
-        }
-        // Conclusion premise reference
-        if (this.conclusionPremiseId !== undefined &&
-            !this.premises.has(this.conclusionPremiseId)) {
-            violations.push({
-                code: ARG_CONCLUSION_NOT_FOUND,
-                message: `Conclusion premise "${this.conclusionPremiseId}" does not exist in this argument.`,
-                entityType: "argument",
-                entityId: this.argument.id,
-            });
-        }
-        return {
-            ok: violations.length === 0,
-            violations,
-        };
+        return validateAfterPremiseMutationStandalone(this.asValidationContext());
     }
     validate() {
-        const violations = [];
-        // 1. Schema check — flush checksums first so fields are populated
-        const savedMeta = this.cachedMetaChecksum;
-        const savedDescendant = this.cachedDescendantChecksum;
-        const savedCombined = this.cachedCombinedChecksum;
-        this.flushChecksums();
-        const arg = this.getArgument();
-        if (!Value.Check(CoreArgumentSchema, arg)) {
-            violations.push({
-                code: ARG_SCHEMA_INVALID,
-                message: `Argument "${arg.id}" does not conform to CoreArgumentSchema.`,
-                entityType: "argument",
-                entityId: arg.id,
-            });
-        }
-        // 2. Delegate to VariableManager.validate()
-        const varResult = this.variables.validate();
-        violations.push(...varResult.violations);
-        // 3. Delegate to each PremiseEngine.validate()
-        for (const pe of this.listPremises()) {
-            const premiseResult = pe.validate();
-            violations.push(...premiseResult.violations);
-        }
-        // 4. Variable ownership: all variables must belong to this argument
-        for (const v of this.variables.toArray()) {
-            const base = v;
-            if (base.argumentId !== this.argument.id ||
-                base.argumentVersion !== this.argument.version) {
-                violations.push({
-                    code: ARG_OWNERSHIP_MISMATCH,
-                    message: `Variable "${base.id}" has argumentId/version "${base.argumentId}/${base.argumentVersion}" but engine is "${this.argument.id}/${this.argument.version}".`,
-                    entityType: "variable",
-                    entityId: base.id,
-                });
-            }
-        }
-        // 5. Claim-bound variable references
-        for (const v of this.variables.toArray()) {
-            const base = v;
-            if (isClaimBound(base)) {
-                const cb = base;
-                if (!this.claimLibrary.get(cb.claimId, cb.claimVersion)) {
-                    violations.push({
-                        code: ARG_CLAIM_REF_NOT_FOUND,
-                        message: `Variable "${cb.id}" references claim "${cb.claimId}" version ${cb.claimVersion} which does not exist in the claim library.`,
-                        entityType: "variable",
-                        entityId: cb.id,
-                    });
-                }
-            }
-        }
-        // 6. Premise-bound internal variable references
-        for (const v of this.variables.toArray()) {
-            const base = v;
-            if (isPremiseBound(base)) {
-                const pb = base;
-                if (pb.boundArgumentId === this.argument.id) {
-                    if (!this.premises.has(pb.boundPremiseId)) {
-                        violations.push({
-                            code: ARG_PREMISE_REF_NOT_FOUND,
-                            message: `Premise-bound variable "${pb.id}" references non-existent premise "${pb.boundPremiseId}".`,
-                            entityType: "variable",
-                            entityId: pb.id,
-                        });
-                    }
-                }
-            }
-        }
-        // 7. Circularity detection for internal premise-bound variables.
-        //    A cycle exists when a premise-bound variable's bound premise
-        //    transitively references back to itself through other
-        //    premise-bound variables.
-        for (const v of this.variables.toArray()) {
-            const base = v;
-            if (isPremiseBound(base)) {
-                const pb = base;
-                if (pb.boundArgumentId === this.argument.id) {
-                    // Trace from the bound premise through expressions'
-                    // variable references to see if we reach back to the
-                    // same premise.
-                    const boundPremise = this.premises.get(pb.boundPremiseId);
-                    if (boundPremise) {
-                        let hasCycle = false;
-                        for (const expr of boundPremise.getExpressions()) {
-                            if (expr.type === "variable") {
-                                try {
-                                    if (this.wouldCreateCycle(expr.variableId, pb.boundPremiseId, new Set())) {
-                                        hasCycle = true;
-                                        break;
-                                    }
-                                }
-                                catch {
-                                    hasCycle = true;
-                                    break;
-                                }
-                            }
-                        }
-                        if (hasCycle) {
-                            violations.push({
-                                code: ARG_CIRCULARITY_DETECTED,
-                                message: `Premise-bound variable "${pb.id}" creates a circular dependency through premise "${pb.boundPremiseId}".`,
-                                entityType: "variable",
-                                entityId: pb.id,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        // 8. Conclusion premise reference
-        if (this.conclusionPremiseId !== undefined &&
-            !this.premises.has(this.conclusionPremiseId)) {
-            violations.push({
-                code: ARG_CONCLUSION_NOT_FOUND,
-                message: `Conclusion premise "${this.conclusionPremiseId}" does not exist in this argument.`,
-                entityType: "argument",
-                entityId: this.argument.id,
-            });
-        }
-        // 9. Argument-level checksum verification
-        if (savedMeta !== undefined && savedMeta !== this.cachedMetaChecksum) {
-            violations.push({
-                code: ARG_CHECKSUM_MISMATCH,
-                message: `Argument "${this.argument.id}" meta checksum changed after flush: "${savedMeta}" → "${this.cachedMetaChecksum}".`,
-                entityType: "argument",
-                entityId: this.argument.id,
-            });
-        }
-        if (savedDescendant !== undefined &&
-            savedDescendant !== this.cachedDescendantChecksum) {
-            violations.push({
-                code: ARG_CHECKSUM_MISMATCH,
-                message: `Argument "${this.argument.id}" descendant checksum changed after flush: "${String(savedDescendant)}" → "${String(this.cachedDescendantChecksum)}".`,
-                entityType: "argument",
-                entityId: this.argument.id,
-            });
-        }
-        if (savedCombined !== undefined &&
-            savedCombined !== this.cachedCombinedChecksum) {
-            violations.push({
-                code: ARG_CHECKSUM_MISMATCH,
-                message: `Argument "${this.argument.id}" combined checksum changed after flush: "${savedCombined}" → "${this.cachedCombinedChecksum}".`,
-                entityType: "argument",
-                entityId: this.argument.id,
-            });
-        }
-        return {
-            ok: violations.length === 0,
-            violations,
-        };
+        return validateArgumentStandalone(this.asValidationContext());
     }
     validateEvaluability() {
-        const issues = [];
-        if (this.conclusionPremiseId === undefined) {
-            issues.push(makeErrorIssue({
-                code: "ARGUMENT_NO_CONCLUSION",
-                message: "Argument has no designated conclusion premise.",
-            }));
-        }
-        else if (!this.premises.has(this.conclusionPremiseId)) {
-            issues.push(makeErrorIssue({
-                code: "ARGUMENT_CONCLUSION_NOT_FOUND",
-                message: `Conclusion premise "${this.conclusionPremiseId}" does not exist.`,
-                premiseId: this.conclusionPremiseId,
-            }));
-        }
-        const idToSymbols = new Map();
-        const symbolToIds = new Map();
-        for (const premise of this.listPremises()) {
-            const varById = new Map(premise.getVariables().map((v) => [v.id, v]));
-            for (const expr of premise.getExpressions()) {
-                if (expr.type !== "variable")
-                    continue;
-                const variable = varById.get(expr.variableId);
-                if (!variable)
-                    continue;
-                getOrCreate(idToSymbols, variable.id, () => new Set()).add(variable.symbol);
-                getOrCreate(symbolToIds, variable.symbol, () => new Set()).add(variable.id);
-            }
-        }
-        for (const [variableId, symbols] of idToSymbols) {
-            if (symbols.size > 1) {
-                issues.push(makeErrorIssue({
-                    code: "ARGUMENT_VARIABLE_ID_SYMBOL_MISMATCH",
-                    message: `Variable ID "${variableId}" is used with multiple symbols: ${sortedUnique(symbols).join(", ")}.`,
-                    variableId,
-                }));
-            }
-        }
-        for (const [symbol, ids] of symbolToIds) {
-            if (ids.size > 1) {
-                issues.push(makeErrorIssue({
-                    code: "ARGUMENT_VARIABLE_SYMBOL_AMBIGUOUS",
-                    message: `Variable symbol "${symbol}" is used with multiple IDs: ${sortedUnique(ids).join(", ")}.`,
-                }));
-            }
-        }
-        for (const premise of this.listPremises()) {
-            const premiseValidation = premise.validateEvaluability();
-            issues.push(...premiseValidation.issues);
-        }
-        return makeValidationResult(issues);
-    }
-    /**
-     * Run fixed-point constraint propagation over accepted operators.
-     * Fills unknown (null) variable values based on operator semantics.
-     * Never overwrites user-assigned values (true/false).
-     */
-    propagateOperatorConstraints(assignment) {
-        const vars = { ...assignment.variables };
-        const opAssignments = assignment.operatorAssignments;
-        // Collect all expressions across all premises, indexed by id
-        const exprById = new Map();
-        // Children lookup: parentId -> sorted children
-        const childrenOf = new Map();
-        for (const pm of this.listPremises()) {
-            for (const expr of pm.getExpressions()) {
-                exprById.set(expr.id, expr);
-            }
-            // Build children map using getChildExpressions for each operator/formula
-            for (const expr of pm.getExpressions()) {
-                if (expr.type === "operator" || expr.type === "formula") {
-                    childrenOf.set(expr.id, pm.getChildExpressions(expr.id));
-                }
-            }
-        }
-        /**
-         * Resolve the current Kleene value of an expression subtree
-         * given the current variable assignments. Does not force-accept
-         * nested operators — evaluates them normally via Kleene logic.
-         */
-        const resolveValue = (exprId) => {
-            const expr = exprById.get(exprId);
-            if (!expr)
-                return null;
-            if (expr.type === "variable") {
-                return (vars[expr
-                    .variableId] ?? null);
-            }
-            if (expr.type === "formula") {
-                const children = childrenOf.get(expr.id) ?? [];
-                return children.length > 0 ? resolveValue(children[0].id) : null;
-            }
-            // operator
-            const op = expr
-                .operator;
-            const children = childrenOf.get(expr.id) ?? [];
-            switch (op) {
-                case "not":
-                    return kleeneNot(resolveValue(children[0].id));
-                case "and":
-                    return children.reduce((acc, child) => kleeneAnd(acc, resolveValue(child.id)), true);
-                case "or":
-                    return children.reduce((acc, child) => kleeneOr(acc, resolveValue(child.id)), false);
-                case "implies": {
-                    return kleeneImplies(resolveValue(children[0].id), resolveValue(children[1].id));
-                }
-                case "iff": {
-                    return kleeneIff(resolveValue(children[0].id), resolveValue(children[1].id));
-                }
-            }
-        };
-        /**
-         * Unwrap formula wrappers to find the leaf variable expression.
-         * Returns the variableId if the leaf is a variable, otherwise null.
-         */
-        const resolveLeafVariableId = (expr) => {
-            if (expr.type === "variable") {
-                return expr.variableId;
-            }
-            if (expr.type === "formula") {
-                const children = childrenOf.get(expr.id) ?? [];
-                if (children.length > 0) {
-                    return resolveLeafVariableId(children[0]);
-                }
-            }
-            return null;
-        };
-        // Track which variable IDs were explicitly set by the user
-        // (true or false). These are never overwritten by propagation.
-        const userAssigned = new Set();
-        for (const [varId, val] of Object.entries(vars)) {
-            if (val !== null && val !== undefined)
-                userAssigned.add(varId);
-        }
-        /**
-         * Try to set a child expression's variable to a value.
-         * Never overwrites user-assigned values.
-         * False overrides propagated true (rejection wins).
-         * Returns true if a value changed.
-         */
-        const trySetChild = (child, value) => {
-            const varId = resolveLeafVariableId(child);
-            if (varId == null || userAssigned.has(varId))
-                return false;
-            const current = vars[varId] ?? null;
-            if (current === null) {
-                vars[varId] = value;
-                return true;
-            }
-            // False overrides propagated true
-            if (value === false && current === true) {
-                vars[varId] = false;
-                return true;
-            }
-            return false;
-        };
-        // Two-phase propagation: rejections first (to establish false values),
-        // then acceptances (which only fill remaining unknowns).
-        // This prevents acceptance from deriving values through chains that
-        // are later invalidated by rejection.
-        for (const phase of ["rejected", "accepted"]) {
-            let changed = true;
-            while (changed) {
-                changed = false;
-                for (const [exprId, expr] of exprById) {
-                    if (expr.type !== "operator")
-                        continue;
-                    const state = opAssignments[exprId];
-                    if (state !== phase)
-                        continue;
-                    const op = expr.operator;
-                    const children = childrenOf.get(exprId) ?? [];
-                    if (state === "accepted") {
-                        switch (op) {
-                            case "not": {
-                                // ¬A accepted (= true) => child must be false
-                                if (children.length > 0) {
-                                    if (trySetChild(children[0], false))
-                                        changed = true;
-                                }
-                                break;
-                            }
-                            case "and": {
-                                // A ∧ B accepted => all children must be true
-                                for (const child of children) {
-                                    if (trySetChild(child, true))
-                                        changed = true;
-                                }
-                                break;
-                            }
-                            case "or": {
-                                // A ∨ B accepted: if all-but-one are false, remaining must be true
-                                const unknownChildren = [];
-                                let allOthersAreFalse = true;
-                                for (const child of children) {
-                                    const childValue = resolveValue(child.id);
-                                    if (childValue === null) {
-                                        unknownChildren.push(child);
-                                    }
-                                    else if (childValue !== false) {
-                                        allOthersAreFalse = false;
-                                    }
-                                }
-                                if (unknownChildren.length === 1 &&
-                                    allOthersAreFalse) {
-                                    if (trySetChild(unknownChildren[0], true))
-                                        changed = true;
-                                }
-                                break;
-                            }
-                            case "implies": {
-                                // A → B accepted: if A=true => B=true; if B=false => A=false
-                                if (children.length >= 2) {
-                                    const leftValue = resolveValue(children[0].id);
-                                    const rightValue = resolveValue(children[1].id);
-                                    if (leftValue === true) {
-                                        if (trySetChild(children[1], true))
-                                            changed = true;
-                                    }
-                                    if (rightValue === false) {
-                                        if (trySetChild(children[0], false))
-                                            changed = true;
-                                    }
-                                }
-                                break;
-                            }
-                            case "iff": {
-                                // A ↔ B accepted: if A known => B matches; if B known => A matches
-                                if (children.length >= 2) {
-                                    const leftValue = resolveValue(children[0].id);
-                                    const rightValue = resolveValue(children[1].id);
-                                    if (leftValue !== null) {
-                                        if (trySetChild(children[1], leftValue))
-                                            changed = true;
-                                    }
-                                    if (rightValue !== null) {
-                                        if (trySetChild(children[0], rightValue))
-                                            changed = true;
-                                    }
-                                }
-                                break;
-                            }
-                        }
-                    }
-                    else {
-                        // state === "rejected" — expression forced false
-                        switch (op) {
-                            case "not": {
-                                // ¬A rejected (= false) => child must be true
-                                if (children.length > 0) {
-                                    if (trySetChild(children[0], true))
-                                        changed = true;
-                                }
-                                break;
-                            }
-                            case "and": {
-                                // A ∧ B rejected (= false): if all-but-one are true, remaining must be false
-                                const unknownChildren = [];
-                                let allOthersAreTrue = true;
-                                for (const child of children) {
-                                    const childValue = resolveValue(child.id);
-                                    if (childValue === null) {
-                                        unknownChildren.push(child);
-                                    }
-                                    else if (childValue !== true) {
-                                        allOthersAreTrue = false;
-                                    }
-                                }
-                                if (unknownChildren.length === 1 &&
-                                    allOthersAreTrue) {
-                                    if (trySetChild(unknownChildren[0], false))
-                                        changed = true;
-                                }
-                                break;
-                            }
-                            case "or": {
-                                // A ∨ B rejected (= false) => all children must be false
-                                for (const child of children) {
-                                    if (trySetChild(child, false))
-                                        changed = true;
-                                }
-                                break;
-                            }
-                            case "implies": {
-                                // A → B rejected (= false) => A must be true, B must be false
-                                if (children.length >= 2) {
-                                    if (trySetChild(children[0], true))
-                                        changed = true;
-                                    if (trySetChild(children[1], false))
-                                        changed = true;
-                                }
-                                break;
-                            }
-                            case "iff": {
-                                // A ↔ B rejected (= false): if A known => B is opposite; if B known => A is opposite
-                                if (children.length >= 2) {
-                                    const leftValue = resolveValue(children[0].id);
-                                    const rightValue = resolveValue(children[1].id);
-                                    if (leftValue !== null) {
-                                        if (trySetChild(children[1], !leftValue))
-                                            changed = true;
-                                    }
-                                    if (rightValue !== null) {
-                                        if (trySetChild(children[0], !rightValue))
-                                            changed = true;
-                                    }
-                                }
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return vars;
+        return validateArgumentEvaluabilityStandalone(this.asValidationContext());
     }
-    evaluate(assignment, options) {
-        const validateFirst = options?.validateFirst ?? true;
-        if (validateFirst) {
-            const validation = this.validateEvaluability();
-            if (!validation.ok) {
+    asValidationContext() {
+        return {
+            argumentId: this.argument.id,
+            argumentVersion: this.argument.version,
+            conclusionPremiseId: this.conclusionPremiseId,
+            getArgument: () => this.getArgument(),
+            getVariables: () => this.variables.toArray(),
+            listPremises: () => this.listPremises(),
+            hasPremise: (premiseId) => this.premises.has(premiseId),
+            lookupClaim: (claimId, claimVersion) => this.claimLibrary.get(claimId, claimVersion),
+            flushAndGetChecksumDeltas: () => {
+                const savedMeta = this.cachedMetaChecksum;
+                const savedDescendant = this.cachedDescendantChecksum;
+                const savedCombined = this.cachedCombinedChecksum;
+                this.flushChecksums();
                 return {
-                    ok: false,
-                    validation,
+                    savedMeta,
+                    savedDescendant,
+                    savedCombined,
+                    currentMeta: this.cachedMetaChecksum,
+                    currentDescendant: this.cachedDescendantChecksum,
+                    currentCombined: this.cachedCombinedChecksum,
                 };
-            }
-        }
-        const conclusion = this.getConclusionPremise();
-        if (!conclusion) {
-            return {
-                ok: false,
-                validation: makeValidationResult([
-                    makeErrorIssue({
-                        code: "ARGUMENT_NO_CONCLUSION",
-                        message: "Argument has no designated conclusion premise.",
-                    }),
-                ]),
-            };
-        }
-        const supportingPremises = this.listSupportingPremises();
-        const supportingIds = new Set(supportingPremises.map((pm) => pm.getId()));
-        const constraintPremises = this.listPremises().filter((pm) => pm.getId() !== this.conclusionPremiseId &&
-            !supportingIds.has(pm.getId()));
-        const allRelevantPremises = [
-            conclusion,
-            ...supportingPremises,
-            ...constraintPremises,
-        ];
-        const allVariableIds = [
-            ...new Set(allRelevantPremises.flatMap((pm) => pm
-                .getExpressions()
-                .filter((expr) => expr.type === "variable")
-                .map((expr) => expr.variableId))),
-        ].sort();
-        // Claim-bound and externally-bound premise variables get truth-table columns;
-        // internally-bound premise variables are resolved lazily.
-        const referencedVariableIds = allVariableIds.filter((vid) => {
-            const v = this.variables.getVariable(vid);
-            if (v == null)
-                return false;
-            if (isClaimBound(v))
-                return true;
-            if (isPremiseBound(v) && v.boundArgumentId !== this.argument.id)
-                return true;
-            return false;
-        });
-        // Run operator constraint propagation
-        const propagatedVars = this.propagateOperatorConstraints(assignment);
-        const propagatedAssignment = {
-            variables: propagatedVars,
-            operatorAssignments: assignment.operatorAssignments,
+            },
+            validateVariables: () => this.variables.validate(),
+            wouldCreateCycle: (variableId, premiseId, visited) => this.wouldCreateCycle(variableId, premiseId, visited),
         };
-        try {
-            // Build a resolver that lazily evaluates premise-bound variables
-            // by evaluating their bound premise's expression tree under the
-            // same assignment. Results are cached per-variable per-evaluate call.
-            const resolverCache = new Map();
-            const resolver = (variableId) => {
-                if (resolverCache.has(variableId)) {
-                    return resolverCache.get(variableId);
-                }
-                const variable = this.variables.getVariable(variableId);
-                if (!variable ||
-                    !isPremiseBound(variable) ||
-                    variable.boundArgumentId !== this.argument.id) {
-                    // Claim-bound or externally-bound: read from assignment
-                    return propagatedAssignment.variables[variableId] ?? null;
-                }
-                // Internal premise-bound: lazy resolution
-                const boundPremiseId = variable.boundPremiseId;
-                const boundPremise = this.premises.get(boundPremiseId);
-                if (!boundPremise) {
-                    resolverCache.set(variableId, null);
-                    return null;
-                }
-                const premiseResult = boundPremise.evaluate(propagatedAssignment, {
-                    resolver,
-                });
-                const value = premiseResult?.rootValue ?? null;
-                resolverCache.set(variableId, value);
-                return value;
-            };
-            const evalOpts = {
-                strictUnknownKeys: options?.strictUnknownAssignmentKeys ?? false,
-                resolver,
-            };
-            const conclusionEvaluation = conclusion.evaluate(propagatedAssignment, evalOpts);
-            const supportingEvaluations = supportingPremises.map((pm) => pm.evaluate(propagatedAssignment, evalOpts));
-            const constraintEvaluations = constraintPremises.map((pm) => pm.evaluate(propagatedAssignment, evalOpts));
-            const isAdmissibleAssignment = constraintEvaluations.reduce((acc, result) => kleeneAnd(acc, result.rootValue ?? null), true);
-            const allSupportingPremisesTrue = supportingEvaluations.reduce((acc, result) => kleeneAnd(acc, result.rootValue ?? null), true);
-            const conclusionTrue = conclusionEvaluation.rootValue ?? null;
-            const isCounterexample = kleeneAnd(isAdmissibleAssignment, kleeneAnd(allSupportingPremisesTrue, kleeneNot(conclusionTrue)));
-            const includeExpressionValues = options?.includeExpressionValues ?? true;
-            const includeDiagnostics = options?.includeDiagnostics ?? true;
-            const strip = (result) => ({
-                ...result,
-                expressionValues: includeExpressionValues
-                    ? result.expressionValues
-                    : {},
-                inferenceDiagnostic: includeDiagnostics
-                    ? result.inferenceDiagnostic
-                    : undefined,
-            });
-            return {
-                ok: true,
-                assignment: {
-                    variables: { ...propagatedAssignment.variables },
-                    operatorAssignments: {
-                        ...propagatedAssignment.operatorAssignments,
-                    },
-                },
-                referencedVariableIds,
-                conclusion: strip(conclusionEvaluation),
-                supportingPremises: supportingEvaluations.map(strip),
-                constraintPremises: constraintEvaluations.map(strip),
-                isAdmissibleAssignment,
-                allSupportingPremisesTrue,
-                conclusionTrue,
-                isCounterexample,
-                preservesTruthUnderAssignment: kleeneNot(isCounterexample),
-            };
-        }
-        catch (error) {
-            return {
-                ok: false,
-                validation: makeValidationResult([
-                    makeErrorIssue({
-                        code: "ASSIGNMENT_MISSING_VARIABLE",
-                        message: error instanceof Error
-                            ? error.message
-                            : "Argument evaluation failed.",
-                    }),
-                ]),
-            };
-        }
     }
-    checkValidity(options) {
-        const validateFirst = options?.validateFirst ?? true;
-        if (validateFirst) {
-            const validation = this.validateEvaluability();
-            if (!validation.ok) {
-                return {
-                    ok: false,
-                    validation,
-                };
-            }
-        }
-        const conclusion = this.getConclusionPremise();
-        if (!conclusion) {
-            return {
-                ok: false,
-                validation: makeValidationResult([
-                    makeErrorIssue({
-                        code: "ARGUMENT_NO_CONCLUSION",
-                        message: "Argument has no designated conclusion premise.",
-                    }),
-                ]),
-            };
-        }
-        const supportingPremises = this.listSupportingPremises();
-        const supportingIds = new Set(supportingPremises.map((pm) => pm.getId()));
-        const constraintPremises = this.listPremises().filter((pm) => pm.getId() !== this.conclusionPremiseId &&
-            !supportingIds.has(pm.getId()));
-        const allVariableIdsForCheck = [
-            ...new Set([
-                conclusion,
-                ...supportingPremises,
-                ...constraintPremises,
-            ].flatMap((pm) => pm
-                .getExpressions()
-                .filter((expr) => expr.type === "variable")
-                .map((expr) => expr.variableId))),
-        ].sort();
-        // Claim-bound and externally-bound premise variables get truth-table columns;
-        // internally-bound premise variables are resolved lazily.
-        const checkedVariableIds = allVariableIdsForCheck.filter((vid) => {
-            const v = this.variables.getVariable(vid);
-            if (v == null)
-                return false;
-            if (isClaimBound(v))
-                return true;
-            if (isPremiseBound(v) && v.boundArgumentId !== this.argument.id)
-                return true;
-            return false;
-        });
-        if (options?.maxVariables !== undefined &&
-            checkedVariableIds.length > options.maxVariables) {
-            return {
-                ok: false,
-                validation: makeValidationResult([
-                    makeErrorIssue({
-                        code: "ASSIGNMENT_UNKNOWN_VARIABLE",
-                        message: `Validity check requires ${checkedVariableIds.length} variables, exceeding limit ${options.maxVariables}.`,
-                    }),
-                ]),
-            };
-        }
-        const mode = options?.mode ?? "firstCounterexample";
-        const maxAssignmentsChecked = options?.maxAssignmentsChecked;
-        const counterexamples = [];
-        let numAssignmentsChecked = 0;
-        let numAdmissibleAssignments = 0;
-        let truncated = false;
-        const totalAssignments = 2 ** checkedVariableIds.length;
-        for (let mask = 0; mask < totalAssignments; mask++) {
-            if (maxAssignmentsChecked !== undefined &&
-                numAssignmentsChecked >= maxAssignmentsChecked) {
-                truncated = true;
-                break;
-            }
-            const assignment = {
-                variables: {},
-                operatorAssignments: {},
-            };
-            for (let i = 0; i < checkedVariableIds.length; i++) {
-                assignment.variables[checkedVariableIds[i]] = Boolean(mask & (1 << i));
-            }
-            const result = this.evaluate(assignment, {
-                validateFirst: false,
-                includeExpressionValues: options?.includeCounterexampleEvaluations ?? false,
-                includeDiagnostics: options?.includeCounterexampleEvaluations ?? false,
-            });
-            if (!result.ok) {
-                return {
-                    ok: false,
-                    validation: result.validation,
-                };
-            }
-            numAssignmentsChecked += 1;
-            if (result.isAdmissibleAssignment === true) {
-                numAdmissibleAssignments += 1;
-            }
-            if (result.isCounterexample === true) {
-                counterexamples.push({
-                    assignment: result.assignment,
-                    result,
-                });
-                if (mode === "firstCounterexample") {
-                    break;
-                }
-            }
-        }
-        const foundCounterexample = counterexamples.length > 0;
-        const fullyChecked = !truncated &&
-            (mode === "exhaustive" ||
-                (mode === "firstCounterexample" && !foundCounterexample));
+    asEvaluationContext() {
         return {
-            ok: true,
-            isValid: foundCounterexample
-                ? false
-                : fullyChecked
-                    ? true
-                    : undefined,
-            checkedVariableIds,
-            numAssignmentsChecked,
-            numAdmissibleAssignments,
-            counterexamples,
-            truncated,
+            argumentId: this.argument.id,
+            conclusionPremiseId: this.conclusionPremiseId,
+            getConclusionPremise: () => this.getConclusionPremise(),
+            listSupportingPremises: () => this.listSupportingPremises(),
+            listPremises: () => this.listPremises(),
+            getVariable: (id) => this.variables.getVariable(id),
+            getPremise: (id) => this.premises.get(id),
+            validateEvaluability: () => this.validateEvaluability(),
         };
     }
+    evaluate(assignment, options) {
+        return evaluateArgumentStandalone(this.asEvaluationContext(), assignment, options);
+    }
+    checkValidity(options) {
+        return checkArgumentValidityStandalone(this.asEvaluationContext(), options);
+    }
     // -----------------------------------------------------------------
     // Forking
     // -----------------------------------------------------------------