fhirsmith 0.7.6 → 0.8.2

package/tx/ocl/cm-ocl.cjs

@@ -59,15 +59,19 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
       return await this.fetchConceptMapById(mappingId);
     }
 
-    const mappings = await this.#searchMappings({ from_source_url: url }, this.maxSearchPages);
-    for (const mapping of mappings) {
-      const cm = this.#toConceptMap(mapping);
-      if (cm) {
-        this.#indexConceptMap(cm);
-        if (cm.url === url && (!version || cm.version === version)) {
-          return cm;
+    try {
+      const mappings = await this.#searchMappings({ from_source_url: url }, this.maxSearchPages);
+      for (const mapping of mappings) {
+        const cm = this.#toConceptMap(mapping);
+        if (cm) {
+          this.#indexConceptMap(cm);
+          if (cm.url === url && (!version || cm.version === version)) {
+            return cm;
+          }
         }
       }
+    } catch (_err) {
+      // OCL API unreachable or returned error — treat as not found
     }
 
     return null;
@@ -87,45 +91,194 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
       return this._idMap.get(rawId);
     }
 
-    const response = await this.httpClient.get(`/mappings/${encodeURIComponent(rawId)}/`);
-    const cm = this.#toConceptMap(response.data);
-    if (!cm) {
+    try {
+      const response = await this.httpClient.get(`/mappings/${encodeURIComponent(rawId)}/`);
+      const cm = this.#toConceptMap(response.data);
+      if (!cm) {
+        return null;
+      }
+      this.#indexConceptMap(cm);
+      return cm;
+    } catch (_err) {
       return null;
     }
-    this.#indexConceptMap(cm);
-    return cm;
   }
 
-  // eslint-disable-next-line no-unused-vars
   async searchConceptMaps(searchParams, _elements) {
     this._validateSearchParams(searchParams);
 
-    const params = Object.fromEntries(searchParams.map(({ name, value }) => [name, String(value).toLowerCase()]));
-    const oclParams = {};
+    const params = Object.fromEntries(
+      searchParams.map(({ name, value }) => [name, String(value).toLowerCase()])
+    );
+    const sourceSystem = params['source-system'] || params.source || null;
+    const targetSystem = params['target-system'] || params.target || null;
 
-    if (params.source) {
-      oclParams.from_source_url = params.source;
+    // Without a source or target filter the search would have to fetch every
+    // mapping in the organisation — too expensive.  Return empty so the
+    // Package providers can still answer generic ConceptMap listings.
+    if (!sourceSystem && !targetSystem) {
+      return [];
+    }
+
+    try {
+      const allMappings = await this.#collectMappingsForSearch(sourceSystem, targetSystem);
+      return this.#aggregateMappingsToConceptMaps(allMappings);
+    } catch (_err) {
+      return [];
     }
-    if (params.target) {
-      oclParams.to_source_url = params.target;
+  }
+
+  async #collectMappingsForSearch(sourceSystem, targetSystem) {
+    const systemUrl = sourceSystem || targetSystem;
+    const candidates = await this.#candidateSourceUrls(systemUrl);
+    const sourcePaths = candidates.filter(s => String(s || '').startsWith('/orgs/'));
+
+    if (sourcePaths.length === 0) {
+      return [];
     }
 
-    const mappings = await this.#searchMappings(oclParams, this.maxSearchPages);
-    const results = [];
+    const allMappings = [];
+    for (const sourcePath of sourcePaths) {
+      const normalizedPath = this.#normalizeSourcePath(sourcePath);
+      let concepts;
+      try {
+        concepts = await this.#fetchAllPages(
+          `${normalizedPath}concepts/`, { limit: PAGE_SIZE }, this.maxSearchPages
+        );
+      } catch (_err) {
+        continue;
+      }
+
+      for (const concept of concepts) {
+        const code = concept.id || concept.mnemonic;
+        if (!code) {
+          continue;
+        }
+        try {
+          const mappings = await this.#fetchAllPages(
+            `${normalizedPath}concepts/${encodeURIComponent(code)}/mappings/`,
+            { limit: PAGE_SIZE }, 2
+          );
+          allMappings.push(...mappings);
+        } catch (_err) {
+          // concept has no mappings or endpoint inaccessible — skip
+        }
+      }
+    }
+
+    const sourceUrlsToResolve = new Set();
+    for (const m of allMappings) {
+      const from = m?.from_source_url || m?.fromSourceUrl;
+      const to = m?.to_source_url || m?.toSourceUrl;
+      if (from) sourceUrlsToResolve.add(from);
+      if (to) sourceUrlsToResolve.add(to);
+    }
+    await this.#ensureCanonicalForSourceUrls(sourceUrlsToResolve);
+
+    return allMappings;
+  }
+
+  #aggregateMappingsToConceptMaps(mappings) {
+    const groups = new Map();
+
     for (const mapping of mappings) {
-      const cm = this.#toConceptMap(mapping);
-      if (!cm) {
+      const fromSource = mapping.from_source_url || mapping.fromSourceUrl || null;
+      const toSource = mapping.to_source_url || mapping.toSourceUrl || null;
+      const sourceCode = mapping.from_concept_code || mapping.fromConceptCode;
+      const targetCode = mapping.to_concept_code || mapping.toConceptCode;
+
+      if (!fromSource || !toSource || !sourceCode || !targetCode) {
         continue;
       }
-      this.#indexConceptMap(cm);
-      if (this.#matches(cm.jsonObj, params)) {
-        results.push(cm);
+
+      const sourceCanonical = this.#canonicalForSourceUrl(fromSource) || fromSource;
+      const targetCanonical = this.#canonicalForSourceUrl(toSource) || toSource;
+      const groupKey = `${this.#norm(sourceCanonical)}|${this.#norm(targetCanonical)}`;
+
+      if (!groups.has(groupKey)) {
+        groups.set(groupKey, {
+          sourceCanonical, targetCanonical, elements: new Map(), lastUpdated: null
+        });
+      }
+
+      const group = groups.get(groupKey);
+      const ts = this.#toIsoDate(
+        mapping.updated_on || mapping.updatedOn || mapping.updated_at || mapping.updatedAt
+      );
+      if (ts && (!group.lastUpdated || ts > group.lastUpdated)) {
+        group.lastUpdated = ts;
+      }
+
+      if (!group.elements.has(sourceCode)) {
+        group.elements.set(sourceCode, {
+          code: sourceCode,
+          display: mapping.from_concept_name_resolved || mapping.fromConceptNameResolved
+                || mapping.from_concept_name || mapping.fromConceptName || null,
+          targets: []
+        });
+      }
+
+      group.elements.get(sourceCode).targets.push({
+        code: targetCode,
+        display: mapping.to_concept_name_resolved || mapping.toConceptNameResolved
+              || mapping.to_concept_name || mapping.toConceptName || null,
+        relationship: this.#toRelationship(mapping.map_type || mapping.mapType),
+        comment: mapping.comment || null
+      });
+    }
+
+    const results = [];
+    for (const [, group] of groups) {
+      const sourceId = this.#lastSegment(group.sourceCanonical);
+      const targetId = this.#lastSegment(group.targetCanonical);
+      const id = `${sourceId}-to-${targetId}`;
+
+      const elements = [];
+      for (const [, el] of group.elements) {
+        elements.push({ code: el.code, display: el.display, target: el.targets });
+      }
+
+      const json = {
+        resourceType: 'ConceptMap',
+        id,
+        url: `${this.baseUrl}/ConceptMap/${id}`,
+        name: id,
+        title: `${sourceId} to ${targetId}`,
+        status: 'active',
+        sourceScopeUri: group.sourceCanonical,
+        targetScopeUri: group.targetCanonical,
+        group: [{
+          source: group.sourceCanonical,
+          target: group.targetCanonical,
+          element: elements
+        }]
+      };
+      if (group.lastUpdated) {
+        json.meta = { lastUpdated: group.lastUpdated };
       }
+
+      const cm = new ConceptMap(json, 'R5');
+      this.#indexConceptMap(cm);
+      results.push(cm);
     }
     return results;
   }
 
+  #lastSegment(canonical) {
+    const raw = String(canonical || '').trim().replace(/\/+$/, '');
+    const slash = raw.lastIndexOf('/');
+    return slash >= 0 && slash < raw.length - 1 ? raw.substring(slash + 1) : raw;
+  }
+
   async findConceptMapForTranslation(opContext, conceptMaps, sourceSystem, sourceScope, targetScope, targetSystem, sourceCode = null) {
+    try {
+      await this.#doFindConceptMapForTranslation(opContext, conceptMaps, sourceSystem, sourceScope, targetScope, targetSystem, sourceCode);
+    } catch (_err) {
+      // OCL API errors must not break $translate for other providers
+    }
+  }
+
+  async #doFindConceptMapForTranslation(opContext, conceptMaps, sourceSystem, sourceScope, targetScope, targetSystem, sourceCode) {
     const sourceCandidates = await this.#candidateSourceUrls(sourceSystem);
     const targetCandidates = await this.#candidateSourceUrls(targetSystem);
 
@@ -135,8 +288,12 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
     if (sourceCode && sourcePaths.length > 0) {
       for (const sourcePath of sourcePaths) {
         const conceptPath = `${this.#normalizeSourcePath(sourcePath)}concepts/${encodeURIComponent(sourceCode)}/mappings/`;
-        const found = await this.#fetchAllPages(conceptPath, { limit: PAGE_SIZE }, Math.min(2, this.maxSearchPages));
-        mappings.push(...found);
+        try {
+          const found = await this.#fetchAllPages(conceptPath, { limit: PAGE_SIZE }, Math.min(2, this.maxSearchPages));
+          mappings.push(...found);
+        } catch (_err) {
+          // concept not found or mappings endpoint unavailable
+        }
       }
     }
 
@@ -311,43 +468,6 @@ class OCLConceptMapProvider extends AbstractConceptMapProvider {
     }
   }
 
-  #matches(json, params) {
-    for (const [name, value] of Object.entries(params)) {
-      if (!value) {
-        continue;
-      }
-
-      if (name === 'url') {
-        if ((json.url || '').toLowerCase() !== value) {
-          return false;
-        }
-        continue;
-      }
-
-      if (name === 'source') {
-        const src = json.group?.[0]?.source || '';
-        if (!src.toLowerCase().includes(value)) {
-          return false;
-        }
-        continue;
-      }
-
-      if (name === 'target') {
-        const tgt = json.group?.[0]?.target || '';
-        if (!tgt.toLowerCase().includes(value)) {
-          return false;
-        }
-        continue;
-      }
-
-      const field = json[name];
-      if (field == null || !String(field).toLowerCase().includes(value)) {
-        return false;
-      }
-    }
-    return true;
-  }
-
   async #searchMappings(params = {}, maxPages = this.maxSearchPages) {
     const endpoint = this.org ? `/orgs/${encodeURIComponent(this.org)}/mappings/` : '/mappings/';
     return await this.#fetchAllPages(endpoint, params, maxPages);

package/tx/ocl/cs-ocl.cjs

@@ -48,6 +48,8 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
     this._pendingChanges = null;
     this._initialized = false;
     this._initializePromise = null;
+    this._organizationIdsCache = null;
+    this._organizationIdsFetchPromise = null;
   }
 
   async initialize() {
@@ -206,35 +208,54 @@ class OCLCodeSystemProvider extends AbstractCodeSystemProvider {
   }
 
   async #fetchOrganizationIds() {
-    const endpoint = '/orgs/';
-    const orgs = await this.#fetchAllPages(endpoint);
+    // Return cached result if available
+    if (this._organizationIdsCache) {
+      return this._organizationIdsCache;
+    }
 
-    const ids = [];
-    const seen = new Set();
-    for (const org of orgs || []) {
-      if (!org || typeof org !== 'object') {
-        continue;
-      }
+    // Deduplicate concurrent requests
+    if (this._organizationIdsFetchPromise) {
+      return this._organizationIdsFetchPromise;
+    }
 
-      const id = org.id || org.mnemonic || org.short_code || org.shortCode || org.name || null;
-      if (!id) {
-        continue;
+    this._organizationIdsFetchPromise = (async () => {
+      const endpoint = '/orgs/';
+      const orgs = await this.#fetchAllPages(endpoint);
+
+      const ids = [];
+      const seen = new Set();
+      for (const org of orgs || []) {
+        if (!org || typeof org !== 'object') {
+          continue;
+        }
+
+        const id = org.id || org.mnemonic || org.short_code || org.shortCode || org.name || null;
+        if (!id) {
+          continue;
+        }
+
+        const normalized = String(id).trim();
+        if (!normalized || seen.has(normalized)) {
+          continue;
+        }
+
+        seen.add(normalized);
+        ids.push(normalized);
       }
 
-      const normalized = String(id).trim();
-      if (!normalized || seen.has(normalized)) {
-        continue;
+      if (ids.length === 0 && this.org) {
+        ids.push(this.org);
       }
 
-      seen.add(normalized);
-      ids.push(normalized);
-    }
+      this._organizationIdsCache = ids;
+      return ids;
+    })();
 
-    if (ids.length === 0 && this.org) {
-      ids.push(this.org);
+    try {
+      return await this._organizationIdsFetchPromise;
+    } finally {
+      this._organizationIdsFetchPromise = null;
     }
-
-    return ids;
   }
 
   #sourceIdentity(source) {
@@ -673,16 +694,33 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
   async designations(code, displays) {
     const ctxt = await this.#ensureContext(code);
     if (ctxt && ctxt.display) {
-      const hasConceptDesignations = Array.isArray(ctxt.designations) && ctxt.designations.length > 0;
+      const hasConceptDesignations = Array.isArray(ctxt.designation) && ctxt.designation.length > 0;
       if (hasConceptDesignations) {
-        for (const d of ctxt.designations) {
+        let hasNoLanguageEntry = false;
+        for (const d of ctxt.designation) {
           if (!d || !d.value) {
             continue;
           }
           displays.addDesignation(true, 'active', d.language || '', CodeSystem.makeUseForDisplay(), d.value);
+          if (!d.language) {
+            hasNoLanguageEntry = true;
+          }
+        }
+        // Guarantee a language-neutral fallback so preferredDesignation() always returns
+        // a display value when the requested language has no matching designation.
+        // This implements the FHIR graceful-fallback rule for displayLanguage.
+        if (!hasNoLanguageEntry) {
+          displays.addDesignation(true, 'active', '', CodeSystem.makeUseForDisplay(), ctxt.display);
         }
       } else {
-        displays.addDesignation(true, 'active', 'en', CodeSystem.makeUseForDisplay(), ctxt.display);
+        // No structured designations available. Use the source's configured language
+        // rather than hard-coding 'en' to avoid mislabeling non-English displays as English.
+        const defaultLang = this.meta?.codeSystem?.jsonObj?.language || '';
+        displays.addDesignation(true, 'active', defaultLang, CodeSystem.makeUseForDisplay(), ctxt.display);
+        // Also provide a no-language fallback for graceful language resolution.
+        if (defaultLang) {
+          displays.addDesignation(true, 'active', '', CodeSystem.makeUseForDisplay(), ctxt.display);
+        }
       }
       this._listSupplementDesignations(ctxt.code, displays);
     }
@@ -914,7 +952,7 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
     if (!this.meta.conceptsUrl) {
       return [];
     }
-    const cacheKey = `${this.meta.conceptsUrl}|p=${page}|l=${CONCEPT_PAGE_SIZE}`;
+    const cacheKey = `${this.meta.conceptsUrl}|p=${page}|l=${CONCEPT_PAGE_SIZE}|verbose=1`;
     if (this.pageCache.has(cacheKey)) {
       const cached = this.pageCache.get(cacheKey);
       return Array.isArray(cached)
@@ -939,7 +977,7 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
     const pending = (async () => {
       let response;
       try {
-        response = await this.httpClient.get(this.meta.conceptsUrl, { params: { page, limit: CONCEPT_PAGE_SIZE } });
+        response = await this.httpClient.get(this.meta.conceptsUrl, { params: { page, limit: CONCEPT_PAGE_SIZE, verbose: true } });
       } catch (error) {
         // Some OCL instances return 404 for sources without concept listing endpoints.
         // Treat this as an empty page so terminology operations degrade gracefully.
@@ -998,7 +1036,7 @@ class OCLSourceCodeSystemProvider extends CodeSystemProvider {
     const pending = (async () => {
       let response;
       try {
-        response = await this.httpClient.get(url);
+        response = await this.httpClient.get(url, { params: { verbose: true } });
       } catch (error) {
         // Missing concept should be treated as not-found, not as an internal server failure.
         if (error && error.response && error.response.status === 404) {
@@ -1302,7 +1340,6 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
 
       this.#applyConceptsToCodeSystemResource(this.meta?.codeSystem || null);
 
-      console.log(`[OCL] Loaded CodeSystem from cold cache: ${canonicalUrl} (${cached.concepts.length} concepts, fingerprint=${this.customFingerprint?.substring(0, 8)})`);
     } catch (error) {
       if (error.code !== 'ENOENT') {
         console.error(`[OCL] Failed to load cold cache for CodeSystem ${canonicalUrl}:`, error.message);
@@ -1329,7 +1366,6 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
       };
 
       await fs.writeFile(cacheFilePath, JSON.stringify(cacheData, null, 2), 'utf-8');
-      console.log(`[OCL] Saved CodeSystem to cold cache: ${canonicalUrl} (${concepts.length} concepts, fingerprint=${fingerprint?.substring(0, 8)})`);
       
       return fingerprint;
     } catch (error) {
@@ -1343,7 +1379,6 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
     const key = `${normalizedSystem}|${version || ''}`;
     const factory = OCLSourceCodeSystemFactory.#findFactory(normalizedSystem, version);
     if (!factory) {
-      console.log(`[OCL] CodeSystem load not scheduled (factory unavailable): ${key}`);
       return false;
     }
     factory.scheduleBackgroundLoad(reason);
@@ -1412,7 +1447,6 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
     }
 
     if (cacheAgeMs != null && cacheAgeMs < COLD_CACHE_FRESHNESS_MS) {
-      console.log(`[OCL] Skipping warm-up for CodeSystem ${this.system()} (cold cache age: ${formatCacheAgeMinutes(cacheAgeMs)})`);
       return;
     }
 
@@ -1420,12 +1454,10 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
     const jobKey = `cs:${key}`;
 
     if (OCLBackgroundJobQueue.isQueuedOrRunning(jobKey)) {
-      console.log(`[OCL] CodeSystem load already queued or running: ${key}`);
       return;
     }
 
     let queuedJobSize = null;
-    console.log(`[OCL] CodeSystem load enqueued: ${key} (${reason})`);
     OCLBackgroundJobQueue.enqueue(
       jobKey,
       'CodeSystem load',
@@ -1444,7 +1476,6 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
   }
 
   async #runBackgroundLoad(key, knownConceptCount = null) {
-    console.log(`[OCL] CodeSystem load started: ${key}`);
     try {
       this.backgroundLoadProgress = { processed: 0, total: null };
       const resolvedTotal = Number.isFinite(knownConceptCount) && knownConceptCount >= 0
@@ -1470,16 +1501,7 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
       const allConcepts = Array.from(this.sharedConceptCache.values());
       const newFingerprint = computeCodeSystemFingerprint(allConcepts);
       
-      if (this.customFingerprint && newFingerprint === this.customFingerprint) {
-        console.log(`[OCL] CodeSystem fingerprint unchanged: ${key} (fingerprint=${newFingerprint?.substring(0, 8)})`);
-      } else {
-        if (this.customFingerprint) {
-          console.log(`[OCL] CodeSystem fingerprint changed: ${key} (${this.customFingerprint?.substring(0, 8)} -> ${newFingerprint?.substring(0, 8)})`);
-          console.log(`[OCL] Replacing cold cache with new hot cache: ${key}`);
-        } else {
-          console.log(`[OCL] Computed fingerprint for CodeSystem: ${key} (fingerprint=${newFingerprint?.substring(0, 8)})`);
-        }
-        
+      if (!this.customFingerprint || newFingerprint !== this.customFingerprint) {
         // Save to cold cache
         const savedFingerprint = await this.#saveColdCache(allConcepts);
         if (savedFingerprint) {
@@ -1487,10 +1509,7 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
         }
       }
 
-      console.log(`[OCL] CodeSystem load completed, marked content=complete: ${key}`);
-      const progress = OCLSourceCodeSystemFactory.loadProgress();
-      console.log(`[OCL] CodeSystem load completed: ${this.system()}. Loaded ${progress.loaded}/${progress.total} CodeSystems (${progress.percentage.toFixed(2)}%)`);
-      console.log(`[OCL] CodeSystem now available in cache: ${key} (${count} concepts)`);
+      console.log(`[OCL] CodeSystem loaded: ${this.system()} (${count} concepts)`);
     } catch (error) {
       console.error(`[OCL] CodeSystem background load failed: ${key}: ${error.message}`);
     }
@@ -1525,7 +1544,7 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
   }
 
   async #fetchAndCacheConceptPage(page) {
-    const cacheKey = `${this.meta.conceptsUrl}|p=${page}|l=${CONCEPT_PAGE_SIZE}`;
+    const cacheKey = `${this.meta.conceptsUrl}|p=${page}|l=${CONCEPT_PAGE_SIZE}|verbose=1`;
     if (this.sharedPageCache.has(cacheKey)) {
       const cached = this.sharedPageCache.get(cacheKey);
       const concepts = Array.isArray(cached)
@@ -1544,7 +1563,7 @@ class OCLSourceCodeSystemFactory extends CodeSystemFactoryProvider {
     const pending = (async () => {
       let response;
       try {
-        response = await this.httpClient.get(this.meta.conceptsUrl, { params: { page, limit: CONCEPT_PAGE_SIZE } });
+        response = await this.httpClient.get(this.meta.conceptsUrl, { params: { page, limit: CONCEPT_PAGE_SIZE, verbose: true } });
       } catch (error) {
         if (error && error.response && error.response.status === 404) {
           this.sharedPageCache.set(cacheKey, []);

package/tx/ocl/jobs/background-queue.cjs

@@ -34,7 +34,6 @@ class OCLBackgroundJobQueue {
       };
       this.#insertPendingJobOrdered(job);
       this.ensureHeartbeatRunning();
-      console.log(`[OCL] ${jobType || 'Background job'} enqueued: ${jobKey} (size=${normalizedSize}, queue=${this.pendingJobs.length}, active=${this.activeCount})`);
       this.processNext();
     };
 
@@ -77,7 +76,6 @@ class OCLBackgroundJobQueue {
     // Prioridade máxima para userRequested
     if (job.userRequested) {
       this.pendingJobs.unshift(job);
-      console.log(`[OCL] User-requested job prioritized: ${job.jobKey}`);
       return;
     }
     let index = this.pendingJobs.findIndex(existing => {
@@ -179,13 +177,8 @@ class OCLBackgroundJobQueue {
         getProgress: job.getProgress || null,
         startedAt: Date.now()
       });
-      console.log(`[OCL] Background job started: ${job.jobType} ${job.jobKey} (size=${job.jobSize}, queue=${this.pendingJobs.length}, active=${this.activeCount})`);
-
       Promise.resolve()
         .then(() => job.runJob())
-        .then(() => {
-          console.log(`[OCL] Background job completed: ${job.jobType} ${job.jobKey}`);
-        })
         .catch((error) => {
           const message = error && error.message ? error.message : String(error);
           console.error(`[OCL] Background job failed: ${job.jobType} ${job.jobKey}: ${message}`);
@@ -194,7 +187,6 @@ class OCLBackgroundJobQueue {
           this.activeCount -= 1;
           this.queuedOrRunningKeys.delete(job.jobKey);
           this.activeJobs.delete(job.jobKey);
-          console.log(`[OCL] Background queue status: queue=${this.pendingJobs.length}, active=${this.activeCount}`);
           this.processNext();
         });
     }

package/tx/ocl/mappers/concept-mapper.cjs

@@ -13,13 +13,14 @@ function toConceptContext(concept) {
     display: concept.display_name || concept.display || concept.name || null,
     definition: concept.description || concept.definition || null,
     retired: concept.retired === true,
-    designations: extractDesignations(concept)
+      designation: extractDesignations(concept)
   };
 }
 
 function extractDesignations(concept) {
   const result = [];
   const seen = new Set();
+  const seenValues = new Set();
 
   const add = (language, value) => {
     const text = typeof value === 'string' ? value.trim() : '';
@@ -28,12 +29,19 @@ function extractDesignations(concept) {
     }
 
     const lang = typeof language === 'string' ? language.trim() : '';
+
+    // Skip empty-language entries whose value already appears under any language
+    if (!lang && seenValues.has(text)) {
+      return;
+    }
+
     const key = `${lang}|${text}`;
     if (seen.has(key)) {
       return;
     }
 
     seen.add(key);
+    seenValues.add(text);
     result.push({ language: lang, value: text });
   };
 
@@ -42,8 +50,10 @@ function extractDesignations(concept) {
       if (!entry || typeof entry !== 'object') {
         continue;
       }
-
-      add(entry.locale || entry.language || entry.lang || '', entry.name || entry.display_name || entry.display || entry.value || entry.term);
+      // Prioriza locale como language
+      const lang = entry.locale;
+      const value = entry.name;
+      add(lang, value);
     }
   }
 

package/tx/ocl/shared/patches.cjs

@@ -253,6 +253,7 @@ function patchValueSetExpandWholeSystemForOcl() {
   });
 }
 
+
 module.exports = {
   patchSearchWorkerForOCLCodeFiltering,
   ensureTxParametersHashIncludesFilter,