schemair 0.2.0 → 0.4.0

package/dist/payload/index.js

@@ -1,4 +1,5 @@
-import { f as validateSchemaNodeDefinition } from "../definition-DmYnDmQO.js";
+import { f as validateSchemaNodeDefinition } from "../definition-BH_LzXGc.js";
+import { n as schemaRefKey, t as indexSchemaRefs } from "../schema-ref-key-DR__tPr-.js";
 
 //#region src/payload/validator.ts
 function hasOwn(value, key) {
@@ -38,22 +39,19 @@ function hasAccessorOrSymbol(value) {
 function isPromiseLike(value) {
 	return (typeof value === "object" && value !== null || typeof value === "function") && typeof value.then === "function";
 }
-function chain(previous, next) {
-	return isPromiseLike(previous) ? Promise.resolve(previous).then(() => next()) : next();
-}
 var PayloadValidator = class {
 	issues = [];
 	activePayload = /* @__PURE__ */ new WeakSet();
 	activeRefs = /* @__PURE__ */ new Set();
+	refIndex;
 	rootSchema;
-	constructor(context, rootSchema, allowAsync) {
+	constructor(context, rootSchema) {
 		this.context = context;
-		this.allowAsync = allowAsync;
 		this.rootSchema = rootSchema;
+		this.refIndex = indexSchemaRefs(context.refs);
 	}
 	run(value) {
-		const validation = this.validateNode(value, this.rootSchema, [], this.rootSchema);
-		if (isPromiseLike(validation)) return Promise.resolve(validation).then(() => this.result());
+		this.validateNode(value, this.rootSchema, [], this.rootSchema);
 		return this.result();
 	}
 	result() {
@@ -93,35 +91,29 @@ var PayloadValidator = class {
 	}
 	validateNode(value, schema, path, root) {
 		switch (schema.kind) {
-			case "primitive": {
+			case "primitive":
 				if (!this.matchesPrimitive(value, schema.name)) {
 					this.reject(path, "type", `expected ${schema.name}`);
 					return;
 				}
-				let pending = void 0;
-				if ((schema.name === "string" || schema.name === "number") && schema.semanticPath) pending = chain(pending, () => this.runSemantic(schema.semanticPath, value, schema, path, root));
-				if ((schema.name === "string" || schema.name === "number") && schema.constraints) pending = chain(pending, () => this.runConstraints(schema.constraints, value, schema, path, root));
-				return pending;
-			}
+				if ((schema.name === "string" || schema.name === "number") && schema.semanticPath) this.runSemantic(schema.semanticPath, value, schema, path, root);
+				if ((schema.name === "string" || schema.name === "number") && schema.constraints) this.runConstraints(schema.constraints, value, schema, path, root);
+				return;
 			case "literal":
 				if (!isLiteral(value) || !equalLiteral(value, schema.literal)) this.reject(path, "literal", "value does not match literal");
 				return;
 			case "record": return this.validateRecord(value, schema, path, root);
-			case "array": {
+			case "array":
 				if (!isDenseArray(value)) {
 					this.reject(path, "array", "expected a dense array");
 					return;
 				}
 				if (!this.enterPayload(value, path)) return;
-				let pending = void 0;
-				for (let index = 0; index < value.length; index += 1) pending = chain(pending, () => this.validateNode(value[index], schema.elementSchema, [...path, index], root));
-				pending = chain(pending, () => {
-					this.leavePayload(value);
-					return schema.constraints ? this.runConstraints(schema.constraints, value, schema, path, root) : void 0;
-				});
-				return pending;
-			}
-			case "tuple": {
+				for (let index = 0; index < value.length; index += 1) this.validateNode(value[index], schema.elementSchema, [...path, index], root);
+				this.leavePayload(value);
+				if (schema.constraints) this.runConstraints(schema.constraints, value, schema, path, root);
+				return;
+			case "tuple":
 				if (!isDenseArray(value)) {
 					this.reject(path, "tuple", "expected a dense array");
 					return;
@@ -131,15 +123,12 @@ var PayloadValidator = class {
 					return;
 				}
 				if (!this.enterPayload(value, path)) return;
-				let pending = void 0;
 				for (let index = 0; index < schema.elementSchemas.length; index += 1) {
 					const elementSchema = schema.elementSchemas[index];
-					if (elementSchema) pending = chain(pending, () => this.validateNode(value[index], elementSchema, [...path, index], root));
+					if (elementSchema) this.validateNode(value[index], elementSchema, [...path, index], root);
 				}
-				return chain(pending, () => {
-					this.leavePayload(value);
-				});
-			}
+				this.leavePayload(value);
+				return;
 			case "literalUnion":
 				if (!isLiteral(value) || !schema.values.some((candidate) => equalLiteral(candidate, value))) this.reject(path, "literal-union", "value is not one of the allowed literals");
 				return;
@@ -165,26 +154,23 @@ var PayloadValidator = class {
 		}
 		if (!this.enterPayload(value, path)) return;
 		const fields = new Map(schema.fields.map((field) => [field.key, field]));
-		let pending = void 0;
 		for (const field of schema.fields) {
 			if (!hasOwn(value, field.key)) {
 				if (field.required === true) this.reject([...path, field.key], "required", "required field is missing");
 				continue;
 			}
-			pending = chain(pending, () => this.validateNode(value[field.key], field.schema, [...path, field.key], root));
+			this.validateNode(value[field.key], field.schema, [...path, field.key], root);
 		}
 		for (const key of Object.keys(value)) {
 			if (fields.has(key)) continue;
 			if (!hasOwn(schema, "additionalFields")) this.reject([...path, key], "additional-field", "unknown field is not allowed");
 			else if (schema.additionalFields !== true) {
 				const additionalSchema = schema.additionalFields;
-				if (additionalSchema) pending = chain(pending, () => this.validateNode(value[key], additionalSchema, [...path, key], root));
+				if (additionalSchema) this.validateNode(value[key], additionalSchema, [...path, key], root);
 			} else if (!this.isJsonValue(value[key], /* @__PURE__ */ new WeakSet())) this.reject([...path, key], "additional-value", "additional field must be JSON-compatible");
 		}
-		return chain(pending, () => {
-			this.leavePayload(value);
-			return schema.constraints ? this.runConstraints(schema.constraints, value, schema, path, root) : void 0;
-		});
+		this.leavePayload(value);
+		if (schema.constraints) this.runConstraints(schema.constraints, value, schema, path, root);
 	}
 	validateTaggedUnion(value, schema, path, root) {
 		if (!isPlainRecord(value) || hasAccessorOrSymbol(value)) {
@@ -207,15 +193,18 @@ var PayloadValidator = class {
 		return this.validateNode(value, variant.schema, path, root);
 	}
 	validateRef(value, schema, path, root) {
-		if (!this.context.resolveRef) {
-			this.unsupported(path, "ref.resolver", "refPath requires an explicit resolver");
-			return;
-		}
-		const refKey = schema.refPath.join("\0");
+		const refKey = schemaRefKey(schema.refPath);
 		if (this.activeRefs.has(refKey)) {
 			this.unknown(path, "ref.cycle", "refPath resolution cycle could not be determined");
 			return;
 		}
+		const materialized = this.refIndex.get(refKey);
+		if (materialized !== void 0) return this.handleResolution(materialized, value, path, root);
+		if (!this.context.resolveRef) {
+			if (this.context.refs !== void 0) this.unknown(path, "ref.unresolved", "refPath is not present in the resolved environment");
+			else this.unsupported(path, "ref.resolver", "refPath requires an explicit resolver");
+			return;
+		}
 		this.activeRefs.add(refKey);
 		let resolved;
 		try {
@@ -231,19 +220,15 @@ var PayloadValidator = class {
 			return;
 		}
 		if (isPromiseLike(resolved)) {
-			if (!this.allowAsync) {
-				this.unsupported(path, "ref.async", "synchronous validation requires a synchronous ref resolver");
-				this.activeRefs.delete(refKey);
-				return;
-			}
-			return Promise.resolve(resolved).then((result) => this.handleResolution(result, value, path, root)).catch((error) => {
-				this.unknown(path, "ref.error", `refPath resolver failed: ${error instanceof Error ? error.message : String(error)}`);
-			}).finally(() => this.activeRefs.delete(refKey));
+			this.unsupported(path, "ref.async", "synchronous validation requires a synchronous ref resolver");
+			this.activeRefs.delete(refKey);
+			return;
+		}
+		try {
+			this.handleResolution(resolved, value, path, root);
+		} finally {
+			this.activeRefs.delete(refKey);
 		}
-		const handled = this.handleResolution(resolved, value, path, root);
-		if (isPromiseLike(handled)) return Promise.resolve(handled).finally(() => this.activeRefs.delete(refKey));
-		this.activeRefs.delete(refKey);
-		return handled;
 	}
 	handleResolution(resolved, value, path, root) {
 		if (resolved === void 0) {
@@ -279,19 +264,17 @@ var PayloadValidator = class {
 		}), path, "semantic");
 	}
 	runConstraints(constraints, value, schema, path, root) {
-		let pending = void 0;
 		for (const constraint of constraints) {
 			if (!this.context.constraintProvider) {
 				this.unsupported(path, "constraint.provider", `constraint path ${constraint.constraintPath.join("/")} has no provider`);
 				continue;
 			}
-			pending = chain(pending, () => this.applyProvider(() => this.context.constraintProvider(constraint.constraintPath, constraint.args, value, {
+			this.applyProvider(() => this.context.constraintProvider(constraint.constraintPath, constraint.args, value, {
 				path,
 				schema,
 				rootSchema: root
-			}), path, "constraint"));
+			}), path, "constraint");
 		}
-		return pending;
 	}
 	applyProvider(call, path, kind) {
 		let result;
@@ -302,13 +285,8 @@ var PayloadValidator = class {
 			return;
 		}
 		if (isPromiseLike(result)) {
-			if (!this.allowAsync) {
-				this.unsupported(path, `${kind}.async`, `synchronous validation requires a synchronous ${kind} provider`);
-				return;
-			}
-			return Promise.resolve(result).then((decision) => this.applyDecision(decision, path, kind)).catch((error) => {
-				this.unknown(path, `${kind}.error`, `${kind} provider failed: ${error instanceof Error ? error.message : String(error)}`);
-			});
+			this.unsupported(path, `${kind}.async`, `synchronous validation requires a synchronous ${kind} provider`);
+			return;
 		}
 		return this.applyDecision(result, path, kind);
 	}
@@ -368,22 +346,8 @@ function validateDefinition(schema) {
 function validatePayload(value, schema, context = {}) {
 	const validated = validateDefinition(schema);
 	if ("status" in validated) return validated;
-	const result = new PayloadValidator(context, validated, false).run(value);
-	if (isPromiseLike(result)) return {
-		status: "unknown",
-		issues: [{
-			code: "payload.unknown.async",
-			path: [],
-			message: "synchronous payload validation produced an asynchronous result"
-		}]
-	};
-	return result;
-}
-async function validatePayloadAsync(value, schema, context = {}) {
-	const validated = validateDefinition(schema);
-	if ("status" in validated) return validated;
-	return Promise.resolve(new PayloadValidator(context, validated, true).run(value));
+	return new PayloadValidator(context, validated).run(value);
 }
 
 //#endregion
-export { validatePayload, validatePayloadAsync };
+export { validatePayload };

package/dist/relations/index.cjs

@@ -1,8 +1,5 @@
-const require_relations = require('../relations-Cymx4iTc.cjs');
+const require_relations = require('../relations-NUVJkAG8.cjs');
 
 exports.checkOperationRelation = require_relations.checkOperationRelation;
-exports.checkOperationRelationAsync = require_relations.checkOperationRelationAsync;
 exports.checkSchemaAssignability = require_relations.checkSchemaAssignability;
-exports.checkSchemaAssignabilityAsync = require_relations.checkSchemaAssignabilityAsync;
-exports.checkSchemaRelation = require_relations.checkSchemaRelation;
-exports.checkSchemaRelationAsync = require_relations.checkSchemaRelationAsync;
+exports.checkSchemaRelation = require_relations.checkSchemaRelation;

package/dist/relations/index.d.cts

@@ -1,2 +1,2 @@
-import { _ as checkSchemaAssignabilityAsync, a as AsyncRelationContext, c as RelationPath, d as RelationResolution, f as RelationResolutionContext, g as checkSchemaAssignability, h as RelationStatus, i as checkOperationRelationAsync, l as RelationProviderContext, m as RelationSide, n as OperationRelationDirection, o as RelationContext, p as RelationResult, r as checkOperationRelation, s as RelationDiagnostic, t as OperationRelationComponent, u as RelationProviderDecision, v as checkSchemaRelation, y as checkSchemaRelationAsync } from "../index-CNjYUKvu.cjs";
-export { AsyncRelationContext, OperationRelationComponent, OperationRelationDirection, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };
+import { a as RelationDiagnostic, c as RelationProviderDecision, d as RelationResult, f as RelationSide, h as checkSchemaRelation, i as RelationContext, l as RelationResolution, m as checkSchemaAssignability, n as OperationRelationDirection, o as RelationPath, p as RelationStatus, r as checkOperationRelation, s as RelationProviderContext, t as OperationRelationComponent, u as RelationResolutionContext } from "../index-ba_52Yu9.cjs";
+export { OperationRelationComponent, OperationRelationDirection, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkOperationRelation, checkSchemaAssignability, checkSchemaRelation };

package/dist/relations/index.d.ts

@@ -1,2 +1,2 @@
-import { _ as checkSchemaAssignabilityAsync, a as AsyncRelationContext, c as RelationPath, d as RelationResolution, f as RelationResolutionContext, g as checkSchemaAssignability, h as RelationStatus, i as checkOperationRelationAsync, l as RelationProviderContext, m as RelationSide, n as OperationRelationDirection, o as RelationContext, p as RelationResult, r as checkOperationRelation, s as RelationDiagnostic, t as OperationRelationComponent, u as RelationProviderDecision, v as checkSchemaRelation, y as checkSchemaRelationAsync } from "../index-CBbd4hXJ.js";
-export { AsyncRelationContext, OperationRelationComponent, OperationRelationDirection, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };
+import { a as RelationDiagnostic, c as RelationProviderDecision, d as RelationResult, f as RelationSide, h as checkSchemaRelation, i as RelationContext, l as RelationResolution, m as checkSchemaAssignability, n as OperationRelationDirection, o as RelationPath, p as RelationStatus, r as checkOperationRelation, s as RelationProviderContext, t as OperationRelationComponent, u as RelationResolutionContext } from "../index-DxvfPmw6.js";
+export { OperationRelationComponent, OperationRelationDirection, RelationContext, RelationDiagnostic, RelationPath, RelationProviderContext, RelationProviderDecision, RelationResolution, RelationResolutionContext, RelationResult, RelationSide, RelationStatus, checkOperationRelation, checkSchemaAssignability, checkSchemaRelation };

package/dist/relations/index.js

@@ -1,3 +1,3 @@
-import { a as checkSchemaRelation, i as checkSchemaAssignabilityAsync, n as checkOperationRelationAsync, o as checkSchemaRelationAsync, r as checkSchemaAssignability, t as checkOperationRelation } from "../relations-ysXDmi-Z.js";
+import { n as checkSchemaAssignability, r as checkSchemaRelation, t as checkOperationRelation } from "../relations-QtnCRW9x.js";
 
-export { checkOperationRelation, checkOperationRelationAsync, checkSchemaAssignability, checkSchemaAssignabilityAsync, checkSchemaRelation, checkSchemaRelationAsync };
+export { checkOperationRelation, checkSchemaAssignability, checkSchemaRelation };

package/dist/{relations-Cymx4iTc.cjs → relations-NUVJkAG8.cjs}

@@ -1,4 +1,5 @@
 const require_definition = require('./definition-BLLBpLKv.cjs');
+const require_schema_ref_key = require('./schema-ref-key-BHVFVfj1.cjs');
 
 //#region src/relations/validator.ts
 function equalLiteral(left, right) {
@@ -17,11 +18,13 @@ var RelationChecker = class {
 	activePairs = /* @__PURE__ */ new Set();
 	activeRefs = /* @__PURE__ */ new Set();
 	ids = /* @__PURE__ */ new WeakMap();
+	refIndex;
 	nextId = 1;
 	constructor(context, rootSourceSchema, rootTargetSchema) {
 		this.context = context;
 		this.rootSourceSchema = rootSourceSchema;
 		this.rootTargetSchema = rootTargetSchema;
+		this.refIndex = require_schema_ref_key.indexSchemaRefs(context.refs);
 	}
 	run() {
 		const result = this.compare(this.rootSourceSchema, this.rootTargetSchema, [], this.rootSourceSchema, this.rootTargetSchema);
@@ -251,8 +254,14 @@ var RelationChecker = class {
 		}
 	}
 	compareRef(ref, other, path, rootSource, rootTarget, side) {
-		if (!this.context.resolveRef) return this.unknown(path, "ref.resolver", "refPath relation requires an explicit resolver");
-		const key = `${side}:${ref.refPath.join("\0")}`;
+		const materialized = this.refIndex.get(require_schema_ref_key.schemaRefKey(ref.refPath));
+		if (materialized !== void 0) {
+			const definition$1 = require_definition.validateSchemaNodeDefinition(materialized);
+			if (!definition$1.ok) return this.rejected(path, "ref.schema", "resolved ref environment contains an invalid schema");
+			return side === "source" ? this.compare(definition$1.node, other, path, rootSource, rootTarget) : this.compare(other, definition$1.node, path, rootSource, rootTarget);
+		}
+		if (!this.context.resolveRef) return this.context.refs === void 0 ? this.unknown(path, "ref.resolver", "refPath relation requires an explicit resolver") : this.unknown(path, "ref.unresolved", "refPath is not present in the resolved environment");
+		const key = `${side}:${require_schema_ref_key.schemaRefKey(ref.refPath)}`;
 		if (this.activeRefs.has(key)) return this.unknown(path, "ref.cycle", "refPath relation cycle could not be determined");
 		this.activeRefs.add(key);
 		let resolved;
@@ -364,210 +373,6 @@ function checkSchemaRelation(source, target, context = {}) {
 	return new RelationChecker(context, validSource, validTarget).run();
 }
 const checkSchemaAssignability = checkSchemaRelation;
-async function resolveAsyncSchema(schema, context, active, path, side, rootSourceSchema, rootTargetSchema) {
-	if (schema.kind === "ref" && context.resolveRef) {
-		const key = schema.refPath.join("\0");
-		if (active.has(key)) return schema;
-		active.add(key);
-		let resolved;
-		try {
-			resolved = await context.resolveRef(schema.refPath, {
-				path,
-				side,
-				sourceSchema: side === "source" ? schema : rootSourceSchema,
-				targetSchema: side === "source" ? rootTargetSchema : schema,
-				rootSourceSchema,
-				rootTargetSchema,
-				refPath: schema.refPath
-			});
-		} catch {
-			return schema;
-		} finally {
-			active.delete(key);
-		}
-		if (resolved && !(typeof resolved === "object" && "status" in resolved && resolved.status !== "resolved")) {
-			const definition = require_definition.validateSchemaNodeDefinition(typeof resolved === "object" && "status" in resolved ? resolved.schema : resolved);
-			if (definition.ok) return resolveAsyncSchema(definition.node, context, new Set(active), path, side, rootSourceSchema, rootTargetSchema);
-		}
-		return schema;
-	}
-	switch (schema.kind) {
-		case "record": return {
-			...schema,
-			fields: await Promise.all(schema.fields.map(async (field) => ({
-				...field,
-				schema: await resolveAsyncSchema(field.schema, context, new Set(active), [
-					...path,
-					"fields",
-					field.key
-				], side, rootSourceSchema, rootTargetSchema)
-			}))),
-			...schema.additionalFields && schema.additionalFields !== true ? { additionalFields: await resolveAsyncSchema(schema.additionalFields, context, new Set(active), [...path, "additionalFields"], side, rootSourceSchema, rootTargetSchema) } : {}
-		};
-		case "array": return {
-			...schema,
-			elementSchema: await resolveAsyncSchema(schema.elementSchema, context, new Set(active), [...path, "elementSchema"], side, rootSourceSchema, rootTargetSchema)
-		};
-		case "tuple": return {
-			...schema,
-			elementSchemas: await Promise.all(schema.elementSchemas.map((item, index) => resolveAsyncSchema(item, context, new Set(active), [
-				...path,
-				"elementSchemas",
-				index
-			], side, rootSourceSchema, rootTargetSchema)))
-		};
-		case "nullable": return {
-			...schema,
-			value: await resolveAsyncSchema(schema.value, context, new Set(active), path, side, rootSourceSchema, rootTargetSchema)
-		};
-		case "taggedUnion": return {
-			...schema,
-			variants: await Promise.all(schema.variants.map(async (variant) => ({
-				...variant,
-				schema: await resolveAsyncSchema(variant.schema, context, new Set(active), [
-					...path,
-					"variants",
-					variant.key
-				], side, rootSourceSchema, rootTargetSchema)
-			})))
-		};
-		default: return schema;
-	}
-}
-function collectRelationPairs(source, target, path = [], result = [], seen = /* @__PURE__ */ new Set()) {
-	const key = `${JSON.stringify(path)}:${JSON.stringify(source)}:${JSON.stringify(target)}`;
-	if (seen.has(key)) return result;
-	seen.add(key);
-	result.push({
-		source,
-		target,
-		path
-	});
-	if (source.kind === "record" && target.kind === "record") {
-		const targetFields = new Map(target.fields.map((field) => [field.key, field]));
-		for (const field of source.fields) {
-			const targetField = targetFields.get(field.key);
-			if (targetField) collectRelationPairs(field.schema, targetField.schema, [
-				...path,
-				"fields",
-				field.key
-			], result, seen);
-		}
-	} else if (source.kind === "array" && target.kind === "array") collectRelationPairs(source.elementSchema, target.elementSchema, [...path, "elementSchema"], result, seen);
-	else if (source.kind === "tuple" && target.kind === "tuple") for (let index = 0; index < Math.min(source.elementSchemas.length, target.elementSchemas.length); index += 1) collectRelationPairs(source.elementSchemas[index], target.elementSchemas[index], [
-		...path,
-		"elementSchemas",
-		index
-	], result, seen);
-	else if (source.kind === "nullable" && target.kind === "nullable") collectRelationPairs(source.value, target.value, path, result, seen);
-	else if (source.kind === "taggedUnion" && target.kind === "taggedUnion" && source.discriminator === target.discriminator) {
-		const targetVariants = new Map(target.variants.map((variant) => [variant.key, variant]));
-		for (const variant of source.variants) {
-			const targetVariant = targetVariants.get(variant.key);
-			if (targetVariant) collectRelationPairs(variant.schema, targetVariant.schema, [
-				...path,
-				"variants",
-				variant.key
-			], result, seen);
-		}
-	}
-	return result;
-}
-async function checkSchemaRelationAsync(source, target, context = {}) {
-	try {
-		const validSource = validateSchema(source, "source");
-		if ("status" in validSource) return validSource;
-		const validTarget = validateSchema(target, "target");
-		if ("status" in validTarget) return validTarget;
-		const resolvedSource = await resolveAsyncSchema(validSource, context, /* @__PURE__ */ new Set(), [], "source", validSource, validTarget);
-		const resolvedTarget = await resolveAsyncSchema(validTarget, context, /* @__PURE__ */ new Set(), [], "target", validSource, validTarget);
-		const pairs = collectRelationPairs(resolvedSource, resolvedTarget);
-		const semanticCache = /* @__PURE__ */ new Map();
-		const constraintCache = /* @__PURE__ */ new Map();
-		if (context.semanticProvider) for (const pair of pairs) {
-			const { source: left, target: right } = pair;
-			const sourceSemantic = left.kind === "primitive" && (left.name === "string" || left.name === "number") ? left.semanticPath : void 0;
-			const targetSemantic = right.kind === "primitive" && (right.name === "string" || right.name === "number") ? right.semanticPath : void 0;
-			if (right.kind !== "primitive" || right.name !== "string" && right.name !== "number" || sourceSemantic === void 0 && targetSemantic === void 0) continue;
-			const providerContext = {
-				path: pair.path,
-				side: "source",
-				sourceSchema: left,
-				targetSchema: right,
-				rootSourceSchema: resolvedSource,
-				rootTargetSchema: resolvedTarget
-			};
-			let decision;
-			try {
-				decision = await context.semanticProvider(sourceSemantic, targetSemantic, providerContext);
-			} catch (error) {
-				decision = {
-					status: "unknown",
-					message: `semantic provider failed: ${error instanceof Error ? error.message : String(error)}`
-				};
-			}
-			semanticCache.set(JSON.stringify([
-				pair.path,
-				sourceSemantic,
-				targetSemantic
-			]), decision);
-		}
-		if (context.constraintProvider) for (const pair of pairs) {
-			const { source: left, target: right } = pair;
-			if (left.kind === "primitive" || left.kind === "array" || left.kind === "record" || left.kind === "literal" || left.kind === "literalUnion") {
-				const literalToPrimitive = (left.kind === "literal" || left.kind === "literalUnion") && right.kind === "primitive";
-				if (right.kind !== left.kind && !literalToPrimitive) continue;
-				const sourceConstraints = "constraints" in left ? left.constraints : void 0;
-				const targetConstraints = "constraints" in right ? right.constraints : void 0;
-				if (sourceConstraints === void 0 && targetConstraints === void 0) continue;
-				const providerContext = {
-					path: pair.path,
-					side: "source",
-					sourceSchema: left,
-					targetSchema: right,
-					rootSourceSchema: resolvedSource,
-					rootTargetSchema: resolvedTarget
-				};
-				let decision;
-				try {
-					decision = await context.constraintProvider(sourceConstraints, targetConstraints, providerContext);
-				} catch (error) {
-					decision = {
-						status: "unknown",
-						message: `constraint provider failed: ${error instanceof Error ? error.message : String(error)}`
-					};
-				}
-				constraintCache.set(JSON.stringify([
-					pair.path,
-					sourceConstraints,
-					targetConstraints
-				]), decision);
-			}
-		}
-		return checkSchemaRelation(resolvedSource, resolvedTarget, {
-			semanticProvider: (sourcePath, targetPath, providerContext) => semanticCache.get(JSON.stringify([
-				providerContext.path,
-				sourcePath,
-				targetPath
-			])) ?? { status: "unknown" },
-			constraintProvider: (sourceConstraints, targetConstraints, providerContext) => constraintCache.get(JSON.stringify([
-				providerContext.path,
-				sourceConstraints,
-				targetConstraints
-			])) ?? { status: "unknown" }
-		});
-	} catch (error) {
-		return {
-			status: "unknown",
-			issues: [{
-				code: "relation.unknown.async",
-				path: [],
-				message: `async relation provider failed: ${error instanceof Error ? error.message : String(error)}`
-			}]
-		};
-	}
-}
-const checkSchemaAssignabilityAsync = checkSchemaRelationAsync;
 
 //#endregion
 //#region src/relations/operation.ts
@@ -701,14 +506,6 @@ function checkOperationRelation(source, target, context = {}) {
 	if (!Array.isArray(work)) return work;
 	return combine(work.map((item) => "result" in item ? item.result : prefix(checkSchemaRelation(item.source, item.target, context), item.path)));
 }
-/** Async companion with the same substitution rules and schema-local providers. */
-async function checkOperationRelationAsync(source, target, context = {}) {
-	const work = prepare(source, target);
-	if (!Array.isArray(work)) return work;
-	const results = [];
-	for (const item of work) results.push("result" in item ? item.result : prefix(await checkSchemaRelationAsync(item.source, item.target, context), item.path));
-	return combine(results);
-}
 
 //#endregion
 Object.defineProperty(exports, 'checkOperationRelation', {
@@ -717,33 +514,15 @@ Object.defineProperty(exports, 'checkOperationRelation', {
     return checkOperationRelation;
   }
 });
-Object.defineProperty(exports, 'checkOperationRelationAsync', {
-  enumerable: true,
-  get: function () {
-    return checkOperationRelationAsync;
-  }
-});
 Object.defineProperty(exports, 'checkSchemaAssignability', {
   enumerable: true,
   get: function () {
     return checkSchemaAssignability;
   }
 });
-Object.defineProperty(exports, 'checkSchemaAssignabilityAsync', {
-  enumerable: true,
-  get: function () {
-    return checkSchemaAssignabilityAsync;
-  }
-});
 Object.defineProperty(exports, 'checkSchemaRelation', {
   enumerable: true,
   get: function () {
     return checkSchemaRelation;
   }
-});
-Object.defineProperty(exports, 'checkSchemaRelationAsync', {
-  enumerable: true,
-  get: function () {
-    return checkSchemaRelationAsync;
-  }
 });