@canon-protocol/sdk 8.0.0

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

@@ -0,0 +1,133 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { normalizeToStringList } from '../normalizeToStringList.js';
+export class SubPropertyOfReferenceRule {
+    builtInProperties = new Set([
+        'type',
+        'label',
+        'comment',
+        'domain',
+        'range',
+        'subPropertyOf',
+        'subClassOf',
+        'inverseOf',
+        'sameAs',
+        'seeAlso',
+        'isDefinedBy',
+        'functional',
+        'required'
+    ]);
+    get ruleName() {
+        return 'SubPropertyOfReference';
+    }
+    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 (type === 'DatatypeProperty' || type === 'ObjectProperty' || type === 'AnnotationProperty') {
+                    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 parentProperties = normalizeToStringList(entity['subPropertyOf']);
+                for (let i = 0; i < parentProperties.length; i++) {
+                    const parentProperty = parentProperties[i];
+                    if (this.builtInProperties.has(parentProperty)) {
+                        continue;
+                    }
+                    if (definedProperties.has(parentProperty)) {
+                        continue;
+                    }
+                    const isAvailable = await this.isPropertyAvailableInImports(document, repository, parentProperty);
+                    if (!isAvailable) {
+                        const indexSuffix = parentProperties.length > 1 ? `[${i}]` : '';
+                        const error = new OntologyValidationError();
+                        error.ruleType = this.ruleName;
+                        error.severity = ValidationSeverity.Error;
+                        error.message = `Property '${parentProperty}' referenced in subPropertyOf${indexSuffix} is not defined or imported`;
+                        error.suggestion = `Define '${parentProperty}' as a DatatypeProperty or ObjectProperty, or import a namespace that contains it`;
+                        error.entityName = entityName;
+                        error.propertyName = 'subPropertyOf';
+                        error.actualValue = parentProperty;
+                        error.expectedValue = 'Defined or imported property';
+                        errors.push(error);
+                    }
+                }
+            }
+        }
+        return errors;
+    }
+    async isPropertyAvailableInImports(document, repository, propertyName) {
+        if (!document.metadata.imports) {
+            return false;
+        }
+        let namespaceAlias = null;
+        let actualPropertyName = propertyName;
+        if (propertyName.includes('.')) {
+            const parts = propertyName.split('.', 2);
+            namespaceAlias = parts[0];
+            actualPropertyName = parts[1];
+        }
+        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 lookupName = namespaceAlias !== null ? actualPropertyName : propertyName;
+                    const entityDef = importedDoc.body[lookupName];
+                    if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                        const entity = entityDef;
+                        const type = entity['type']?.toString();
+                        if (type === 'DatatypeProperty' || type === 'ObjectProperty' || type === 'AnnotationProperty') {
+                            return true; // Found the property definition
+                        }
+                    }
+                    const visitedDocs = new Set();
+                    if (await this.isPropertyAvailableInImportsRecursive(importedDoc, repository, lookupName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    async isPropertyAvailableInImportsRecursive(document, repository, propertyName, visitedDocs) {
+        const docId = document.metadata.namespace_?.toString() ?? '';
+        if (docId && visitedDocs.has(docId)) {
+            return false; // Already checked this document
+        }
+        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 (type === 'DatatypeProperty' || type === 'ObjectProperty' || type === 'AnnotationProperty') {
+                            return true;
+                        }
+                    }
+                    if (await this.isPropertyAvailableInImportsRecursive(importedDoc, repository, propertyName, visitedDocs)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,10 @@
+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 TypeAmbiguityRule implements IRepositoryValidationRule {
+    readonly ruleName = "TypeAmbiguity";
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private checkAmbiguousReference;
+    private getTransitiveImportsAsync;
+}

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

@@ -0,0 +1,104 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+import { normalizeToStringList } from '../normalizeToStringList.js';
+export class TypeAmbiguityRule {
+    ruleName = 'TypeAmbiguity';
+    async validateAsync(document, repository) {
+        const errors = [];
+        const typeDefinitions = new Map();
+        const importedDocs = [];
+        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) {
+                        importedDocs.push({ doc: importedDoc, import: import_, publisher });
+                        const transitiveImports = await this.getTransitiveImportsAsync(repository, importedDoc, new Set());
+                        importedDocs.push(...transitiveImports.map(doc => ({ doc, import: null, publisher })));
+                    }
+                }
+            }
+        }
+        for (const { doc: importedDoc, import: import_ } of importedDocs) {
+            const namespaceName = importedDoc.metadata?.namespace_?.toString() ?? 'unknown';
+            for (const entityName of Object.keys(importedDoc.body)) {
+                if (!typeDefinitions.has(entityName)) {
+                    typeDefinitions.set(entityName, []);
+                }
+                typeDefinitions.get(entityName).push({ namespace: namespaceName, import: import_ });
+            }
+        }
+        for (const [entityName, entityValue] of Object.entries(document.body)) {
+            if (entityValue && typeof entityValue === 'object' && !Array.isArray(entityValue)) {
+                const entityDict = entityValue;
+                this.checkAmbiguousReference(entityDict, 'type', typeDefinitions, entityName, errors);
+                this.checkAmbiguousReference(entityDict, 'subClassOf', typeDefinitions, entityName, errors);
+                this.checkAmbiguousReference(entityDict, 'subPropertyOf', typeDefinitions, entityName, errors);
+                this.checkAmbiguousReference(entityDict, 'domain', typeDefinitions, entityName, errors);
+                this.checkAmbiguousReference(entityDict, 'range', typeDefinitions, entityName, errors);
+            }
+        }
+        return errors;
+    }
+    checkAmbiguousReference(entityDict, propertyName, typeDefinitions, entityName, errors) {
+        const value = entityDict[propertyName];
+        if (!value) {
+            return;
+        }
+        const referencedTypes = normalizeToStringList(value);
+        for (const referencedType of referencedTypes) {
+            if (referencedType.includes('.')) {
+                continue;
+            }
+            const definitions = typeDefinitions.get(referencedType);
+            if (definitions && definitions.length > 1) {
+                const namespaces = definitions.map(d => d.namespace).join(', ');
+                const suggestions = [];
+                for (const { namespace: ns, import: import_ } of definitions) {
+                    if (import_?.alias) {
+                        suggestions.push(`${import_.alias}.${referencedType}`);
+                    }
+                    else {
+                        const parts = ns.split('/');
+                        const lastPart = parts[parts.length - 1];
+                        const packageName = lastPart?.split('@')[0] ?? 'alias';
+                        suggestions.push(`${packageName}.${referencedType}`);
+                    }
+                }
+                const suggestionText = suggestions.length > 0
+                    ? `Use one of: ${suggestions.join(', ')}`
+                    : 'Consider adding namespace aliases to your imports';
+                const error = new OntologyValidationError();
+                error.ruleType = this.ruleName;
+                error.severity = ValidationSeverity.Warning;
+                error.entityName = entityName;
+                error.propertyName = propertyName;
+                error.actualValue = referencedType;
+                error.message = `Type '${referencedType}' is ambiguous. It's defined in: ${namespaces}`;
+                error.suggestion = suggestionText;
+                errors.push(error);
+            }
+        }
+    }
+    async getTransitiveImportsAsync(repository, document, visited) {
+        const result = [];
+        const docId = document.metadata?.namespace_?.toString() ?? '';
+        if (visited.has(docId)) {
+            return result;
+        }
+        visited.add(docId);
+        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) {
+                        result.push(importedDoc);
+                        const transitive = await this.getTransitiveImportsAsync(repository, importedDoc, visited);
+                        result.push(...transitive);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/validation/rules/repository/UnresolvedReferenceRule.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 UnresolvedReferenceRule implements IRepositoryValidationRule {
+    readonly ruleName = "UnresolvedReference";
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private validateReferenceValue;
+    private createUnresolvedReferenceError;
+    private getPropertyValue;
+}

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

@@ -0,0 +1,91 @@
+import { ResourceResolver } from '../../../resolution/ResourceResolver.js';
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class UnresolvedReferenceRule {
+    ruleName = 'UnresolvedReference';
+    async validateAsync(document, repository) {
+        const errors = [];
+        const resourceResolver = new ResourceResolver(repository);
+        const entityIndex = await resourceResolver.buildEntityIndexAsync(document);
+        const objectProperties = new Set();
+        for (const [entityName, resourceResolution] of entityIndex.entries()) {
+            const typeValue = resourceResolution.entity['type'];
+            if (typeValue) {
+                const type = typeValue.toString();
+                if (type === 'ObjectProperty' || type.endsWith('.ObjectProperty')) {
+                    objectProperties.add(entityName);
+                }
+            }
+        }
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (!entityDef || typeof entityDef !== 'object' || Array.isArray(entityDef)) {
+                continue;
+            }
+            const entity = entityDef;
+            const entityType = this.getPropertyValue(entity, 'type');
+            if (!entityType ||
+                entityType === 'Class' ||
+                entityType.endsWith('Property') ||
+                entityType === 'AnnotationProperty') {
+                continue;
+            }
+            for (const [propName, propValue] of Object.entries(entity)) {
+                if (propName === 'type' || propName === 'label' || propName === 'comment') {
+                    continue;
+                }
+                const isObjectProperty = objectProperties.has(propName) ||
+                    Array.from(objectProperties).some(p => p.endsWith(`.${propName}`));
+                if (!isObjectProperty) {
+                    continue;
+                }
+                await this.validateReferenceValue(entityName, propName, propValue, document, resourceResolver, errors);
+            }
+        }
+        return errors;
+    }
+    async validateReferenceValue(entityName, propertyName, value, document, resourceResolver, errors) {
+        if (value == null) {
+            return;
+        }
+        if (typeof value === 'string') {
+            const resolution = await resourceResolver.resolveEntityAsync(value, document);
+            if (!resolution) {
+                errors.push(this.createUnresolvedReferenceError(entityName, propertyName, value));
+            }
+        }
+        else if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                const item = value[i];
+                if (typeof item === 'string') {
+                    const resolution = await resourceResolver.resolveEntityAsync(item, document);
+                    if (!resolution) {
+                        errors.push(this.createUnresolvedReferenceError(entityName, `${propertyName}[${i}]`, item));
+                    }
+                }
+            }
+        }
+    }
+    createUnresolvedReferenceError(entityName, propertyName, referencedEntity) {
+        const suggestion = `The entity '${referencedEntity}' cannot be found in the current document or any imported namespaces.\n\n` +
+            'Possible solutions:\n' +
+            '  • Add import if the entity is defined in another namespace:\n' +
+            '    canon namespace add-import <publisher>/<package>@<version>\n' +
+            `  • Check for typos in the reference name '${referencedEntity}'\n` +
+            `  • Define '${referencedEntity}' in the current namespace or an appropriate namespace\n` +
+            `  • Use 'canon search type ${referencedEntity} --include-imports' to locate the entity`;
+        const error = new OntologyValidationError();
+        error.ruleType = this.ruleName;
+        error.severity = ValidationSeverity.Warning;
+        error.entityName = entityName;
+        error.propertyName = propertyName;
+        error.actualValue = referencedEntity;
+        error.message = `Reference to '${referencedEntity}' could not be resolved`;
+        error.suggestion = suggestion;
+        error.expectedValue = 'A valid entity reference that exists in the current document or imported namespaces';
+        return error;
+    }
+    getPropertyValue(dict, propertyName) {
+        const value = dict[propertyName];
+        return value ? value.toString() : null;
+    }
+}

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

@@ -0,0 +1,11 @@
+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 XsdImportRule implements IRepositoryValidationRule {
+    private readonly xsdTypes;
+    get ruleName(): string;
+    validateAsync(document: CanonDocument, repository: ICanonDocumentRepository): Promise<OntologyValidationError[]>;
+    private checkXsdImportAsync;
+    private getPropertyValue;
+}

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

@@ -0,0 +1,125 @@
+import { OntologyValidationError } from '../../OntologyValidationError.js';
+import { ValidationSeverity } from '../../ValidationSeverity.js';
+export class XsdImportRule {
+    xsdTypes = new Set([
+        'string',
+        'integer',
+        'boolean',
+        'decimal',
+        'float',
+        'double',
+        'date',
+        'dateTime',
+        'time',
+        'duration',
+        'anyURI',
+        'base64Binary',
+        'hexBinary',
+        'long',
+        'int',
+        'short',
+        'byte',
+        'unsignedLong',
+        'unsignedInt',
+        'unsignedShort',
+        'unsignedByte',
+        'positiveInteger',
+        'nonPositiveInteger',
+        'negativeInteger',
+        'nonNegativeInteger',
+        'normalizedString',
+        'token',
+        'language',
+        'Name',
+        'NCName',
+        'ENTITY',
+        'ENTITIES',
+        'IDREF',
+        'IDREFS',
+        'NMTOKEN',
+        'NMTOKENS'
+    ]);
+    get ruleName() {
+        return 'XsdImport';
+    }
+    async validateAsync(document, repository) {
+        const errors = [];
+        const usedXsdTypes = new Set();
+        const datatypeProperties = [];
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (typeof entityDef === 'object' && entityDef !== null && !Array.isArray(entityDef)) {
+                const entity = entityDef;
+                let isDatatypeProperty = false;
+                const typeValue = entity['type'];
+                if (Array.isArray(typeValue)) {
+                    for (const type of typeValue) {
+                        if (type?.toString() === 'DatatypeProperty') {
+                            isDatatypeProperty = true;
+                            break;
+                        }
+                    }
+                }
+                else if (typeValue?.toString() === 'DatatypeProperty') {
+                    isDatatypeProperty = true;
+                }
+                if (isDatatypeProperty) {
+                    datatypeProperties.push(entityName);
+                    const rangeValue = this.getPropertyValue(entity, 'range');
+                    if (rangeValue && this.xsdTypes.has(rangeValue)) {
+                        usedXsdTypes.add(rangeValue);
+                    }
+                }
+            }
+        }
+        if (usedXsdTypes.size > 0) {
+            const hasXsdImport = await this.checkXsdImportAsync(document.metadata, repository);
+            if (!hasXsdImport) {
+                const xsdTypesList = Array.from(usedXsdTypes).sort().join(', ');
+                const propertyList = datatypeProperties.sort().join(', ');
+                const error = new OntologyValidationError();
+                error.ruleType = this.ruleName;
+                error.severity = ValidationSeverity.Error;
+                error.message = `XSD namespace not imported but XSD types are used: ${xsdTypesList}`;
+                error.suggestion = `Add an XSD import to the imports section. The core XSD types package is 'core-xsd' from publisher 'canon-protocol.org'. Used by properties: ${propertyList}`;
+                error.entityName = 'imports';
+                errors.push(error);
+            }
+        }
+        return errors;
+    }
+    async checkXsdImportAsync(metadata, repository, visitedPackages = new Set()) {
+        if (!metadata?.imports) {
+            return false;
+        }
+        const currentPackage = metadata.namespace_?.toString() ?? '';
+        if (currentPackage && visitedPackages.has(currentPackage)) {
+            return false; // Already visited, prevent cycle
+        }
+        if (currentPackage) {
+            visitedPackages.add(currentPackage);
+        }
+        for (const [, imports] of Object.entries(metadata.imports)) {
+            for (const import_ of imports) {
+                if (import_.packageName === 'xsd' || import_.packageName.toLowerCase().endsWith('-xsd')) {
+                    return true;
+                }
+            }
+        }
+        for (const [publisher, imports] of Object.entries(metadata.imports)) {
+            for (const import_ of imports) {
+                const importedDoc = await repository.getHighestCompatibleVersionAsync(publisher, import_);
+                if (importedDoc?.metadata) {
+                    const hasXsd = await this.checkXsdImportAsync(importedDoc.metadata, repository, visitedPackages);
+                    if (hasXsd) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    getPropertyValue(dict, propertyName) {
+        const value = dict[propertyName];
+        return value?.toString();
+    }
+}

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

@@ -0,0 +1,20 @@
+export type { IRepositoryValidationRule } from './IRepositoryValidationRule.js';
+export { ImportExistenceRule } from './ImportExistenceRule.js';
+export { UnresolvedReferenceRule } from './UnresolvedReferenceRule.js';
+export { TypeAmbiguityRule } from './TypeAmbiguityRule.js';
+export { ClassHierarchyCycleRule } from './ClassHierarchyCycleRule.js';
+export { PropertyHierarchyCycleRule } from './PropertyHierarchyCycleRule.js';
+export { PropertyRangeRequiredRule } from './PropertyRangeRequiredRule.js';
+export { SubClassOfReferenceRule } from './SubClassOfReferenceRule.js';
+export { SubPropertyOfReferenceRule } from './SubPropertyOfReferenceRule.js';
+export { NamespaceImportCycleRule } from './NamespaceImportCycleRule.js';
+export { InstancePropertyReferenceRule } from './InstancePropertyReferenceRule.js';
+export { DefinitionPropertyReferenceRule } from './DefinitionPropertyReferenceRule.js';
+export { XsdImportRule } from './XsdImportRule.js';
+export { AmbiguousReferenceRule } from './AmbiguousReferenceRule.js';
+export { PropertyRangeReferenceRule } from './PropertyRangeReferenceRule.js';
+export { ObjectPropertyImportRule } from './ObjectPropertyImportRule.js';
+export { ObjectPropertyValueValidationRule } from './ObjectPropertyValueValidationRule.js';
+export { PropertyDomainRule } from './PropertyDomainRule.js';
+export { PropertyValueTypeRule } from './PropertyValueTypeRule.js';
+export { ClassDefinitionRule } from './ClassDefinitionRule.js';

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

@@ -0,0 +1,19 @@
+export { ImportExistenceRule } from './ImportExistenceRule.js';
+export { UnresolvedReferenceRule } from './UnresolvedReferenceRule.js';
+export { TypeAmbiguityRule } from './TypeAmbiguityRule.js';
+export { ClassHierarchyCycleRule } from './ClassHierarchyCycleRule.js';
+export { PropertyHierarchyCycleRule } from './PropertyHierarchyCycleRule.js';
+export { PropertyRangeRequiredRule } from './PropertyRangeRequiredRule.js';
+export { SubClassOfReferenceRule } from './SubClassOfReferenceRule.js';
+export { SubPropertyOfReferenceRule } from './SubPropertyOfReferenceRule.js';
+export { NamespaceImportCycleRule } from './NamespaceImportCycleRule.js';
+export { InstancePropertyReferenceRule } from './InstancePropertyReferenceRule.js';
+export { DefinitionPropertyReferenceRule } from './DefinitionPropertyReferenceRule.js';
+export { XsdImportRule } from './XsdImportRule.js';
+export { AmbiguousReferenceRule } from './AmbiguousReferenceRule.js';
+export { PropertyRangeReferenceRule } from './PropertyRangeReferenceRule.js';
+export { ObjectPropertyImportRule } from './ObjectPropertyImportRule.js';
+export { ObjectPropertyValueValidationRule } from './ObjectPropertyValueValidationRule.js';
+export { PropertyDomainRule } from './PropertyDomainRule.js';
+export { PropertyValueTypeRule } from './PropertyValueTypeRule.js';
+export { ClassDefinitionRule } from './ClassDefinitionRule.js';

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@canon-protocol/sdk",
+  "version": "8.0.0",
+  "description": "Canon Protocol SDK - Document repository and parsing implementations for TypeScript",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./repositories": {
+      "types": "./dist/repositories/index.d.ts",
+      "default": "./dist/repositories/index.js"
+    },
+    "./parsing": {
+      "types": "./dist/parsing/index.d.ts",
+      "default": "./dist/parsing/index.js"
+    },
+    "./resolution": {
+      "types": "./dist/resolution/index.d.ts",
+      "default": "./dist/resolution/index.js"
+    },
+    "./validation": {
+      "types": "./dist/validation/index.d.ts",
+      "default": "./dist/validation/index.js"
+    },
+    "./filtering": {
+      "types": "./dist/filtering/index.d.ts",
+      "default": "./dist/filtering/index.js"
+    },
+    "./ctl": {
+      "types": "./dist/ctl/index.d.ts",
+      "default": "./dist/ctl/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "docs": "typedoc",
+    "docs:watch": "typedoc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/canon-protocol/canon-protocol.git"
+  },
+  "keywords": [
+    "canon",
+    "ontology",
+    "semantic-web",
+    "typescript",
+    "sdk",
+    "document-repository",
+    "yaml-parser"
+  ],
+  "dependencies": {
+    "@canon-protocol/types": "^8.0.0",
+    "ignore": "^7.0.5",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.19.25",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.1.0",
+    "typedoc": "^0.28.14",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}