@canon-protocol/sdk 8.0.0

package/dist/ctl/CtlGraphResolver.js

@@ -0,0 +1,411 @@
+import { ResolvedResourceType } from '@canon-protocol/types/ctl/resolution/enums';
+import { ResourceTypeClassifier } from './ResourceTypeClassifier.js';
+const CORE_PACKAGES = new Set([
+    'canon-protocol.org/core-rdf',
+    'canon-protocol.org/core-rdfs',
+    'canon-protocol.org/core-owl',
+    'canon-protocol.org/core-xsd',
+    'canon-protocol.org/core-canon'
+]);
+var EntityTier;
+(function (EntityTier) {
+    EntityTier[EntityTier["Direct"] = 0] = "Direct";
+    EntityTier[EntityTier["Inherited"] = 1] = "Inherited";
+    EntityTier[EntityTier["Foundation"] = 2] = "Foundation";
+})(EntityTier || (EntityTier = {}));
+export class CtlGraphResolver {
+    repository;
+    constructor(repository) {
+        if (!repository) {
+            throw new Error('Repository is required for CTL graph resolution');
+        }
+        this.repository = repository;
+    }
+    async resolveAsync(document, maxDepth = 1000) {
+        if (!document) {
+            throw new Error('Document cannot be null');
+        }
+        const visited = new Set();
+        const directRefs = [];
+        const inheritedRefs = [];
+        const foundationRefs = [];
+        const unresolved = [];
+        const directRefUris = new Set();
+        for (const reference of document.references) {
+            if (reference.parsedUri) {
+                directRefUris.add(reference.parsedUri.toString());
+            }
+        }
+        const entityLookup = new Map();
+        const entitiesByNamespace = new Map();
+        const allDocs = await this.repository.getAllDocumentsAsync();
+        for (const doc of allDocs) {
+            const ns = doc.metadata?.namespace_?.toString();
+            if (!ns || !doc.body)
+                continue;
+            const nsEntities = [];
+            for (const [entityName, entityDef] of Object.entries(doc.body)) {
+                if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                    const mockEntity = this.createMockSubjectCanon(entityName, entityDef, ns);
+                    const key = `canon://${ns}/${entityName}`;
+                    if (!entityLookup.has(key)) {
+                        entityLookup.set(key, { entity: mockEntity, namespace: ns });
+                    }
+                    nsEntities.push(mockEntity);
+                }
+            }
+            entitiesByNamespace.set(ns, nsEntities);
+        }
+        let maxDepthReached = 0;
+        let wasTruncated = false;
+        for (const reference of document.references) {
+            if (!reference.parsedUri) {
+                unresolved.push({
+                    reference: reference.rawUri,
+                    reason: reference.error ?? 'Failed to parse URI'
+                });
+                continue;
+            }
+            const canonUri = reference.parsedUri.toString();
+            if (visited.has(canonUri))
+                continue;
+            const depthReached = await this.resolveEntityRecursive(canonUri, null, null, 0, maxDepth, visited, directRefUris, directRefs, inheritedRefs, foundationRefs, unresolved, entityLookup, entitiesByNamespace);
+            maxDepthReached = Math.max(maxDepthReached, depthReached);
+            if (depthReached >= maxDepth)
+                wasTruncated = true;
+        }
+        const title = extractTitle(document.rawMarkdown);
+        return {
+            sourceFile: document.filePath ?? null,
+            originalContent: document.rawMarkdown,
+            title,
+            directReferences: directRefs,
+            inheritedReferences: inheritedRefs,
+            foundationTypes: foundationRefs,
+            get totalResourceCount() {
+                return directRefs.length + inheritedRefs.length + foundationRefs.length;
+            },
+            get allResources() {
+                return [...directRefs, ...inheritedRefs, ...foundationRefs];
+            },
+            maxDepthReached,
+            wasTruncated,
+            unresolvedResources: unresolved
+        };
+    }
+    async resolveEntityRecursive(canonUri, entity, sourceDocument, depth, maxDepth, visited, directRefUris, directRefs, inheritedRefs, foundationRefs, unresolved, entityLookup, entitiesByNamespace) {
+        if (visited.has(canonUri))
+            return depth;
+        visited.add(canonUri);
+        if (depth >= maxDepth)
+            return depth;
+        if (!entity) {
+            const lookup = entityLookup.get(canonUri);
+            if (!lookup) {
+                unresolved.push({
+                    reference: canonUri,
+                    reason: 'Resource not found in workspace'
+                });
+                return depth;
+            }
+            entity = lookup.entity;
+        }
+        const entityAny = entity;
+        const entityNamespace = entityAny.namespace ?? entityAny.namespace_ ?? '';
+        if (!sourceDocument && entityNamespace) {
+            sourceDocument = await this.repository.getDocumentAsync(entityNamespace);
+        }
+        const resolved = this.createResolvedResource(entity, canonUri, depth, entitiesByNamespace);
+        const tier = this.classifyTier(canonUri, entityNamespace, directRefUris);
+        switch (tier) {
+            case EntityTier.Direct:
+                directRefs.push(resolved);
+                break;
+            case EntityTier.Foundation:
+                foundationRefs.push(resolved);
+                break;
+            default:
+                inheritedRefs.push(resolved);
+                break;
+        }
+        let maxDepthReached = depth;
+        for (const parentClass of resolved.parentClasses) {
+            const parentUri = this.resolveReferenceToUri(parentClass, entityNamespace, sourceDocument);
+            if (parentUri && !visited.has(parentUri)) {
+                const lookup = entityLookup.get(parentUri);
+                const depthReached = await this.resolveEntityRecursive(parentUri, lookup?.entity ?? null, null, // Let it fetch its own source document
+                depth + 1, maxDepth, visited, directRefUris, directRefs, inheritedRefs, foundationRefs, unresolved, entityLookup, entitiesByNamespace);
+                maxDepthReached = Math.max(maxDepthReached, depthReached);
+            }
+        }
+        for (const property of resolved.properties.filter((p) => p.isObjectProperty)) {
+            const rangeUri = this.resolveReferenceToUri(property.rangeType, entityNamespace, sourceDocument);
+            if (rangeUri && !visited.has(rangeUri)) {
+                const lookup = entityLookup.get(rangeUri);
+                const depthReached = await this.resolveEntityRecursive(rangeUri, lookup?.entity ?? null, null, depth + 1, maxDepth, visited, directRefUris, directRefs, inheritedRefs, foundationRefs, unresolved, entityLookup, entitiesByNamespace);
+                maxDepthReached = Math.max(maxDepthReached, depthReached);
+            }
+        }
+        if (resolved.instanceOf_) {
+            const typeUri = this.resolveReferenceToUri(resolved.instanceOf_, entityNamespace, sourceDocument);
+            if (typeUri && !visited.has(typeUri)) {
+                const lookup = entityLookup.get(typeUri);
+                const depthReached = await this.resolveEntityRecursive(typeUri, lookup?.entity ?? null, null, depth + 1, maxDepth, visited, directRefUris, directRefs, inheritedRefs, foundationRefs, unresolved, entityLookup, entitiesByNamespace);
+                maxDepthReached = Math.max(maxDepthReached, depthReached);
+            }
+        }
+        return maxDepthReached;
+    }
+    createResolvedResource(entity, canonUri, depth, entitiesByNamespace) {
+        const entityAny = entity;
+        const entityName = entityAny.name ?? '';
+        const entityNamespace = entityAny.namespace ?? entityAny.namespace_ ?? '';
+        const resourceType = this.classifyEntityType(entity);
+        const comment = getComment(entity);
+        const parentClasses = getParentClasses(entity);
+        const instanceOf = getInstanceOf(entity);
+        let properties = [];
+        if (resourceType === ResolvedResourceType.Class) {
+            const nsEntities = entitiesByNamespace.get(entityNamespace);
+            if (nsEntities) {
+                properties = extractPropertiesForClass(entityName, nsEntities);
+            }
+        }
+        return {
+            name: entityName,
+            canonUri,
+            resource: entity,
+            resourceType,
+            parentClass: parentClasses.length > 0 ? parentClasses[0] : null,
+            parentClasses,
+            comment,
+            properties,
+            namespace_: entityNamespace,
+            resolutionDepth: depth,
+            instanceOf_: instanceOf
+        };
+    }
+    classifyEntityType(entity) {
+        if (ResourceTypeClassifier.isClassType(entity))
+            return ResolvedResourceType.Class;
+        if (ResourceTypeClassifier.isAnnotationPropertyType(entity))
+            return ResolvedResourceType.AnnotationProperty;
+        if (ResourceTypeClassifier.isDatatypePropertyType(entity))
+            return ResolvedResourceType.DatatypeProperty;
+        if (ResourceTypeClassifier.isObjectPropertyType(entity))
+            return ResolvedResourceType.ObjectProperty;
+        const typeUri = ResourceTypeClassifier.getTypeUri(entity);
+        if (typeUri && !ResourceTypeClassifier.isCoreOntologyType(typeUri)) {
+            return ResolvedResourceType.Instance;
+        }
+        return ResolvedResourceType.Other;
+    }
+    classifyTier(canonUri, entityNamespace, directRefUris) {
+        if (directRefUris.has(canonUri))
+            return EntityTier.Direct;
+        if (isCoreOntologyEntity(entityNamespace))
+            return EntityTier.Foundation;
+        return EntityTier.Inherited;
+    }
+    resolveReferenceToUri(reference, currentNamespace, sourceDocument) {
+        if (reference.toLowerCase().startsWith('canon://'))
+            return reference;
+        if (reference.includes('.') && sourceDocument?.metadata) {
+            const dotIndex = reference.indexOf('.');
+            const alias = reference.substring(0, dotIndex);
+            const name = reference.substring(dotIndex + 1);
+            if (name) {
+                const allImports = sourceDocument.metadata.allImports;
+                if (allImports) {
+                    for (const imp of allImports) {
+                        const importAlias = imp.alias ?? imp.packageName;
+                        if (importAlias.toLowerCase() === alias.toLowerCase()) {
+                            const ns = imp.version
+                                ? `${imp.publisher}/${imp.packageName}@${imp.version}`
+                                : `${imp.publisher}/${imp.packageName}`;
+                            return `canon://${ns}/${name}`;
+                        }
+                    }
+                }
+            }
+        }
+        if (!reference.includes('.') && currentNamespace) {
+            return `canon://${currentNamespace}/${reference}`;
+        }
+        return null;
+    }
+    createMockSubjectCanon(name, entityDef, namespace) {
+        const statements = [];
+        for (const [key, value] of Object.entries(entityDef)) {
+            if (typeof value === 'string') {
+                if (key === 'type' || key === 'subClassOf' || key === 'domain' || key === 'range' || key === 'subPropertyOf') {
+                    statements.push({
+                        predicate: { subject: { name: key, publisher: '', package_: '' } },
+                        object: { subject: { name: value, publisher: '', package_: '' } }
+                    });
+                }
+                else {
+                    statements.push({
+                        predicate: { subject: { name: key, publisher: '', package_: '' } },
+                        object: value
+                    });
+                }
+            }
+            else if (Array.isArray(value)) {
+                statements.push({
+                    predicate: { subject: { name: key, publisher: '', package_: '' } },
+                    object: value.map((item) => {
+                        if (typeof item === 'string') {
+                            return { subject: { name: item, publisher: '', package_: '' } };
+                        }
+                        return item;
+                    })
+                });
+            }
+        }
+        return {
+            name,
+            namespace_: namespace,
+            statement: statements,
+            entity: entityDef
+        };
+    }
+}
+function isCoreOntologyEntity(namespaceStr) {
+    if (!namespaceStr)
+        return false;
+    const parts = namespaceStr.split('/');
+    if (parts.length < 2)
+        return false;
+    const publisher = parts[0];
+    const packageWithVersion = parts[1];
+    const package_ = packageWithVersion.includes('@')
+        ? packageWithVersion.split('@')[0]
+        : packageWithVersion;
+    return CORE_PACKAGES.has(`${publisher}/${package_}`);
+}
+function getComment(entity) {
+    const entityAny = entity;
+    if (entityAny.entity && typeof entityAny.entity === 'object') {
+        return entityAny.entity['comment'] ?? null;
+    }
+    if (entityAny.statement && Array.isArray(entityAny.statement)) {
+        for (const stmt of entityAny.statement) {
+            if (stmt.predicate?.subject?.name === 'comment' && typeof stmt.object === 'string') {
+                return stmt.object;
+            }
+        }
+    }
+    return null;
+}
+function getParentClasses(entity) {
+    const parents = [];
+    const entityAny = entity;
+    const entityName = entityAny.name ?? '';
+    if (entityAny.entity && typeof entityAny.entity === 'object') {
+        const subClassOf = entityAny.entity['subClassOf'];
+        if (typeof subClassOf === 'string') {
+            if (subClassOf.toLowerCase() !== entityName.toLowerCase()) {
+                parents.push(subClassOf);
+            }
+        }
+        else if (Array.isArray(subClassOf)) {
+            for (const item of subClassOf) {
+                const name = typeof item === 'string' ? item : item?.subject?.name ?? item?.name;
+                if (name && name.toLowerCase() !== entityName.toLowerCase()) {
+                    parents.push(name);
+                }
+            }
+        }
+        return parents;
+    }
+    if (entityAny.statement && Array.isArray(entityAny.statement)) {
+        for (const stmt of entityAny.statement) {
+            if (stmt.predicate?.subject?.name === 'subClassOf') {
+                if (stmt.object?.subject?.name) {
+                    const name = stmt.object.subject.name;
+                    if (name.toLowerCase() !== entityName.toLowerCase()) {
+                        parents.push(name);
+                    }
+                }
+                else if (Array.isArray(stmt.object)) {
+                    for (const item of stmt.object) {
+                        const name = item?.subject?.name ?? item?.name;
+                        if (name && name.toLowerCase() !== entityName.toLowerCase()) {
+                            parents.push(name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return parents;
+}
+function getInstanceOf(entity) {
+    const typeUri = ResourceTypeClassifier.getTypeUri(entity);
+    if (!typeUri)
+        return null;
+    if (!ResourceTypeClassifier.isCoreOntologyType(typeUri)) {
+        return typeUri.name;
+    }
+    return null;
+}
+function extractPropertiesForClass(className, nsEntities) {
+    const properties = [];
+    for (const entity of nsEntities) {
+        if (!ResourceTypeClassifier.isAnyPropertyType(entity))
+            continue;
+        const entityAny = entity;
+        const domains = [];
+        const rangeTypes = [];
+        if (entityAny.entity && typeof entityAny.entity === 'object') {
+            const domainVal = entityAny.entity['domain'];
+            if (typeof domainVal === 'string') {
+                domains.push(domainVal);
+            }
+            else if (Array.isArray(domainVal)) {
+                for (const d of domainVal) {
+                    domains.push(typeof d === 'string' ? d : d?.name ?? String(d));
+                }
+            }
+            const rangeVal = entityAny.entity['range'];
+            if (typeof rangeVal === 'string') {
+                rangeTypes.push(rangeVal);
+            }
+            else if (Array.isArray(rangeVal)) {
+                for (const r of rangeVal) {
+                    rangeTypes.push(typeof r === 'string' ? r : r?.name ?? String(r));
+                }
+            }
+        }
+        if (!domains.some((d) => d.toLowerCase() === className.toLowerCase()))
+            continue;
+        if (rangeTypes.length === 0)
+            rangeTypes.push('unknown');
+        const isObjectProperty = ResourceTypeClassifier.isObjectPropertyType(entity);
+        const isCollection = entityAny.entity?.['collection'] != null;
+        const comment = getComment(entity);
+        properties.push({
+            name: entityAny.name ?? '',
+            rangeTypes,
+            domains,
+            get rangeType() {
+                return rangeTypes.length > 0 ? rangeTypes.join(', ') : 'unknown';
+            },
+            isObjectProperty,
+            isCollection,
+            comment
+        });
+    }
+    return properties;
+}
+function extractTitle(markdown) {
+    const lines = markdown.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('# ') && !trimmed.startsWith('## ')) {
+            return trimmed.substring(2).trim();
+        }
+    }
+    return null;
+}

package/dist/ctl/CtlMarkdownRenderer.d.ts

@@ -0,0 +1,17 @@
+import type { ResolvedResourceGraph } from '@canon-protocol/types/ctl/resolution/types';
+import type { CtlMarkdownRenderer as ICtlMarkdownRenderer } from '@canon-protocol/types/exporters/ctl/markdown/types';
+export declare class CtlMarkdownRenderer implements ICtlMarkdownRenderer {
+    private resolvedResourceNames;
+    render(graph: ResolvedResourceGraph): string;
+    private generateAnchor;
+    private renderInternalLink;
+    private renderInternalLinks;
+    private transformTemplateLinks;
+    private renderSummary;
+    private renderQuickReference;
+    private renderHierarchyDiagram;
+    private renderTier;
+    private renderEntity;
+    private renderPropertiesTable;
+    private renderUnresolved;
+}

package/dist/ctl/CtlMarkdownRenderer.js

@@ -0,0 +1,262 @@
+import { ResolvedResourceType } from '@canon-protocol/types/ctl/resolution/enums';
+export class CtlMarkdownRenderer {
+    resolvedResourceNames = new Set();
+    render(graph) {
+        if (!graph) {
+            throw new Error('Graph cannot be null');
+        }
+        this.resolvedResourceNames = new Set(graph.allResources.map((e) => e.name.toLowerCase()));
+        const lines = [];
+        lines.push(this.transformTemplateLinks(graph.originalContent));
+        lines.push('');
+        lines.push('---');
+        lines.push('');
+        lines.push('# Canon Resource Reference');
+        lines.push('');
+        this.renderSummary(lines, graph);
+        this.renderHierarchyDiagram(lines, graph);
+        this.renderQuickReference(lines, graph);
+        this.renderTier(lines, 'Direct References', graph.directReferences, 'Resources explicitly referenced in this template.');
+        this.renderTier(lines, 'Inherited References', graph.inheritedReferences, 'Parent classes, property types, and other dependencies of directly referenced entities.');
+        this.renderTier(lines, 'Foundation Types', graph.foundationTypes, 'Core ontology types that form the base of the type hierarchy.');
+        if (graph.unresolvedResources.length > 0) {
+            this.renderUnresolved(lines, graph.unresolvedResources);
+        }
+        return lines.join('\n');
+    }
+    generateAnchor(entityName) {
+        return entityName.toLowerCase();
+    }
+    renderInternalLink(entityName) {
+        if (this.resolvedResourceNames.has(entityName.toLowerCase())) {
+            return `[${entityName}](#${this.generateAnchor(entityName)})`;
+        }
+        return entityName;
+    }
+    renderInternalLinks(entityNames) {
+        return entityNames.map((n) => this.renderInternalLink(n)).join(', ');
+    }
+    transformTemplateLinks(content) {
+        const pattern = /\[([^\]]+)\]\(can:\/\/([^)]+)\)/g;
+        return content.replace(pattern, (_match, linkText, canUri) => {
+            let entityName;
+            if (canUri.includes('#')) {
+                entityName = canUri.substring(canUri.indexOf('#') + 1);
+            }
+            else {
+                const lastDot = canUri.lastIndexOf('.');
+                entityName = lastDot >= 0 ? canUri.substring(lastDot + 1) : canUri;
+            }
+            if (this.resolvedResourceNames.has(entityName.toLowerCase())) {
+                return `[${linkText}](#${this.generateAnchor(entityName)})`;
+            }
+            return _match;
+        });
+    }
+    renderSummary(lines, graph) {
+        lines.push(`**Total Resources**: ${graph.totalResourceCount}`);
+        lines.push(`- Direct: ${graph.directReferences.length}`);
+        lines.push(`- Inherited: ${graph.inheritedReferences.length}`);
+        lines.push(`- Foundation: ${graph.foundationTypes.length}`);
+        if (graph.wasTruncated) {
+            lines.push('');
+            lines.push(`**Resolution was truncated at depth ${graph.maxDepthReached}** - some resources may be missing.`);
+            lines.push('To include more resources, re-run with a higher depth limit: `canon ctl resolve <file> --depth 2000`');
+        }
+        lines.push('');
+    }
+    renderQuickReference(lines, graph) {
+        const allEntities = graph.allResources;
+        if (allEntities.length === 0)
+            return;
+        lines.push('## Quick Reference');
+        lines.push('');
+        const classes = allEntities.filter((e) => e.resourceType === ResolvedResourceType.Class);
+        const annotationProps = allEntities.filter((e) => e.resourceType === ResolvedResourceType.AnnotationProperty);
+        const datatypeProps = allEntities.filter((e) => e.resourceType === ResolvedResourceType.DatatypeProperty);
+        const objectProps = allEntities.filter((e) => e.resourceType === ResolvedResourceType.ObjectProperty);
+        const instances = allEntities.filter((e) => e.resourceType === ResolvedResourceType.Instance);
+        if (classes.length > 0) {
+            lines.push(`### Classes (${classes.length})`);
+            lines.push('');
+            lines.push('| Class | Extends | Properties |');
+            lines.push('|-------|---------|------------|');
+            for (const cls of [...classes].sort((a, b) => a.name.localeCompare(b.name))) {
+                const link = this.renderInternalLink(cls.name);
+                const extends_ = cls.parentClasses.length > 0
+                    ? this.renderInternalLinks(cls.parentClasses)
+                    : '-';
+                lines.push(`| ${link} | ${extends_} | ${cls.properties.length} |`);
+            }
+            lines.push('');
+        }
+        const allProps = [...annotationProps, ...datatypeProps, ...objectProps];
+        if (allProps.length > 0) {
+            lines.push(`### Properties (${allProps.length})`);
+            lines.push('');
+            lines.push('| Property | Type | Description |');
+            lines.push('|----------|------|-------------|');
+            for (const prop of [...allProps].sort((a, b) => a.name.localeCompare(b.name))) {
+                const link = this.renderInternalLink(prop.name);
+                const propType = formatEntityType(prop.resourceType);
+                const desc = truncateForTable(prop.comment ?? '');
+                lines.push(`| ${link} | ${propType} | ${desc} |`);
+            }
+            lines.push('');
+        }
+        if (instances.length > 0) {
+            const instancesByType = new Map();
+            for (const inst of instances) {
+                const key = inst.instanceOf_ ?? 'Unknown';
+                if (!instancesByType.has(key))
+                    instancesByType.set(key, []);
+                instancesByType.get(key).push(inst);
+            }
+            lines.push('### Resources by Type');
+            lines.push('');
+            lines.push('| Type | Resources |');
+            lines.push('|------|-----------|');
+            for (const [typeName, insts] of [...instancesByType.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+                const typeLink = this.renderInternalLink(typeName);
+                const instanceLinks = this.renderInternalLinks(insts.map((i) => i.name));
+                lines.push(`| ${typeLink} | ${instanceLinks} |`);
+            }
+            lines.push('');
+        }
+    }
+    renderHierarchyDiagram(lines, graph) {
+        const classes = graph.allResources.filter((e) => e.resourceType === ResolvedResourceType.Class);
+        if (classes.length === 0)
+            return;
+        const classesWithRelations = classes.filter((c) => c.parentClasses.length > 0);
+        if (classesWithRelations.length === 0)
+            return;
+        const allParentNames = new Set();
+        for (const c of classesWithRelations) {
+            for (const p of c.parentClasses)
+                allParentNames.add(p.toLowerCase());
+        }
+        const classNames = new Set(classes.map((c) => c.name.toLowerCase()));
+        lines.push('## Type Hierarchy');
+        lines.push('');
+        lines.push('```mermaid');
+        lines.push('flowchart TB');
+        for (const cls of [...classes].sort((a, b) => a.name.localeCompare(b.name))) {
+            const safeId = makeMermaidSafeId(cls.name);
+            lines.push(`    ${safeId}["${cls.name}"]`);
+        }
+        for (const parentName of [...allParentNames]) {
+            if (!classNames.has(parentName)) {
+                let originalName = parentName;
+                for (const c of classesWithRelations) {
+                    for (const p of c.parentClasses) {
+                        if (p.toLowerCase() === parentName)
+                            originalName = p;
+                    }
+                }
+                const safeId = makeMermaidSafeId(originalName);
+                lines.push(`    ${safeId}["${originalName}"]:::external`);
+            }
+        }
+        lines.push('');
+        for (const cls of classesWithRelations) {
+            const childId = makeMermaidSafeId(cls.name);
+            for (const parent of cls.parentClasses) {
+                const parentId = makeMermaidSafeId(parent);
+                lines.push(`    ${parentId} --> ${childId}`);
+            }
+        }
+        lines.push('');
+        lines.push('    classDef external fill:#f9f9f9,stroke:#999,stroke-dasharray: 5 5');
+        lines.push('```');
+        lines.push('');
+    }
+    renderTier(lines, title, entities, description) {
+        if (entities.length === 0)
+            return;
+        lines.push(`## ${title} (${entities.length})`);
+        lines.push('');
+        lines.push(`*${description}*`);
+        lines.push('');
+        for (const entity of [...entities].sort((a, b) => a.name.localeCompare(b.name))) {
+            this.renderEntity(lines, entity);
+        }
+    }
+    renderEntity(lines, entity) {
+        const anchor = this.generateAnchor(entity.name);
+        lines.push(`### ${entity.name}`);
+        lines.push(`<a id="${anchor}"></a>`);
+        lines.push('');
+        lines.push('| Attribute | Value |');
+        lines.push('|-----------|-------|');
+        lines.push(`| **URI** | \`${entity.canonUri}\` |`);
+        lines.push(`| **Type** | ${formatEntityType(entity.resourceType)} |`);
+        if (entity.parentClasses.length > 0) {
+            const parentLinks = this.renderInternalLinks(entity.parentClasses);
+            lines.push(`| **Extends** | ${parentLinks} |`);
+        }
+        if (entity.instanceOf_) {
+            const instanceLink = this.renderInternalLink(entity.instanceOf_);
+            lines.push(`| **Instance of** | ${instanceLink} |`);
+        }
+        lines.push('');
+        if (entity.comment) {
+            lines.push(entity.comment);
+            lines.push('');
+        }
+        if (entity.resourceType === ResolvedResourceType.Class && entity.properties.length > 0) {
+            this.renderPropertiesTable(lines, entity.properties);
+        }
+        lines.push('---');
+        lines.push('');
+    }
+    renderPropertiesTable(lines, properties) {
+        lines.push('| Property | Type | Description |');
+        lines.push('|----------|------|-------------|');
+        for (const prop of [...properties].sort((a, b) => a.name.localeCompare(b.name))) {
+            const rangeLinks = prop.rangeTypes.map((r) => {
+                const link = this.renderInternalLink(r);
+                return prop.isObjectProperty ? `-> ${link}` : link;
+            });
+            let typeStr = rangeLinks.join(', ');
+            if (prop.isCollection) {
+                typeStr = `${typeStr}[]`;
+            }
+            const desc = (prop.comment ?? '')
+                .replace(/\|/g, '\\|')
+                .replace(/\n/g, ' ')
+                .replace(/\r/g, '');
+            lines.push(`| ${prop.name} | ${typeStr} | ${desc} |`);
+        }
+        lines.push('');
+    }
+    renderUnresolved(lines, unresolved) {
+        lines.push(`## Unresolved References (${unresolved.length})`);
+        lines.push('');
+        lines.push('*The following references could not be resolved:*');
+        lines.push('');
+        for (const entity of unresolved) {
+            lines.push(`- \`${entity.reference}\`: ${entity.reason}`);
+        }
+        lines.push('');
+    }
+}
+function formatEntityType(type) {
+    switch (type) {
+        case ResolvedResourceType.Class: return 'Class';
+        case ResolvedResourceType.AnnotationProperty: return 'Annotation Property';
+        case ResolvedResourceType.DatatypeProperty: return 'Datatype Property';
+        case ResolvedResourceType.ObjectProperty: return 'Object Property';
+        case ResolvedResourceType.Instance: return 'Instance';
+        default: return 'Other';
+    }
+}
+function truncateForTable(text) {
+    if (!text)
+        return '';
+    text = text.replace(/\|/g, '\\|').replace(/\n/g, ' ').replace(/\r/g, '');
+    return text.length <= 50 ? text : text.substring(0, 47) + '...';
+}
+function makeMermaidSafeId(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, '_');
+}