schemair 0.1.0 → 0.3.0

package/dist/{type-interpreter-Ck0VDhzn.js → type-interpreter-BA8gcLUU.js}

@@ -1,5 +1,6 @@
-import { t as validateSchemaNodeDefinition } from "./definition-BXj3T94L.js";
-import { i as checkSchemaRelationAsync, r as checkSchemaRelation } from "./relations-By0bK3UK.js";
+import { a as expressionShapeIssue, f as validateSchemaNodeDefinition, i as expressionKinds, n as validateSchemaTypeTermDefinition, r as expressionFields } from "./definition-BH_LzXGc.js";
+import { n as schemaRefKey, t as indexSchemaRefs } from "./schema-ref-key-DR__tPr-.js";
+import { r as checkSchemaRelation } from "./relations-QtnCRW9x.js";
 
 //#region src/type-interpreter/materializer.ts
 function isRecord(value) {
@@ -861,6 +862,18 @@ function compareTerms(source, target, context) {
 					message: "source does not provide a required field"
 				}]
 			};
+			if (!sourceField && source.additionalFields !== void 0) {
+				if (source.additionalFields === true) return {
+					status: "unknown",
+					issues: [{
+						code: "relation.unknown.additionalField",
+						path: ["fields", field.key],
+						message: "unconstrained source residual values do not prove compatibility with the target field"
+					}]
+				};
+				const residual = compareTerms(source.additionalFields, field.value, context);
+				if (residual.status !== "assignable") return residual;
+			}
 			if (sourceField) {
 				if (field.required === true && sourceField.required !== true) return {
 					status: "incompatible",
@@ -935,125 +948,11 @@ function unknownTermRelation() {
 		}]
 	};
 }
-async function compareTermsAsync(source, target, context) {
-	if (source.kind === "never") return {
-		status: "assignable",
-		issues: []
-	};
-	if (source.kind === "absent") return target.kind === "absent" || target.kind === "maybeAbsent" ? {
-		status: "assignable",
-		issues: []
-	} : incompatiblePresence("absent");
-	if (target.kind === "never" || target.kind === "absent") return incompatiblePresence(target.kind);
-	if (source.kind === "maybeAbsent" && target.kind !== "maybeAbsent") return incompatiblePresence("maybeAbsent");
-	if (target.kind === "unknown") return {
-		status: "assignable",
-		issues: []
-	};
-	if (source.kind === "unknown") return unknownTermRelation();
-	if (source.kind === "opaqueHostType" && target.kind === "opaqueHostType") {
-		if (samePath(source.hostPath, target.hostPath)) return {
-			status: "assignable",
-			issues: []
-		};
-		if (!context.hostTypeRelation) return {
-			status: "incompatible",
-			issues: [{
-				code: "relation.incompatible.opaqueHostType",
-				path: [],
-				message: "different opaque host types require an explicit relation provider"
-			}]
-		};
-		return hostDecision(await context.hostTypeRelation(source.hostPath, target.hostPath), "opaque host type relation provider rejected the relation");
-	}
-	if (source.kind === "arrayOf" && target.kind === "arrayOf") {
-		if (!sameData(source.constraints, target.constraints)) return unknownMetadata();
-		return compareTermsAsync(source.element, target.element, context);
-	}
-	if (source.kind === "maybeAbsent" || target.kind === "maybeAbsent") {
-		if (source.kind !== "maybeAbsent") {
-			if (target.kind === "maybeAbsent") return compareTermsAsync(source, target.value, context);
-			return unreachableRelation();
-		}
-		if (target.kind !== "maybeAbsent") return incompatiblePresence("maybeAbsent");
-		return compareTermsAsync(source.value, target.value, context);
-	}
-	if (source.kind === "array" && target.kind === "array") return checkSchemaRelationAsync(source, target, context.relation);
-	if (source.kind === "record" && target.kind === "record") return checkSchemaRelationAsync(source, target, context.relation);
-	if (source.kind === "tupleOf" && target.kind === "tupleOf") {
-		if (source.elements.length !== target.elements.length) return {
-			status: "incompatible",
-			issues: [{
-				code: "relation.incompatible.tuple.length",
-				path: [],
-				message: "tuple lengths are different"
-			}]
-		};
-		for (let index = 0; index < source.elements.length; index += 1) {
-			const result$1 = await compareTermsAsync(source.elements[index], target.elements[index], context);
-			if (result$1.status !== "assignable") return result$1;
-		}
-		return {
-			status: "assignable",
-			issues: []
-		};
-	}
-	if (source.kind === "tuple" && target.kind === "tuple") return checkSchemaRelationAsync(source, target, context.relation);
-	if (source.kind === "recordOf" && target.kind === "recordOf") {
-		if (!sameData(source.constraints, target.constraints) || !sameData(source.additionalFields, target.additionalFields)) return unknownMetadata();
-		const sourceFields = new Map(source.fields.map((field) => [field.key, field]));
-		for (const field of target.fields) {
-			const sourceField = sourceFields.get(field.key);
-			if (!sourceField && field.required === true) return {
-				status: "incompatible",
-				issues: [{
-					code: "relation.incompatible.required",
-					path: ["fields", field.key],
-					message: "source does not provide a required field"
-				}]
-			};
-			if (sourceField) {
-				if (field.required === true && sourceField.required !== true) return {
-					status: "incompatible",
-					issues: [{
-						code: "relation.incompatible.required",
-						path: ["fields", field.key],
-						message: "source field may be absent"
-					}]
-				};
-				const result$1 = await compareTermsAsync(sourceField.value, field.value, context);
-				if (result$1.status !== "assignable") return result$1;
-			}
-		}
-		for (const field of source.fields) if (!target.fields.some((candidate) => candidate.key === field.key)) {
-			if (target.additionalFields === void 0) return {
-				status: "incompatible",
-				issues: [{
-					code: "relation.incompatible.additionalField",
-					path: ["fields", field.key],
-					message: "target record does not allow this source field"
-				}]
-			};
-			if (target.additionalFields !== true) {
-				const relation = await compareTermsAsync(field.value, target.additionalFields, context);
-				if (relation.status !== "assignable") return relation;
-			}
-		}
-		return {
-			status: "assignable",
-			issues: []
-		};
-	}
-	const sourceSchema = validateSchemaNodeDefinition(source);
-	const targetSchema = validateSchemaNodeDefinition(target);
-	if (sourceSchema.ok && targetSchema.ok) return checkSchemaRelationAsync(sourceSchema.node, targetSchema.node, context.relation);
+function relationWithInterpreterRefs(relation, interpreter) {
+	if (interpreter?.refs === void 0) return relation ?? {};
 	return {
-		status: "unknown",
-		issues: [{
-			code: "relation.unknown.term",
-			path: [],
-			message: "async relation requires normalized term comparison"
-		}]
+		...relation ?? {},
+		refs: [...relation?.refs ?? [], ...interpreter.refs]
 	};
 }
 function diagnostics(result$1, status) {
@@ -1077,211 +976,12 @@ function compareEvaluated(source, target, relation = {}, hostTypeRelation) {
 	} : { relation });
 }
 function checkTypeTermRelation(source, target, context = {}) {
-	return compareEvaluated(evaluateExpression(source, context.interpreter), evaluateExpression(target, context.interpreter), context.relation, context.hostTypeRelation);
-}
-async function checkTypeTermRelationAsync(source, target, context = {}) {
-	const [sourceResult, targetResult] = await Promise.all([evaluateExpressionAsync(source, context.interpreter), evaluateExpressionAsync(target, context.interpreter)]);
-	if (sourceResult.status !== "evaluated" || targetResult.status !== "evaluated") return compareEvaluated(sourceResult, targetResult);
-	return compareTermsAsync(sourceResult.term, targetResult.term, context);
+	const relation = relationWithInterpreterRefs(context.relation, context.interpreter);
+	return compareEvaluated(evaluateExpression(source, context.interpreter), evaluateExpression(target, context.interpreter), relation, context.hostTypeRelation);
 }
 
 //#endregion
 //#region src/type-interpreter/interpreter.ts
-const expressionKinds = new Set([
-	"typeVar",
-	"opaqueHostType",
-	"absent",
-	"never",
-	"unknown",
-	"maybeAbsent",
-	"arrayOf",
-	"tupleOf",
-	"recordOf",
-	"elementOf",
-	"valueOf",
-	"elementAt",
-	"fieldOf",
-	"keyOf",
-	"fieldsOf",
-	"pickFields",
-	"omitFields",
-	"partialFields",
-	"requiredFields",
-	"mergeRecords",
-	"nullableOf",
-	"taggedUnionOf",
-	"intersect",
-	"refine",
-	"excludeVariants",
-	"extractVariants"
-]);
-const expressionFields = {
-	typeVar: {
-		required: ["name"],
-		allowed: [
-			"kind",
-			"name",
-			"extends"
-		]
-	},
-	opaqueHostType: {
-		required: ["hostPath"],
-		allowed: ["kind", "hostPath"]
-	},
-	absent: {
-		required: [],
-		allowed: ["kind"]
-	},
-	never: {
-		required: [],
-		allowed: ["kind"]
-	},
-	unknown: {
-		required: [],
-		allowed: ["kind"]
-	},
-	maybeAbsent: {
-		required: ["value"],
-		allowed: ["kind", "value"]
-	},
-	arrayOf: {
-		required: ["element"],
-		allowed: [
-			"kind",
-			"element",
-			"constraints"
-		]
-	},
-	tupleOf: {
-		required: ["elements"],
-		allowed: ["kind", "elements"]
-	},
-	recordOf: {
-		required: ["fields"],
-		allowed: [
-			"kind",
-			"fields",
-			"additionalFields",
-			"constraints"
-		]
-	},
-	nullableOf: {
-		required: ["value"],
-		allowed: ["kind", "value"]
-	},
-	taggedUnionOf: {
-		required: ["discriminator", "variants"],
-		allowed: [
-			"kind",
-			"discriminator",
-			"variants"
-		]
-	},
-	elementOf: {
-		required: ["source"],
-		allowed: ["kind", "source"]
-	},
-	valueOf: {
-		required: ["source"],
-		allowed: ["kind", "source"]
-	},
-	elementAt: {
-		required: ["source", "index"],
-		allowed: [
-			"kind",
-			"source",
-			"index"
-		]
-	},
-	fieldOf: {
-		required: ["source", "key"],
-		allowed: [
-			"kind",
-			"source",
-			"key"
-		]
-	},
-	keyOf: {
-		required: ["source"],
-		allowed: ["kind", "source"]
-	},
-	fieldsOf: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	pickFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	omitFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	partialFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	requiredFields: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	mergeRecords: {
-		required: ["sources", "conflict"],
-		allowed: [
-			"kind",
-			"sources",
-			"conflict"
-		]
-	},
-	intersect: {
-		required: ["sources"],
-		allowed: ["kind", "sources"]
-	},
-	refine: {
-		required: ["source", "fields"],
-		allowed: [
-			"kind",
-			"source",
-			"fields"
-		]
-	},
-	excludeVariants: {
-		required: ["source", "variants"],
-		allowed: [
-			"kind",
-			"source",
-			"variants"
-		]
-	},
-	extractVariants: {
-		required: ["source", "variants"],
-		allowed: [
-			"kind",
-			"source",
-			"variants"
-		]
-	}
-};
 function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1341,99 +1041,19 @@ function childTerms(expression) {
 	});
 	return children;
 }
-function hasOnlyKeys(value, keys) {
-	return Object.keys(value).every((key) => keys.includes(key));
-}
-function isSelector(value) {
-	if (!isObject(value)) return false;
-	if (value.kind === "all") return hasOnlyKeys(value, ["kind"]);
-	return value.kind === "keys" && hasOnlyKeys(value, [
-		"kind",
-		"keys",
-		"onMissing"
-	]) && Array.isArray(value.keys) && value.keys.every((key) => typeof key === "string") && new Set(value.keys).size === value.keys.length && (value.onMissing === "error" || value.onMissing === "ignore");
-}
-function expressionShapeIssue(expression) {
-	const kind = expression.kind;
-	if (kind === "typeVar" && (typeof expression.name !== "string" || !expression.name.trim())) return "typeVar name must be non-blank";
-	if (kind === "opaqueHostType" && (!Array.isArray(expression.hostPath) || expression.hostPath.length === 0 || expression.hostPath.some((part) => typeof part !== "string" || !part.trim()))) return "hostPath must be a non-empty path";
-	if (kind === "tupleOf" && (!Array.isArray(expression.elements) || !isDense(expression.elements))) return "elements must be a dense array";
-	if (kind === "recordOf") {
-		if (!Array.isArray(expression.fields) || !isDense(expression.fields)) return "fields must be a dense array";
-		const keys = /* @__PURE__ */ new Set();
-		for (const field of expression.fields) {
-			if (!isObject(field) || !hasOnlyKeys(field, [
-				"key",
-				"value",
-				"required",
-				"description"
-			]) || typeof field.key !== "string" || keys.has(field.key)) return "record fields must have unique keys and a valid shape";
-			if (field.required !== void 0 && typeof field.required !== "boolean") return "record field required must be a boolean";
-			if (field.description !== void 0 && typeof field.description !== "string") return "record field description must be a string";
-			keys.add(field.key);
-		}
-		if (expression.additionalFields !== void 0 && expression.additionalFields !== true && !isObject(expression.additionalFields)) return "additionalFields must be a type term or true";
-		if (expression.constraints !== void 0 && (!Array.isArray(expression.constraints) || !isDense(expression.constraints))) return "constraints must be a dense array";
-	}
-	if (kind === "arrayOf" && expression.constraints !== void 0 && (!Array.isArray(expression.constraints) || !isDense(expression.constraints))) return "constraints must be a dense array";
-	if (kind === "taggedUnionOf") {
-		if (typeof expression.discriminator !== "string" || !expression.discriminator.trim() || !Array.isArray(expression.variants) || !isDense(expression.variants) || expression.variants.length < 2) return "taggedUnionOf requires a discriminator and at least two dense variants";
-		const keys = /* @__PURE__ */ new Set();
-		for (const variant of expression.variants) {
-			if (!isObject(variant) || !hasOnlyKeys(variant, [
-				"key",
-				"value",
-				"description"
-			]) || typeof variant.key !== "string" || !variant.key.trim() || keys.has(variant.key)) return "taggedUnionOf variants must have unique non-blank keys and a valid shape";
-			if (variant.description !== void 0 && typeof variant.description !== "string") return "variant description must be a string";
-			keys.add(variant.key);
-		}
-	}
-	if ([
-		"fieldsOf",
-		"pickFields",
-		"omitFields",
-		"partialFields",
-		"requiredFields"
-	].includes(String(kind)) && !isSelector(expression.fields)) return "fields must be a valid field selector";
-	if ((kind === "excludeVariants" || kind === "extractVariants") && !isSelector(expression.variants)) return "variants must be a valid variant selector";
-	if (kind === "elementAt" && (!Number.isSafeInteger(expression.index) || expression.index < 0)) return "index must be a non-negative safe integer";
-	if (kind === "fieldOf" && typeof expression.key !== "string") return "key must be a string";
-	if (kind === "mergeRecords" && (!Array.isArray(expression.sources) || !isDense(expression.sources) || expression.sources.length < 2 || ![
-		"leftWins",
-		"rightWins",
-		"error"
-	].includes(String(expression.conflict)))) return "mergeRecords requires at least two dense sources and a valid conflict policy";
-	if (kind === "intersect" && (!Array.isArray(expression.sources) || !isDense(expression.sources) || expression.sources.length < 2)) return "intersect requires at least two dense sources";
-	if (kind === "refine") {
-		if (!Array.isArray(expression.fields) || !isDense(expression.fields) || expression.fields.length === 0) return "refine requires non-empty dense field actions";
-		const keys = /* @__PURE__ */ new Set();
-		for (const action of expression.fields) {
-			if (!isObject(action) || !hasOnlyKeys(action, [
-				"key",
-				"require",
-				"intersectWith",
-				"addConstraints"
-			]) || typeof action.key !== "string" || keys.has(action.key)) return "refine actions must have unique keys and a valid shape";
-			if (action.require !== void 0 && action.require !== true) return "refine require must be true when specified";
-			if (action.addConstraints !== void 0 && (!Array.isArray(action.addConstraints) || !isDense(action.addConstraints))) return "addConstraints must be a dense array";
-			keys.add(action.key);
-		}
-	}
-}
-function isDense(value) {
-	for (let index = 0; index < value.length; index += 1) if (!Object.prototype.hasOwnProperty.call(value, index)) return false;
-	return true;
-}
 function replaceChild(expression, path, value) {
 	const [key, indexText, subkey] = path.split(".");
 	if (indexText === void 0) {
 		expression[key] = value;
 		return;
 	}
-	const items = expression[key];
+	const items = [...expression[key]];
+	expression[key] = items;
 	const index = Number(indexText);
-	if (subkey) items[index][subkey] = value;
+	if (subkey) items[index] = {
+		...items[index],
+		[subkey]: value
+	};
 	else items[index] = value;
 }
 function projectNormalized(expression) {
@@ -1542,33 +1162,32 @@ function operandKindIssue(expression) {
 function normalize(term, state, depth = 0) {
 	state.steps += 1;
 	if (state.steps > (state.context.maxSteps ?? 2e3) || depth > (state.context.maxDepth ?? 64)) return failure("incomplete", "budget", "type interpretation work budget exceeded");
+	const definition = validateSchemaTypeTermDefinition(term);
+	if (!definition.ok) {
+		const status = definition.issues.every((issue$1) => issue$1.code === "expression.cycle" || issue$1.code === "expression.budget") ? "incomplete" : "rejected";
+		return {
+			status,
+			issues: definition.issues.map((issue$1) => ({
+				...issue$1,
+				code: `interpreter.${status}.${issue$1.code}`
+			}))
+		};
+	}
 	if (!isObject(term)) return failure("rejected", "term.object", "type term must be an object");
 	if (schemaTerm(term)) {
 		if (term.kind !== "ref") return result(term);
-		if (!state.context.resolveRef) return failure("incomplete", "ref.resolver", "refPath requires an explicit resolver");
-		const key = term.refPath.join("\0");
-		if (state.refs.has(key)) return failure("incomplete", "cycle.ref", "refPath resolution cycle could not be determined");
-		state.refs.add(key);
-		let resolved;
-		try {
-			resolved = state.context.resolveRef(term.refPath);
-		} catch (error) {
-			state.refs.delete(key);
-			return failure("incomplete", "ref.error", `refPath resolver failed: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		if (!resolved) {
-			state.refs.delete(key);
-			return failure("incomplete", "ref.unresolved", "refPath resolver returned no schema");
-		}
-		if (typeof resolved === "object" && "status" in resolved && resolved.status !== "resolved") {
-			state.refs.delete(key);
-			return failure("incomplete", `ref.${resolved.status}`, resolved.message ?? "refPath resolver could not determine this path");
-		}
-		try {
-			return normalize(typeof resolved === "object" && "status" in resolved ? resolved.schema : resolved, state, depth + 1);
-		} finally {
-			state.refs.delete(key);
+		const key = schemaRefKey(term.refPath);
+		const materialized = state.refIndex.get(key);
+		if (materialized !== void 0) {
+			if (state.refs.has(key)) return failure("incomplete", "cycle.ref", "refPath resolution encountered a recursive reference");
+			state.refs.add(key);
+			try {
+				return normalize(materialized, state, depth + 1);
+			} finally {
+				state.refs.delete(key);
+			}
 		}
+		return failure("incomplete", state.context.refs === void 0 ? "ref.environment" : "ref.unresolved", state.context.refs === void 0 ? "refPath requires a preloaded refs environment" : "refPath is not present in the preloaded refs environment");
 	}
 	const kind = term.kind;
 	if (typeof kind !== "string" || !expressionKinds.has(kind)) return failure("rejected", "expression.kind", "term is neither a valid SchemaNode nor a supported expression");
@@ -1605,7 +1224,7 @@ function normalize(term, state, depth = 0) {
 		if (evaluated.status === "evaluated" && upper !== void 0) {
 			const upperResult = result(upper);
 			if (evaluated.unresolvedTypeVars?.length || upperResult.status === "evaluated" && upperResult.unresolvedTypeVars?.length) return failure("incomplete", "typeVar.bound", "type variable upper bound could not be established");
-			const relation = checkTypeTermRelation(evaluated.term, upper);
+			const relation = checkTypeTermRelation(evaluated.term, upper, { interpreter: state.context });
 			if (relation.status !== "assignable") return failure(relation.status === "incompatible" || relation.status === "rejected" ? "rejected" : "incomplete", "typeVar.bound", `binding for '${term.name}' does not satisfy its upper bound: ${relation.issues[0]?.message ?? relation.status}`);
 		}
 		return evaluated;
@@ -1671,97 +1290,14 @@ function normalize(term, state, depth = 0) {
 function evaluateExpression(term, context = {}) {
 	return normalize(term, {
 		context,
+		refIndex: indexSchemaRefs(context.refs),
 		active: /* @__PURE__ */ new Set(),
 		variables: /* @__PURE__ */ new Set(),
 		refs: /* @__PURE__ */ new Set(),
 		steps: 0
 	});
 }
-async function evaluateExpressionAsync(term, context = {}) {
-	const activeRefs = /* @__PURE__ */ new Set();
-	const activeVars = /* @__PURE__ */ new Set();
-	const activeObjects = /* @__PURE__ */ new Set();
-	let steps = 0;
-	const resolveTree = async (value, depth = 0) => {
-		steps += 1;
-		if (steps > (context.maxSteps ?? 2e3) || depth > (context.maxDepth ?? 64)) return { failure: failure("incomplete", "budget", "type interpretation work budget exceeded") };
-		if (!isObject(value)) return { value };
-		if (activeObjects.has(value)) return { failure: failure("incomplete", "cycle.expression", "expression cycle could not be determined") };
-		activeObjects.add(value);
-		try {
-			const definition = validateSchemaNodeDefinition(value);
-			if (definition.ok && definition.node.kind === "ref") {
-				if (!context.resolveRef) return { failure: failure("incomplete", "ref.resolver", "refPath requires an explicit resolver") };
-				const key = definition.node.refPath.join("\0");
-				if (activeRefs.has(key)) return { failure: failure("incomplete", "cycle.ref", "refPath resolution cycle could not be determined") };
-				activeRefs.add(key);
-				try {
-					let resolution;
-					try {
-						resolution = await context.resolveRef(definition.node.refPath);
-					} catch (error) {
-						return { failure: failure("incomplete", "ref.error", `refPath resolver failed: ${error instanceof Error ? error.message : String(error)}`) };
-					}
-					if (!resolution) return { failure: failure("incomplete", "ref.unresolved", "refPath resolver returned no schema") };
-					if (typeof resolution === "object" && "status" in resolution && resolution.status !== "resolved") return { failure: failure("incomplete", `ref.${resolution.status}`, resolution.message ?? "refPath resolver could not determine this path") };
-					return await resolveTree(typeof resolution === "object" && "status" in resolution ? resolution.schema : resolution, depth + 1);
-				} finally {
-					activeRefs.delete(key);
-				}
-			}
-			if (value.kind === "typeVar") {
-				if (typeof value.name !== "string" || !value.name.trim()) return { value };
-				const bound = context.typeVars?.[value.name];
-				if (bound === void 0) {
-					if (value.extends === void 0) return { value };
-					const upper = await resolveTree(value.extends, depth + 1);
-					return upper.failure ? upper : { value: {
-						...value,
-						extends: upper.value
-					} };
-				}
-				if (activeVars.has(value.name)) return { failure: failure("incomplete", "cycle.typeVar", "typeVar resolution cycle could not be determined") };
-				activeVars.add(value.name);
-				try {
-					const resolved$1 = await resolveTree(bound, depth + 1);
-					if (resolved$1.failure || value.extends === void 0) return resolved$1;
-					const upper = await resolveTree(value.extends, depth + 1);
-					if (upper.failure) return upper;
-					const source = evaluateExpression(resolved$1.value);
-					const target = evaluateExpression(upper.value);
-					if (source.status !== "evaluated" || target.status !== "evaluated" || source.unresolvedTypeVars?.length || target.unresolvedTypeVars?.length) return { failure: failure("incomplete", "typeVar.bound", "type variable upper bound could not be established") };
-					const relation = checkTypeTermRelation(source.term, target.term);
-					if (relation.status !== "assignable") return { failure: failure(relation.status === "incompatible" || relation.status === "rejected" ? "rejected" : "incomplete", "typeVar.bound", `binding for '${value.name}' does not satisfy its upper bound: ${relation.issues[0]?.message ?? relation.status}`) };
-					return resolved$1;
-				} finally {
-					activeVars.delete(value.name);
-				}
-			}
-			const kind = value.kind;
-			if (typeof kind !== "string" || !expressionKinds.has(kind)) return { value };
-			const shape = expressionFields[kind];
-			if (Object.keys(value).some((key) => !shape.allowed.includes(key)) || shape.required.some((key) => !(key in value))) return { value };
-			if (expressionShapeIssue(value)) return { value };
-			const copy = { ...value };
-			for (const [path, child] of childTerms(value)) {
-				const resolved$1 = await resolveTree(child, depth + 1);
-				if (resolved$1.failure) return resolved$1;
-				replaceChild(copy, path, resolved$1.value);
-			}
-			return { value: copy };
-		} finally {
-			activeObjects.delete(value);
-		}
-	};
-	const resolved = await resolveTree(term);
-	if (resolved.failure) return resolved.failure;
-	return evaluateExpression(resolved.value, {
-		maxDepth: Number.MAX_SAFE_INTEGER,
-		maxSteps: Number.MAX_SAFE_INTEGER
-	});
-}
-const evaluateSchemaValueTypeTerm = evaluateExpression;
-const evaluateSchemaValueTypeTermAsync = evaluateExpressionAsync;
+const evaluateSchemaTypeTerm = evaluateExpression;
 
 //#endregion
 //#region src/type-interpreter/type-variable-solver.ts
@@ -1820,6 +1356,11 @@ function initial(input, context) {
 		code: "solver.rejected.variable.prebound",
 		message: "a variable declared for solving is already bound in the interpreter context"
 	}]);
+	for (const [index, constraint] of input.constraints.entries()) if (!validateSchemaTypeTermDefinition(constraint.source).ok || !validateSchemaTypeTermDefinition(constraint.target).ok) return makeResult("rejected", {}, names, [{
+		code: "solver.rejected.input",
+		constraint: index,
+		message: "constraint terms must be well formed"
+	}]);
 }
 function interpreterContext(context, bindings) {
 	return {
@@ -1887,49 +1428,6 @@ function solveTypeVariables(input, context = {}) {
 	}
 	return makeResult("solved", bindings, input.variables, []);
 }
-async function solveTypeVariablesAsync(input, context = {}) {
-	const invalid = initial(input, context);
-	if (invalid) return invalid;
-	const bindings = Object.create(null);
-	const names = new Set(input.variables);
-	for (let pass = 0; pass <= input.variables.length; pass += 1) {
-		let changed = false;
-		for (const [index, constraint] of input.constraints.entries()) {
-			const actual = await evaluateExpressionAsync(constraint.source, interpreterContext(context.interpreter, bindings));
-			if (actual.status === "evaluated" && actual.unresolvedTypeVars?.length) continue;
-			if (actual.status !== "evaluated") return makeResult(actual.status === "incomplete" ? "unknown" : actual.status, bindings, input.variables, [issue(actual.status, index, actual.issues[0]?.message ?? "source could not be evaluated")]);
-			const found = [];
-			if (candidates(actual.term, constraint.target, found)) return makeResult("incompatible", bindings, input.variables, [issue("incompatible.shape", index, "source and target container shapes differ")]);
-			for (const candidate of found) {
-				if (context.interpreter?.typeVars?.[candidate.name] !== void 0 && !names.has(candidate.name)) continue;
-				if (!names.has(candidate.name)) return makeResult("rejected", bindings, input.variables, [issue("rejected.variable.undeclared", index, "target uses an undeclared type variable", candidate.name)]);
-				const previous = bindings[candidate.name];
-				if (!previous) {
-					bindings[candidate.name] = candidate.term;
-					changed = true;
-					continue;
-				}
-				if ((await checkTypeTermRelationAsync(candidate.term, previous, relationContext(context, bindings))).status === "assignable") continue;
-				if ((await checkTypeTermRelationAsync(previous, candidate.term, relationContext(context, bindings))).status === "assignable") {
-					bindings[candidate.name] = candidate.term;
-					changed = true;
-					continue;
-				}
-				return makeResult("unknown", bindings, input.variables, [issue("unknown.variable.join", index, "no supported unique common supertype for variable candidates", candidate.name)]);
-			}
-		}
-		if (!changed) break;
-	}
-	if (input.variables.some((name) => !Object.hasOwn(bindings, name))) return makeResult("unknown", bindings, input.variables, [{
-		code: "solver.unknown.variable.unresolved",
-		message: "one or more declared type variables could not be inferred"
-	}]);
-	for (const [index, constraint] of input.constraints.entries()) {
-		const relation = await checkTypeTermRelationAsync(constraint.source, constraint.target, relationContext(context, bindings));
-		if (relation.status !== "assignable") return makeResult(relation.status, bindings, input.variables, [issue(relation.status, index, relation.issues[0]?.message ?? "type relation could not be established")]);
-	}
-	return makeResult("solved", bindings, input.variables, []);
-}
 
 //#endregion
-export { evaluateSchemaValueTypeTerm as a, checkTypeTermRelationAsync as c, evaluateExpressionAsync as i, solveTypeVariablesAsync as n, evaluateSchemaValueTypeTermAsync as o, evaluateExpression as r, checkTypeTermRelation as s, solveTypeVariables as t };
+export { checkTypeTermRelation as i, evaluateExpression as n, evaluateSchemaTypeTerm as r, solveTypeVariables as t };