@canon-protocol/sdk 8.0.0

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

@@ -0,0 +1,205 @@
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { ResourceResolver } from '../../../resolution/ResourceResolver.js';
+export class ClassDefinitionRule {
+    builtInClasses = new Set([
+        'Resource',
+        'Class',
+        'Literal',
+        'Thing',
+        'Nothing',
+        'Property',
+        'DatatypeProperty',
+        'ObjectProperty',
+        'AnnotationProperty',
+        'FunctionalProperty',
+        'InverseFunctionalProperty',
+        'TransitiveProperty',
+        'SymmetricProperty'
+    ]);
+    get ruleName() {
+        return 'ClassDefinition';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const usedClasses = new Map(); // class -> entities using it
+        const definedClasses = new Set();
+        for (const [entityName, entityValue] of Object.entries(document.body)) {
+            if (typeof entityValue === 'object' && entityValue !== null && !Array.isArray(entityValue)) {
+                const entityDict = entityValue;
+                const typeObj = entityDict['type'];
+                if (typeObj) {
+                    if (Array.isArray(typeObj)) {
+                        for (const type of typeObj) {
+                            const typeStr = type?.toString();
+                            if (typeStr === 'Class' || (typeStr && typeStr.endsWith('.Class'))) {
+                                definedClasses.add(entityName);
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        const typeStr = typeObj?.toString();
+                        if (typeStr === 'Class' || (typeStr && typeStr.endsWith('.Class'))) {
+                            definedClasses.add(entityName);
+                        }
+                    }
+                }
+            }
+        }
+        for (const [entityName, entityValue] of Object.entries(document.body)) {
+            if (typeof entityValue === 'object' && entityValue !== null && !Array.isArray(entityValue)) {
+                const entityDict = entityValue;
+                const typeObj = entityDict['type'];
+                if (typeObj) {
+                    if (Array.isArray(typeObj)) {
+                        let shouldSkip = false;
+                        for (const type of typeObj) {
+                            const typeStr = type?.toString();
+                            if (typeStr) {
+                                if (this.isDefinitionType(typeStr)) {
+                                    shouldSkip = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!shouldSkip) {
+                            for (const type of typeObj) {
+                                const typeStr = type?.toString();
+                                if (typeStr && typeStr.trim().length > 0) {
+                                    if (!usedClasses.has(typeStr)) {
+                                        usedClasses.set(typeStr, []);
+                                    }
+                                    usedClasses.get(typeStr).push(entityName);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        const typeStr = typeObj?.toString();
+                        if (typeStr && typeStr.trim().length > 0) {
+                            if (!this.isDefinitionType(typeStr)) {
+                                if (!usedClasses.has(typeStr)) {
+                                    usedClasses.set(typeStr, []);
+                                }
+                                usedClasses.get(typeStr).push(entityName);
+                            }
+                        }
+                    }
+                }
+                this.checkNestedTypes(entityDict, entityName, usedClasses, entityName);
+            }
+        }
+        const resolver = new ResourceResolver(repository);
+        for (const [className, entities] of usedClasses) {
+            if (this.builtInClasses.has(className)) {
+                continue;
+            }
+            if (definedClasses.has(className)) {
+                continue;
+            }
+            const resolvedEntity = await resolver.resolveEntityAsync(className, document);
+            const isAvailable = resolvedEntity && this.isClassEntity(resolvedEntity.entity);
+            if (!isAvailable) {
+                const uniqueEntities = Array.from(new Set(entities)).sort();
+                for (const entityName of uniqueEntities) {
+                    errors.push({
+                        ruleType: this.ruleName,
+                        severity: ValidationSeverity.Error,
+                        message: `Class '${className}' is not defined or imported`,
+                        suggestion: `Define '${className}' as a Class in this document, or import a namespace that contains it`,
+                        entityName: entityName, // Actual entity name for position finding
+                        propertyName: 'type', // The property with the invalid value
+                        actualValue: className,
+                        expectedValue: 'Defined or imported class'
+                    });
+                }
+            }
+        }
+        return errors;
+    }
+    checkNestedTypes(value, parentEntity, usedClasses, currentPath) {
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            const dict = value;
+            const typeObj = dict['type'];
+            if (typeObj) {
+                const skipTypes = new Set(['Class', 'DatatypeProperty', 'ObjectProperty', 'AnnotationProperty']);
+                if (Array.isArray(typeObj)) {
+                    for (const type of typeObj) {
+                        const typeStr = type?.toString();
+                        if (typeStr && typeStr.trim().length > 0 && !skipTypes.has(typeStr)) {
+                            if (!usedClasses.has(typeStr)) {
+                                usedClasses.set(typeStr, []);
+                            }
+                            usedClasses.get(typeStr).push(currentPath);
+                        }
+                    }
+                }
+                else {
+                    const typeStr = typeObj?.toString();
+                    if (typeStr && typeStr.trim().length > 0 && !skipTypes.has(typeStr)) {
+                        if (!usedClasses.has(typeStr)) {
+                            usedClasses.set(typeStr, []);
+                        }
+                        usedClasses.get(typeStr).push(currentPath);
+                    }
+                }
+            }
+            for (const [key, val] of Object.entries(dict)) {
+                if (key !== 'type') {
+                    const newPath = `${currentPath}.${key}`;
+                    this.checkNestedTypes(val, parentEntity, usedClasses, newPath);
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                const newPath = `${currentPath}[${i}]`;
+                this.checkNestedTypes(value[i], parentEntity, usedClasses, newPath);
+            }
+        }
+    }
+    isClassEntity(entityDict) {
+        if (!entityDict) {
+            return false;
+        }
+        const typeObj = entityDict['type'];
+        if (!typeObj) {
+            return false;
+        }
+        if (Array.isArray(typeObj)) {
+            for (const type of typeObj) {
+                const typeStr = type?.toString();
+                if (typeStr === 'Class' || (typeStr && typeStr.endsWith('.Class'))) {
+                    return true;
+                }
+            }
+        }
+        else {
+            const typeStr = typeObj?.toString();
+            if (typeStr === 'Class' || (typeStr && typeStr.endsWith('.Class'))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isDefinitionType(typeStr) {
+        if (!typeStr || typeStr.trim().length === 0) {
+            return false;
+        }
+        const definitionTypes = new Set([
+            'Class',
+            'Property',
+            'DatatypeProperty',
+            'ObjectProperty',
+            'AnnotationProperty'
+        ]);
+        if (definitionTypes.has(typeStr)) {
+            return true;
+        }
+        return (typeStr.endsWith('.Class') ||
+            typeStr.endsWith('.Property') ||
+            typeStr.endsWith('.DatatypeProperty') ||
+            typeStr.endsWith('.ObjectProperty') ||
+            typeStr.endsWith('.AnnotationProperty'));
+    }
+}

package/dist/validation/rules/repository/ClassHierarchyCycleRule.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 ClassHierarchyCycleRule implements IRepositoryValidationRule {
+    readonly ruleName = "ClassHierarchyCycle";
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private buildClassHierarchy;
+    private detectCycle;
+    private detectCycleRecursive;
+}

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

@@ -0,0 +1,98 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { normalizeToStringList } from '../normalizeToStringList.js';
+export class ClassHierarchyCycleRule {
+    ruleName = 'ClassHierarchyCycle';
+    async validateAsync(document, repository) {
+        const errors = [];
+        const classHierarchy = new Map();
+        const visitedDocs = new Set();
+        await this.buildClassHierarchy(document, repository, classHierarchy, visitedDocs);
+        for (const [entityName, entityValue] of Object.entries(document.body)) {
+            if (entityValue && typeof entityValue === 'object' && !Array.isArray(entityValue)) {
+                const entityDict = entityValue;
+                const typeValue = entityDict['type'];
+                const subClassOfValue = entityDict['subClassOf'];
+                if (typeValue?.toString() === 'Class' && subClassOfValue) {
+                    const className = entityName;
+                    const cycle = this.detectCycle(className, classHierarchy);
+                    if (cycle) {
+                        const cycleChain = cycle.join(' → ');
+                        const error = new OntologyValidationError();
+                        error.ruleType = this.ruleName;
+                        error.severity = ValidationSeverity.Error;
+                        error.message = `Circular class hierarchy detected: ${cycleChain}`;
+                        error.suggestion = 'Remove the circular dependency by breaking one of the subClassOf relationships';
+                        error.entityName = className;
+                        error.propertyName = 'subClassOf';
+                        error.actualValue = cycleChain;
+                        errors.push(error);
+                        break;
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    async buildClassHierarchy(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'];
+                const subClassOfValue = entityDict['subClassOf'];
+                if (typeValue?.toString() === 'Class' && subClassOfValue) {
+                    const parentClasses = normalizeToStringList(subClassOfValue);
+                    if (parentClasses.length > 0) {
+                        hierarchy.set(entityName, parentClasses);
+                    }
+                }
+            }
+        }
+        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.buildClassHierarchy(importedDoc, repository, hierarchy, visitedDocs);
+                    }
+                }
+            }
+        }
+    }
+    detectCycle(startClass, hierarchy) {
+        const path = [];
+        const visited = new Set();
+        return this.detectCycleRecursive(startClass, hierarchy, path, visited);
+    }
+    detectCycleRecursive(className, hierarchy, path, visited) {
+        if (path.includes(className)) {
+            const cycleStart = path.indexOf(className);
+            const cycle = path.slice(cycleStart);
+            cycle.push(className); // Complete the cycle
+            return cycle;
+        }
+        if (visited.has(className)) {
+            return null;
+        }
+        path.push(className);
+        visited.add(className);
+        const parentClasses = hierarchy.get(className);
+        if (parentClasses) {
+            for (const parentClass of parentClasses) {
+                const cycle = this.detectCycleRecursive(parentClass, hierarchy, path, visited);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+        }
+        path.pop();
+        return null;
+    }
+}

package/dist/validation/rules/repository/DefinitionPropertyReferenceRule.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 DefinitionPropertyReferenceRule implements IRepositoryValidationRule {
+    private readonly metadataKeys;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private isPropertyType;
+    private isClassType;
+    private isPropertyAvailableInImports;
+    private isPropertyAvailableInImportsRecursive;
+}

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

@@ -0,0 +1,162 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class DefinitionPropertyReferenceRule {
+    metadataKeys = new Set([
+        'type',
+        'label',
+        'comment',
+        'subClassOf',
+        'subPropertyOf',
+        'domain',
+        'range',
+        'inverseOf',
+        'transitive',
+        'symmetric',
+        'functional',
+        'inverseFunctional'
+    ]);
+    get ruleName() {
+        return 'DefinitionPropertyReference';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const definedProperties = new Set();
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const type = entity['type']?.toString();
+                if (this.isPropertyType(type)) {
+                    definedProperties.add(entityName);
+                }
+            }
+        }
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                const type = entity['type']?.toString();
+                if (!this.isPropertyType(type) && !this.isClassType(type)) {
+                    continue;
+                }
+                for (const [propertyName, propertyValue] of Object.entries(entity)) {
+                    if (!propertyName) {
+                        continue;
+                    }
+                    if (this.metadataKeys.has(propertyName)) {
+                        continue;
+                    }
+                    let actualPropertyName = propertyName;
+                    let namespaceAlias = null;
+                    if (propertyName.includes('.')) {
+                        const lastDotIndex = propertyName.lastIndexOf('.');
+                        namespaceAlias = propertyName.substring(0, lastDotIndex);
+                        actualPropertyName = propertyName.substring(lastDotIndex + 1);
+                    }
+                    if (definedProperties.has(actualPropertyName)) {
+                        continue;
+                    }
+                    const isAvailable = await this.isPropertyAvailableInImports(document, repository, actualPropertyName, namespaceAlias);
+                    if (!isAvailable) {
+                        const definitionType = this.isClassType(type) ? 'class' : 'property';
+                        const error = new OntologyValidationError();
+                        error.ruleType = this.ruleName;
+                        error.severity = ValidationSeverity.Error;
+                        error.message = `Property '${propertyName}' used on ${definitionType} '${entityName}' is not defined or imported`;
+                        error.suggestion = namespaceAlias
+                            ? `The property '${actualPropertyName}' is not found in the imported namespace with alias '${namespaceAlias}'.\n` +
+                                `  1. Verify the namespace is imported with the correct alias\n` +
+                                `  2. Check if the property name is spelled correctly\n` +
+                                `  3. Ensure the imported namespace version contains this property`
+                            : `The property '${propertyName}' is not defined in this namespace or any imported namespace.\n` +
+                                `  1. Define '${propertyName}' as an ObjectProperty or DatatypeProperty in this namespace, OR\n` +
+                                `  2. Import the namespace that contains '${propertyName}', OR\n` +
+                                `  3. Use a qualified reference like 'alias.${propertyName}' if already imported with an alias`;
+                        error.entityName = entityName;
+                        error.propertyName = propertyName;
+                        error.actualValue = propertyValue?.toString();
+                        error.expectedValue = 'A defined or imported property';
+                        errors.push(error);
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    isPropertyType(typeStr) {
+        if (!typeStr) {
+            return false;
+        }
+        return (typeStr === 'ObjectProperty' ||
+            typeStr === 'DatatypeProperty' ||
+            typeStr === 'AnnotationProperty' ||
+            typeStr === 'Property' ||
+            typeStr.endsWith('.ObjectProperty') ||
+            typeStr.endsWith('.DatatypeProperty') ||
+            typeStr.endsWith('.AnnotationProperty') ||
+            typeStr.endsWith('.Property'));
+    }
+    isClassType(typeStr) {
+        if (!typeStr) {
+            return false;
+        }
+        return typeStr === 'Class' || typeStr.endsWith('.Class');
+    }
+    async isPropertyAvailableInImports(document, repository, propertyName, namespaceAlias) {
+        if (!document.metadata.imports) {
+            return false;
+        }
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                if (namespaceAlias !== null && import_.alias !== namespaceAlias) {
+                    continue;
+                }
+                const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (importedDoc) {
+                    const entityDef = importedDoc.body[propertyName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (this.isPropertyType(type)) {
+                            return true;
+                        }
+                    }
+                    const visitedDocs = new Set();
+                    if (await this.isPropertyAvailableInImportsRecursive(importedDoc, repository, propertyName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    async isPropertyAvailableInImportsRecursive(document, repository, propertyName, visitedDocs) {
+        const docId = document.metadata.namespace_?.toString() ?? '';
+        if (docId && visitedDocs.has(docId)) {
+            return false;
+        }
+        if (docId) {
+            visitedDocs.add(docId);
+        }
+        if (!document.metadata.imports) {
+            return false;
+        }
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (importedDoc) {
+                    const entityDef = importedDoc.body[propertyName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (this.isPropertyType(type)) {
+                            return true;
+                        }
+                    }
+                    if (await this.isPropertyAvailableInImportsRecursive(importedDoc, repository, propertyName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { OntologyValidationError } from '../../OntologyValidationError.js';
+export interface IRepositoryValidationRule {
+    readonly ruleName: string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,12 @@
+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 ImportExistenceRule implements IRepositoryValidationRule {
+    readonly ruleName = "ImportExistence";
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private determineImportErrorAsync;
+    private getAcceptableVersionRange;
+    private findSimilarPackages;
+    private levenshteinDistance;
+}

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

@@ -0,0 +1,124 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class ImportExistenceRule {
+    ruleName = 'ImportExistence';
+    async validateAsync(document, repository) {
+        const errors = [];
+        if (!document.metadata?.imports) {
+            return errors; // No imports to validate
+        }
+        const allDocuments = await repository.getAllDocumentsAsync();
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                const resolvedDocument = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (!resolvedDocument) {
+                    const errorDetails = await this.determineImportErrorAsync(repository, publisher, import_, allDocuments);
+                    const error = new OntologyValidationError();
+                    error.ruleType = this.ruleName;
+                    error.severity = ValidationSeverity.Error;
+                    error.message = errorDetails.message;
+                    error.suggestion = errorDetails.suggestion;
+                    error.entityName = `Import: ${publisher}/${import_.packageName}`;
+                    error.actualValue = import_.toString();
+                    error.expectedValue = errorDetails.expectedValue;
+                    errors.push(error);
+                }
+            }
+        }
+        return errors;
+    }
+    async determineImportErrorAsync(repository, publisher, import_, allDocuments) {
+        const allVersions = await repository.getDocumentsByNamespaceAsync(publisher, import_.packageName);
+        if (allVersions.length === 0) {
+            const availablePackages = allDocuments
+                .filter(d => d.metadata.namespace_?.publisher === publisher)
+                .map(d => d.metadata.namespace_.package_)
+                .filter((pkg, index, self) => self.indexOf(pkg) === index); // Distinct
+            const suggestions = this.findSimilarPackages(import_.packageName, availablePackages);
+            const message = `Import '${publisher}/${import_.package_}' not found - package does not exist`;
+            const suggestion = suggestions.length > 0
+                ? `Did you mean: ${suggestions.slice(0, 3).join(', ')}?`
+                : availablePackages.length > 0
+                    ? `Available packages in ${publisher}: ${availablePackages.slice(0, 5).join(', ')}`
+                    : `No packages found for publisher '${publisher}'. Verify the publisher name is correct.`;
+            return {
+                message,
+                suggestion,
+                expectedValue: 'Existing package'
+            };
+        }
+        const availableVersions = allVersions
+            .filter(d => d.metadata.namespace_?.version)
+            .map(d => d.metadata.namespace_.version.toString())
+            .sort();
+        const versionList = availableVersions.join(', ');
+        const acceptableRange = this.getAcceptableVersionRange(import_);
+        return {
+            message: `Import '${publisher}/${import_.toString()}' version mismatch - no compatible version found`,
+            suggestion: `Available versions: ${versionList}. Required: ${acceptableRange}`,
+            expectedValue: acceptableRange
+        };
+    }
+    getAcceptableVersionRange(import_) {
+        switch (import_.versionOperator) {
+            case 0: // Exact
+                return `exactly ${import_.version.major}.${import_.version.minor}.${import_.version.patch}`;
+            case 1: // Compatible (~)
+                return `${import_.version.major}.${import_.version.minor}.${import_.version.patch} to ${import_.version.major}.${import_.version.minor}.x`;
+            case 2: // Major (^)
+                return import_.version.major === 0
+                    ? `0.${import_.version.minor}.x`
+                    : `${import_.version.major}.x.x`;
+            case 3: // Any (>=)
+                return `any version >= ${import_.version.major}.${import_.version.minor}.${import_.version.patch}`;
+            default:
+                return import_.toString();
+        }
+    }
+    findSimilarPackages(targetPackage, availablePackages) {
+        if (availablePackages.length === 0) {
+            return [];
+        }
+        const substringMatches = availablePackages.filter(pkg => pkg.toLowerCase().includes(targetPackage.toLowerCase()) ||
+            targetPackage.toLowerCase().includes(pkg.toLowerCase()));
+        if (substringMatches.length > 0) {
+            return substringMatches.sort((a, b) => a.length - b.length); // Prefer shorter matches
+        }
+        const scoredPackages = availablePackages
+            .map(pkg => ({
+            package: pkg,
+            distance: this.levenshteinDistance(targetPackage.toLowerCase(), pkg.toLowerCase())
+        }))
+            .sort((a, b) => a.distance - b.distance);
+        const threshold = Math.max(3, Math.floor(targetPackage.length * 0.4));
+        return scoredPackages
+            .filter(x => x.distance <= threshold)
+            .map(x => x.package);
+    }
+    levenshteinDistance(source, target) {
+        if (!source || source.length === 0) {
+            return target?.length ?? 0;
+        }
+        if (!target || target.length === 0) {
+            return source.length;
+        }
+        const sourceLength = source.length;
+        const targetLength = target.length;
+        const distance = Array(sourceLength + 1)
+            .fill(null)
+            .map(() => Array(targetLength + 1).fill(0));
+        for (let i = 0; i <= sourceLength; i++) {
+            distance[i][0] = i;
+        }
+        for (let j = 0; j <= targetLength; j++) {
+            distance[0][j] = j;
+        }
+        for (let i = 1; i <= sourceLength; i++) {
+            for (let j = 1; j <= targetLength; j++) {
+                const cost = source[i - 1] === target[j - 1] ? 0 : 1;
+                distance[i][j] = Math.min(Math.min(distance[i - 1][j] + 1, distance[i][j - 1] + 1), distance[i - 1][j - 1] + cost);
+            }
+        }
+        return distance[sourceLength][targetLength];
+    }
+}

package/dist/validation/rules/repository/InstancePropertyReferenceRule.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 InstancePropertyReferenceRule implements IRepositoryValidationRule {
+    private readonly metadataKeys;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private isPropertyType;
+    private isClassType;
+    private isPropertyAvailableInImports;
+    private isPropertyAvailableInImportsRecursive;
+}