@oml/language 0.19.1 → 0.19.3

package/src/oml/oml-scope.ts

@@ -101,10 +101,26 @@ export class OmlScopeComputation extends DefaultScopeComputation {
  */
 export class OmlScopeProvider extends DefaultScopeProvider {
     protected services: LangiumCoreServices;
+    // Descriptions for an ontology's *own* exported symbols, keyed by ontology then referenceType.
+    // WeakMap so a re-parsed ontology (new AST root) naturally drops its old entry.
+    private ownDescCache = new WeakMap<Ontology, Map<string, AstNodeDescription[]>>();
+    // Descriptions contributed by an ontology's *imports* (all imports combined), keyed by the
+    // importing ontology then referenceType. The `prefix:name` variant uses the importer's prefix,
+    // so this is correctly indexed on the importer side.
+    private importedDescCache = new WeakMap<Ontology, Map<string, AstNodeDescription[]>>();
 
     constructor(services: LangiumCoreServices) {
         super(services);
         this.services = services;
+        // Wipe caches on any document update. Within a sustained linking pass (the hot phase)
+        // no documents are mutating, so the caches stay warm. After an update the importer-side
+        // cache could otherwise hold descriptions pointing at stale (re-parsed) imported nodes,
+        // so we reset rather than try to invalidate selectively.
+        const shared = (services as any).shared as LangiumSharedServices | undefined;
+        shared?.workspace.DocumentBuilder.onUpdate(() => {
+            this.ownDescCache = new WeakMap();
+            this.importedDescCache = new WeakMap();
+        });
     }
 
     override getScope(context: ReferenceInfo): Scope {
@@ -233,34 +249,52 @@ export class OmlScopeProvider extends DefaultScopeProvider {
         return resolved;
     }
 
-    private addDescription(scope: Scope, node: any, name: string, document: LangiumDocument): Scope {
+    private pushDescription(out: AstNodeDescription[], node: any, name: string, document: LangiumDocument): void {
         try {
-            const desc = this.descriptions.createDescription(node, name, document);
-            return this.createScope(stream([desc]), scope);
+            out.push(this.descriptions.createDescription(node, name, document));
         } catch {
-            return scope;
+            // ignore — a missing name or invalid node should not abort the rest of the scope
         }
     }
 
-    private addCurrentOntologyEntries(scope: Scope, document: LangiumDocument, ontology: Ontology, referenceType: string): Scope {
-        let result = scope;
+    private getOwnDescriptions(document: LangiumDocument, ontology: Ontology, referenceType: string): AstNodeDescription[] {
+        let perType = this.ownDescCache.get(ontology);
+        if (!perType) {
+            perType = new Map();
+            this.ownDescCache.set(ontology, perType);
+        }
+        const cached = perType.get(referenceType);
+        if (cached) {
+            return cached;
+        }
+        const descs: AstNodeDescription[] = [];
         const prefix = (ontology as any).prefix as string | undefined;
         for (const symbol of this.getExportedSymbols(ontology)) {
             if (!this.reflection.isSubtype(symbol.node.$type, referenceType)) {
                 continue;
             }
             if (prefix) {
-                result = this.addDescription(result, symbol.node, `${prefix}:${symbol.name}`, document);
+                this.pushDescription(descs, symbol.node, `${prefix}:${symbol.name}`, document);
             }
             if (symbol.relationAlias) {
-                result = this.addDescription(result, symbol.node, symbol.name, document);
+                this.pushDescription(descs, symbol.node, symbol.name, document);
             }
         }
-        return result;
+        perType.set(referenceType, descs);
+        return descs;
     }
 
-    private addImportedOntologyEntries(scope: Scope, current: Ontology, referenceType: string): Scope {
-        let result = scope;
+    private getImportedDescriptions(current: Ontology, referenceType: string): AstNodeDescription[] {
+        let perType = this.importedDescCache.get(current);
+        if (!perType) {
+            perType = new Map();
+            this.importedDescCache.set(current, perType);
+        }
+        const cached = perType.get(referenceType);
+        if (cached) {
+            return cached;
+        }
+        const descs: AstNodeDescription[] = [];
         for (const resolvedImport of this.resolveImports(current)) {
             const imported = resolvedImport.target;
             const importedSymbols = this.getExportedSymbols(imported.ontology);
@@ -269,18 +303,24 @@ export class OmlScopeProvider extends DefaultScopeProvider {
                     continue;
                 }
                 if (resolvedImport.prefix) {
-                    result = this.addDescription(result, symbol.node, `${resolvedImport.prefix}:${symbol.name}`, imported.document);
+                    this.pushDescription(descs, symbol.node, `${resolvedImport.prefix}:${symbol.name}`, imported.document);
                 }
                 const separator = imported.namespace.endsWith('#') || imported.namespace.endsWith('/') ? '' : '#';
-                result = this.addDescription(
-                    result,
-                    symbol.node,
-                    `<${imported.namespace}${separator}${symbol.name}>`,
-                    imported.document
-                );
+                this.pushDescription(descs, symbol.node, `<${imported.namespace}${separator}${symbol.name}>`, imported.document);
             }
         }
-        return result;
+        perType.set(referenceType, descs);
+        return descs;
+    }
+
+    private addCurrentOntologyEntries(scope: Scope, document: LangiumDocument, ontology: Ontology, referenceType: string): Scope {
+        const descs = this.getOwnDescriptions(document, ontology, referenceType);
+        return descs.length === 0 ? scope : this.createScope(stream(descs), scope);
+    }
+
+    private addImportedOntologyEntries(scope: Scope, current: Ontology, referenceType: string): Scope {
+        const descs = this.getImportedDescriptions(current, referenceType);
+        return descs.length === 0 ? scope : this.createScope(stream(descs), scope);
     }
 
 }

package/src/oml/oml-serializer.ts

@@ -86,6 +86,8 @@ import {
     isVocabulary,
     isVocabularyBundle,
 } from './generated/ast.js';
+import { escapeIdentifier } from './oml-identifiers.js';
+import { formatDoubleLiteralValue } from './oml-literals.js';
 import {
     findOwningOntologyNode,
     normalizeNamespace,
@@ -857,12 +859,9 @@ const serializeLiteral = (literal: Literal): string => {
         return appendUnitSuffix(base, literal);
     }
     if (isDoubleLiteral(literal)) {
-        const v = literal.value as unknown;
         // Langium parses double literals to JS numbers, losing the required e-notation.
-        // OML DOUBLE terminal requires e/E; always emit it.
-        const base = (typeof v === 'number' && Number.isFinite(v))
-            ? (Number.isInteger(v) ? `${v}.0e0` : `${v}e0`)
-            : `${literal.value}`;
+        // OML DOUBLE terminal requires e/E, but JS may already stringify small numbers with one.
+        const base = formatDoubleLiteralValue(literal.value);
         return appendUnitSuffix(base, literal);
     }
     return '';
@@ -977,16 +976,6 @@ const formatIriRef = (iri: string): string => {
     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 => {
@@ -1041,58 +1030,3 @@ const pushAnnotations = (lines: string[], indent: string, annotations: Annotatio
 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'
-]);

package/src/oml/oml-update.ts

@@ -319,9 +319,9 @@ async function executeOperation(
             return new Set([context.ontologyIri]);
         case 'createInstanceRef':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            await ensureReferenceImport(shared, context.ontology, operation.instanceIri);
+            await ensureReferenceImport(shared, context.ontology, operation.instanceIri, contexts);
             if (operation.typeIri) {
-                await ensureReferenceImport(shared, context.ontology, operation.typeIri);
+                await ensureReferenceImport(shared, context.ontology, operation.typeIri, contexts);
             }
             {
                 const ownedTypes: any[] = [];
@@ -347,9 +347,9 @@ async function executeOperation(
             return new Set([context.ontologyIri]);
         case 'createRelationInstanceRef':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            await ensureReferenceImport(shared, context.ontology, operation.instanceIri);
+            await ensureReferenceImport(shared, context.ontology, operation.instanceIri, contexts);
             if (operation.typeIri) {
-                await ensureReferenceImport(shared, context.ontology, operation.typeIri);
+                await ensureReferenceImport(shared, context.ontology, operation.typeIri, contexts);
             }
             {
                 const ownedTypes: any[] = [];
@@ -377,12 +377,12 @@ async function executeOperation(
             return new Set([context.ontologyIri]);
         case 'addAssertion':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            return await addAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await addAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object, contexts)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'updateAssertion':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            return await updateAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await updateAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object, contexts)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'removeAssertion':
@@ -391,11 +391,11 @@ async function executeOperation(
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'addAnnotation':
-            return await addAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await addAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object, contexts)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'updateAnnotation':
-            return await updateAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await updateAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object, contexts)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'removeAnnotation':
@@ -457,7 +457,14 @@ function ensureUniqueLocalName(ontology: any, memberName: string): void {
     }
 }
 
-async function addAssertion(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
+async function addAssertion(
+    shared: any,
+    ontology: any,
+    subjectIri: string,
+    predicateIri: string,
+    objectValue: unknown,
+    contexts?: ReadonlyMap<string, OntologyContext>
+): Promise<boolean> {
     const normalizedPredicate = normalizeIri(predicateIri);
     const subject = findNamedInstanceByIri(ontology, subjectIri);
     if (!subject) {
@@ -469,7 +476,7 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
         if ((subject.ownedTypes ?? []).some((entry: any) => matchesPredicateRef(ontology, entry?.type, normalizedTypeIri))) {
             return false;
         }
-        await ensureReferenceImport(shared, ontology, normalizedTypeIri);
+        await ensureReferenceImport(shared, ontology, normalizedTypeIri, contexts);
         subject.ownedTypes ??= [];
         pushAstArrayChild(subject, 'ownedTypes', {
             $type: 'TypeAssertion',
@@ -483,7 +490,7 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
             throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
         }
         const sourceIri = normalizeIri(asRequiredIri(objectValue, 'source assertion object'));
-        await ensureReferenceImport(shared, ontology, sourceIri);
+        await ensureReferenceImport(shared, ontology, sourceIri, contexts);
         subject.sources ??= [];
         subject.sources.push(asRef(ontology, sourceIri));
         return true;
@@ -494,7 +501,7 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
             throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
         }
         const targetIri = normalizeIri(asRequiredIri(objectValue, 'target assertion object'));
-        await ensureReferenceImport(shared, ontology, targetIri);
+        await ensureReferenceImport(shared, ontology, targetIri, contexts);
         subject.targets ??= [];
         subject.targets.push(asRef(ontology, targetIri));
         return true;
@@ -505,7 +512,7 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
         .filter((assertion: any) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
     let propertyAssertion = matchingAssertions[0];
     if (!propertyAssertion) {
-        await ensureReferenceImport(shared, ontology, normalizedPredicate);
+        await ensureReferenceImport(shared, ontology, normalizedPredicate, contexts);
         propertyAssertion = {
             $type: 'PropertyValueAssertion',
             property: asRef(ontology, normalizedPredicate),
@@ -518,9 +525,9 @@ async function addAssertion(shared: any, ontology: any, subjectIri: string, pred
         normalizePropertyAssertionGroup(subject, propertyAssertion, matchingAssertions.slice(1));
     }
     if (isIriLike(objectValue)) {
-        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')));
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')), contexts);
     } else {
-        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue, contexts);
     }
     appendAssertionValue(ontology, propertyAssertion, objectValue);
     normalizeAllPropertyAssertions(subject, ontology);
@@ -618,7 +625,14 @@ function removeAssertion(ontology: any, subjectIri: string, predicateIri: string
     return changed;
 }
 
-async function updateAssertion(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
+async function updateAssertion(
+    shared: any,
+    ontology: any,
+    subjectIri: string,
+    predicateIri: string,
+    objectValue: unknown,
+    contexts?: ReadonlyMap<string, OntologyContext>
+): Promise<boolean> {
     const normalizedPredicate = normalizeIri(predicateIri);
     const subject = findNamedInstanceByIri(ontology, subjectIri);
     if (!subject) {
@@ -627,19 +641,19 @@ async function updateAssertion(shared: any, ontology: any, subjectIri: string, p
 
     if (normalizedPredicate === RDF_TYPE_IRI || isSourcePredicate(normalizedPredicate) || isTargetPredicate(normalizedPredicate)) {
         const removed = removeAssertion(ontology, subjectIri, predicateIri, undefined);
-        const added = await addAssertion(shared, ontology, subjectIri, predicateIri, objectValue);
+        const added = await addAssertion(shared, ontology, subjectIri, predicateIri, objectValue, contexts);
         return removed || added;
     }
 
     subject.ownedPropertyValues ??= [];
     let propertyAssertion = subject.ownedPropertyValues.find((assertion: any) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
     if (!propertyAssertion) {
-        return addAssertion(shared, ontology, subjectIri, predicateIri, objectValue);
+        return addAssertion(shared, ontology, subjectIri, predicateIri, objectValue, contexts);
     }
     if (isIriLike(objectValue)) {
-        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')));
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')), contexts);
     } else {
-        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue, contexts);
     }
     propertyAssertion.literalValues = [];
     propertyAssertion.referencedValues = [];
@@ -648,13 +662,20 @@ async function updateAssertion(shared: any, ontology: any, subjectIri: string, p
     return true;
 }
 
-async function addAnnotation(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
+async function addAnnotation(
+    shared: any,
+    ontology: any,
+    subjectIri: string,
+    predicateIri: string,
+    objectValue: unknown,
+    contexts?: ReadonlyMap<string, OntologyContext>
+): Promise<boolean> {
     const subject = findAnnotationSubjectByIri(ontology, subjectIri);
     if (!subject) {
         throw new Error(`Annotation subject '${subjectIri}' was not found in the ontology.`);
     }
     const normalizedPredicate = normalizeIri(predicateIri);
-    await ensureReferenceImport(shared, ontology, normalizedPredicate);
+    await ensureReferenceImport(shared, ontology, normalizedPredicate, contexts);
     subject.ownedAnnotations ??= [];
     const matchingAnnotations = subject.ownedAnnotations
         .filter((entry: any) => matchesPredicateRef(ontology, entry?.property, normalizedPredicate));
@@ -671,9 +692,9 @@ async function addAnnotation(shared: any, ontology: any, subjectIri: string, pre
         normalizeAnnotationGroup(subject, annotation, matchingAnnotations.slice(1));
     }
     if (isIriLike(objectValue)) {
-        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')));
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')), contexts);
     } else {
-        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue, contexts);
     }
     appendAnnotationValue(ontology, annotation, objectValue);
     normalizeAllAnnotations(subject, ontology);
@@ -718,7 +739,14 @@ function removeAnnotation(ontology: any, subjectIri: string, predicateIri: strin
     return changed;
 }
 
-async function updateAnnotation(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
+async function updateAnnotation(
+    shared: any,
+    ontology: any,
+    subjectIri: string,
+    predicateIri: string,
+    objectValue: unknown,
+    contexts?: ReadonlyMap<string, OntologyContext>
+): Promise<boolean> {
     const subject = findAnnotationSubjectByIri(ontology, subjectIri);
     if (!subject) {
         throw new Error(`Annotation subject '${subjectIri}' was not found in the ontology.`);
@@ -727,12 +755,12 @@ async function updateAnnotation(shared: any, ontology: any, subjectIri: string,
     subject.ownedAnnotations ??= [];
     const annotation = subject.ownedAnnotations.find((entry: any) => matchesPredicateRef(ontology, entry?.property, normalizedPredicate));
     if (!annotation) {
-        return addAnnotation(shared, ontology, subjectIri, predicateIri, objectValue);
+        return addAnnotation(shared, ontology, subjectIri, predicateIri, objectValue, contexts);
     }
     if (isIriLike(objectValue)) {
-        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')));
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')), contexts);
     } else {
-        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue, contexts);
     }
     annotation.literalValues = [];
     annotation.referencedValues = [];
@@ -1190,7 +1218,12 @@ function toRefText(ontology: any, iri: string): string {
     return `<${normalizedIri}>`;
 }
 
-async function ensureReferenceImport(shared: any, ontology: any, iri: string): Promise<void> {
+async function ensureReferenceImport(
+    shared: any,
+    ontology: any,
+    iri: string,
+    contexts?: ReadonlyMap<string, OntologyContext>
+): Promise<void> {
     const target = parseIriParts(iri);
     if (!target) {
         return;
@@ -1215,7 +1248,8 @@ async function ensureReferenceImport(shared: any, ontology: any, iri: string): P
         const importedNamespace = normalizeNamespace(String(resolveImportNamespaceRaw(imp) ?? ''));
         return importedNamespace === target.namespace;
     });
-    const importedOntology = await findOntologyByNamespace(shared, target.namespace);
+    const importedOntology = findOntologyInContexts(contexts, target.namespace)
+        ?? await findOntologyByNamespace(shared, target.namespace);
     const declaredPrefix = typeof importedOntology?.prefix === 'string' ? importedOntology.prefix.trim() : '';
     const preferredPrefix = declaredPrefix && !usedPrefixes.has(declaredPrefix)
         ? declaredPrefix
@@ -1363,6 +1397,13 @@ async function findOntologyByNamespace(shared: any, namespace: string): Promise<
     return ontology && isOntology(ontology) ? ontology : undefined;
 }
 
+function findOntologyInContexts(contexts: ReadonlyMap<string, OntologyContext> | undefined, namespace: string): any | undefined {
+    if (!contexts) {
+        return undefined;
+    }
+    return contexts.get(normalizeOntologyIriKey(namespace))?.ontology;
+}
+
 function matchesRefTextTarget(
     ontology: any,
     statement: any,
@@ -1423,6 +1464,9 @@ function matchesRefTextFragment(statement: any, fragment: string): boolean {
 }
 
 function asLiteral(ontology: any, value: unknown): any {
+    if (isExplicitLiteralTransport(value)) {
+        return explicitLiteralFromTransport(ontology, value);
+    }
     if (isQuantityLiteralTransport(value)) {
         const raw = value.value;
         const num = typeof raw === 'number' ? raw : Number(raw);
@@ -1454,12 +1498,6 @@ function asLiteral(ontology: any, value: unknown): any {
         }
         return literal;
     }
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        const record = value as Record<string, unknown>;
-        if ((record.$type === 'DoubleLiteral' || record.$type === 'DecimalLiteral') && 'value' in record) {
-            return { $type: record.$type, value: record.value };
-        }
-    }
     if (typeof value === 'boolean') {
         return { $type: 'BooleanLiteral', value };
     }
@@ -1472,17 +1510,125 @@ function asLiteral(ontology: any, value: unknown): any {
     return { $type: 'QuotedLiteral', value: String(value ?? '') };
 }
 
-async function ensureTypedLiteralDatatypeImport(shared: any, ontology: any, value: unknown): Promise<void> {
+function isExplicitLiteralTransport(value: unknown): value is {
+    $type: 'BooleanLiteral' | 'DecimalLiteral' | 'DoubleLiteral' | 'IntegerLiteral' | 'QuotedLiteral';
+    value?: unknown;
+    langTag?: unknown;
+    language?: unknown;
+    datatypeIri?: unknown;
+    datatypeRefText?: unknown;
+    typeIri?: unknown;
+    typeRefText?: unknown;
+    type?: unknown;
+    unitIri?: unknown;
+    unitRefText?: unknown;
+    unit?: unknown;
+} {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const type = (value as Record<string, unknown>).$type;
+    return type === 'BooleanLiteral'
+        || type === 'DecimalLiteral'
+        || type === 'DoubleLiteral'
+        || type === 'IntegerLiteral'
+        || type === 'QuotedLiteral';
+}
+
+function explicitLiteralFromTransport(ontology: any, value: {
+    $type: 'BooleanLiteral' | 'DecimalLiteral' | 'DoubleLiteral' | 'IntegerLiteral' | 'QuotedLiteral';
+    value?: unknown;
+    langTag?: unknown;
+    language?: unknown;
+    datatypeIri?: unknown;
+    datatypeRefText?: unknown;
+    typeIri?: unknown;
+    typeRefText?: unknown;
+    type?: unknown;
+    unitIri?: unknown;
+    unitRefText?: unknown;
+    unit?: unknown;
+}): Record<string, unknown> {
+    if (value.$type === 'QuotedLiteral') {
+        const literalValue = String(value.value ?? '');
+        const langTag = literalLanguageTagFromTransport(value);
+        const datatypeIri = literalDatatypeIriFromTransport(ontology, value);
+        const literal: Record<string, unknown> = {
+            $type: 'QuotedLiteral',
+            value: literalValue,
+        };
+        if (langTag) {
+            literal.langTag = langTag;
+        }
+        if (datatypeIri && !isXsdStringDatatypeIri(ontology, datatypeIri)) {
+            literal.type = { $refText: toRefText(ontology, datatypeIri) };
+        }
+        return literal;
+    }
+    if (value.$type === 'BooleanLiteral') {
+        return {
+            $type: 'BooleanLiteral',
+            value: booleanLiteralValue(value.value),
+        };
+    }
+    const literal: Record<string, unknown> = {
+        $type: value.$type,
+        value: numericLiteralValue(value.$type, value.value),
+    };
+    const unitIri = literalUnitIriFromTransport(ontology, value);
+    if (unitIri) {
+        literal.unit = { $refText: toRefText(ontology, unitIri) };
+    }
+    return literal;
+}
+
+function numericLiteralValue(type: 'DecimalLiteral' | 'DoubleLiteral' | 'IntegerLiteral', value: unknown): number {
+    const numberValue = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim().length > 0
+            ? Number(value.trim())
+            : Number.NaN;
+    if (!Number.isFinite(numberValue)) {
+        throw new Error(`${type} value must be a finite number.`);
+    }
+    if (type === 'IntegerLiteral' && !Number.isInteger(numberValue)) {
+        throw new Error('IntegerLiteral value must be an integer.');
+    }
+    return numberValue;
+}
+
+function booleanLiteralValue(value: unknown): boolean {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true') {
+            return true;
+        }
+        if (normalized === 'false') {
+            return false;
+        }
+    }
+    throw new Error('BooleanLiteral value must be true or false.');
+}
+
+async function ensureTypedLiteralDatatypeImport(
+    shared: any,
+    ontology: any,
+    value: unknown,
+    contexts?: ReadonlyMap<string, OntologyContext>
+): Promise<void> {
     if (isTypedQuotedLiteralTransport(value)) {
         const datatypeIri = literalDatatypeIriFromTransport(ontology, value);
         if (datatypeIri && !isXsdStringDatatypeIri(ontology, datatypeIri)) {
-            await ensureReferenceImport(shared, ontology, datatypeIri);
+            await ensureReferenceImport(shared, ontology, datatypeIri, contexts);
         }
     }
     if (isQuantityLiteralTransport(value)) {
         const unitIri = literalUnitIriFromTransport(ontology, value);
         if (unitIri) {
-            await ensureReferenceImport(shared, ontology, unitIri);
+            await ensureReferenceImport(shared, ontology, unitIri, contexts);
         }
     }
 }