@cavelang/solver 0.35.0 → 0.36.0

package/dist/src/validate.js

@@ -1,6 +1,57 @@
+import { diagnosticText } from "./diagnostic-text.js";
 import { defaultLimits } from "./adapter.js";
 import * as Exact from "./exact.js";
+import { numericDigits } from "./numeric-size.js";
 import { schema } from "./model.js";
+export { validateContext as explanationContext } from "./context.js";
+/** Validate a portable unknown-outcome reason without changing its contents. */
+export const unknownReason = (value) => {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError('unknown solver reason must be an object');
+    }
+    const { kind, message, limit } = value;
+    if (typeof kind !== 'string' || !['timeout', 'resource-limit', 'cancelled', 'backend-error', 'indeterminate'].includes(kind)) {
+        throw new TypeError('unknown solver reason kind must be timeout, resource-limit, cancelled, backend-error or indeterminate');
+    }
+    if (typeof message !== 'string')
+        throw new TypeError('unknown solver reason message must be a string');
+    if (limit !== undefined && (typeof limit !== 'string' || !Object.hasOwn(defaultLimits, limit))) {
+        throw new TypeError('unknown solver reason limit must name a supported solver limit');
+    }
+};
+/** Validate metadata shared by adapter results and explanation runs. */
+export const resultMetadata = (value) => {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TypeError('solver result metadata must be an object');
+    }
+    const { backend, elapsedMs, diagnostics } = value;
+    if (backend === null || typeof backend !== 'object' || Array.isArray(backend)) {
+        throw new TypeError('solver backend must be an object');
+    }
+    const { name, version } = backend;
+    if (typeof name !== 'string' || name === '')
+        throw new TypeError('solver backend name must be a non-empty string');
+    if (typeof version !== 'string' || version === '')
+        throw new TypeError('solver backend version must be a non-empty string');
+    if (typeof elapsedMs !== 'number' || !Number.isFinite(elapsedMs) || elapsedMs < 0) {
+        throw new TypeError('solver elapsedMs must be a finite non-negative number');
+    }
+    if (!Array.isArray(diagnostics))
+        throw new TypeError('solver diagnostics must be an array');
+    for (let index = 0; index < diagnostics.length; index++) {
+        const entry = diagnostics[index];
+        if (!Object.hasOwn(diagnostics, index) || entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new TypeError(`solver diagnostics[${index}] must be an object`);
+        }
+        const { level, code, message } = entry;
+        if (level !== 'info' && level !== 'warning' && level !== 'error') {
+            throw new TypeError(`solver diagnostics[${index}].level must be info, warning or error`);
+        }
+        if (typeof code !== 'string' || typeof message !== 'string') {
+            throw new TypeError(`solver diagnostics[${index}] code and message must be strings`);
+        }
+    }
+};
 export class ModelValidationError extends Error {
     problems;
     constructor(problems) {
@@ -25,7 +76,8 @@ const idPattern = /^[A-Za-z][A-Za-z0-9._:/-]*$/;
 const numeric = (sort) => sort.kind === 'int' || sort.kind === 'real';
 const same = (left, right) => left.kind === right.kind && (left.kind !== 'enum' || (right.kind === 'enum' && left.domain === right.domain));
 const compatible = (left, right) => same(left, right) || (numeric(left) && numeric(right));
-const rationalOfInteger = (value, side) => String(Exact.integer(value[side]));
+const captureRational = (value) => value !== null && typeof value === 'object'
+    ? { numerator: value.numerator, denominator: value.denominator } : value;
 const pushExactProblem = (problems, path, run) => {
     try {
         run();
@@ -34,19 +86,41 @@ const pushExactProblem = (problems, path, run) => {
         problems.push(`${path}: ${error instanceof Error ? error.message : String(error)}`);
     }
 };
+/** Describe malformed fields without traversing caller objects or invoking JSON hooks. */
+const diagnosticValue = (value) => {
+    if (typeof value === 'string')
+        return diagnosticText(value);
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+        return JSON.stringify(value);
+    }
+    return value === undefined ? 'undefined' : `<${typeof value}>`;
+};
+const diagnosticSort = (kind) => typeof kind === 'string' ? diagnosticText(kind, false) : diagnosticValue(kind);
 const requireId = (id, path, problems) => {
-    if (!idPattern.test(id)) {
+    if (typeof id !== 'string' || id.match(idPattern)?.[0] !== id) {
         problems.push(`${path} must match ${String(idPattern)}`);
     }
 };
 const provenance = (value, path, problems) => {
+    const description = value.description;
+    if (description !== undefined && typeof description !== 'string') {
+        problems.push(`${path}.description must be a string`);
+    }
     if (value.declaration !== undefined) {
-        if (value.declaration.uri.trim() === '')
-            problems.push(`${path}.declaration.uri must not be empty`);
-        for (const position of ['line', 'column']) {
-            const at = value.declaration[position];
-            if (at !== undefined && (!Number.isSafeInteger(at) || at <= 0)) {
-                problems.push(`${path}.declaration.${position} must be a positive safe integer`);
+        const declaration = value.declaration;
+        if (declaration === null || typeof declaration !== 'object' || Array.isArray(declaration)) {
+            problems.push(`${path}.declaration must be an object`);
+        }
+        else {
+            if (typeof declaration.uri !== 'string')
+                problems.push(`${path}.declaration.uri must be a string`);
+            else if (declaration.uri.trim() === '')
+                problems.push(`${path}.declaration.uri must not be empty`);
+            for (const position of ['line', 'column']) {
+                const at = declaration[position];
+                if (at !== undefined && (!Number.isSafeInteger(at) || at <= 0)) {
+                    problems.push(`${path}.declaration.${position} must be a positive safe integer`);
+                }
             }
         }
     }
@@ -56,58 +130,159 @@ const provenance = (value, path, problems) => {
     ]) {
         if (ids === undefined)
             continue;
-        if (new Set(ids).size !== ids.length)
+        if (!Array.isArray(ids)) {
+            problems.push(`${path}.${name} must be an array`);
+            continue;
+        }
+        const seen = new Set();
+        let duplicate = false;
+        for (let index = 0; index < ids.length; index++) {
+            const id = Object.hasOwn(ids, index) ? ids[index] : undefined;
+            if (typeof id !== 'string')
+                problems.push(`${path}.${name}[${index}] must be a string`);
+            else {
+                if (id.trim() === '')
+                    problems.push(`${path}.${name}[${index}] must not be empty`);
+                if (seen.has(id))
+                    duplicate = true;
+                seen.add(id);
+            }
+        }
+        if (duplicate)
             problems.push(`${path}.${name} contains duplicate identifiers`);
-        ids.forEach((id, index) => {
-            if (id.trim() === '')
-                problems.push(`${path}.${name}[${index}] must not be empty`);
-        });
     }
 };
+/** Traverse caller arrays without dispatching through overridden array methods. */
+const eachIndexed = (values, visit) => {
+    const length = values.length;
+    for (let index = 0; index < length; index++)
+        visit(values[index], index);
+};
+const mapIndexed = (values, visit) => {
+    const result = [];
+    eachIndexed(values, (value, index) => result.push(visit(value, index)));
+    return result;
+};
 const duplicates = (ids, path, problems) => {
     const seen = new Set();
     for (const id of ids) {
         if (seen.has(id)) {
-            problems.push(`${path} contains duplicate identifier ${JSON.stringify(id)}`);
+            problems.push(`${path} contains duplicate identifier ${diagnosticValue(id)}`);
         }
         seen.add(id);
     }
 };
+function* children(expression) {
+    switch (expression.kind) {
+        case 'not':
+        case 'negate':
+            yield { value: expression.value, suffix: 'value' };
+            return;
+        case 'and':
+        case 'or':
+        case 'add':
+        case 'multiply':
+            for (let index = 0; index < expression.operands.length; index++) {
+                yield { value: Object.hasOwn(expression.operands, index) ? expression.operands[index] : undefined, suffix: `operands[${index}]` };
+            }
+            return;
+        case 'if':
+            yield { value: expression.condition, suffix: 'condition' };
+            yield { value: expression.then, suffix: 'then' };
+            yield { value: expression.else, suffix: 'else' };
+            return;
+        case 'implies':
+        case 'eq':
+        case 'neq':
+        case 'lt':
+        case 'lte':
+        case 'gt':
+        case 'gte':
+        case 'subtract':
+        case 'divide':
+            yield { value: expression.left, suffix: 'left' };
+            yield { value: expression.right, suffix: 'right' };
+    }
+}
 const infer = (expression, path, variables, domains, problems, walk, depth) => {
-    walk.nodes += 1;
-    walk.depth = Math.max(walk.depth, depth);
-    const child = (value, suffix) => infer(value, `${path}.${suffix}`, variables, domains, problems, walk, depth + 1);
+    const frames = [];
+    const resolved = new WeakMap();
+    const enter = (value, at, level) => {
+        walk.nodes += 1;
+        walk.depth = Math.max(walk.depth, level);
+        if (walk.nodes > walk.limits.maxExpressionNodes) {
+            throw new ModelLimitError('maxExpressionNodes', walk.nodes, walk.limits.maxExpressionNodes);
+        }
+        if (level > walk.limits.maxExpressionDepth) {
+            throw new ModelLimitError('maxExpressionDepth', level, walk.limits.maxExpressionDepth);
+        }
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            throw new ModelValidationError([`${at} must be an expression object`]);
+        }
+        if ((value.kind === 'and' || value.kind === 'or' || value.kind === 'add' || value.kind === 'multiply') && !Array.isArray(value.operands)) {
+            throw new ModelValidationError([`${at}.operands must be an array`]);
+        }
+        frames.push({ expression: value, path: at, depth: level, children: children(value) });
+    };
+    enter(expression, path, depth);
+    while (frames.length > 0) {
+        const frame = frames[frames.length - 1];
+        const next = frame.children.next();
+        if (!next.done) {
+            enter(next.value.value, `${frame.path}.${next.value.suffix}`, frame.depth + 1);
+        }
+        else {
+            resolved.set(frame.expression, inferNode(frame.expression, frame.path, variables, domains, problems, resolved, walk));
+            frames.pop();
+        }
+    }
+    return resolved.get(expression);
+};
+const inferNode = (expression, path, variables, domains, problems, resolved, walk) => {
+    const child = (value, _suffix) => resolved.get(value);
     const expectBool = (sort, at) => {
         if (sort.kind !== 'bool')
-            problems.push(`${at} must be boolean, received ${sort.kind}`);
+            problems.push(`${at} must be boolean, received ${diagnosticSort(sort.kind)}`);
     };
     const expectNumeric = (sort, at) => {
         if (!numeric(sort))
-            problems.push(`${at} must be numeric, received ${sort.kind}`);
+            problems.push(`${at} must be numeric, received ${diagnosticSort(sort.kind)}`);
     };
     switch (expression.kind) {
         case 'literal':
             switch (expression.sort) {
-                case 'bool': return { kind: 'bool' };
-                case 'int':
-                    pushExactProblem(problems, path, () => Exact.integer(expression.value));
+                case 'bool':
+                    if (typeof expression.value !== 'boolean')
+                        problems.push(`${path}.value must be a Boolean`);
+                    return { kind: 'bool' };
+                case 'int': {
+                    const value = expression.value;
+                    walk.charge(value, 'int');
+                    pushExactProblem(problems, path, () => walk.zeroLiterals.set(expression, Exact.integer(value) === 0n));
                     return { kind: 'int' };
-                case 'real':
-                    pushExactProblem(problems, path, () => Exact.rational(expression.value));
+                }
+                case 'real': {
+                    const value = captureRational(expression.value);
+                    walk.charge(value, 'real');
+                    pushExactProblem(problems, path, () => walk.zeroLiterals.set(expression, Exact.rational(value).numerator === '0'));
                     return { kind: 'real' };
+                }
                 case 'enum': {
                     const values = domains.get(expression.domain);
                     if (values === undefined)
-                        problems.push(`${path} references unknown enum domain ${JSON.stringify(expression.domain)}`);
-                    else if (!values.includes(expression.value))
-                        problems.push(`${path} value ${JSON.stringify(expression.value)} is outside enum domain ${JSON.stringify(expression.domain)}`);
+                        problems.push(`${path} references unknown enum domain ${diagnosticValue(expression.domain)}`);
+                    else if (!values.has(expression.value))
+                        problems.push(`${path} value ${diagnosticValue(expression.value)} is outside enum domain ${diagnosticValue(expression.domain)}`);
                     return { kind: 'enum', domain: expression.domain };
                 }
+                default:
+                    problems.push(`${path} uses an unsupported literal sort`);
+                    return { kind: 'bool' };
             }
         case 'variable': {
             const variable = variables.get(expression.id);
             if (variable === undefined) {
-                problems.push(`${path} references unknown variable ${JSON.stringify(expression.id)}`);
+                problems.push(`${path} references unknown variable ${diagnosticValue(expression.id)}`);
                 return { kind: 'bool' };
             }
             return variable.sort === 'enum' ? { kind: 'enum', domain: variable.domain } : { kind: variable.sort };
@@ -120,7 +295,7 @@ const infer = (expression, path, variables, domains, problems, walk, depth) => {
         case 'or': {
             if (expression.operands.length < 2)
                 problems.push(`${path}.${expression.kind} requires at least two operands`);
-            expression.operands.forEach((operand, index) => expectBool(child(operand, `operands[${index}]`), `${path}.operands[${index}]`));
+            eachIndexed(expression.operands, (operand, index) => expectBool(child(operand, `operands[${index}]`), `${path}.operands[${index}]`));
             return { kind: 'bool' };
         }
         case 'implies': {
@@ -133,7 +308,7 @@ const infer = (expression, path, variables, domains, problems, walk, depth) => {
             const left = child(expression.left, 'left');
             const right = child(expression.right, 'right');
             if (!compatible(left, right))
-                problems.push(`${path} compares incompatible ${left.kind} and ${right.kind} expressions`);
+                problems.push(`${path} compares incompatible ${diagnosticSort(left.kind)} and ${diagnosticSort(right.kind)} expressions`);
             return { kind: 'bool' };
         }
         case 'lt':
@@ -148,7 +323,7 @@ const infer = (expression, path, variables, domains, problems, walk, depth) => {
         case 'multiply': {
             if (expression.operands.length < 2)
                 problems.push(`${path}.${expression.kind} requires at least two operands`);
-            const sorts = expression.operands.map((operand, index) => child(operand, `operands[${index}]`));
+            const sorts = mapIndexed(expression.operands, (operand, index) => child(operand, `operands[${index}]`));
             sorts.forEach((sort, index) => expectNumeric(sort, `${path}.operands[${index}]`));
             return { kind: sorts.some(sort => sort.kind === 'real') ? 'real' : 'int' };
         }
@@ -165,7 +340,7 @@ const infer = (expression, path, variables, domains, problems, walk, depth) => {
             const divisor = expression.right;
             if (divisor.kind === 'literal' && (divisor.sort === 'int' || divisor.sort === 'real')) {
                 pushExactProblem(problems, `${path}.right`, () => {
-                    const zero = divisor.sort === 'int' ? Exact.integer(divisor.value) === 0n : Exact.isZero(divisor.value);
+                    const zero = walk.zeroLiterals.get(divisor);
                     if (zero)
                         throw new TypeError('literal divisor must not be zero');
                 });
@@ -182,21 +357,29 @@ const infer = (expression, path, variables, domains, problems, walk, depth) => {
             const thenSort = child(expression.then, 'then');
             const elseSort = child(expression.else, 'else');
             if (!compatible(thenSort, elseSort))
-                problems.push(`${path} branches have incompatible ${thenSort.kind} and ${elseSort.kind} sorts`);
+                problems.push(`${path} branches have incompatible ${diagnosticSort(thenSort.kind)} and ${diagnosticSort(elseSort.kind)} sorts`);
             return numeric(thenSort) && numeric(elseSort) && (thenSort.kind === 'real' || elseSort.kind === 'real')
                 ? { kind: 'real' }
                 : thenSort;
         }
         default:
-            problems.push(`${path} uses unsupported expression kind ${JSON.stringify(expression.kind)}`);
+            problems.push(`${path} uses unsupported expression kind ${diagnosticValue(expression.kind)}`);
             return { kind: 'bool' };
     }
 };
 export const mergeLimits = (input = {}) => {
-    const limits = { ...defaultLimits, ...input };
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('solver limits must be an object');
+    }
+    for (const name of Object.keys(input)) {
+        if (!Object.hasOwn(defaultLimits, name))
+            throw new TypeError(`unknown solver limit ${diagnosticText(name)}`);
+    }
+    const limits = Object.fromEntries(Object.entries(defaultLimits).map(([name, fallback]) => [name, name in input ? input[name] : fallback]));
     for (const [name, value] of Object.entries(limits)) {
         if (!Number.isSafeInteger(value) || value <= 0) {
-            throw new TypeError(`solver limit ${name} must be a positive safe integer, received ${String(value)}`);
+            const received = typeof value === 'object' || typeof value === 'function' ? typeof value : diagnosticText(String(value), false);
+            throw new TypeError(`solver limit ${name} must be a positive safe integer, received ${received}`);
         }
     }
     return limits;
@@ -219,47 +402,117 @@ const enforce = (stats, limits) => {
 export const model = (input, limitInput = {}) => {
     const limits = mergeLimits(limitInput);
     const problems = [];
+    let numericTotal = 0;
+    const charge = (value, sort) => {
+        numericTotal += numericDigits(value, sort);
+        if (numericTotal > limits.maxNumericDigits) {
+            throw new ModelLimitError('maxNumericDigits', numericTotal, limits.maxNumericDigits);
+        }
+    };
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new ModelValidationError(['model must be an object']);
+    }
+    for (const key of ['variables', 'constraints', 'enums', 'softConstraints', 'objectives']) {
+        const declarations = input[key];
+        if (declarations === undefined && key !== 'variables' && key !== 'constraints')
+            continue;
+        if (!Array.isArray(declarations)) {
+            problems.push(`${key} must be an array`);
+        }
+    }
+    if (problems.length > 0)
+        throw new ModelValidationError(problems);
+    enforce({
+        variables: input.variables.length,
+        constraints: input.constraints.length + (input.softConstraints?.length ?? 0),
+        objectives: input.objectives?.length ?? 0,
+        enumValues: 0, expressionNodes: 0, expressionDepth: 0,
+    }, limits);
+    for (const key of ['variables', 'constraints', 'enums', 'softConstraints', 'objectives']) {
+        const declarations = input[key];
+        if (declarations === undefined)
+            continue;
+        for (let index = 0; index < declarations.length; index++) {
+            const declaration = Object.hasOwn(declarations, index) ? declarations[index] : undefined;
+            if (declaration === null || typeof declaration !== 'object' || Array.isArray(declaration)) {
+                problems.push(`${key}[${index}] must be a declaration object`);
+            }
+        }
+    }
+    if (problems.length > 0)
+        throw new ModelValidationError(problems);
     if (input.schema !== schema)
         problems.push(`schema must be ${JSON.stringify(schema)}`);
     const domains = new Map();
     const enumDeclarations = input.enums ?? [];
-    duplicates(enumDeclarations.map(domain => domain.id), 'enums', problems);
-    enumDeclarations.forEach((domain, index) => {
+    let enumValues = 0;
+    duplicates(mapIndexed(enumDeclarations, domain => domain.id), 'enums', problems);
+    eachIndexed(enumDeclarations, (domain, index) => {
         requireId(domain.id, `enums[${index}].id`, problems);
         provenance(domain, `enums[${index}]`, problems);
-        if (domain.values.length === 0)
+        const values = Array.isArray(domain.values) ? domain.values : [];
+        if (!Array.isArray(domain.values))
+            problems.push(`enums[${index}].values must be an array`);
+        enumValues += values.length;
+        if (enumValues > limits.maxEnumValues)
+            throw new ModelLimitError('maxEnumValues', enumValues, limits.maxEnumValues);
+        if (values.length === 0)
             problems.push(`enums[${index}] must contain at least one value`);
-        if (new Set(domain.values).size !== domain.values.length)
+        const members = new Set();
+        let duplicate = false;
+        for (let member = 0; member < values.length; member++) {
+            const value = Object.hasOwn(values, member) ? values[member] : undefined;
+            if (typeof value !== 'string')
+                problems.push(`enums[${index}].values[${member}] must be a string`);
+            else {
+                if (members.has(value))
+                    duplicate = true;
+                members.add(value);
+            }
+        }
+        if (duplicate)
             problems.push(`enums[${index}] contains duplicate values`);
-        domains.set(domain.id, domain.values);
+        domains.set(domain.id, members);
     });
     const variables = new Map();
-    duplicates(input.variables.map(variable => variable.id), 'variables', problems);
-    input.variables.forEach((variable, index) => {
+    duplicates(mapIndexed(input.variables, variable => variable.id), 'variables', problems);
+    eachIndexed(input.variables, (variable, index) => {
         requireId(variable.id, `variables[${index}].id`, problems);
+        if (!['bool', 'int', 'real', 'enum'].includes(variable.sort))
+            problems.push(`variables[${index}] uses an unsupported sort`);
         provenance(variable, `variables[${index}]`, problems);
         variables.set(variable.id, variable);
         if (variable.sort === 'enum' && !domains.has(variable.domain)) {
-            problems.push(`variables[${index}] references unknown enum domain ${JSON.stringify(variable.domain)}`);
+            problems.push(`variables[${index}] references unknown enum domain ${diagnosticValue(variable.domain)}`);
         }
         if (variable.sort === 'int') {
-            pushExactProblem(problems, `variables[${index}].min`, () => Exact.integer(variable.min));
-            pushExactProblem(problems, `variables[${index}].max`, () => Exact.integer(variable.max));
+            const min = variable.min, max = variable.max;
+            charge(min, 'int');
+            charge(max, 'int');
+            pushExactProblem(problems, `variables[${index}].min`, () => Exact.integer(min));
+            pushExactProblem(problems, `variables[${index}].max`, () => Exact.integer(max));
             try {
-                if (Exact.compare(rationalOfInteger(variable, 'min'), rationalOfInteger(variable, 'max')) > 0) {
+                if (Exact.compare(String(Exact.integer(min)), String(Exact.integer(max))) > 0) {
                     problems.push(`variables[${index}] has min greater than max`);
                 }
             }
             catch { /* exact-value problems are already reported above */ }
         }
         if (variable.sort === 'real') {
-            if (variable.min !== undefined)
-                pushExactProblem(problems, `variables[${index}].min`, () => Exact.rational(variable.min));
-            if (variable.max !== undefined)
-                pushExactProblem(problems, `variables[${index}].max`, () => Exact.rational(variable.max));
-            if (variable.min !== undefined && variable.max !== undefined) {
+            const rawMin = variable.min, rawMax = variable.max;
+            const min = rawMin === undefined ? undefined : captureRational(rawMin);
+            const max = rawMax === undefined ? undefined : captureRational(rawMax);
+            if (min !== undefined)
+                charge(min, 'real');
+            if (max !== undefined)
+                charge(max, 'real');
+            if (min !== undefined)
+                pushExactProblem(problems, `variables[${index}].min`, () => Exact.rational(min));
+            if (max !== undefined)
+                pushExactProblem(problems, `variables[${index}].max`, () => Exact.rational(max));
+            if (min !== undefined && max !== undefined) {
                 try {
-                    if (Exact.compare(variable.min, variable.max) > 0)
+                    if (Exact.compare(min, max) > 0)
                         problems.push(`variables[${index}] has min greater than max`);
                 }
                 catch { /* exact-value problems are already reported above */ }
@@ -267,35 +520,40 @@ export const model = (input, limitInput = {}) => {
         }
     });
     duplicates([
-        ...input.constraints.map(constraint => constraint.id),
-        ...(input.softConstraints ?? []).map(constraint => constraint.id)
+        ...mapIndexed(input.constraints, constraint => constraint.id),
+        ...mapIndexed(input.softConstraints ?? [], constraint => constraint.id)
     ], 'constraints', problems);
-    duplicates((input.objectives ?? []).map(objective => objective.id), 'objectives', problems);
-    const walk = { nodes: 0, depth: 0 };
-    input.constraints.forEach((constraint, index) => {
+    duplicates(mapIndexed(input.objectives ?? [], objective => objective.id), 'objectives', problems);
+    const walk = { nodes: 0, depth: 0, limits, charge, zeroLiterals: new WeakMap() };
+    eachIndexed(input.constraints, (constraint, index) => {
         requireId(constraint.id, `constraints[${index}].id`, problems);
         provenance(constraint, `constraints[${index}]`, problems);
         const sort = infer(constraint.expression, `constraints[${index}].expression`, variables, domains, problems, walk, 1);
         if (sort.kind !== 'bool')
-            problems.push(`constraints[${index}].expression must be boolean, received ${sort.kind}`);
+            problems.push(`constraints[${index}].expression must be boolean, received ${diagnosticSort(sort.kind)}`);
     });
-    (input.softConstraints ?? []).forEach((constraint, index) => {
+    eachIndexed(input.softConstraints ?? [], (constraint, index) => {
         requireId(constraint.id, `softConstraints[${index}].id`, problems);
         provenance(constraint, `softConstraints[${index}]`, problems);
         const sort = infer(constraint.expression, `softConstraints[${index}].expression`, variables, domains, problems, walk, 1);
         if (sort.kind !== 'bool')
-            problems.push(`softConstraints[${index}].expression must be boolean, received ${sort.kind}`);
+            problems.push(`softConstraints[${index}].expression must be boolean, received ${diagnosticSort(sort.kind)}`);
+        const weight = captureRational(constraint.weight);
+        charge(weight, 'real');
         pushExactProblem(problems, `softConstraints[${index}].weight`, () => {
-            if (Exact.compare(constraint.weight, '0') <= 0)
+            if (Exact.compare(weight, '0') <= 0)
                 throw new TypeError('weight must be greater than zero');
         });
     });
-    (input.objectives ?? []).forEach((objective, index) => {
+    eachIndexed(input.objectives ?? [], (objective, index) => {
         requireId(objective.id, `objectives[${index}].id`, problems);
+        if (objective.direction !== 'minimize' && objective.direction !== 'maximize') {
+            problems.push(`objectives[${index}].direction must be minimize or maximize`);
+        }
         provenance(objective, `objectives[${index}]`, problems);
         const sort = infer(objective.expression, `objectives[${index}].expression`, variables, domains, problems, walk, 1);
         if (!numeric(sort))
-            problems.push(`objectives[${index}].expression must be numeric, received ${sort.kind}`);
+            problems.push(`objectives[${index}].expression must be numeric, received ${diagnosticSort(sort.kind)}`);
     });
     if (problems.length > 0)
         throw new ModelValidationError(problems);
@@ -303,7 +561,7 @@ export const model = (input, limitInput = {}) => {
         variables: input.variables.length,
         constraints: input.constraints.length + (input.softConstraints?.length ?? 0),
         objectives: input.objectives?.length ?? 0,
-        enumValues: enumDeclarations.reduce((sum, domain) => sum + domain.values.length, 0),
+        enumValues,
         expressionNodes: walk.nodes,
         expressionDepth: walk.depth
     };