@oml/language 0.7.0

package/src/oml/oml-serializer.ts

@@ -0,0 +1,1080 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type {
+    Annotation,
+    AnnotationProperty,
+    AnonymousInstance,
+    Argument,
+    Aspect,
+    BuiltIn,
+    BuiltInPredicate,
+    Concept,
+    Description,
+    DescriptionBundle,
+    DescriptionStatement,
+    DifferentFromPredicate,
+    EntityEquivalenceAxiom,
+    ForwardRelation,
+    Import,
+    InstanceEnumerationAxiom,
+    KeyAxiom,
+    Literal,
+    LiteralEnumerationAxiom,
+    NamedInstance,
+    Ontology,
+    Predicate,
+    PropertyCardinalityRestrictionAxiom,
+    PropertyEquivalenceAxiom,
+    PropertyPredicate,
+    PropertyRangeRestrictionAxiom,
+    PropertyRestrictionAxiom,
+    PropertySelfRestrictionAxiom,
+    PropertyValueAssertion,
+    PropertyValueRestrictionAxiom,
+    QuotedLiteral,
+    RelationEntity,
+    RelationEntityPredicate,
+    ReverseRelation,
+    Rule,
+    SameAsPredicate,
+    Scalar,
+    ScalarEquivalenceAxiom,
+    ScalarProperty,
+    SpecializableTerm,
+    SpecializationAxiom,
+    TypeAssertion,
+    TypePredicate,
+    UnreifiedRelation,
+    Vocabulary,
+    VocabularyBundle,
+    VocabularyStatement,
+} from './generated/ast.js';
+import {
+    isAnnotationProperty,
+    isAnonymousConceptInstance,
+    isAnonymousRelationInstance,
+    isAspect,
+    isBooleanLiteral,
+    isBuiltIn,
+    isBuiltInPredicate,
+    isConcept,
+    isConceptInstance,
+    isDecimalLiteral,
+    isDescription,
+    isDescriptionBundle,
+    isDifferentFromPredicate,
+    isDoubleLiteral,
+    isForwardRelation,
+    isIntegerLiteral,
+    isPropertyCardinalityRestrictionAxiom,
+    isPropertyPredicate,
+    isPropertyRangeRestrictionAxiom,
+    isPropertySelfRestrictionAxiom,
+    isPropertyValueRestrictionAxiom,
+    isQuotedLiteral,
+    isRelationEntity,
+    isRelationEntityPredicate,
+    isRelationInstance,
+    isReverseRelation,
+    isRule,
+    isSameAsPredicate,
+    isScalar,
+    isScalarProperty,
+    isSpecializableTerm,
+    isTypePredicate,
+    isUnreifiedRelation,
+    isVocabulary,
+    isVocabularyBundle,
+} from './generated/ast.js';
+import {
+    findOwningOntologyNode,
+    normalizeNamespace,
+    resolveImportNamespace,
+    splitIri
+} from './oml-utils.js';
+
+const INDENT = '    ';
+type SerializeContext = {
+    namespace: string;
+    prefix?: string;
+    prefixByNamespace: Map<string, string>;
+};
+let activeContext: SerializeContext | null = null;
+
+export const serializeOntology = (ontology: Ontology): string => {
+    const prev = activeContext;
+    activeContext = createSerializeContext(ontology);
+    try {
+        if (isDescription(ontology)) {
+            return serializeDescription(ontology);
+        }
+        if (isDescriptionBundle(ontology)) {
+            return serializeDescriptionBundle(ontology);
+        }
+        if (isVocabulary(ontology)) {
+            return serializeVocabulary(ontology);
+        }
+        if (isVocabularyBundle(ontology)) {
+            return serializeVocabularyBundle(ontology);
+        }
+        throw new Error('Serializer only supports OML ontologies for now.');
+    } finally {
+        activeContext = prev;
+    }
+};
+
+const serializeVocabulary = (vocabulary: Vocabulary): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, '', vocabulary.ownedAnnotations);
+
+    const namespace = wrapNamespace(vocabulary.namespace);
+    lines.push(`vocabulary ${namespace} as ${serializeName(vocabulary.prefix)} {`);
+
+    if (vocabulary.ownedImports?.length) {
+        for (const imp of vocabulary.ownedImports) {
+            lines.push(`${INDENT}${serializeImport(imp)}`);
+        }
+    }
+
+    if (vocabulary.ownedStatements?.length) {
+        if (vocabulary.ownedImports?.length) {
+            lines.push('');
+        }
+        for (const [index, statement] of vocabulary.ownedStatements.entries()) {
+            if (index > 0) {
+                lines.push('');
+            }
+            lines.push(serializeVocabularyStatement(statement, INDENT));
+        }
+    }
+
+    lines.push('}');
+    return `${lines.join('\n')}\n`;
+};
+
+const serializeVocabularyBundle = (vocabulary: VocabularyBundle): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, '', vocabulary.ownedAnnotations);
+
+    const namespace = wrapNamespace(vocabulary.namespace);
+    lines.push(`vocabulary bundle ${namespace} as ${serializeName(vocabulary.prefix)} {`);
+
+    if (vocabulary.ownedImports?.length) {
+        for (const imp of vocabulary.ownedImports) {
+            lines.push(`${INDENT}${serializeImport(imp)}`);
+        }
+    }
+
+    lines.push('}');
+    return `${lines.join('\n')}\n`;
+};
+
+const serializeDescription = (description: Description): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, '', description.ownedAnnotations);
+
+    const namespace = wrapNamespace(description.namespace);
+    lines.push(`description ${namespace} as ${serializeName(description.prefix)} {`);
+
+    if (description.ownedImports?.length) {
+        for (const imp of description.ownedImports) {
+            lines.push(`${INDENT}${serializeImport(imp)}`);
+        }
+    }
+
+    if (description.ownedStatements?.length) {
+        if (description.ownedImports?.length) {
+            lines.push('');
+        }
+        for (const [index, statement] of description.ownedStatements.entries()) {
+            if (index > 0) {
+                lines.push('');
+            }
+            lines.push(serializeDescriptionStatement(statement, INDENT));
+        }
+    }
+
+    lines.push('}');
+    return `${lines.join('\n')}\n`;
+};
+
+const serializeDescriptionBundle = (description: DescriptionBundle): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, '', description.ownedAnnotations);
+
+    const namespace = wrapNamespace(description.namespace);
+    lines.push(`description bundle ${namespace} as ${serializeName(description.prefix)} {`);
+
+    if (description.ownedImports?.length) {
+        for (const imp of description.ownedImports) {
+            lines.push(`${INDENT}${serializeImport(imp)}`);
+        }
+    }
+
+    lines.push('}');
+    return `${lines.join('\n')}\n`;
+};
+
+const serializeVocabularyStatement = (statement: VocabularyStatement, indent: string): string => {
+    if (isRule(statement)) {
+        return serializeRule(statement, indent);
+    }
+    if (isBuiltIn(statement)) {
+        return serializeBuiltIn(statement, indent);
+    }
+    if (isSpecializableTerm(statement)) {
+        return serializeSpecializableTerm(statement, indent);
+    }
+    return '';
+};
+
+const serializeDescriptionStatement = (statement: DescriptionStatement, indent: string): string => {
+    return serializeNamedInstance(statement, indent);
+};
+
+const serializeImport = (imp: Import): string => {
+    const namespace = resolveImportNamespace(imp);
+    const prefix = imp.prefix ? ` as ${serializeName(imp.prefix)}` : '';
+    return `${imp.kind} ${wrapNamespace(namespace)}${prefix}`;
+};
+
+const serializeRule = (rule: Rule, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, rule.ownedAnnotations);
+
+    const header = rule.ref?.$refText
+        ? `ref rule ${rule.ref.$refText}`
+        : `rule ${serializeName(rule.name)}`.trim();
+    const predicates = serializeRulePredicates(rule);
+    const body = predicates ? `${header} [${predicates}]` : header;
+    lines.push(`${indent}${body}`);
+    return lines.join('\n');
+};
+
+const serializeRulePredicates = (rule: Rule): string => {
+    const antecedent = (rule.antecedent ?? []).map(serializePredicate).filter(Boolean);
+    const consequent = (rule.consequent ?? []).map(serializePredicate).filter(Boolean);
+    if (!antecedent.length && !consequent.length) {
+        return '';
+    }
+    const antText = antecedent.join(' & ');
+    const conText = consequent.join(' & ');
+    if (antText && conText) {
+        return `${antText} -> ${conText}`;
+    }
+    if (antText) {
+        return `${antText} ->`;
+    }
+    return `-> ${conText}`;
+};
+
+const serializeBuiltIn = (builtIn: BuiltIn, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, builtIn.ownedAnnotations);
+    const header = builtIn.ref?.$refText
+        ? `ref builtin ${builtIn.ref.$refText}`
+        : `builtin ${serializeName(builtIn.name)}`.trim();
+    lines.push(`${indent}${header}`);
+    return lines.join('\n');
+};
+
+const serializePredicate = (predicate: Predicate): string => {
+    if (isTypePredicate(predicate)) {
+        return serializeTypePredicate(predicate);
+    }
+    if (isRelationEntityPredicate(predicate)) {
+        return serializeRelationEntityPredicate(predicate);
+    }
+    if (isPropertyPredicate(predicate)) {
+        return serializePropertyPredicate(predicate);
+    }
+    if (isSameAsPredicate(predicate)) {
+        return serializeSameAsPredicate(predicate);
+    }
+    if (isDifferentFromPredicate(predicate)) {
+        return serializeDifferentFromPredicate(predicate);
+    }
+    if (isBuiltInPredicate(predicate)) {
+        return serializeBuiltInPredicate(predicate);
+    }
+    return '';
+};
+
+const serializeArgument = (argument: Argument): string => {
+    if (argument.variable) {
+        return argument.variable;
+    }
+    if (argument.literal) {
+        return serializeLiteral(argument.literal);
+    }
+    if (argument.instance) {
+        return resolveRefText(argument.instance);
+    }
+    return '';
+};
+
+const serializeTypePredicate = (predicate: TypePredicate): string => {
+    const typeRef = resolveRefText(predicate.type);
+    return `${typeRef}(${serializeArgument(predicate.argument)})`;
+};
+
+const serializeRelationEntityPredicate = (predicate: RelationEntityPredicate): string => {
+    const typeRef = resolveRefText(predicate.type);
+    const arg1 = serializeArgument(predicate.argument1);
+    const arg = serializeArgument(predicate.argument);
+    const arg2 = serializeArgument(predicate.argument2);
+    return `${typeRef}(${arg1}, ${arg}, ${arg2})`;
+};
+
+const serializePropertyPredicate = (predicate: PropertyPredicate): string => {
+    const property = resolveRefText(predicate.property);
+    const arg1 = serializeArgument(predicate.argument1);
+    const arg2 = serializeArgument(predicate.argument2);
+    return `${property}(${arg1}, ${arg2})`;
+};
+
+const serializeSameAsPredicate = (predicate: SameAsPredicate): string => {
+    const arg1 = serializeArgument(predicate.argument1);
+    const arg2 = serializeArgument(predicate.argument2);
+    return `sameAs(${arg1}, ${arg2})`;
+};
+
+const serializeDifferentFromPredicate = (predicate: DifferentFromPredicate): string => {
+    const arg1 = serializeArgument(predicate.argument1);
+    const arg2 = serializeArgument(predicate.argument2);
+    return `differentFrom(${arg1}, ${arg2})`;
+};
+
+const serializeBuiltInPredicate = (predicate: BuiltInPredicate): string => {
+    const builtIn = resolveRefText(predicate.builtIn);
+    const args = (predicate.arguments ?? []).map(serializeArgument).filter(Boolean).join(', ');
+    return args ? `builtIn(${builtIn}, ${args})` : `builtIn(${builtIn})`;
+};
+
+const serializeSpecializableTerm = (term: SpecializableTerm, indent: string): string => {
+    if (isScalar(term)) {
+        return serializeScalar(term, indent);
+    }
+    if (isAspect(term)) {
+        return serializeAspect(term, indent);
+    }
+    if (isConcept(term)) {
+        return serializeConcept(term, indent);
+    }
+    if (isRelationEntity(term)) {
+        return serializeRelationEntity(term, indent);
+    }
+    if (isAnnotationProperty(term)) {
+        return serializeAnnotationProperty(term, indent);
+    }
+    if (isScalarProperty(term)) {
+        return serializeScalarProperty(term, indent);
+    }
+    if (isUnreifiedRelation(term)) {
+        return serializeUnreifiedRelation(term, indent);
+    }
+    return '';
+};
+
+const serializeAnnotationProperty = (property: AnnotationProperty, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, property.ownedAnnotations);
+    const header = property.ref?.$refText
+        ? `ref annotation property ${property.ref.$refText}`
+        : `annotation property ${serializeName(property.name)}`.trim();
+    const suffix = `${serializePropertySpecialization(property.ownedSpecializations)}${serializePropertyEquivalences(
+        property.ownedEquivalences
+    )}`;
+    lines.push(`${indent}${header}${suffix}`);
+    return lines.join('\n');
+};
+
+const serializeScalar = (scalar: Scalar, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, scalar.ownedAnnotations);
+    const header = scalar.ref?.$refText ? `ref scalar ${scalar.ref.$refText}` : `scalar ${serializeName(scalar.name)}`.trim();
+    const blockLines: string[] = [];
+    if (scalar.ownedEnumeration) {
+        blockLines.push(serializeLiteralEnumerationAxiom(scalar.ownedEnumeration));
+    }
+    const suffix = `${serializeScalarSpecialization(scalar)}${serializeScalarEquivalences(scalar.ownedEquivalences)}`;
+    renderBlock(lines, indent, header, blockLines, suffix);
+    return lines.join('\n');
+};
+
+const serializeAspect = (aspect: Aspect, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, aspect.ownedAnnotations);
+    const header = aspect.ref?.$refText ? `ref aspect ${aspect.ref.$refText}` : `aspect ${serializeName(aspect.name)}`.trim();
+    const blockLines = (aspect.ownedKeys ?? []).map(serializeKeyAxiom);
+    const suffix = `${serializeEntitySpecialization(aspect)}${serializeEntityEquivalences(aspect.ownedEquivalences)}`;
+    renderBlock(lines, indent, header, blockLines, suffix);
+    return lines.join('\n');
+};
+
+const serializeConcept = (concept: Concept, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, concept.ownedAnnotations);
+    const header = concept.ref?.$refText ? `ref concept ${concept.ref.$refText}` : `concept ${serializeName(concept.name)}`.trim();
+    const blockLines: string[] = [];
+    if (concept.ownedEnumeration) {
+        blockLines.push(serializeInstanceEnumerationAxiom(concept.ownedEnumeration));
+    }
+    for (const key of concept.ownedKeys ?? []) {
+        blockLines.push(serializeKeyAxiom(key));
+    }
+    const suffix = `${serializeEntitySpecialization(concept)}${serializeEntityEquivalences(concept.ownedEquivalences)}`;
+    renderBlock(lines, indent, header, blockLines, suffix);
+    return lines.join('\n');
+};
+
+const serializeRelationEntity = (relation: RelationEntity, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, relation.ownedAnnotations);
+    const header = relation.ref?.$refText
+        ? `ref relation entity ${relation.ref.$refText}`
+        : `relation entity ${serializeName(relation.name)}`.trim();
+
+    const blockLines: string[] = [];
+    const sources = relation.sources?.map(resolveRefText).filter(Boolean);
+    if (sources.length) {
+        blockLines.push(`from ${sources.join(', ')}`);
+    }
+    const targets = relation.targets?.map(resolveRefText).filter(Boolean);
+    if (targets.length) {
+        blockLines.push(`to ${targets.join(', ')}`);
+    }
+    if (relation.forwardRelation) {
+        blockLines.push(...serializeRelationLines(relation.forwardRelation));
+    }
+    if (relation.reverseRelation) {
+        blockLines.push(...serializeRelationLines(relation.reverseRelation));
+    }
+    blockLines.push(...serializeRelationTraitsLines(relation));
+    for (const key of relation.ownedKeys ?? []) {
+        blockLines.push(serializeKeyAxiom(key));
+    }
+
+    const suffix = `${serializeEntitySpecialization(relation)}${serializeEntityEquivalences(relation.ownedEquivalences)}`;
+    renderBlock(lines, indent, header, blockLines, suffix);
+    return lines.join('\n');
+};
+
+const serializeScalarProperty = (property: ScalarProperty, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, property.ownedAnnotations);
+    const header = property.ref?.$refText
+        ? `ref scalar property ${property.ref.$refText}`
+        : `scalar property ${serializeName(property.name)}`.trim();
+
+    const blockLines: string[] = [];
+    const domains = property.domains?.map(resolveRefText).filter(Boolean);
+    if (domains.length) {
+        blockLines.push(`domain ${domains.join(', ')}`);
+    }
+    const ranges = property.ranges?.map(resolveRefText).filter(Boolean);
+    if (ranges.length) {
+        blockLines.push(`range ${ranges.join(', ')}`);
+    }
+    if (property.functional) {
+        blockLines.push('functional');
+    }
+
+    const suffix = `${serializePropertySpecialization(property.ownedSpecializations)}${serializePropertyEquivalences(
+        property.ownedEquivalences
+    )}`;
+    renderBlock(lines, indent, header, blockLines, suffix);
+    return lines.join('\n');
+};
+
+const serializeUnreifiedRelation = (relation: UnreifiedRelation, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, relation.ownedAnnotations);
+    const header = relation.ref?.$refText
+        ? `ref relation ${relation.ref.$refText}`
+        : `relation ${serializeName(relation.name)}`.trim();
+
+    const blockLines: string[] = [];
+    const sources = relation.sources?.map(resolveRefText).filter(Boolean);
+    if (sources.length) {
+        blockLines.push(`from ${sources.join(', ')}`);
+    }
+    const targets = relation.targets?.map(resolveRefText).filter(Boolean);
+    if (targets.length) {
+        blockLines.push(`to ${targets.join(', ')}`);
+    }
+    if (relation.reverseRelation) {
+        blockLines.push(...serializeRelationLines(relation.reverseRelation));
+    }
+    blockLines.push(...serializeRelationTraitsLines(relation));
+
+    const suffix = `${serializePropertySpecialization(relation.ownedSpecializations)}${serializePropertyEquivalences(
+        relation.ownedEquivalences
+    )}`;
+    renderBlock(lines, indent, header, blockLines, suffix);
+    return lines.join('\n');
+};
+
+const serializeRelationLines = (relation: ForwardRelation | ReverseRelation): string[] => {
+    const lines: string[] = [];
+    if (isForwardRelation(relation)) {
+        for (const annotation of relation.ownedAnnotations ?? []) {
+            lines.push(serializeAnnotation(annotation));
+        }
+        lines.push(`forward ${serializeName(relation.name)}`);
+        return lines;
+    }
+    if (isReverseRelation(relation)) {
+        for (const annotation of relation.ownedAnnotations ?? []) {
+            lines.push(serializeAnnotation(annotation));
+        }
+        lines.push(`reverse ${serializeName(relation.name)}`);
+        return lines;
+    }
+    return lines;
+};
+
+const serializeRelationTraitsLines = (relation: RelationEntity | UnreifiedRelation): string[] => {
+    const lines: string[] = [];
+    if (relation.functional) {
+        lines.push('functional');
+    }
+    if (relation.inverseFunctional) {
+        lines.push('inverse functional');
+    }
+    if (relation.symmetric) {
+        lines.push('symmetric');
+    }
+    if (relation.asymmetric) {
+        lines.push('asymmetric');
+    }
+    if (relation.reflexive) {
+        lines.push('reflexive');
+    }
+    if (relation.irreflexive) {
+        lines.push('irreflexive');
+    }
+    if (relation.transitive) {
+        lines.push('transitive');
+    }
+    return lines;
+};
+
+const serializeInstanceEnumerationAxiom = (axiom: InstanceEnumerationAxiom): string => {
+    const instances = axiom.instances?.map(resolveRefText).filter(Boolean).join(', ');
+    return `oneOf ${instances}`.trim();
+};
+
+const serializeLiteralEnumerationAxiom = (axiom: LiteralEnumerationAxiom): string => {
+    const literals = axiom.literals?.map(serializeLiteral).filter(Boolean).join(', ');
+    return `oneOf ${literals}`.trim();
+};
+
+const serializeKeyAxiom = (axiom: KeyAxiom): string => {
+    const properties = axiom.properties?.map(resolveRefText).filter(Boolean).join(', ');
+    return `key ${properties}`.trim();
+};
+
+const serializePropertySpecialization = (specializations: SpecializationAxiom[] = []): string => {
+    const supers = specializations.map(serializeSpecializationAxiom).filter(Boolean);
+    return supers.length ? ` < ${supers.join(', ')}` : '';
+};
+
+const serializeScalarSpecialization = (scalar: Scalar): string => {
+    return serializePropertySpecialization(scalar.ownedSpecializations);
+};
+
+const serializeEntitySpecialization = (entity: Aspect | Concept | RelationEntity): string => {
+    const supers = (entity.ownedSpecializations ?? []).map(serializeSpecializationAxiom).filter(Boolean);
+    const restrictions = (entity.ownedPropertyRestrictions ?? []).map(serializePropertyRestrictionAxiom).filter(Boolean);
+    if (!supers.length && !restrictions.length) {
+        return '';
+    }
+    if (supers.length && restrictions.length) {
+        return ` < ${supers.join(', ')} [${restrictions.join(' ')}]`;
+    }
+    if (supers.length) {
+        return ` < ${supers.join(', ')}`;
+    }
+    return ` < [${restrictions.join(' ')}]`;
+};
+
+const serializeEntityEquivalences = (equivalences: EntityEquivalenceAxiom[] = []): string => {
+    const entries = equivalences.map(serializeEntityEquivalenceAxiom).filter(Boolean);
+    return entries.length ? ` = ${entries.join(', ')}` : '';
+};
+
+const serializePropertyEquivalences = (equivalences: PropertyEquivalenceAxiom[] = []): string => {
+    const entries = equivalences.map(serializePropertyEquivalenceAxiom).filter(Boolean);
+    return entries.length ? ` = ${entries.join(', ')}` : '';
+};
+
+const serializeScalarEquivalences = (equivalences: ScalarEquivalenceAxiom[] = []): string => {
+    const entries = equivalences.map(serializeScalarEquivalenceAxiom).filter(Boolean);
+    return entries.length ? ` = ${entries.join(', ')}` : '';
+};
+
+const serializeSpecializationAxiom = (axiom: SpecializationAxiom): string => {
+    return resolveRefText(axiom.superTerm);
+};
+
+const serializeEntityEquivalenceAxiom = (axiom: EntityEquivalenceAxiom): string => {
+    const supers = (axiom.superTerms ?? []).map(resolveRefText).filter(Boolean);
+    const restrictions = (axiom.ownedPropertyRestrictions ?? []).map(serializePropertyRestrictionAxiom).filter(Boolean);
+    if (restrictions.length) {
+        if (supers.length) {
+            return `${supers.join(' & ')} [${restrictions.join(' ')}]`;
+        }
+        return `[${restrictions.join(' ')}]`;
+    }
+    return supers.join(' & ');
+};
+
+const serializePropertyEquivalenceAxiom = (axiom: PropertyEquivalenceAxiom): string => {
+    const supers = (axiom.superTerms ?? []).map(resolveRefText).filter(Boolean);
+    return supers.join(' ');
+};
+
+const serializeScalarEquivalenceAxiom = (axiom: ScalarEquivalenceAxiom): string => {
+    const supers = (axiom.superTerms ?? []).map(resolveRefText).filter(Boolean).join(' ');
+    const facets: string[] = [];
+    for (const value of axiom.length ?? []) {
+        facets.push(`length ${value}`);
+    }
+    for (const value of axiom.minLength ?? []) {
+        facets.push(`minLength ${value}`);
+    }
+    for (const value of axiom.maxLength ?? []) {
+        facets.push(`maxLength ${value}`);
+    }
+    for (const value of axiom.pattern ?? []) {
+        facets.push(`pattern ${serializeStringLiteral(value)}`);
+    }
+    for (const value of axiom.language ?? []) {
+        facets.push(`language ${value}`);
+    }
+    for (const value of axiom.minInclusive ?? []) {
+        facets.push(`minInclusive ${serializeLiteral(value)}`);
+    }
+    for (const value of axiom.minExclusive ?? []) {
+        facets.push(`minExclusive ${serializeLiteral(value)}`);
+    }
+    for (const value of axiom.maxInclusive ?? []) {
+        facets.push(`maxInclusive ${serializeLiteral(value)}`);
+    }
+    for (const value of axiom.maxExclusive ?? []) {
+        facets.push(`maxExclusive ${serializeLiteral(value)}`);
+    }
+    const facetText = facets.length ? ` [${facets.join(' ')}]` : '';
+    return `${supers}${facetText}`.trim();
+};
+
+const serializePropertyRestrictionAxiom = (axiom: PropertyRestrictionAxiom): string => {
+    if (isPropertyRangeRestrictionAxiom(axiom)) {
+        return serializePropertyRangeRestrictionAxiom(axiom);
+    }
+    if (isPropertyCardinalityRestrictionAxiom(axiom)) {
+        return serializePropertyCardinalityRestrictionAxiom(axiom);
+    }
+    if (isPropertyValueRestrictionAxiom(axiom)) {
+        return serializePropertyValueRestrictionAxiom(axiom);
+    }
+    if (isPropertySelfRestrictionAxiom(axiom)) {
+        return serializePropertySelfRestrictionAxiom(axiom);
+    }
+    return '';
+};
+
+const serializePropertyRangeRestrictionAxiom = (axiom: PropertyRangeRestrictionAxiom): string => {
+    const property = resolveRefText(axiom.property);
+    const range = resolveRefText(axiom.range);
+    return `restricts ${axiom.kind} ${property} to ${range}`.trim();
+};
+
+const serializePropertyCardinalityRestrictionAxiom = (axiom: PropertyCardinalityRestrictionAxiom): string => {
+    const property = resolveRefText(axiom.property);
+    const range = axiom.range ? ` ${resolveRefText(axiom.range)}` : '';
+    return `restricts ${property} to ${axiom.kind} ${axiom.cardinality}${range}`.trim();
+};
+
+const serializePropertyValueRestrictionAxiom = (axiom: PropertyValueRestrictionAxiom): string => {
+    const property = resolveRefText(axiom.property);
+    const value = serializeRestrictionValue(axiom);
+    return `restricts ${property} to ${value}`.trim();
+};
+
+const serializeRestrictionValue = (axiom: PropertyValueRestrictionAxiom): string => {
+    if (axiom.literalValue) {
+        return serializeLiteral(axiom.literalValue);
+    }
+    if (axiom.referencedValue) {
+        return resolveRefText(axiom.referencedValue);
+    }
+    if (axiom.containedValue) {
+        return serializeAnonymousInstance(axiom.containedValue);
+    }
+    return '';
+};
+
+const serializePropertySelfRestrictionAxiom = (axiom: PropertySelfRestrictionAxiom): string => {
+    const property = resolveRefText(axiom.property);
+    return `restricts ${property} to self`.trim();
+};
+
+const serializeNamedInstance = (instance: NamedInstance, indent: string): string => {
+    const lines: string[] = [];
+    pushAnnotations(lines, indent, instance.ownedAnnotations ?? []);
+
+    const header = serializeInstanceHeader(instance);
+    const body = serializeInstanceBody(instance);
+    renderBlock(lines, indent, header, body, '');
+    return lines.join('\n');
+};
+
+const serializeInstanceHeader = (instance: NamedInstance): string => {
+    const types = instance.ownedTypes ?? [];
+    const typeText = types.length ? ` : ${types.map(serializeTypeAssertion).join(', ')}` : '';
+    if (isRelationInstance(instance)) {
+        if (instance.ref?.$refText) {
+            return `ref relation instance ${instance.ref.$refText}${typeText}`;
+        }
+        return `relation instance ${serializeName(instance.name)}${typeText}`.trim();
+    }
+    if (isConceptInstance(instance)) {
+        if (instance.ref?.$refText) {
+            return `ref instance ${instance.ref.$refText}${typeText}`;
+        }
+        return `instance ${serializeName(instance.name)}${typeText}`.trim();
+    }
+    return '';
+};
+
+const serializeTypeAssertion = (typeAssertion: TypeAssertion): string => {
+    const refText = (typeAssertion.type as any)?.$refText;
+    if (refText) {
+        return refText;
+    }
+    const name = (typeAssertion.type?.ref as any)?.name;
+    return name ?? '';
+};
+
+const serializeInstanceBody = (instance: NamedInstance): string[] => {
+    const lines: string[] = [];
+    if (isRelationInstance(instance)) {
+        if (instance.sources?.length) {
+            const sources = instance.sources.map((ref) => resolveRefText(ref)).filter(Boolean);
+            if (sources.length) {
+                lines.push(`from ${sources.join(', ')}`);
+            }
+        }
+        if (instance.targets?.length) {
+            const targets = instance.targets.map((ref) => resolveRefText(ref)).filter(Boolean);
+            if (targets.length) {
+                lines.push(`to ${targets.join(', ')}`);
+            }
+        }
+    }
+    const properties = instance.ownedPropertyValues ?? [];
+    for (const prop of properties) {
+        lines.push(serializePropertyValueAssertion(prop));
+    }
+    return lines;
+};
+
+const serializePropertyValueAssertion = (assertion: PropertyValueAssertion): string => {
+    const propRef = resolveRefText(assertion.property);
+    const values: string[] = [];
+    for (const lit of assertion.literalValues ?? []) {
+        values.push(serializeLiteral(lit));
+    }
+    for (const ref of assertion.referencedValues ?? []) {
+        const refText = resolveRefText(ref);
+        if (refText) {
+            values.push(refText);
+        }
+    }
+    for (const contained of assertion.containedValues ?? []) {
+        values.push(serializeAnonymousInstance(contained));
+    }
+    const valueText = values.join(', ');
+    return valueText ? `${propRef} ${valueText}`.trim() : propRef;
+};
+
+const serializeAnonymousInstance = (instance: AnonymousInstance): string => {
+    if (isAnonymousRelationInstance(instance)) {
+        const header = `${resolveRefText(instance.target)} [`.trim();
+        const lines = [header];
+        appendIndentedLines(lines, INDENT, (instance.ownedPropertyValues ?? []).map(serializePropertyValueAssertion));
+        lines.push(']');
+        return lines.join('\n');
+    }
+    if (isAnonymousConceptInstance(instance)) {
+        const typeRef = resolveRefText(instance.type);
+        const header = typeRef ? `: ${typeRef} [` : '[';
+        const lines = [header];
+        appendIndentedLines(lines, INDENT, (instance.ownedPropertyValues ?? []).map(serializePropertyValueAssertion));
+        lines.push(']');
+        return lines.join('\n');
+    }
+    return '';
+};
+
+const serializeAnnotation = (annotation: Annotation): string => {
+    const property = resolveRefText(annotation.property);
+    const values: string[] = [];
+    for (const value of annotation.literalValues ?? []) {
+        values.push(serializeLiteral(value));
+    }
+    for (const ref of annotation.referencedValues ?? []) {
+        const refText = resolveRefText(ref);
+        if (refText) {
+            values.push(refText);
+        }
+    }
+    if (!values.length) {
+        return `@${property}`;
+    }
+    return `@${property} ${values.join(', ')}`;
+};
+
+const serializeLiteral = (literal: Literal): string => {
+    if (isQuotedLiteral(literal)) {
+        return serializeQuotedLiteral(literal);
+    }
+    if (isBooleanLiteral(literal)) {
+        return literal.value ? 'true' : 'false';
+    }
+    if (isIntegerLiteral(literal)) {
+        return `${literal.value}`;
+    }
+    if (isDecimalLiteral(literal)) {
+        return `${literal.value}`;
+    }
+    if (isDoubleLiteral(literal)) {
+        return `${literal.value}`;
+    }
+    return '';
+};
+
+const serializeQuotedLiteral = (literal: QuotedLiteral): string => {
+    const base = serializeStringLiteral(literal.value ?? '');
+    if (literal.type?.$refText) {
+        return `${base}^^${literal.type.$refText}`;
+    }
+    if (literal.langTag) {
+        return `${base}$${literal.langTag}`;
+    }
+    return base;
+};
+
+const serializeStringLiteral = (value: string): string => {
+    const raw = value ?? '';
+    if (raw.includes('\n') || raw.includes('\r')) {
+        if (!raw.includes('"""')) {
+            return `"""${raw}"""`;
+        }
+        if (!raw.includes("'''")) {
+            return `'''${raw}'''`;
+        }
+    }
+    if (!raw.includes('"')) {
+        return `"${raw}"`;
+    }
+    if (!raw.includes("'")) {
+        return `'${raw}'`;
+    }
+    if (!raw.includes('"""')) {
+        return `"""${raw}"""`;
+    }
+    return `'''${raw}'''`;
+};
+
+const resolveRefText = (ref: any): string => {
+    if (!ref) {
+        return '';
+    }
+    if (typeof ref === 'string') {
+        return formatRefText(ref);
+    }
+    if (ref.$refText) {
+        return formatRefText(ref.$refText);
+    }
+    const target = ref.ref ?? ref._ref ?? ref;
+    const name = target?.name ?? '';
+    if (!name) {
+        return '';
+    }
+    const targetOntology = findOwningOntologyNode(target);
+    const targetNamespace = targetOntology ? normalizeNamespace(targetOntology.namespace ?? '') : '';
+    if (activeContext && targetNamespace) {
+        if (targetNamespace === activeContext.namespace) {
+            return escapeIdentifier(name);
+        }
+        const prefix = activeContext.prefixByNamespace.get(targetNamespace);
+        if (prefix) {
+            return `${prefix}:${name}`;
+        }
+    }
+    return escapeIdentifier(name);
+};
+
+const formatRefText = (value: string): string => {
+    if (!value) {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith('^')) {
+        return trimmed;
+    }
+    if (trimmed.startsWith('<') && trimmed.endsWith('>')) {
+        const unwrapped = trimmed.slice(1, -1);
+        return formatIriRef(unwrapped);
+    }
+    if (trimmed.includes('://')) {
+        return formatIriRef(trimmed);
+    }
+    if (activeContext?.prefix && trimmed.startsWith(`${activeContext.prefix}:`)) {
+        const local = trimmed.slice(activeContext.prefix.length + 1);
+        return escapeIdentifier(local);
+    }
+    if (trimmed.includes(':')) {
+        return trimmed;
+    }
+    return escapeIdentifier(trimmed);
+};
+
+const formatIriRef = (iri: string): string => {
+    const parts = splitIri(iri);
+    if (!parts?.base || !parts.fragment || !activeContext) {
+        return `<${iri}>`;
+    }
+    const ns = normalizeNamespace(parts.base);
+    if (ns === activeContext.namespace) {
+        return escapeIdentifier(parts.fragment);
+    }
+    const prefix = activeContext.prefixByNamespace.get(ns);
+    if (prefix) {
+        return `${prefix}:${parts.fragment}`;
+    }
+    return `<${iri}>`;
+};
+
+const escapeIdentifier = (value: string): string => {
+    if (!value) {
+        return '';
+    }
+    if (value.startsWith('^')) {
+        return value;
+    }
+    return OML_KEYWORDS.has(value) ? `^${value}` : value;
+};
+
+const serializeName = (value?: string): string => escapeIdentifier(value ?? '');
+
+const createSerializeContext = (ontology: Ontology): SerializeContext => {
+    const namespace = normalizeNamespace(ontology.namespace ?? '');
+    const prefixByNamespace = new Map<string, string>();
+    const prefix = (ontology as any).prefix as string | undefined;
+    if (prefix && namespace) {
+        prefixByNamespace.set(namespace, prefix);
+    }
+    (ontology as any).ownedImports?.forEach((imp: Import) => {
+        if (!imp.prefix) return;
+        const ns = normalizeNamespace(resolveImportNamespace(imp));
+        if (ns) {
+            prefixByNamespace.set(ns, imp.prefix);
+        }
+    });
+    return { namespace, prefix, prefixByNamespace };
+};
+
+const renderBlock = (
+    lines: string[],
+    indent: string,
+    header: string,
+    blockLines: string[],
+    suffix: string
+): void => {
+    if (blockLines.length) {
+        lines.push(`${indent}${header} [`);
+        appendIndentedLines(lines, `${indent}${INDENT}`, blockLines);
+        const closing = suffix ? `${indent}]${suffix}` : `${indent}]`;
+        lines.push(closing);
+    } else {
+        lines.push(`${indent}${header}${suffix}`);
+    }
+};
+
+const appendIndentedLines = (lines: string[], indent: string, contentLines: string[]): void => {
+    for (const line of contentLines) {
+        const parts = line.split('\n');
+        for (const part of parts) {
+            lines.push(`${indent}${part}`);
+        }
+    }
+};
+
+const pushAnnotations = (lines: string[], indent: string, annotations: Annotation[] = []): void => {
+    for (const annotation of annotations) {
+        lines.push(`${indent}${serializeAnnotation(annotation)}`);
+    }
+};
+
+const stripAngles = (value: string): string => value.replace(/^<|>$/g, '');
+
+const wrapNamespace = (value: string): string => `<${stripAngles(value)}>`;
+
+const OML_KEYWORDS = new Set([
+    'all',
+    'annotation',
+    'as',
+    'aspect',
+    'asymmetric',
+    'builtIn',
+    'builtin',
+    'bundle',
+    'concept',
+    'description',
+    'differentFrom',
+    'domain',
+    'entity',
+    'exactly',
+    'extends',
+    'forward',
+    'from',
+    'functional',
+    'includes',
+    'instance',
+    'inverse',
+    'irreflexive',
+    'key',
+    'language',
+    'length',
+    'max',
+    'maxExclusive',
+    'maxInclusive',
+    'maxLength',
+    'min',
+    'minExclusive',
+    'minInclusive',
+    'minLength',
+    'oneOf',
+    'pattern',
+    'property',
+    'range',
+    'ref',
+    'reflexive',
+    'relation',
+    'restricts',
+    'reverse',
+    'rule',
+    'sameAs',
+    'scalar',
+    'self',
+    'some',
+    'symmetric',
+    'to',
+    'transitive',
+    'uses',
+    'vocabulary'
+]);