@orkestrel/reason 0.0.12 → 0.0.14

package/dist/src/core/index.js

@@ -1,6 +1,6 @@
-import { GUARD_DEPTH_LIMIT, arrayOf, holds, isArray, isBoolean, isError, isFiniteNumber, isFunction, isInstance, isNumber, isObject, isRecord, isString, lazyOf, literalOf, notOf, orOf, parseJSONAs, parseNumber, parseNumberField, readArrayEntries, recordOf, resolveField, unionOf, whereOf } from "@orkestrel/contract";
+import { GUARD_DEPTH_LIMIT, INTRINSICS, arrayOf, holds, isArray, isBoolean, isError, isFiniteNumber, isFunction, isInstance, isNumber, isObject, isRecord, isString, lazyOf, literalOf, notOf, orOf, parseJSONAs, parseNumber, parseNumberField, readArrayEntries, recordOf, resolveField, unionOf, whereOf } from "@orkestrel/contract";
 import { Emitter } from "@orkestrel/emitter";
-//#region src/core/constants.ts
+// src/core/constants.ts
 /**
 * Holds the default `bail` for the `Reason` orchestrator — a reasoner throw is rethrown
 * after the `error` emit. Default: `true`.
@@ -97,8 +97,7 @@ var DEFINITION_BUILDER_BRAND = Symbol("reasons.definitionBuilder");
 * match the other's guard.
 */
 var SUBJECT_BUILDER_BRAND = Symbol("reasons.subjectBuilder");
-//#endregion
-//#region src/core/errors.ts
+// src/core/errors.ts
 /**
 * Represents an error thrown by the reasons layer.
 *
@@ -122,6 +121,7 @@ var ReasonError = class extends Error {
 	context;
 	constructor(code, message, context) {
 		super(message);
+		Object.defineProperty(this, Symbol.for("@orkestrel/reason.ReasonError"), { value: this });
 		this.name = "ReasonError";
 		this.code = code;
 		if (context !== void 0) this.context = context;
@@ -130,6 +130,13 @@ var ReasonError = class extends Error {
 /**
 * Narrows an unknown caught value to a {@link ReasonError}.
 *
+* @remarks
+* Accepts errors from another installed copy and subclasses regardless of `name`.
+* Requires the own self-valued `Symbol.for('@orkestrel/reason.ReasonError')`
+* brand, a non-base global `Error` prototype, and valid declared members.
+* Plain objects, unbranded look-alikes, and transparent proxies are rejected.
+* Hostile reads return false through the contract intrinsics inside `holds`.
+*
 * @param value - The value to test (typically a `catch` binding)
 * @returns True if `value` is a {@link ReasonError}; false otherwise
 *
@@ -143,10 +150,15 @@ var ReasonError = class extends Error {
 * ```
 */
 function isReasonError(value) {
-	return isInstance(value, ReasonError);
+	return holds(() => {
+		if (!isInstance(value, Error) || INTRINSICS.prototype(value) === Error.prototype) return false;
+		if (INTRINSICS.describe(value, Symbol.for("@orkestrel/reason.ReasonError"))?.value !== value) return false;
+		const code = INTRINSICS.reflect.read(value, "code");
+		const context = INTRINSICS.reflect.read(value, "context");
+		return (code === "MISSING" || code === "INVALID" || code === "MISMATCH" || code === "DESTROYED" || code === "TARGET" || code === "OPERATOR") && isString(INTRINSICS.reflect.read(value, "message")) && (context === void 0 || isObject(context) || isFunction(context));
+	});
 }
-//#endregion
-//#region src/core/validators.ts
+// src/core/validators.ts
 /**
 * Determines whether a value is a {@link Reasoning} literal.
 *
@@ -163,20 +175,20 @@ function isReasonError(value) {
 */
 var isReasoning = literalOf("quantitative", "logical", "symbolic", "inferential");
 /**
-* Determines whether a value is a {@link ChainingStrategy} literal.
+* Determines whether a value is a {@link ChainStrategy} literal.
 *
 * @param value - The value to test
 * @returns True if `value` is `'forward'` or `'backward'`; false otherwise
 *
 * @example
 * ```ts
-* import { isChainingStrategy } from '@src/core'
+* import { isChainStrategy } from '@src/core'
 *
-* isChainingStrategy('forward') // true
-* isChainingStrategy('upward')  // false
+* isChainStrategy('forward') // true
+* isChainStrategy('upward')  // false
 * ```
 */
-var isChainingStrategy = literalOf("forward", "backward");
+var isChainStrategy = literalOf("forward", "backward");
 /**
 * Determines whether a value is a {@link MathOperation} literal.
 *
@@ -699,7 +711,7 @@ function isLogicalDefinition(value) {
 		name: isString,
 		description: isString,
 		rules: arrayOf(isRule),
-		strategy: isChainingStrategy,
+		strategy: isChainStrategy,
 		depth: isFiniteNumber
 	}, ["description", "depth"])(value);
 }
@@ -750,7 +762,7 @@ function isInferentialDefinition(value) {
 		description: isString,
 		inferences: arrayOf(isInference),
 		facts: arrayOf(isFact),
-		strategy: isChainingStrategy,
+		strategy: isChainStrategy,
 		depth: isFiniteNumber
 	}, ["description", "depth"])(value);
 }
@@ -1011,8 +1023,7 @@ function isProofNode(value) {
 			if (!isArray(children)) return false;
 			const entries = readArrayEntries(children);
 			if (!entries.success || !entries.value.dense) return false;
-			for (let index = entries.value.entries.length - 1; index >= 0; index -= 1) {
-				const child = entries.value.entries[index];
+			for (const child of entries.value.entries.toReversed()) {
 				if (!isObject(child) || isArray(child)) return false;
 				worklist.push([
 					child,
@@ -1199,8 +1210,7 @@ function isDefinitionBuilder(value) {
 function isSubjectBuilder(value) {
 	return isObject(value) && Reflect.get(value, SUBJECT_BUILDER_BRAND) === true;
 }
-//#endregion
-//#region src/core/helpers.ts
+// src/core/helpers.ts
 /**
 * Formats a {@link FieldPath} for display — the single string key itself, or the
 * array segments joined with `.`.
@@ -1222,6 +1232,19 @@ function formatField(field) {
 	return isString(field) ? field : field.join(".");
 }
 /**
+* Iterates nonnegative indices below a numeric limit without allocating a range.
+*
+* @example
+* ```ts
+* [...iterateIndices(2.5)] // [0, 1, 2]
+* ```
+*/
+function* iterateIndices(limit) {
+	yield* Array.prototype.keys.call({ length: Math.max(0, Math.ceil(limit)) });
+	if (limit > Number.MAX_SAFE_INTEGER) yield Number.MAX_SAFE_INTEGER;
+	if (limit > Number.MAX_SAFE_INTEGER + 1) for (;;) yield Number.MAX_SAFE_INTEGER + 1;
+}
+/**
 * Clamps a number to inclusive {@link Bounds}.
 *
 * @remarks
@@ -1242,10 +1265,8 @@ function formatField(field) {
 */
 function clamp(value, limit) {
 	if (!limit) return value;
-	let result = value;
-	if (limit.minimum !== void 0 && result < limit.minimum) result = limit.minimum;
-	if (limit.maximum !== void 0 && result > limit.maximum) result = limit.maximum;
-	return result;
+	const minimum = limit.minimum !== void 0 && value < limit.minimum ? limit.minimum : value;
+	return limit.maximum !== void 0 && minimum > limit.maximum ? limit.maximum : minimum;
 }
 /**
 * Checks whether a value falls inside an inclusive range expressed as an array.
@@ -1441,12 +1462,7 @@ function equalValues(left, right) {
 * ```
 */
 function sortByPriority(items) {
-	const usable = [];
-	for (const item of items) {
-		if (!isObject(item)) continue;
-		usable.push(item);
-	}
-	return usable.sort((left, right) => (left.priority ?? 0) - (right.priority ?? 0));
+	return Iterator.from(items).filter(isObject).toArray().sort((left, right) => (left.priority ?? 0) - (right.priority ?? 0));
 }
 /**
 * Collects the ids that appear more than once in an id-carrying list — each
@@ -1469,9 +1485,10 @@ function sortByPriority(items) {
 * ```
 */
 function findDuplicates(items) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const item of items) counts.set(item.id, (counts.get(item.id) ?? 0) + 1);
-	return [...counts.entries()].filter(([, count]) => count > 1).map(([id]) => id);
+	const indexed = Iterator.from(items).map((item, index) => [item.id, index]).toArray();
+	const first = new Map(indexed.toReversed());
+	const duplicates = new Set(indexed.filter(([id, index]) => first.get(id) !== index).map(([id]) => id));
+	return indexed.filter(([id, index]) => first.get(id) === index && duplicates.has(id)).map(([id]) => id);
 }
 /**
 * Derives a fact's predicate+arity bucket key — length-prefixed so the
@@ -1527,14 +1544,7 @@ function factToArityKey(fact) {
 * ```
 */
 function indexByArity(facts) {
-	const index = /* @__PURE__ */ new Map();
-	for (const entry of facts) {
-		const key = factToArityKey(entry);
-		const bucket = index.get(key);
-		if (bucket) bucket.push(entry);
-		else index.set(key, [entry]);
-	}
-	return index;
+	return Map.groupBy(facts, factToArityKey);
 }
 /**
 * Derives one fact term's contribution to a dedup key — reference identity for
@@ -1634,21 +1644,20 @@ function factToKey(fact, identities) {
 function matchFacts(pattern, candidate) {
 	if (pattern.predicate !== candidate.predicate) return void 0;
 	if (pattern.terms.length !== candidate.terms.length) return void 0;
-	const bindings = {};
-	for (let index = 0; index < pattern.terms.length; index++) {
-		const patternTerm = pattern.terms[index];
+	const bindings = /* @__PURE__ */ new Map();
+	for (const [index, patternTerm] of pattern.terms.entries()) {
 		const factTerm = candidate.terms[index];
 		if (isString(patternTerm) && patternTerm.startsWith("?")) {
-			if (patternTerm in bindings) {
-				if (bindings[patternTerm] !== factTerm) return void 0;
-			} else bindings[patternTerm] = factTerm;
+			if (bindings.has(patternTerm)) {
+				if (bindings.get(patternTerm) !== factTerm) return void 0;
+			} else bindings.set(patternTerm, factTerm);
 		} else if (isString(factTerm) && factTerm.startsWith("?")) {
-			if (factTerm in bindings) {
-				if (bindings[factTerm] !== patternTerm) return void 0;
-			} else bindings[factTerm] = patternTerm;
+			if (bindings.has(factTerm)) {
+				if (bindings.get(factTerm) !== patternTerm) return void 0;
+			} else bindings.set(factTerm, patternTerm);
 		} else if (patternTerm !== factTerm) return;
 	}
-	return bindings;
+	return Object.fromEntries(bindings);
 }
 /**
 * Substitutes a fact's bound `'?'`-variables with their values — a fresh fact
@@ -1710,15 +1719,11 @@ function instantiateFact(fact, bindings) {
 * ```
 */
 function computePremiseConfidence(premises, index, bindings) {
-	let confidence = 1;
-	for (const premise of premises) {
+	return Iterator.from(premises).reduce((confidence, premise) => {
 		const instantiated = instantiateFact(premise, bindings);
-		for (const candidate of index.get(factToArityKey(premise)) ?? []) if (matchFacts(instantiated, candidate)) {
-			confidence *= candidate.confidence ?? 1;
-			break;
-		}
-	}
-	return confidence;
+		for (const candidate of index.get(factToArityKey(premise)) ?? []) if (matchFacts(instantiated, candidate)) return confidence * (candidate.confidence ?? 1);
+		return confidence;
+	}, 1);
 }
 /**
 * Projects a subject's scalar fields into `has(key, value)` base facts — the
@@ -1742,25 +1747,24 @@ function computePremiseConfidence(premises, index, bindings) {
 * ```
 */
 function subjectToFacts(subject) {
-	const facts = [];
-	const trace = [];
-	for (const key of Object.keys(subject)) {
-		if (key === "id") continue;
+	const rows = Object.keys(subject).flatMap((key) => {
+		if (key === "id") return [];
 		const value = subject[key];
-		if (value === void 0 || value === null) continue;
-		if (isObject(value)) continue;
-		facts.push({
-			id: `subject:${key}`,
-			predicate: "has",
-			terms: [key, value],
-			confidence: 1
-		});
-		trace.push(`Subject field "${key}" → has(${key}, ${String(value)})`);
-	}
-	if (facts.length > 0) trace.push(`Injected ${facts.length} fact(s) from subject`);
+		if (value === void 0 || value === null) return [];
+		if (isObject(value)) return [];
+		return [{
+			fact: {
+				id: `subject:${key}`,
+				predicate: "has",
+				terms: [key, value],
+				confidence: 1
+			},
+			trace: `Subject field "${key}" → has(${key}, ${String(value)})`
+		}];
+	});
 	return {
-		facts,
-		trace
+		facts: rows.map((row) => row.fact),
+		trace: [...rows.map((row) => row.trace), ...rows.length > 0 ? [`Injected ${rows.length} fact(s) from subject`] : []]
 	};
 }
 /**
@@ -1790,17 +1794,8 @@ function subjectToFacts(subject) {
 * ```
 */
 function findUnboundVariables(inference) {
-	const bound = /* @__PURE__ */ new Set();
-	for (const premise of inference.premises) for (const term of premise.terms) if (isString(term) && term.startsWith("?")) bound.add(term);
-	const unbound = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const term of inference.conclusion.terms) {
-		if (!isString(term) || !term.startsWith("?")) continue;
-		if (bound.has(term) || seen.has(term)) continue;
-		seen.add(term);
-		unbound.push(term);
-	}
-	return unbound;
+	const bound = new Set(Iterator.from(inference.premises).flatMap((premise) => Iterator.from(premise.terms).filter((term) => isString(term) && term.startsWith("?"))));
+	return [...new Set(Iterator.from(inference.conclusion.terms).filter((term) => isString(term) && term.startsWith("?") && !bound.has(term)))];
 }
 /**
 * Determines whether a symbolic expression contains an unbound occurrence of a
@@ -2017,8 +2012,9 @@ function extractAtoms(expression) {
 			continue;
 		}
 		const operands = node.operands;
-		for (let index = operands.length - 1; index >= 0; index--) {
-			const operand = operands[index];
+		const length = operands.length;
+		for (const offset of iterateIndices(length)) {
+			const operand = operands[length - 1 - offset];
 			if (operand !== void 0) stack.push(operand);
 		}
 	}
@@ -2088,21 +2084,9 @@ function extractConclusions(expression) {
 * ```
 */
 function findOverlayMismatches(rules) {
-	const writeKeys = [];
-	const seenWrites = /* @__PURE__ */ new Set();
-	for (const candidate of rules) for (const atomLeaf of extractAtoms(candidate.conclusion)) {
-		if (!isArray(atomLeaf.check.field)) continue;
-		const key = formatField(atomLeaf.check.field);
-		if (seenWrites.has(key)) continue;
-		seenWrites.add(key);
-		writeKeys.push(key);
-	}
-	const readKeys = /* @__PURE__ */ new Set();
-	for (const candidate of rules) for (const premise of candidate.premises) for (const atomLeaf of extractAtoms(premise)) {
-		if (!isArray(atomLeaf.check.field)) continue;
-		readKeys.add(formatField(atomLeaf.check.field));
-	}
-	return writeKeys.filter((key) => readKeys.has(key));
+	const writeKeys = new Set(Iterator.from(rules).flatMap((candidate) => extractAtoms(candidate.conclusion).flatMap((atom) => isArray(atom.check.field) ? [formatField(atom.check.field)] : [])));
+	const readKeys = new Set(Iterator.from(rules).flatMap((candidate) => Iterator.from(candidate.premises).flatMap((premise) => extractAtoms(premise).flatMap((atom) => isArray(atom.check.field) ? [formatField(atom.check.field)] : []))));
+	return [...writeKeys].filter((key) => readKeys.has(key));
 }
 /**
 * Builds the empty, type-shaped failure {@link ReasonResult} matching a
@@ -2370,20 +2354,20 @@ function removeById(items, id) {
 function mergeById(base, incoming, resolve) {
 	const baseById = /* @__PURE__ */ new Map();
 	for (const item of base) if (!baseById.has(item.id)) baseById.set(item.id, item);
-	const seen = /* @__PURE__ */ new Set();
-	const merged = [];
+	const merged = /* @__PURE__ */ new Map();
 	for (const item of incoming) {
-		if (seen.has(item.id)) continue;
-		seen.add(item.id);
+		const query = item.id;
+		if (merged.has(query)) continue;
+		const id = item.id;
 		const existing = baseById.get(item.id);
-		merged.push(existing === void 0 ? item : resolve ? resolve(existing, item) : item);
+		merged.set(id, existing === void 0 ? item : resolve ? resolve(existing, item) : item);
 	}
 	for (const item of base) {
-		if (seen.has(item.id)) continue;
-		seen.add(item.id);
-		merged.push(item);
+		const query = item.id;
+		if (merged.has(query)) continue;
+		merged.set(item.id, item);
 	}
-	return merged;
+	return [...merged.values()];
 }
 /**
 * Inserts `group` into a {@link QuantitativeDefinition}'s `groups` — dedup-then-
@@ -3342,15 +3326,12 @@ function mergeSubjects(base, incoming) {
 */
 function repeatSubject(subject, count) {
 	const baseId = subject.id;
-	const clones = [];
-	for (let index = 0; index < count; index += 1) clones.push(isString(baseId) ? {
+	return iterateIndices(count).map((index) => isString(baseId) ? {
 		...subject,
 		id: `${baseId}-${index}`
-	} : { ...subject });
-	return clones;
+	} : { ...subject }).toArray();
 }
-//#endregion
-//#region src/core/parsers.ts
+// src/core/parsers.ts
 /**
 * Parses a JSON string into a {@link Definition}, failing safe to `undefined`.
 *
@@ -3377,8 +3358,7 @@ function repeatSubject(subject, count) {
 function parseDefinition(json) {
 	return parseJSONAs(json, isDefinition);
 }
-//#endregion
-//#region src/core/Reason.ts
+// src/core/Reason.ts
 /**
 * Implements the reasoning orchestrator — a thin router over registered
 * {@link ReasonerInterface}s.
@@ -3505,8 +3485,7 @@ var Reason = class {
 		if (this.#destroyed) throw new ReasonError("DESTROYED", "Reason has been destroyed");
 	}
 };
-//#endregion
-//#region src/core/operators/Evaluator.ts
+// src/core/operators/Evaluator.ts
 /**
 * Evaluates {@link Check}s against subjects — the shared predicate engine of the
 * quantitative and logical reasoners.
@@ -3576,8 +3555,7 @@ var Evaluator = class {
 		}
 	}
 };
-//#endregion
-//#region src/core/operators/Transformer.ts
+// src/core/operators/Transformer.ts
 /**
 * Applies math {@link Transform}s to numbers — the quantitative reasoner's
 * per-factor pipeline stage.
@@ -3616,8 +3594,7 @@ var Transformer = class {
 		return transforms.reduce((result, transform) => this.apply(result, transform), value);
 	}
 };
-//#endregion
-//#region src/core/operators/Aggregator.ts
+// src/core/operators/Aggregator.ts
 /**
 * Reduces number lists to one number per {@link Aggregation} — the quantitative
 * reasoner's group and definition combiner.
@@ -3667,8 +3644,7 @@ var Aggregator = class {
 		}
 	}
 };
-//#endregion
-//#region src/core/reasoners/QuantitativeReasoner.ts
+// src/core/reasoners/QuantitativeReasoner.ts
 /**
 * Performs factor-based numeric scoring.
 *
@@ -3775,24 +3751,19 @@ var QuantitativeReasoner = class {
 		};
 		const trace = [];
 		const errors = [];
-		let count = 0;
-		const groupResults = [];
-		for (const group of definition.groups) {
-			if (!isObject(group)) continue;
+		const groupResults = Iterator.from(definition.groups).flatMap((group) => {
+			if (!isObject(group)) return [];
 			if (group.enabled === false) {
 				trace.push(`Skipped group "${group.id}" (disabled)`);
-				continue;
+				return [];
 			}
-			const groupResult = this.#evaluateGroup(group, subject, trace, errors);
-			groupResults.push(groupResult);
-			if (groupResult.applied) count++;
-		}
+			return [this.#evaluateGroup(group, subject, trace, errors)];
+		}).toArray();
 		const groupValues = groupResults.filter((group) => group.applied).map((group) => group.value);
 		const base = definition.base ?? 0;
-		let value = base + this.#aggregator.aggregate(groupValues, definition.aggregation);
-		trace.push(`Aggregated ${groupValues.length} groups with "${definition.aggregation}": base=${base}, raw=${value}`);
-		value = clamp(value, definition.bounds);
-		value = roundTo(value, definition.precision ?? 4);
+		const raw = base + this.#aggregator.aggregate(groupValues, definition.aggregation);
+		trace.push(`Aggregated ${groupValues.length} groups with "${definition.aggregation}": base=${base}, raw=${raw}`);
+		const value = roundTo(clamp(raw, definition.bounds), definition.precision ?? 4);
 		if (!isFiniteNumber(value)) {
 			const description = Number.isNaN(value) ? "NaN" : String(value);
 			trace.push(`Definition "${definition.id}": produced non-finite value (${description})`);
@@ -3802,7 +3773,7 @@ var QuantitativeReasoner = class {
 			reasoning: "quantitative",
 			value,
 			groups: groupResults,
-			count,
+			count: groupValues.length,
 			success: errors.length === 0,
 			trace,
 			errors
@@ -3818,14 +3789,13 @@ var QuantitativeReasoner = class {
 				factors: []
 			};
 		}
-		const factorResults = [];
-		for (const factor of sortByPriority(group.factors)) {
+		const factorResults = Iterator.from(sortByPriority(group.factors)).flatMap((factor) => {
 			if (factor.enabled === false) {
 				trace.push(`Skipped factor "${factor.id}" (disabled)`);
-				continue;
+				return [];
 			}
-			factorResults.push(this.#evaluateFactor(factor, subject, trace, errors));
-		}
+			return [this.#evaluateFactor(factor, subject, trace, errors)];
+		}).toArray();
 		const appliedFactors = factorResults.filter((factor) => factor.applied);
 		if (group.strict && appliedFactors.length !== factorResults.length) {
 			trace.push(`Group "${group.id}" strict mode: not all factors applied`);
@@ -3843,8 +3813,7 @@ var QuantitativeReasoner = class {
 			if (!weightById.has(original.id)) weightById.set(original.id, original.weight ?? 1);
 		}
 		const weights = appliedFactors.map((factor) => weightById.get(factor.id) ?? 1);
-		let value = (group.base ?? 0) + this.#aggregator.aggregate(factorValues, group.aggregation, weights);
-		value = clamp(value, group.bounds);
+		const value = clamp((group.base ?? 0) + this.#aggregator.aggregate(factorValues, group.aggregation, weights), group.bounds);
 		trace.push(`Group "${group.id}": ${appliedFactors.length}/${factorResults.length} factors applied, value=${value}`);
 		return {
 			id: group.id,
@@ -3888,9 +3857,7 @@ var QuantitativeReasoner = class {
 				raw
 			};
 		}
-		let value = raw;
-		if (factor.transforms && factor.transforms.length > 0) value = this.#transformer.chain(value, factor.transforms);
-		value = clamp(value, factor.bounds);
+		const value = clamp(factor.transforms && factor.transforms.length > 0 ? this.#transformer.chain(raw, factor.transforms) : raw, factor.bounds);
 		if (!isFiniteNumber(value)) {
 			const description = Number.isNaN(value) ? "NaN" : String(value);
 			trace.push(`Factor "${factor.id}": produced non-finite value (${description})`);
@@ -3911,8 +3878,30 @@ var QuantitativeReasoner = class {
 		};
 	}
 };
-//#endregion
-//#region src/core/reasoners/LogicalReasoner.ts
+// src/core/LogicalState.ts
+/**
+* Stores the derived fields and rule results of one logical reasoning call.
+*/
+var LogicalState = class {
+	#fields = {};
+	#rules = /* @__PURE__ */ new Map();
+	get fields() {
+		return this.#fields;
+	}
+	field(key) {
+		return this.#fields[key];
+	}
+	set(key, value) {
+		this.#fields[key] = value;
+	}
+	rule(id) {
+		return this.#rules.get(id);
+	}
+	record(result) {
+		this.#rules.set(result.id, result);
+	}
+};
+// src/core/reasoners/LogicalReasoner.ts
 /**
 * Deduces booleans from rules with forward or backward chaining.
 *
@@ -4027,58 +4016,59 @@ var LogicalReasoner = class {
 	}
 	#forward(definition, subject, trace, errors) {
 		const maxDepth = definition.depth ?? 10;
-		const derived = {};
+		const state = new LogicalState();
 		if (definition.rules.length === 0) trace.push("No rules defined");
 		const sortedRules = sortByPriority(definition.rules);
-		const reportedErrors = /* @__PURE__ */ new Set();
-		for (const rule of sortedRules) {
-			if (!isObject(rule)) continue;
-			if (rule.enabled === false) continue;
+		const reportedErrors = new Set(sortedRules.flatMap((rule) => {
+			if (!isObject(rule)) return [];
+			if (rule.enabled === false) return [];
 			if (!rule.premises || rule.premises.length === 0) {
 				errors.push(`Rule "${rule.id}" has no premises — skipped`);
-				reportedErrors.add(rule.id);
+				return [rule.id];
 			} else if (!rule.conclusion) {
 				errors.push(`Rule "${rule.id}" has no conclusion — skipped`);
-				reportedErrors.add(rule.id);
+				return [rule.id];
 			}
-		}
-		for (let iteration = 0; iteration < maxDepth; iteration++) {
-			let newDerivation = false;
+			return [];
+		}));
+		for (const iteration of iterateIndices(maxDepth)) {
 			const currentSubject = {
 				...subject,
-				...derived
+				...state.fields
 			};
-			for (const rule of sortedRules) {
+			if (!sortedRules.reduce((previous, rule) => {
 				if (rule.enabled === false) {
 					trace.push(`Skipped rule "${rule.id}" (disabled)`);
-					continue;
+					return previous;
 				}
-				if (reportedErrors.has(rule.id)) continue;
+				if (reportedErrors.has(rule.id)) return previous;
 				if (this.#evaluateRule(rule, currentSubject).applied) {
 					const conclusions = extractConclusions(rule.conclusion);
-					for (const [key, value] of Object.entries(conclusions)) if (!equalValues(derived[key], value)) {
-						derived[key] = value;
-						newDerivation = true;
-						trace.push(`Rule "${rule.id}" derived: ${key}=${String(value)} (iteration ${iteration + 1})`);
-					}
+					return Object.entries(conclusions).reduce((updated, [key, value]) => {
+						if (!equalValues(state.field(key), value)) {
+							state.set(key, value);
+							trace.push(`Rule "${rule.id}" derived: ${key}=${String(value)} (iteration ${iteration + 1})`);
+							return true;
+						}
+						return updated;
+					}, previous);
 				}
-			}
-			if (!newDerivation) {
+				return previous;
+			}, false)) {
 				trace.push(`Forward chaining converged at iteration ${iteration + 1}`);
 				break;
 			}
 		}
 		const finalSubject = {
 			...subject,
-			...derived
+			...state.fields
 		};
-		const finalResults = [];
-		for (const rule of definition.rules) {
-			if (!isObject(rule)) continue;
-			if (rule.enabled === false) continue;
-			if (reportedErrors.has(rule.id)) continue;
-			finalResults.push(this.#evaluateRule(rule, finalSubject));
-		}
+		const finalResults = Iterator.from(definition.rules).flatMap((rule) => {
+			if (!isObject(rule)) return [];
+			if (rule.enabled === false) return [];
+			if (reportedErrors.has(rule.id)) return [];
+			return [this.#evaluateRule(rule, finalSubject)];
+		}).toArray();
 		return {
 			conclusion: finalResults.length > 0 ? finalResults[finalResults.length - 1]?.applied ?? false : false,
 			rules: finalResults
@@ -4086,8 +4076,7 @@ var LogicalReasoner = class {
 	}
 	#backward(definition, subject, trace, errors) {
 		const maxDepth = definition.depth ?? 10;
-		const derived = {};
-		const ruleResults = /* @__PURE__ */ new Map();
+		const state = new LogicalState();
 		if (definition.rules.length === 0) trace.push("No rules defined");
 		const sortedRules = sortByPriority(definition.rules.filter((rule) => {
 			if (!isObject(rule)) return false;
@@ -4106,52 +4095,45 @@ var LogicalReasoner = class {
 			if (!isObject(rule)) continue;
 			if (rule.enabled === false) trace.push(`Skipped rule "${rule.id}" (disabled)`);
 		}
-		for (const rule of sortedRules) this.#proveRule(rule, 0, /* @__PURE__ */ new Set(), sortedRules, derived, subject, trace, ruleResults, maxDepth);
-		const finalResults = [];
-		for (const rule of sortedRules) {
-			const existing = ruleResults.get(rule.id);
-			if (existing) finalResults.push(existing);
-			else finalResults.push(this.#evaluateRule(rule, {
-				...subject,
-				...derived
-			}));
-		}
+		for (const rule of sortedRules) this.#proveRule(rule, 0, /* @__PURE__ */ new Set(), sortedRules, state, subject, trace, maxDepth);
+		const finalResults = sortedRules.map((rule) => state.rule(rule.id) ?? this.#evaluateRule(rule, {
+			...subject,
+			...state.fields
+		}));
 		return {
 			conclusion: finalResults.length > 0 ? finalResults[finalResults.length - 1]?.applied ?? false : false,
 			rules: finalResults
 		};
 	}
-	#proveRule(rule, depth, visited, rules, derived, subject, trace, ruleResults, maxDepth) {
+	#proveRule(rule, depth, visited, rules, state, subject, trace, maxDepth) {
 		if (depth > maxDepth) return false;
 		if (visited.has(rule.id)) return false;
-		const nextVisited = new Set(visited);
-		nextVisited.add(rule.id);
+		const nextVisited = /* @__PURE__ */ new Set([...visited, rule.id]);
 		const currentSubject = {
 			...subject,
-			...derived
+			...state.fields
 		};
-		const premiseResults = [];
-		for (const premise of rule.premises) premiseResults.push(this.#establish(premise, currentSubject, rules, depth + 1, nextVisited, derived, subject, trace, ruleResults, maxDepth));
+		const premiseResults = Iterator.from(rule.premises).map((premise) => this.#establish(premise, currentSubject, rules, depth + 1, nextVisited, state, subject, trace, maxDepth)).toArray();
 		const allMet = premiseResults.every(Boolean);
-		ruleResults.set(rule.id, {
+		state.record({
 			id: rule.id,
 			applied: allMet,
 			premises: premiseResults
 		});
 		if (allMet) {
 			const conclusions = extractConclusions(rule.conclusion);
-			for (const [key, value] of Object.entries(conclusions)) if (!equalValues(derived[key], value)) {
-				derived[key] = value;
+			for (const [key, value] of Object.entries(conclusions)) if (!equalValues(state.field(key), value)) {
+				state.set(key, value);
 				trace.push(`Rule "${rule.id}" derived: ${key}=${String(value)} (backward, depth ${depth})`);
 			}
 		} else trace.push(`Rule "${rule.id}": does not hold (backward, depth ${depth})`);
 		return allMet;
 	}
-	#establish(expression, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth) {
+	#establish(expression, currentSubject, rules, depth, visited, state, subject, trace, maxDepth) {
 		if (this.#evaluateExpression(expression, currentSubject)) return true;
-		return this.#proveExpression(expression, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth);
+		return this.#proveExpression(expression, rules, depth, visited, state, subject, trace, maxDepth);
 	}
-	#proveExpression(expression, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth) {
+	#proveExpression(expression, rules, depth, visited, state, subject, trace, maxDepth) {
 		if (depth > maxDepth) return false;
 		if (expression.form === "atom") for (const rule of rules) {
 			if (!isObject(rule)) continue;
@@ -4160,30 +4142,25 @@ var LogicalReasoner = class {
 			const field = formatField(expression.check.field);
 			const value = expression.check.value;
 			if (field in conclusionFacts && conclusionFacts[field] === value) {
-				const nextVisited = new Set(visited);
-				nextVisited.add(rule.id);
+				const nextVisited = /* @__PURE__ */ new Set([...visited, rule.id]);
 				const currentSubject = {
 					...subject,
-					...derived
+					...state.fields
 				};
 				const premiseResults = [];
-				let allMet = true;
-				for (const premise of rule.premises) {
-					const met = this.#establish(premise, currentSubject, rules, depth + 1, nextVisited, derived, subject, trace, ruleResults, maxDepth);
+				const allMet = Iterator.from(rule.premises).every((premise) => {
+					const met = this.#establish(premise, currentSubject, rules, depth + 1, nextVisited, state, subject, trace, maxDepth);
 					premiseResults.push(met);
-					if (!met) {
-						allMet = false;
-						break;
-					}
-				}
-				ruleResults.set(rule.id, {
+					return met;
+				});
+				state.record({
 					id: rule.id,
 					applied: allMet,
 					premises: premiseResults
 				});
 				if (allMet) {
-					for (const [key, entry] of Object.entries(conclusionFacts)) if (!equalValues(derived[key], entry)) {
-						derived[key] = entry;
+					for (const [key, entry] of Object.entries(conclusionFacts)) if (!equalValues(state.field(key), entry)) {
+						state.set(key, entry);
 						trace.push(`Rule "${rule.id}" derived: ${key}=${String(entry)} (backward, depth ${depth})`);
 					}
 					return true;
@@ -4193,31 +4170,31 @@ var LogicalReasoner = class {
 		if (expression.form === "compound") {
 			const currentSubject = {
 				...subject,
-				...derived
+				...state.fields
 			};
 			switch (expression.operator) {
-				case "and": return expression.operands.every((operand) => this.#establish(operand, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth));
-				case "or": return expression.operands.some((operand) => this.#establish(operand, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth));
+				case "and": return expression.operands.every((operand) => this.#establish(operand, currentSubject, rules, depth, visited, state, subject, trace, maxDepth));
+				case "or": return expression.operands.some((operand) => this.#establish(operand, currentSubject, rules, depth, visited, state, subject, trace, maxDepth));
 				case "not": {
 					if (expression.operands.length === 0) return true;
 					const first = expression.operands[0];
 					if (!first) return true;
-					return !this.#establish(first, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth);
+					return !this.#establish(first, currentSubject, rules, depth, visited, state, subject, trace, maxDepth);
 				}
 				case "implies": {
 					if (expression.operands.length < 2) return true;
 					const antecedent = expression.operands[0];
 					const consequent = expression.operands[1];
 					if (!antecedent || !consequent) return true;
-					if (!this.#establish(antecedent, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth)) return true;
-					return this.#establish(consequent, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth);
+					if (!this.#establish(antecedent, currentSubject, rules, depth, visited, state, subject, trace, maxDepth)) return true;
+					return this.#establish(consequent, currentSubject, rules, depth, visited, state, subject, trace, maxDepth);
 				}
 				case "xor": {
 					if (expression.operands.length < 2) return false;
 					const left = expression.operands[0];
 					const right = expression.operands[1];
 					if (!left || !right) return false;
-					return this.#establish(left, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth) !== this.#establish(right, currentSubject, rules, depth, visited, derived, subject, trace, ruleResults, maxDepth);
+					return this.#establish(left, currentSubject, rules, depth, visited, state, subject, trace, maxDepth) !== this.#establish(right, currentSubject, rules, depth, visited, state, subject, trace, maxDepth);
 				}
 				default: return false;
 			}
@@ -4255,8 +4232,23 @@ var LogicalReasoner = class {
 		}
 	}
 };
-//#endregion
-//#region src/core/reasoners/SymbolicReasoner.ts
+// src/core/SymbolicState.ts
+/**
+* Stores numeric bindings for one symbolic reasoning call.
+*/
+var SymbolicState = class {
+	#values;
+	constructor(values) {
+		this.#values = { ...values };
+	}
+	get values() {
+		return this.#values;
+	}
+	set(name, value) {
+		this.#values[name] = value;
+	}
+};
+// src/core/reasoners/SymbolicReasoner.ts
 /**
 * Solves algebraic equations by variable isolation.
 *
@@ -4350,17 +4342,17 @@ var SymbolicReasoner = class {
 		const trace = [];
 		const errors = [];
 		const precision = definition.precision ?? 4;
-		const bindings = { ...definition.variables };
-		let bound = 0;
-		for (const key of Object.keys(subject)) {
-			if (key === "id") continue;
+		const state = new SymbolicState(definition.variables);
+		const bound = Object.keys(subject).reduce((count, key) => {
+			if (key === "id") return count;
 			const value = parseNumber(subject[key]);
 			if (value !== void 0) {
-				bindings[key] = value;
+				state.set(key, value);
 				trace.push(`Subject field "${key}" bound as ${key} = ${value}`);
-				bound++;
+				return count + 1;
 			}
-		}
+			return count;
+		}, 0);
 		if (bound > 0) trace.push(`Bound ${bound} variable(s) from subject`);
 		if (definition.equations.length === 0) {
 			trace.push("No equations to solve");
@@ -4375,7 +4367,7 @@ var SymbolicReasoner = class {
 		for (const equation of definition.equations) {
 			if (!isObject(equation)) continue;
 			try {
-				const value = this.#solve(equation, bindings);
+				const value = this.#solve(equation, state.values);
 				const rounded = roundTo(value, precision);
 				if (!isFiniteNumber(value) || !isFiniteNumber(rounded)) {
 					const offender = isFiniteNumber(value) ? rounded : value;
@@ -4384,7 +4376,7 @@ var SymbolicReasoner = class {
 					trace.push(`Equation "${equation.id}": FAILED — produced non-finite value (${description})`);
 					continue;
 				}
-				bindings[equation.target] = rounded;
+				state.set(equation.target, rounded);
 				trace.push(`Equation "${equation.id}": ${equation.target} = ${rounded}`);
 			} catch (error) {
 				const message = isError(error) ? error.message : String(error);
@@ -4392,15 +4384,15 @@ var SymbolicReasoner = class {
 				trace.push(`Equation "${equation.id}": FAILED — ${message}`);
 			}
 		}
-		const solutions = {};
+		const solutions = new SymbolicState();
 		for (const equation of definition.equations) {
 			if (!isObject(equation)) continue;
-			const value = bindings[equation.target];
-			if (value !== void 0) solutions[equation.target] = value;
+			const value = state.values[equation.target];
+			if (value !== void 0) solutions.set(equation.target, value);
 		}
 		return {
 			reasoning: "symbolic",
-			solutions,
+			solutions: solutions.values,
 			success: errors.length === 0,
 			trace,
 			errors
@@ -4458,8 +4450,37 @@ var SymbolicReasoner = class {
 		}
 	}
 };
-//#endregion
-//#region src/core/reasoners/InferentialReasoner.ts
+// src/core/InferenceJoin.ts
+/**
+* Joins premise bindings against a predicate-and-arity fact index.
+*/
+var InferenceJoin = class {
+	#index;
+	#bindings = [{}];
+	constructor(index) {
+		this.#index = index;
+	}
+	resolve(premises) {
+		this.#bindings = [{}];
+		if (premises.length === 0) return this.#bindings;
+		for (const premise of premises) {
+			const candidates = this.#index.get(factToArityKey(premise)) ?? [];
+			this.#bindings = this.#bindings.flatMap((existing) => {
+				const instantiated = instantiateFact(premise, existing);
+				return Iterator.from(candidates).flatMap((fact) => {
+					const match = matchFacts(instantiated, fact);
+					return match ? [{
+						...existing,
+						...match
+					}] : [];
+				}).toArray();
+			});
+			if (this.#bindings.length === 0) break;
+		}
+		return this.#bindings;
+	}
+};
+// src/core/reasoners/InferentialReasoner.ts
 /**
 * Derives facts with unification variables and proof trees.
 *
@@ -4614,35 +4635,31 @@ var InferentialReasoner = class {
 			}
 			validInferences.push(inference);
 		}
-		for (let iteration = 0; iteration < maxDepth; iteration++) {
-			let newDerivation = false;
-			for (const inference of validInferences) {
-				const allBindings = this.#findAllBindings(inference.premises, byArity);
-				for (const bindings of allBindings) {
-					const conclusion = instantiateFact(inference.conclusion, bindings);
-					const finalConfidence = computePremiseConfidence(inference.premises, byArity, bindings) * (inference.confidence ?? 1);
-					const derivedFact = {
-						...conclusion,
-						confidence: roundTo(finalConfidence, 4)
-					};
-					const key = factToKey(derivedFact, identities);
-					if (!seen.has(key)) {
-						knownFacts.push(derivedFact);
-						const arityKey = factToArityKey(derivedFact);
-						const bucket = byArity.get(arityKey);
-						if (bucket) bucket.push(derivedFact);
-						else byArity.set(arityKey, [derivedFact]);
-						seen.add(key);
-						derived.push(derivedFact);
-						newDerivation = true;
-						trace.push(`Derived ${derivedFact.predicate}(${derivedFact.terms.join(", ")}) through "${inference.id}" [confidence: ${derivedFact.confidence}] (iteration ${iteration + 1})`);
-					}
+		for (const iteration of iterateIndices(maxDepth)) if (!validInferences.reduce((previous, inference) => {
+			return new InferenceJoin(byArity).resolve(inference.premises).reduce((updated, bindings) => {
+				const conclusion = instantiateFact(inference.conclusion, bindings);
+				const finalConfidence = computePremiseConfidence(inference.premises, byArity, bindings) * (inference.confidence ?? 1);
+				const derivedFact = {
+					...conclusion,
+					confidence: roundTo(finalConfidence, 4)
+				};
+				const key = factToKey(derivedFact, identities);
+				if (!seen.has(key)) {
+					knownFacts.push(derivedFact);
+					const arityKey = factToArityKey(derivedFact);
+					const bucket = byArity.get(arityKey);
+					if (bucket) bucket.push(derivedFact);
+					else byArity.set(arityKey, [derivedFact]);
+					seen.add(key);
+					derived.push(derivedFact);
+					trace.push(`Derived ${derivedFact.predicate}(${derivedFact.terms.join(", ")}) through "${inference.id}" [confidence: ${derivedFact.confidence}] (iteration ${iteration + 1})`);
+					return true;
 				}
-			}
-			if (!newDerivation) {
-				trace.push(`Forward chaining converged at iteration ${iteration + 1}`);
-				break;
-			}
+				return updated;
+			}, previous);
+		}, false)) {
+			trace.push(`Forward chaining converged at iteration ${iteration + 1}`);
+			break;
 		}
 		return { derived };
 	}
@@ -4695,17 +4712,15 @@ var InferentialReasoner = class {
 			const conclusionBindings = matchFacts(goal, inference.conclusion);
 			if (!conclusionBindings) continue;
 			const children = [];
-			let allProved = true;
-			for (const premise of inference.premises) {
+			if (Iterator.from(inference.premises).every((premise) => {
 				const instantiated = instantiateFact(premise, conclusionBindings);
 				const child = this.#prove(instantiated, inferences, baseFacts, depth + 1, maxDepth);
-				if (child) children.push(child);
-				else {
-					allProved = false;
-					break;
+				if (child) {
+					children.push(child);
+					return true;
 				}
-			}
-			if (allProved) return {
+				return false;
+			})) return {
 				fact: goal.id,
 				inference: inference.id,
 				children,
@@ -4713,30 +4728,8 @@ var InferentialReasoner = class {
 			};
 		}
 	}
-	#findAllBindings(premises, byArity) {
-		if (premises.length === 0) return [{}];
-		let currentBindings = [{}];
-		for (const premise of premises) {
-			const nextBindings = [];
-			const candidates = byArity.get(factToArityKey(premise)) ?? [];
-			for (const existing of currentBindings) {
-				const instantiated = instantiateFact(premise, existing);
-				for (const fact of candidates) {
-					const match = matchFacts(instantiated, fact);
-					if (match) nextBindings.push({
-						...existing,
-						...match
-					});
-				}
-			}
-			currentBindings = nextBindings;
-			if (currentBindings.length === 0) break;
-		}
-		return currentBindings;
-	}
 };
-//#endregion
-//#region src/core/builders/managers/Collection.ts
+// src/core/builders/managers/Collection.ts
 /**
 * Holds the id-keyed collection state the `DefinitionBuilder`'s list managers
 * share — the array, the placement verbs, the silent re-seat, and the
@@ -4802,8 +4795,7 @@ var Collection = class {
 		if (this.#destroyed) throw new ReasonError("DESTROYED", `${this.#owner} has been destroyed`);
 	}
 };
-//#endregion
-//#region src/core/builders/managers/EquationManager.ts
+// src/core/builders/managers/EquationManager.ts
 /**
 * Implements the {@link EquationManagerInterface} — a self-owning,
 * kind-free manager over a symbolic definition's `equations`.
@@ -4874,11 +4866,7 @@ var EquationManager = class {
 			for (const equation of this.#equations.items()) this.#removeOne(equation.id);
 			return;
 		}
-		if (isArray(idOrIds)) {
-			let all = true;
-			for (const id of idOrIds) if (!this.#removeOne(id)) all = false;
-			return all;
-		}
+		if (isArray(idOrIds)) return Iterator.from(idOrIds).reduce((all, id) => this.#removeOne(id) && all, true);
 		return this.#removeOne(idOrIds);
 	}
 	seat(equations) {
@@ -4895,8 +4883,7 @@ var EquationManager = class {
 		return true;
 	}
 };
-//#endregion
-//#region src/core/builders/managers/FactManager.ts
+// src/core/builders/managers/FactManager.ts
 /**
 * Implements the {@link FactManagerInterface} — a self-owning, kind-free
 * manager over an inferential definition's `facts`.
@@ -4962,11 +4949,7 @@ var FactManager = class {
 			for (const fact of this.#facts.items()) this.#removeOne(fact.id);
 			return;
 		}
-		if (isArray(idOrIds)) {
-			let all = true;
-			for (const id of idOrIds) if (!this.#removeOne(id)) all = false;
-			return all;
-		}
+		if (isArray(idOrIds)) return Iterator.from(idOrIds).reduce((all, id) => this.#removeOne(id) && all, true);
 		return this.#removeOne(idOrIds);
 	}
 	seat(facts) {
@@ -4983,8 +4966,7 @@ var FactManager = class {
 		return true;
 	}
 };
-//#endregion
-//#region src/core/builders/managers/FactorManager.ts
+// src/core/builders/managers/FactorManager.ts
 /**
 * Implements the {@link FactorManagerInterface} — the one divergent
 * manager: factors nest inside groups, so it holds no collection state of its
@@ -5068,11 +5050,7 @@ var FactorManager = class {
 			for (const factor of this.#locate(groupId).factors) this.#removeOne(groupId, factor.id);
 			return;
 		}
-		if (isArray(idOrIds)) {
-			let all = true;
-			for (const id of idOrIds) if (!this.#removeOne(groupId, id)) all = false;
-			return all;
-		}
+		if (isArray(idOrIds)) return Iterator.from(idOrIds).reduce((all, id) => this.#removeOne(groupId, id) && all, true);
 		return this.#removeOne(groupId, idOrIds);
 	}
 	destroy() {
@@ -5096,8 +5074,7 @@ var FactorManager = class {
 		return group;
 	}
 };
-//#endregion
-//#region src/core/builders/managers/GroupManager.ts
+// src/core/builders/managers/GroupManager.ts
 /**
 * Implements the {@link GroupManagerInterface} — a self-owning, kind-free
 * manager over a quantitative definition's `groups`.
@@ -5163,11 +5140,7 @@ var GroupManager = class {
 			for (const group of this.#groups.items()) this.#removeOne(group.id);
 			return;
 		}
-		if (isArray(idOrIds)) {
-			let all = true;
-			for (const id of idOrIds) if (!this.#removeOne(id)) all = false;
-			return all;
-		}
+		if (isArray(idOrIds)) return Iterator.from(idOrIds).reduce((all, id) => this.#removeOne(id) && all, true);
 		return this.#removeOne(idOrIds);
 	}
 	seat(groups) {
@@ -5184,8 +5157,7 @@ var GroupManager = class {
 		return true;
 	}
 };
-//#endregion
-//#region src/core/builders/managers/InferenceManager.ts
+// src/core/builders/managers/InferenceManager.ts
 /**
 * Implements the {@link InferenceManagerInterface} — a self-owning,
 * kind-free manager over an inferential definition's `inferences`.
@@ -5261,11 +5233,7 @@ var InferenceManager = class {
 			for (const inference of this.#inferences.items()) this.#removeOne(inference.id);
 			return;
 		}
-		if (isArray(idOrIds)) {
-			let all = true;
-			for (const id of idOrIds) if (!this.#removeOne(id)) all = false;
-			return all;
-		}
+		if (isArray(idOrIds)) return Iterator.from(idOrIds).reduce((all, id) => this.#removeOne(id) && all, true);
 		return this.#removeOne(idOrIds);
 	}
 	seat(inferences) {
@@ -5282,8 +5250,7 @@ var InferenceManager = class {
 		return true;
 	}
 };
-//#endregion
-//#region src/core/builders/managers/RuleManager.ts
+// src/core/builders/managers/RuleManager.ts
 /**
 * Implements the {@link RuleManagerInterface} — a self-owning, kind-free
 * manager over a logical definition's `rules`.
@@ -5352,11 +5319,7 @@ var RuleManager = class {
 			for (const rule of this.#rules.items()) this.#removeOne(rule.id);
 			return;
 		}
-		if (isArray(idOrIds)) {
-			let all = true;
-			for (const id of idOrIds) if (!this.#removeOne(id)) all = false;
-			return all;
-		}
+		if (isArray(idOrIds)) return Iterator.from(idOrIds).reduce((all, id) => this.#removeOne(id) && all, true);
 		return this.#removeOne(idOrIds);
 	}
 	seat(rules) {
@@ -5373,8 +5336,7 @@ var RuleManager = class {
 		return true;
 	}
 };
-//#endregion
-//#region src/core/builders/managers/VariableManager.ts
+// src/core/builders/managers/VariableManager.ts
 /**
 * Implements the {@link VariableManagerInterface} — a self-owning,
 * kind-free manager over a symbolic definition's `variables`, a name-keyed
@@ -5441,11 +5403,7 @@ var VariableManager = class {
 			for (const name of Object.keys(this.#variables)) this.#removeOne(name);
 			return;
 		}
-		if (isArray(nameOrNames)) {
-			let all = true;
-			for (const name of nameOrNames) if (!this.#removeOne(name)) all = false;
-			return all;
-		}
+		if (isArray(nameOrNames)) return Iterator.from(nameOrNames).reduce((all, name) => this.#removeOne(name) && all, true);
 		return this.#removeOne(nameOrNames);
 	}
 	seat(variables) {
@@ -5468,8 +5426,7 @@ var VariableManager = class {
 		return true;
 	}
 };
-//#endregion
-//#region src/core/builders/DefinitionBuilder.ts
+// src/core/builders/DefinitionBuilder.ts
 /**
 * Implements a stateful workspace builder accumulating a {@link Definition}
 * through always-present self-owning manager properties: a private scalar
@@ -5581,28 +5538,13 @@ var DefinitionBuilder = class {
 			definition: this.#id,
 			reasoning: current.reasoning
 		});
-		let merged;
-		if (current.reasoning === "quantitative" && incoming.reasoning === "quantitative") merged = mergeQuantitativeDefinition(current, incoming);
-		else if (current.reasoning === "logical" && incoming.reasoning === "logical") merged = mergeLogicalDefinition(current, incoming);
-		else if (current.reasoning === "symbolic" && incoming.reasoning === "symbolic") merged = mergeSymbolicDefinition(current, incoming);
-		else if (current.reasoning === "inferential" && incoming.reasoning === "inferential") merged = mergeInferentialDefinition(current, incoming);
-		else merged = current;
+		const merged = current.reasoning === "quantitative" && incoming.reasoning === "quantitative" ? mergeQuantitativeDefinition(current, incoming) : current.reasoning === "logical" && incoming.reasoning === "logical" ? mergeLogicalDefinition(current, incoming) : current.reasoning === "symbolic" && incoming.reasoning === "symbolic" ? mergeSymbolicDefinition(current, incoming) : current.reasoning === "inferential" && incoming.reasoning === "inferential" ? mergeInferentialDefinition(current, incoming) : current;
 		this.#seat(merged);
 		this.#emitter.emit("merge", merged.reasoning);
 	}
 	clear(key) {
 		this.#ensureAlive();
-		const current = this.#compose();
-		let next;
-		if (current.reasoning === "quantitative" && isQuantitativeClearKey(key)) next = clearQuantitativeDefinition(current, key);
-		else if (current.reasoning === "logical" && isLogicalClearKey(key)) next = clearLogicalDefinition(current, key);
-		else if (current.reasoning === "symbolic" && isSymbolicClearKey(key)) next = clearSymbolicDefinition(current, key);
-		else if (current.reasoning === "inferential" && isInferentialClearKey(key)) next = clearInferentialDefinition(current, key);
-		else throw new ReasonError("MISMATCH", `"${key}" is not a clearable field for reasoning "${current.reasoning}"`, {
-			key,
-			reasoning: current.reasoning
-		});
-		this.#envelope = definitionToEnvelope(next);
+		this.#envelope = definitionToEnvelope(this.#clear(key));
 		this.#emitter.emit("clear", key);
 	}
 	destroy() {
@@ -5617,6 +5559,17 @@ var DefinitionBuilder = class {
 		this.#emitter.emit("destroy");
 		this.#emitter.destroy();
 	}
+	#clear(key) {
+		const current = this.#compose();
+		if (current.reasoning === "quantitative" && isQuantitativeClearKey(key)) return clearQuantitativeDefinition(current, key);
+		else if (current.reasoning === "logical" && isLogicalClearKey(key)) return clearLogicalDefinition(current, key);
+		else if (current.reasoning === "symbolic" && isSymbolicClearKey(key)) return clearSymbolicDefinition(current, key);
+		else if (current.reasoning === "inferential" && isInferentialClearKey(key)) return clearInferentialDefinition(current, key);
+		else throw new ReasonError("MISMATCH", `"${key}" is not a clearable field for reasoning "${current.reasoning}"`, {
+			key,
+			reasoning: current.reasoning
+		});
+	}
 	#compose() {
 		const envelope = this.#envelope;
 		switch (envelope.reasoning) {
@@ -5662,8 +5615,7 @@ var DefinitionBuilder = class {
 		if (this.#destroyed) throw new ReasonError("DESTROYED", "DefinitionBuilder has been destroyed");
 	}
 };
-//#endregion
-//#region src/core/builders/SubjectBuilder.ts
+// src/core/builders/SubjectBuilder.ts
 /**
 * Implements a stateful workspace builder accumulating a {@link Subject} — one
 * flat key-value collection, no managers.
@@ -5751,11 +5703,7 @@ var SubjectBuilder = class {
 			for (const key of Object.keys(this.#subject)) if (key !== "id") this.#removeOne(key);
 			return;
 		}
-		if (isArray(keyOrKeys)) {
-			let all = true;
-			for (const key of keyOrKeys) if (!this.#removeOne(key)) all = false;
-			return all;
-		}
+		if (isArray(keyOrKeys)) return Iterator.from(keyOrKeys).reduce((all, key) => this.#removeOne(key) && all, true);
 		return this.#removeOne(keyOrKeys);
 	}
 	merge(incoming) {
@@ -5799,8 +5747,7 @@ var SubjectBuilder = class {
 		return existed;
 	}
 };
-//#endregion
-//#region src/core/factories.ts
+// src/core/factories.ts
 /**
 * Creates a check evaluator.
 *
@@ -6872,7 +6819,6 @@ function createInferentialDefinition(id, name, facts, inferences, overrides) {
 		...overrides
 	};
 }
-//#endregion
-export { AGGREGATOR_ID, Aggregator, CONFIDENCE_PRECISION, DEFAULT_BASE, DEFAULT_CONFIDENCE, DEFAULT_DEPTH, DEFAULT_PRECISION, DEFAULT_PRIORITY, DEFAULT_REASON_BAIL, DEFAULT_VALIDATE, DEFAULT_WEIGHT, DEFINITION_BUILDER_BRAND, DefinitionBuilder, EVALUATOR_ID, EquationManager, Evaluator, FactManager, FactorManager, GroupManager, INFERENTIAL_ID, INVERTIBLE_OPERATIONS, InferenceManager, InferentialReasoner, LOGICAL_ID, LogicalReasoner, QUANTITATIVE_ID, QuantitativeReasoner, Reason, ReasonError, RuleManager, SUBJECT_BUILDER_BRAND, SYMBOLIC_ID, SubjectBuilder, SymbolicReasoner, TRANSFORMER_ID, Transformer, VariableManager, addVariable, appendById, appendEquation, appendFact, appendFactor, appendGroup, appendInference, appendRule, applyOperation, assignField, buildErrorResult, clamp, clearInferentialDefinition, clearLogicalDefinition, clearQuantitativeDefinition, clearSymbolicDefinition, computePremiseConfidence, containsVariable, createAggregator, createAtom, createBounds, createCheck, createCompound, createConstant, createDefinitionBuilder, createEquation, createEquationManager, createEvaluator, createFact, createFactManager, createFactorGroup, createFactorManager, createFieldFactor, createFieldSource, createGroupManager, createInference, createInferenceManager, createInferentialDefinition, createInferentialReasoner, createLogicalDefinition, createLogicalReasoner, createLookupFactor, createLookupSource, createOperation, createQuantitativeDefinition, createQuantitativeReasoner, createRangeFactor, createRangeSource, createReason, createRule, createRuleManager, createStaticFactor, createStaticSource, createSubjectBuilder, createSymbolicDefinition, createSymbolicReasoner, createTransform, createTransformer, createVariable, createVariableManager, definitionToEnvelope, emptyAggregate, equalValues, extractAtoms, extractConclusions, factToArityKey, factToKey, findDuplicates, findOverlayMismatches, findUnboundVariables, formatField, indexByArity, instantiateFact, invertLeft, invertRight, isAggregation, isBounds, isChainingStrategy, isCheck, isCheckResult, isComparison, isDefinition, isDefinitionBuilder, isEquation, isExpression, isFact, isFactor, isFactorGroup, isFactorRange, isFactorResult, isFieldPath, isGroupResult, isInference, isInferentialClearKey, isInferentialDefinition, isInferentialResult, isLogicalClearKey, isLogicalDefinition, isLogicalOperator, isLogicalResult, isMathOperation, isNumberRecord, isProofNode, isQuantitativeClearKey, isQuantitativeDefinition, isQuantitativeResult, isReasonError, isReasonResult, isReasonValidationResult, isReasoning, isResultFact, isRule, isRuleResult, isSource, isSubjectBuilder, isSymbolicClearKey, isSymbolicDefinition, isSymbolicExpression, isSymbolicResult, isTransform, matchFacts, matchesBounds, mergeById, mergeInferentialDefinition, mergeLogicalDefinition, mergeQuantitativeDefinition, mergeSubjects, mergeSymbolicDefinition, parseDefinition, prependById, prependEquation, prependFact, prependFactor, prependGroup, prependInference, prependRule, removeById, removeEquation, removeFact, removeFactor, removeField, removeGroup, removeInference, removeRule, removeVariable, repeatSubject, replaceById, replaceEquation, replaceFact, replaceFactor, replaceGroup, replaceInference, replaceRule, resolveOperand, resolveSource, roundTo, sortByPriority, subjectToFacts, termToKey };
+export { AGGREGATOR_ID, Aggregator, CONFIDENCE_PRECISION, DEFAULT_BASE, DEFAULT_CONFIDENCE, DEFAULT_DEPTH, DEFAULT_PRECISION, DEFAULT_PRIORITY, DEFAULT_REASON_BAIL, DEFAULT_VALIDATE, DEFAULT_WEIGHT, DEFINITION_BUILDER_BRAND, DefinitionBuilder, EVALUATOR_ID, EquationManager, Evaluator, FactManager, FactorManager, GroupManager, INFERENTIAL_ID, INVERTIBLE_OPERATIONS, InferenceManager, InferentialReasoner, LOGICAL_ID, LogicalReasoner, QUANTITATIVE_ID, QuantitativeReasoner, Reason, ReasonError, RuleManager, SUBJECT_BUILDER_BRAND, SYMBOLIC_ID, SubjectBuilder, SymbolicReasoner, TRANSFORMER_ID, Transformer, VariableManager, addVariable, appendById, appendEquation, appendFact, appendFactor, appendGroup, appendInference, appendRule, applyOperation, assignField, buildErrorResult, clamp, clearInferentialDefinition, clearLogicalDefinition, clearQuantitativeDefinition, clearSymbolicDefinition, computePremiseConfidence, containsVariable, createAggregator, createAtom, createBounds, createCheck, createCompound, createConstant, createDefinitionBuilder, createEquation, createEquationManager, createEvaluator, createFact, createFactManager, createFactorGroup, createFactorManager, createFieldFactor, createFieldSource, createGroupManager, createInference, createInferenceManager, createInferentialDefinition, createInferentialReasoner, createLogicalDefinition, createLogicalReasoner, createLookupFactor, createLookupSource, createOperation, createQuantitativeDefinition, createQuantitativeReasoner, createRangeFactor, createRangeSource, createReason, createRule, createRuleManager, createStaticFactor, createStaticSource, createSubjectBuilder, createSymbolicDefinition, createSymbolicReasoner, createTransform, createTransformer, createVariable, createVariableManager, definitionToEnvelope, emptyAggregate, equalValues, extractAtoms, extractConclusions, factToArityKey, factToKey, findDuplicates, findOverlayMismatches, findUnboundVariables, formatField, indexByArity, instantiateFact, invertLeft, invertRight, isAggregation, isBounds, isChainStrategy, isCheck, isCheckResult, isComparison, isDefinition, isDefinitionBuilder, isEquation, isExpression, isFact, isFactor, isFactorGroup, isFactorRange, isFactorResult, isFieldPath, isGroupResult, isInference, isInferentialClearKey, isInferentialDefinition, isInferentialResult, isLogicalClearKey, isLogicalDefinition, isLogicalOperator, isLogicalResult, isMathOperation, isNumberRecord, isProofNode, isQuantitativeClearKey, isQuantitativeDefinition, isQuantitativeResult, isReasonError, isReasonResult, isReasonValidationResult, isReasoning, isResultFact, isRule, isRuleResult, isSource, isSubjectBuilder, isSymbolicClearKey, isSymbolicDefinition, isSymbolicExpression, isSymbolicResult, isTransform, iterateIndices, matchFacts, matchesBounds, mergeById, mergeInferentialDefinition, mergeLogicalDefinition, mergeQuantitativeDefinition, mergeSubjects, mergeSymbolicDefinition, parseDefinition, prependById, prependEquation, prependFact, prependFactor, prependGroup, prependInference, prependRule, removeById, removeEquation, removeFact, removeFactor, removeField, removeGroup, removeInference, removeRule, removeVariable, repeatSubject, replaceById, replaceEquation, replaceFact, replaceFactor, replaceGroup, replaceInference, replaceRule, resolveOperand, resolveSource, roundTo, sortByPriority, subjectToFacts, termToKey };
 
 //# sourceMappingURL=index.js.map