@canon-protocol/sdk 8.0.0

package/dist/validation/rules/repository/ObjectPropertyValueValidationRule.js

@@ -0,0 +1,281 @@
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { ResourceResolver } from '../../../resolution/ResourceResolver.js';
+import { TypeResolver } from '../../../resolution/TypeResolver.js';
+export class ObjectPropertyValueValidationRule {
+    standardProperties = new Set([
+        'type', // Special meta-property that references class definitions (validated separately)
+        'label',
+        'comment',
+        'subClassOf',
+        'domain',
+        'range',
+        'subPropertyOf',
+        'inverseOf',
+        'sameAs',
+        'seeAlso',
+        'isDefinedBy'
+    ]);
+    get ruleName() {
+        return 'ObjectPropertyValue';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const resourceResolver = new ResourceResolver(repository);
+        const typeResolver = new TypeResolver(resourceResolver);
+        const entityIndex = await resourceResolver.buildEntityIndexAsync(document);
+        const propertyMetadata = await this.buildPropertyMetadataAsync(document, repository, resourceResolver, entityIndex);
+        for (const [entityName, entityValue] of Object.entries(document.body)) {
+            if (typeof entityValue === 'object' && entityValue !== null && !Array.isArray(entityValue)) {
+                await this.scanEntityForObjectProperties(entityValue, entityName, '', // Start with empty path - entity name is tracked separately in EntityName
+                propertyMetadata, resourceResolver, typeResolver, document, errors);
+            }
+        }
+        return errors;
+    }
+    async scanEntityForObjectProperties(entityDict, rootEntityName, currentPath, propertyMetadata, resourceResolver, typeResolver, document, errors) {
+        for (const [propertyName, value] of Object.entries(entityDict)) {
+            if (this.standardProperties.has(propertyName)) {
+                continue;
+            }
+            let lookupName = propertyName;
+            const dotIndex = propertyName.lastIndexOf('.');
+            if (dotIndex > 0 && dotIndex < propertyName.length - 1) {
+                lookupName = propertyName.substring(dotIndex + 1);
+            }
+            const propInfo = propertyMetadata.get(lookupName);
+            if (propInfo) {
+                const isObjectProperty = typeResolver.isEffectiveObjectProperty(propInfo.propertyType, propInfo.rangeUri);
+                if (isObjectProperty) {
+                    const fullPath = currentPath ? `${currentPath}.${propertyName}` : propertyName;
+                    if (typeof value === 'string' && value.trim().length > 0) {
+                        const strValue = value.trim();
+                        if (strValue.includes(',')) {
+                            const parts = strValue.split(',').map(s => s.trim()).filter(s => s.length > 0);
+                            errors.push({
+                                ruleType: this.ruleName,
+                                severity: ValidationSeverity.Error,
+                                message: `Property '${propertyName}' has a comma-separated string value, but ObjectProperty expects a list of references`,
+                                suggestion: `Use YAML list format:\n  ${propertyName}:\n    - ${parts[0]}\n${parts.slice(1).map(p => `    - ${p}`).join('\n')}`,
+                                entityName: rootEntityName,
+                                propertyName: propertyName,
+                                propertyPath: fullPath,
+                                actualValue: strValue,
+                                expectedValue: `A single reference to ${propInfo.range ?? 'an entity'} OR a YAML list`
+                            });
+                            continue; // Skip further validation for this malformed value
+                        }
+                        const resolution = await resourceResolver.resolveEntityAsync(strValue, document);
+                        if (!resolution) {
+                            const rangeHint = propInfo.range ?? 'entity';
+                            errors.push({
+                                ruleType: this.ruleName,
+                                severity: ValidationSeverity.Error,
+                                message: `Property '${propertyName}' references '${strValue}' which is not defined or imported`,
+                                suggestion: `Define '${strValue}' or import a namespace that contains it. Expected range: ${rangeHint}`,
+                                entityName: rootEntityName,
+                                propertyName: propertyName,
+                                propertyPath: fullPath,
+                                actualValue: strValue,
+                                expectedValue: 'Defined or imported entity'
+                            });
+                        }
+                        else if (propInfo.range) {
+                            const isCorrectType = await this.validateRangeType(resolution, propInfo.range, resourceResolver, document);
+                            if (!isCorrectType) {
+                                errors.push({
+                                    ruleType: this.ruleName,
+                                    severity: ValidationSeverity.Warning,
+                                    message: `Property '${propertyName}' expects a ${propInfo.range}, but '${strValue}' may not be a ${propInfo.range}`,
+                                    suggestion: `Ensure '${strValue}' is defined with appropriate type`,
+                                    entityName: rootEntityName,
+                                    propertyName: propertyName,
+                                    propertyPath: fullPath,
+                                    actualValue: strValue,
+                                    expectedValue: propInfo.range
+                                });
+                            }
+                        }
+                    }
+                    else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                        const newPath = currentPath ? `${currentPath}.${propertyName}` : propertyName;
+                        await this.scanEntityForObjectProperties(value, rootEntityName, newPath, propertyMetadata, resourceResolver, typeResolver, document, errors);
+                    }
+                    else if (Array.isArray(value)) {
+                        for (let i = 0; i < value.length; i++) {
+                            const item = value[i];
+                            if (typeof item === 'string' && item.trim().length > 0) {
+                                const strItem = item.trim();
+                                const resolution = await resourceResolver.resolveEntityAsync(strItem, document);
+                                if (!resolution) {
+                                    const rangeHint = propInfo.range ?? 'entity';
+                                    const arrayPath = currentPath
+                                        ? `${currentPath}.${propertyName}[${i}]`
+                                        : `${propertyName}[${i}]`;
+                                    errors.push({
+                                        ruleType: this.ruleName,
+                                        severity: ValidationSeverity.Error,
+                                        message: `Property '${propertyName}' references '${strItem}' which is not defined or imported`,
+                                        suggestion: `Define '${strItem}' or import a namespace that contains it. Expected range: ${rangeHint}`,
+                                        entityName: rootEntityName,
+                                        propertyName: `${propertyName}[${i}]`,
+                                        propertyPath: arrayPath,
+                                        actualValue: strItem,
+                                        expectedValue: 'Defined or imported entity'
+                                    });
+                                }
+                                else if (propInfo.range) {
+                                    const isCorrectType = await this.validateRangeType(resolution, propInfo.range, resourceResolver, document);
+                                    if (!isCorrectType) {
+                                        const arrayPath = currentPath
+                                            ? `${currentPath}.${propertyName}[${i}]`
+                                            : `${propertyName}[${i}]`;
+                                        errors.push({
+                                            ruleType: this.ruleName,
+                                            severity: ValidationSeverity.Warning,
+                                            message: `Property '${propertyName}' expects a ${propInfo.range}, but '${strItem}' may not be a ${propInfo.range}`,
+                                            suggestion: `Ensure '${strItem}' is defined with appropriate type`,
+                                            entityName: rootEntityName,
+                                            propertyName: `${propertyName}[${i}]`,
+                                            propertyPath: arrayPath,
+                                            actualValue: strItem,
+                                            expectedValue: propInfo.range
+                                        });
+                                    }
+                                }
+                            }
+                            else if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
+                                const newPath = currentPath
+                                    ? `${currentPath}.${propertyName}[${i}]`
+                                    : `${propertyName}[${i}]`;
+                                await this.scanEntityForObjectProperties(item, rootEntityName, newPath, propertyMetadata, resourceResolver, typeResolver, document, errors);
+                            }
+                        }
+                    }
+                }
+            }
+            if (typeof value === 'object' &&
+                value !== null &&
+                !Array.isArray(value) &&
+                !propertyMetadata.has(propertyName)) {
+                const newPath = currentPath ? `${currentPath}.${propertyName}` : propertyName;
+                await this.scanEntityForObjectProperties(value, rootEntityName, newPath, propertyMetadata, resourceResolver, typeResolver, document, errors);
+            }
+            else if (Array.isArray(value)) {
+                for (let i = 0; i < value.length; i++) {
+                    const item = value[i];
+                    if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
+                        const newPath = currentPath
+                            ? `${currentPath}.${propertyName}[${i}]`
+                            : `${propertyName}[${i}]`;
+                        await this.scanEntityForObjectProperties(item, rootEntityName, newPath, propertyMetadata, resourceResolver, typeResolver, document, errors);
+                    }
+                }
+            }
+        }
+    }
+    async validateRangeType(resolution, expectedRange, resourceResolver, document) {
+        const metaTypes = new Set([
+            'Property',
+            'DatatypeProperty',
+            'ObjectProperty',
+            'AnnotationProperty',
+            'Class',
+            'Resource'
+        ]);
+        if (!metaTypes.has(expectedRange)) {
+            return true; // Don't validate non-meta-types
+        }
+        const typeValue = resolution.entity['type'];
+        if (typeValue) {
+            const types = [];
+            if (Array.isArray(typeValue)) {
+                for (const t of typeValue) {
+                    const typeStr = t?.toString();
+                    if (typeStr && typeStr.trim().length > 0) {
+                        types.push(typeStr);
+                    }
+                }
+            }
+            else {
+                const typeStr = typeValue?.toString();
+                if (typeStr && typeStr.trim().length > 0) {
+                    types.push(typeStr);
+                }
+            }
+            for (const type of types) {
+                const typeName = type.includes('.') ? type.split('.')[1] : type;
+                if (typeName === expectedRange) {
+                    return true;
+                }
+                if (expectedRange === 'Property') {
+                    if (typeName === 'DatatypeProperty' ||
+                        typeName === 'ObjectProperty' ||
+                        typeName === 'AnnotationProperty') {
+                        return true;
+                    }
+                }
+                if (expectedRange === 'Class') {
+                    if (typeName === 'Class') {
+                        return true;
+                    }
+                }
+                if (await resourceResolver.isSubclassOfAsync(type, expectedRange, document)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async buildPropertyMetadataAsync(document, _repository, resourceResolver, entityIndex) {
+        const metadata = new Map();
+        for (const [entityName, resolution] of entityIndex) {
+            const typeValue = resolution.entity['type'];
+            if (typeValue) {
+                const types = [];
+                if (Array.isArray(typeValue)) {
+                    for (const t of typeValue) {
+                        const typeStr = t?.toString();
+                        if (typeStr && typeStr.trim().length > 0) {
+                            types.push(typeStr);
+                        }
+                    }
+                }
+                else {
+                    const typeStr = typeValue?.toString();
+                    if (typeStr && typeStr.trim().length > 0) {
+                        types.push(typeStr);
+                    }
+                }
+                let isProperty = false;
+                let propertyType = 'Property';
+                for (const type of types) {
+                    const typeName = type.includes('.') ? type.split('.')[1] : type;
+                    if (typeName === 'Property' ||
+                        typeName === 'DatatypeProperty' ||
+                        typeName === 'ObjectProperty' ||
+                        typeName === 'AnnotationProperty') {
+                        isProperty = true;
+                        propertyType = type; // Keep the full type (e.g., "rdf.Property" or "ObjectProperty")
+                        break;
+                    }
+                }
+                if (isProperty) {
+                    const propInfo = { propertyType };
+                    const rangeValue = resolution.entity['range'];
+                    if (rangeValue) {
+                        const range = rangeValue?.toString();
+                        if (range && range.trim().length > 0) {
+                            propInfo.range = range;
+                            const rangeResolution = await resourceResolver.resolveEntityAsync(range, document);
+                            if (rangeResolution) {
+                                propInfo.rangeUri = rangeResolution.uri;
+                            }
+                        }
+                    }
+                    metadata.set(entityName, propInfo);
+                }
+            }
+        }
+        return metadata;
+    }
+}

package/dist/validation/rules/repository/PropertyDomainRule.d.ts

@@ -0,0 +1,14 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+export declare class PropertyDomainRule implements IRepositoryValidationRule {
+    private readonly standardProperties;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private buildCompleteClassHierarchyAsync;
+    private validateEntityProperties;
+    private isTypeCompatibleWithDomain;
+    private getPropertyValue;
+    private extractFirstValue;
+}

package/dist/validation/rules/repository/PropertyDomainRule.js

@@ -0,0 +1,221 @@
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { normalizeToStringList } from '../normalizeToStringList.js';
+export class PropertyDomainRule {
+    standardProperties = new Set([
+        'type',
+        'label',
+        'comment',
+        'subClassOf',
+        'domain',
+        'range',
+        'subPropertyOf',
+        'inverseOf',
+        'sameAs',
+        'seeAlso',
+        'isDefinedBy'
+    ]);
+    get ruleName() {
+        return 'PropertyDomain';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const propertyDefinitions = new Map();
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const type = this.getPropertyValue(entity, 'type');
+                if (type === 'DatatypeProperty' ||
+                    type?.endsWith('.DatatypeProperty') ||
+                    type === 'ObjectProperty' ||
+                    type?.endsWith('.ObjectProperty') ||
+                    type === 'AnnotationProperty' ||
+                    type?.endsWith('.AnnotationProperty')) {
+                    propertyDefinitions.set(entityName, entity);
+                }
+            }
+        }
+        const classHierarchy = await this.buildCompleteClassHierarchyAsync(document, repository);
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const entityType = this.getPropertyValue(entity, 'type');
+                if (!entityType ||
+                    entityType === 'Class' ||
+                    entityType.endsWith('.Class') ||
+                    entityType.endsWith('Property') ||
+                    entityType === 'AnnotationProperty') {
+                    continue;
+                }
+                this.validateEntityProperties(entity, entityName, entityType, propertyDefinitions, classHierarchy, errors);
+            }
+        }
+        return errors;
+    }
+    async buildCompleteClassHierarchyAsync(document, repository) {
+        const classHierarchy = new Map();
+        const visitedNamespaces = new Set();
+        const processDocumentAsync = async (doc, currentNamespace) => {
+            if (visitedNamespaces.has(currentNamespace)) {
+                return;
+            }
+            visitedNamespaces.add(currentNamespace);
+            for (const [entityName, entityDef] of Object.entries(doc.body)) {
+                if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                    const entity = entityDef;
+                    const type = this.getPropertyValue(entity, 'type');
+                    if (type === 'Class' || type?.endsWith('.Class')) {
+                        let subClassOfObj = entity['subClassOf'];
+                        if (subClassOfObj === undefined) {
+                            for (const key of Object.keys(entity)) {
+                                if (key.endsWith('.subClassOf')) {
+                                    subClassOfObj = entity[key];
+                                    break;
+                                }
+                            }
+                        }
+                        const parentClasses = normalizeToStringList(subClassOfObj);
+                        if (parentClasses.length > 0) {
+                            classHierarchy.set(entityName, parentClasses);
+                        }
+                    }
+                }
+            }
+            if (doc.metadata.imports) {
+                for (const [publisher, imports] of Object.entries(doc.metadata.imports)) {
+                    for (const import_ of imports) {
+                        try {
+                            const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                            if (importedDoc) {
+                                const importedNamespace = `${publisher}/${import_.packageName}@${import_.version}`;
+                                await processDocumentAsync(importedDoc, importedNamespace);
+                            }
+                        }
+                        catch {
+                        }
+                    }
+                }
+            }
+        };
+        const currentNs = document.metadata.namespace_?.toString() ?? 'unknown';
+        await processDocumentAsync(document, currentNs);
+        return classHierarchy;
+    }
+    validateEntityProperties(entity, entityPath, entityType, propertyDefinitions, classHierarchy, errors) {
+        for (const [propName, propValue] of Object.entries(entity)) {
+            if (this.standardProperties.has(propName)) {
+                continue;
+            }
+            let lookupName = propName;
+            const dotIndex = propName.lastIndexOf('.');
+            if (dotIndex > 0 && dotIndex < propName.length - 1) {
+                lookupName = propName.substring(dotIndex + 1);
+            }
+            const propDef = propertyDefinitions.get(lookupName);
+            if (!propDef) {
+                continue;
+            }
+            const propertyDomain = this.getPropertyValue(propDef, 'domain');
+            if (!propertyDomain) {
+                continue;
+            }
+            if (!this.isTypeCompatibleWithDomain(entityType, propertyDomain, classHierarchy)) {
+                const rootEntity = entityPath.split('.')[0];
+                errors.push({
+                    ruleType: this.ruleName,
+                    severity: ValidationSeverity.Error,
+                    entityName: rootEntity, // Root entity for lookup
+                    propertyName: entityPath, // Full nested path for navigation
+                    actualValue: propName, // Property to find at end of path
+                    message: `Property '${propName}' has domain '${propertyDomain}' but is used on '${entityType}' at '${entityPath}'`,
+                    suggestion: `Either:\n` +
+                        `  1. Use this property only on '${propertyDomain}' instances\n` +
+                        `  2. Change the property domain to include '${entityType}'\n` +
+                        `  3. Create a different property for '${entityType}'`,
+                    expectedValue: `Property used on ${propertyDomain} or its subclasses`
+                });
+            }
+            if (typeof propValue === 'object' && propValue !== null && !Array.isArray(propValue)) {
+                const embeddedObj = propValue;
+                const embeddedType = this.getPropertyValue(embeddedObj, 'type');
+                if (embeddedType) {
+                    const embeddedPath = `${entityPath}.${propName}`;
+                    this.validateEntityProperties(embeddedObj, embeddedPath, embeddedType, propertyDefinitions, classHierarchy, errors);
+                }
+                else {
+                    const propertyRange = this.getPropertyValue(propDef, 'range');
+                    if (propertyRange) {
+                        const embeddedPath = `${entityPath}.${propName}`;
+                        this.validateEntityProperties(embeddedObj, embeddedPath, propertyRange, propertyDefinitions, classHierarchy, errors);
+                    }
+                }
+            }
+            else if (Array.isArray(propValue)) {
+                for (let i = 0; i < propValue.length; i++) {
+                    const item = propValue[i];
+                    if (typeof item === 'object' && item !== null && !Array.isArray(item)) {
+                        const embeddedItem = item;
+                        const embeddedType = this.getPropertyValue(embeddedItem, 'type');
+                        if (embeddedType) {
+                            const embeddedPath = `${entityPath}.${propName}[${i}]`;
+                            this.validateEntityProperties(embeddedItem, embeddedPath, embeddedType, propertyDefinitions, classHierarchy, errors);
+                        }
+                        else {
+                            const propertyRange = this.getPropertyValue(propDef, 'range');
+                            if (propertyRange) {
+                                const embeddedPath = `${entityPath}.${propName}[${i}]`;
+                                this.validateEntityProperties(embeddedItem, embeddedPath, propertyRange, propertyDefinitions, classHierarchy, errors);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    isTypeCompatibleWithDomain(type, domain, classHierarchy) {
+        if (type === domain) {
+            return true;
+        }
+        const visited = new Set();
+        const queue = [type];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (visited.has(current)) {
+                continue;
+            }
+            visited.add(current);
+            const parentTypes = classHierarchy.get(current);
+            if (parentTypes) {
+                for (const parentType of parentTypes) {
+                    if (parentType === domain) {
+                        return true;
+                    }
+                    queue.push(parentType);
+                }
+            }
+        }
+        return false;
+    }
+    getPropertyValue(dict, propertyName) {
+        if (propertyName in dict) {
+            const value = dict[propertyName];
+            return this.extractFirstValue(value);
+        }
+        for (const key of Object.keys(dict)) {
+            if (key.endsWith(`.${propertyName}`)) {
+                const value = dict[key];
+                return this.extractFirstValue(value);
+            }
+        }
+        return undefined;
+    }
+    extractFirstValue(value) {
+        if (Array.isArray(value)) {
+            const items = [];
+            for (const item of value) {
+                items.push(item?.toString() ?? '');
+            }
+            return items.length > 0 ? items[0] : undefined;
+        }
+        return value?.toString();
+    }
+}

package/dist/validation/rules/repository/PropertyHierarchyCycleRule.d.ts

@@ -0,0 +1,11 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+export declare class PropertyHierarchyCycleRule implements IRepositoryValidationRule {
+    readonly ruleName = "PropertyHierarchyCycle";
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private buildPropertyHierarchy;
+    private detectCycle;
+    private detectCycleRecursive;
+}

package/dist/validation/rules/repository/PropertyHierarchyCycleRule.js

@@ -0,0 +1,104 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { normalizeToStringList } from '../normalizeToStringList.js';
+export class PropertyHierarchyCycleRule {
+    ruleName = 'PropertyHierarchyCycle';
+    async validateAsync(document, repository) {
+        const errors = [];
+        const propertyHierarchy = new Map();
+        const visitedDocs = new Set();
+        await this.buildPropertyHierarchy(document, repository, propertyHierarchy, visitedDocs);
+        for (const [entityName, entityValue] of Object.entries(document.body)) {
+            if (entityValue && typeof entityValue === 'object' && !Array.isArray(entityValue)) {
+                const entityDict = entityValue;
+                const subPropertyOfValue = entityDict['subPropertyOf'];
+                if (subPropertyOfValue) {
+                    const propertyName = entityName;
+                    const cycle = this.detectCycle(propertyName, propertyHierarchy);
+                    if (cycle) {
+                        const cycleChain = cycle.join(' → ');
+                        const error = new OntologyValidationError();
+                        error.ruleType = this.ruleName;
+                        error.severity = ValidationSeverity.Error;
+                        error.message = `Circular property hierarchy detected: ${cycleChain}`;
+                        error.suggestion = 'Remove the circular dependency by breaking one of the subPropertyOf relationships';
+                        error.entityName = propertyName;
+                        error.propertyName = 'subPropertyOf';
+                        error.actualValue = cycleChain;
+                        errors.push(error);
+                        break;
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    async buildPropertyHierarchy(document, repository, hierarchy, visitedDocs) {
+        const docId = document.metadata?.namespace_?.toString() ?? '';
+        if (docId && visitedDocs.has(docId)) {
+            return; // Already processed this document
+        }
+        if (docId) {
+            visitedDocs.add(docId);
+        }
+        for (const [entityName, entityValue] of Object.entries(document.body)) {
+            if (entityValue && typeof entityValue === 'object' && !Array.isArray(entityValue)) {
+                const entityDict = entityValue;
+                const typeValue = entityDict['type'];
+                if (typeValue) {
+                    const typeStr = typeValue.toString();
+                    if (typeStr === 'DatatypeProperty' ||
+                        typeStr === 'ObjectProperty' ||
+                        typeStr === 'AnnotationProperty') {
+                        const subPropertyOfValue = entityDict['subPropertyOf'];
+                        if (subPropertyOfValue) {
+                            const parentProperties = normalizeToStringList(subPropertyOfValue);
+                            if (parentProperties.length > 0) {
+                                hierarchy.set(entityName, parentProperties);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (document.metadata?.imports) {
+            for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+                for (const import_ of imports) {
+                    const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                    if (importedDoc) {
+                        await this.buildPropertyHierarchy(importedDoc, repository, hierarchy, visitedDocs);
+                    }
+                }
+            }
+        }
+    }
+    detectCycle(startProperty, hierarchy) {
+        const path = [];
+        const visited = new Set();
+        return this.detectCycleRecursive(startProperty, hierarchy, path, visited);
+    }
+    detectCycleRecursive(property, hierarchy, path, visited) {
+        if (path.includes(property)) {
+            const cycleStart = path.indexOf(property);
+            const cycle = path.slice(cycleStart);
+            cycle.push(property); // Complete the cycle
+            return cycle;
+        }
+        if (visited.has(property)) {
+            return null;
+        }
+        path.push(property);
+        visited.add(property);
+        const parentProperties = hierarchy.get(property);
+        if (parentProperties) {
+            for (const parentProperty of parentProperties) {
+                const cycle = this.detectCycleRecursive(parentProperty, hierarchy, path, visited);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+        }
+        path.pop();
+        return null;
+    }
+}

package/dist/validation/rules/repository/PropertyRangeReferenceRule.d.ts

@@ -0,0 +1,13 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+export declare class PropertyRangeReferenceRule implements IRepositoryValidationRule {
+    private readonly builtInClasses;
+    private readonly primitiveTypes;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private isTypeAvailableInImports;
+    private isTypeAvailableInImportsRecursive;
+    private isValidRangeTargetType;
+}