@c-rex/services 0.3.0-build.39 → 0.3.0-build.41

package/dist/read-models/index.js

@@ -22,7 +22,10 @@ var read_models_exports = {};
 __export(read_models_exports, {
   INFORMATION_UNIT_PROPERTY_PRESENTATION: () => INFORMATION_UNIT_PROPERTY_PRESENTATION,
   METADATA_VIEW_PROFILES: () => METADATA_VIEW_PROFILES,
+  METADATA_VISIBILITY_POLICY: () => METADATA_VISIBILITY_POLICY,
   READMODEL_CACHE_POLICY: () => READMODEL_CACHE_POLICY,
+  buildMetadataDisplayRows: () => buildMetadataDisplayRows,
+  clearMetadataCacheFamilyRuntimeSuppression: () => clearMetadataCacheFamilyRuntimeSuppression,
   getApplicableForTypes: () => getApplicableForTypes,
   getAvailableLanguagesByVersionOf: () => getAvailableLanguagesByVersionOf,
   getComponents: () => getComponents,
@@ -30,8 +33,10 @@ __export(read_models_exports, {
   getDocumentTypes: () => getDocumentTypes,
   getFunctionalMetadata: () => getFunctionalMetadata,
   getInformationSubjects: () => getInformationSubjects,
+  getMetadataCacheFamily: () => getMetadataCacheFamily,
   getMetadataDisplayRows: () => getMetadataDisplayRows,
   getMetadataFacetLabelOverrides: () => getMetadataFacetLabelOverrides,
+  getMetadataFacetPresentation: () => getMetadataFacetPresentation,
   getMetadataPropertyResolvers: () => getMetadataPropertyResolvers,
   getParties: () => getParties,
   getPlanningTimes: () => getPlanningTimes,
@@ -40,15 +45,26 @@ __export(read_models_exports, {
   getProductMetadata: () => getProductMetadata,
   getProductVariants: () => getProductVariants,
   getQualifications: () => getQualifications,
+  getRuntimeSuppressedMetadataFamilies: () => getRuntimeSuppressedMetadataFamilies,
   getSupplies: () => getSupplies,
   getTopicTypes: () => getTopicTypes,
+  isMetadataGroupDenied: () => isMetadataGroupDenied,
+  isMetadataPropertyRuntimeSuppressed: () => isMetadataPropertyRuntimeSuppressed,
+  resetRuntimeSuppressedMetadataFamiliesForTests: () => resetRuntimeSuppressedMetadataFamiliesForTests,
+  resolveFacetPresentationProperties: () => resolveFacetPresentationProperties,
   resolveFacetTags: () => resolveFacetTags,
-  resolveMetadataDisplayProperties: () => resolveMetadataDisplayProperties
+  resolveLiteralLabel: () => resolveLiteralLabel,
+  resolveMetadataDisplayProperties: () => resolveMetadataDisplayProperties,
+  resolveObjectRefClassLabel: () => resolveObjectRefClassLabel,
+  resolveObjectRefLabel: () => resolveObjectRefLabel,
+  resolveOverrideProperties: () => resolveOverrideProperties,
+  suppressMetadataCacheFamilyRuntime: () => suppressMetadataCacheFamilyRuntime
 });
 module.exports = __toCommonJS(read_models_exports);
 
 // src/read-models/metadata-read-models.ts
 var import_requests2 = require("@c-rex/core/requests");
+var import_logger = require("@c-rex/core/logger");
 var import_cache = require("next/cache");
 
 // src/base-server-request.ts
@@ -172,7 +188,106 @@ var READMODEL_CACHE_POLICY = {
   )
 };
 
+// src/read-models/metadata-visibility-policy.ts
+var CONTENT_LICENSE_CLASS_ID = "https://ids.c-crex.net/ns/iirds/ext#ContentLicense";
+var METADATA_VISIBILITY_POLICY = {
+  parties: {
+    cacheFamily: "parties"
+  },
+  components: {
+    cacheFamily: "components"
+  },
+  informationSubjects: {
+    cacheFamily: "informationSubjects"
+  },
+  topicTypes: {
+    cacheFamily: "topicTypes"
+  },
+  documentTypes: {
+    cacheFamily: "documentTypes"
+  },
+  contentLifeCycleStatus: {
+    cacheFamily: "contentLifeCycleStatus"
+  },
+  applicableForTypes: {
+    cacheFamily: "documentTypes"
+  },
+  planningTimes: {
+    cacheFamily: "planningTimes"
+  },
+  functionalMetadata: {
+    cacheFamily: "functionalMetadata"
+  },
+  productFeatures: {
+    cacheFamily: "productFeatures"
+  },
+  productLifeCyclePhases: {
+    cacheFamily: "productLifeCyclePhases"
+  },
+  productMetadata: {
+    cacheFamily: "productMetadata"
+  },
+  productVariants: {
+    cacheFamily: "productVariants"
+  },
+  qualifications: {
+    cacheFamily: "qualifications",
+    deniedClassIds: [CONTENT_LICENSE_CLASS_ID]
+  },
+  supplies: {
+    cacheFamily: "supplies"
+  }
+};
+var runtimeSuppressedFamilies = /* @__PURE__ */ new Map();
+var getMetadataCacheFamily = (property) => METADATA_VISIBILITY_POLICY[property]?.cacheFamily;
+var isMetadataGroupDenied = (property, options) => {
+  const policy = METADATA_VISIBILITY_POLICY[property];
+  const classId = options.classId?.trim();
+  const partyRoleId = options.partyRoleId?.trim();
+  if (classId && policy?.deniedClassIds?.includes(classId)) {
+    return true;
+  }
+  if (partyRoleId && policy?.deniedPartyRoleIds?.includes(partyRoleId)) {
+    return true;
+  }
+  return false;
+};
+var suppressMetadataCacheFamilyRuntime = (family, entry) => {
+  runtimeSuppressedFamilies.set(family, {
+    family,
+    reason: "cache-overflow",
+    bytes: entry.bytes,
+    limitBytes: entry.limitBytes,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
+var clearMetadataCacheFamilyRuntimeSuppression = (family) => {
+  runtimeSuppressedFamilies.delete(family);
+};
+var isMetadataPropertyRuntimeSuppressed = (property) => {
+  const family = getMetadataCacheFamily(property);
+  return family ? runtimeSuppressedFamilies.has(family) : false;
+};
+var getRuntimeSuppressedMetadataFamilies = () => Array.from(runtimeSuppressedFamilies.values());
+var resetRuntimeSuppressedMetadataFamiliesForTests = () => {
+  runtimeSuppressedFamilies.clear();
+};
+
 // src/read-models/metadata-read-models.ts
+var DEFAULT_METADATA_CACHE_MAX_BYTES = 15e5;
+var resolveMetadataCacheMaxBytes = () => {
+  const value = Number(process.env.CREX_CACHE_METADATA_MAX_BYTES);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_METADATA_CACHE_MAX_BYTES;
+};
+var measureSerializedBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+var logCacheOverflow = async (family, bytes, limitBytes, cacheKey) => {
+  const logger = new import_logger.CrexLogger();
+  await logger.log({
+    level: "warning",
+    category: "Scenario",
+    message: `[MetadataCacheOverflow] family=${family} bytes=${bytes} limitBytes=${limitBytes} cacheKey=${cacheKey}`
+  });
+};
 var resolveLocalizedLabel = (labels, uiLanguage) => {
   if (!labels || labels.length === 0) return void 0;
   const normalizedUiLanguage = uiLanguage.trim().toLowerCase();
@@ -231,12 +346,39 @@ var toEntityRef = (entity, uiLanguage) => {
   const label = resolveLocalizedLabel(entity.labels || [], uiLanguage) || entity.shortId?.trim() || id;
   return { id, shortId: entity.shortId?.trim() || void 0, label };
 };
-var toClassRef = (classRef, uiLanguage) => {
+var toClassRef = (classRef, uiLanguage, classLabelsById) => {
   const id = classRef?.id?.trim();
   if (!id) return void 0;
-  const label = resolveLocalizedLabel(classRef?.labels || [], uiLanguage) || classRef?.shortId?.trim() || id;
+  const label = resolveLocalizedLabel(classRef?.labels || [], uiLanguage) || classLabelsById?.[id] || classRef?.shortId?.trim() || id;
   return { id, shortId: classRef?.shortId?.trim() || void 0, label };
 };
+var isNotFoundError = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.message.includes("HTTP error! status: 404");
+};
+var resolveMissingClassLabels = async (items, uiLanguage) => {
+  const classIds = Array.from(new Set(
+    items.map((item) => item.class?.id?.trim()).filter((id) => Boolean(id)).filter((id) => !resolveLocalizedLabel(items.find((item) => item.class?.id?.trim() === id)?.class?.labels || [], uiLanguage))
+  ));
+  const result = {};
+  await Promise.all(classIds.map(async (classId) => {
+    try {
+      const entity = await withServerRequestContext(
+        { skipCookieTokenLookup: true },
+        () => domainEntitiesGetByIdServer({ id: classId }, { Fields: ["labels"] })
+      );
+      result[classId] = resolveLocalizedLabel(entity.labels || [], uiLanguage);
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+      result[classId] = void 0;
+    }
+  }));
+  return result;
+};
 var deriveParentIds = (entity) => {
   const directParents = (entity.parents || []).map((parent) => getRefId(parent)).filter((value) => Boolean(value));
   if (directParents.length > 0) {
@@ -245,10 +387,6 @@ var deriveParentIds = (entity) => {
   const ancestorParents = (entity.ancestors || []).map((path) => path[path.length - 1]).map((parent) => getRefId(parent)).filter((value) => Boolean(value));
   return Array.from(new Set(ancestorParents));
 };
-var deriveAncestorIds = (entity) => {
-  const ids = (entity.ancestors || []).flatMap((path) => path).map((item) => getRefId(item)).filter((value) => Boolean(value));
-  return Array.from(new Set(ids));
-};
 var buildTaxonomyTree = (items, options) => {
   const nodesById = {};
   const parentLinks = /* @__PURE__ */ new Map();
@@ -257,48 +395,13 @@ var buildTaxonomyTree = (items, options) => {
     if (!entityRef) continue;
     nodesById[entityRef.id] = {
       ...entityRef,
-      classRef: toClassRef(item.class, options.uiLanguage),
-      hasInformationUnits: item.hasInformationUnits === true || item.hasInformationUnitReferences === true,
-      parentIds: deriveParentIds(item),
-      ancestorIds: deriveAncestorIds(item),
-      children: []
+      classRef: toClassRef(item.class, options.uiLanguage, options.classLabelsById),
+      parentIds: deriveParentIds(item)
     };
   }
   Object.values(nodesById).forEach((node) => {
     parentLinks.set(node.id, node.parentIds.filter((id) => Boolean(nodesById[id])));
   });
-  if (options.includeOnlyUsed) {
-    const keepIds = new Set(
-      Object.values(nodesById).filter((node) => node.hasInformationUnits === true).map((node) => node.id)
-    );
-    let changed = true;
-    while (changed) {
-      changed = false;
-      Array.from(keepIds).forEach((nodeId) => {
-        const parentIds = parentLinks.get(nodeId) || [];
-        parentIds.forEach((parentId) => {
-          if (!keepIds.has(parentId)) {
-            keepIds.add(parentId);
-            changed = true;
-          }
-        });
-      });
-    }
-    Object.keys(nodesById).forEach((nodeId) => {
-      if (!keepIds.has(nodeId)) {
-        delete nodesById[nodeId];
-        parentLinks.delete(nodeId);
-      }
-    });
-  }
-  Object.values(nodesById).forEach((node) => {
-    const parents = parentLinks.get(node.id) || [];
-    parents.forEach((parentId) => {
-      if (nodesById[parentId]) {
-        nodesById[parentId].children.push(node);
-      }
-    });
-  });
   const roots = Object.values(nodesById).filter((node) => (parentLinks.get(node.id) || []).length === 0);
   if (!options.groupRootsByClass) {
     return {
@@ -308,13 +411,12 @@ var buildTaxonomyTree = (items, options) => {
     };
   }
   const groupedRoots = /* @__PURE__ */ new Map();
+  const groupedRootCounts = /* @__PURE__ */ new Map();
   const ungroupedRootId = "class:ungrouped";
   groupedRoots.set(ungroupedRootId, {
     id: ungroupedRootId,
     label: "Ungrouped",
     parentIds: [],
-    ancestorIds: [],
-    children: [],
     isVirtualGroup: true
   });
   roots.forEach((root) => {
@@ -325,17 +427,12 @@ var buildTaxonomyTree = (items, options) => {
         shortId: root.classRef?.shortId,
         label: root.classRef?.label || "Ungrouped",
         parentIds: [],
-        ancestorIds: [],
-        children: [],
         isVirtualGroup: true
       });
     }
-    groupedRoots.get(classId)?.children.push(root);
+    groupedRootCounts.set(classId, (groupedRootCounts.get(classId) || 0) + 1);
   });
-  const groupedRootNodes = Array.from(groupedRoots.values()).filter((group) => group.children.length > 0).map((group) => ({
-    ...group,
-    children: [...group.children].sort((a, b) => a.label.localeCompare(b.label))
-  })).sort((a, b) => a.label.localeCompare(b.label));
+  const groupedRootNodes = Array.from(groupedRoots.values()).filter((group) => (groupedRootCounts.get(group.id) || 0) > 0).sort((a, b) => a.label.localeCompare(b.label));
   return {
     roots: groupedRootNodes,
     nodesById,
@@ -348,15 +445,29 @@ var defaultTreeOptions = (uiLanguage) => ({
 });
 var createTaxonomyResolver = (options) => {
   const cached = (0, import_cache.unstable_cache)(
-    async (_queryKey, query, uiLanguage, readOptions) => {
+    async (_queryKey, query, uiLanguage) => {
       const items = await withServerRequestContext(
         { skipCookieTokenLookup: true },
         () => fetchAllPages(options.fetch, query)
       );
-      return buildTaxonomyTree(items, {
+      const classLabelsById = await resolveMissingClassLabels(items, uiLanguage);
+      const result = buildTaxonomyTree(items, {
         ...defaultTreeOptions(uiLanguage),
-        includeOnlyUsed: readOptions.includeOnlyUsed
+        classLabelsById
       });
+      const bytes = measureSerializedBytes(result);
+      const limitBytes = resolveMetadataCacheMaxBytes();
+      if (bytes > limitBytes) {
+        suppressMetadataCacheFamilyRuntime(options.cacheFamily, { bytes, limitBytes });
+        await logCacheOverflow(options.cacheFamily, bytes, limitBytes, options.cacheKey);
+        return {
+          roots: [],
+          nodesById: {},
+          generatedAt: result.generatedAt
+        };
+      }
+      clearMetadataCacheFamilyRuntimeSuppression(options.cacheFamily);
+      return result;
     },
     ["read-model", options.cacheKey],
     {
@@ -369,101 +480,116 @@ var createTaxonomyResolver = (options) => {
       ]
     }
   );
-  return async (query, readOptions) => {
+  return async (query) => {
     const uiLanguage = resolveUiLanguage();
     const normalizedQuery = { ...options.defaultQuery, ...query || {} };
-    const normalizedReadOptions = {
-      includeOnlyUsed: readOptions?.includeOnlyUsed === true
-    };
-    const cacheKey = stableSerialize({ normalizedQuery, uiLanguage, normalizedReadOptions });
-    return cached(cacheKey, normalizedQuery, uiLanguage, normalizedReadOptions);
+    const cacheKey = stableSerialize({ normalizedQuery, uiLanguage });
+    return cached(cacheKey, normalizedQuery, uiLanguage);
   };
 };
 var defaultMetadataQuery = {
   PageNumber: 1,
   PageSize: READMODEL_PAGE_SIZE,
-  Fields: ["labels", "class", "hasInformationUnits"],
+  Fields: ["labels", "class"],
   Sort: ["shortId"]
 };
 var getCategoriesCached = createTaxonomyResolver({
   cacheKey: "categories",
+  cacheFamily: "informationSubjects",
   tags: [import_requests2.CREX_READMODEL_CACHE_INFORMATION_SUBJECTS_TAG],
-  defaultQuery: defaultMetadataQuery,
+  defaultQuery: {
+    ...defaultMetadataQuery,
+    Fields: ["labels", "class", "parents", "ancestors", "ancestorsOrSelf"]
+  },
   fetch: categoriesGetAllServer
 });
 var getInformationSubjectsLegacyCached = createTaxonomyResolver({
   cacheKey: "information-subjects-legacy",
+  cacheFamily: "informationSubjects",
   tags: [import_requests2.CREX_READMODEL_CACHE_INFORMATION_SUBJECTS_TAG],
   defaultQuery: defaultMetadataQuery,
   fetch: informationSubjectsGetAllServer
 });
 var getDocumentTypesCached = createTaxonomyResolver({
   cacheKey: "document-types",
+  cacheFamily: "documentTypes",
   tags: [import_requests2.CREX_READMODEL_CACHE_DOCUMENT_TYPES_TAG],
   defaultQuery: defaultMetadataQuery,
   fetch: documentTypesGetAllServer
 });
 var getComponentsCached = createTaxonomyResolver({
   cacheKey: "components",
+  cacheFamily: "components",
   tags: [import_requests2.CREX_READMODEL_CACHE_COMPONENTS_TAG],
   defaultQuery: {
     ...defaultMetadataQuery,
-    Fields: ["labels", "class", "parents", "ancestors", "ancestorsOrSelf", "hasInformationUnits"]
+    Fields: ["labels", "class", "parents", "ancestors", "ancestorsOrSelf"]
   },
   fetch: componentsGetAllServer
 });
 var getTopicTypesCached = createTaxonomyResolver({
   cacheKey: "topic-types",
+  cacheFamily: "topicTypes",
   defaultQuery: defaultMetadataQuery,
   fetch: topicTypesGetAllServer
 });
 var getContentLifeCycleStatusCached = createTaxonomyResolver({
   cacheKey: "content-life-cycle-status",
+  cacheFamily: "contentLifeCycleStatus",
   defaultQuery: defaultMetadataQuery,
   fetch: contentLifeCycleStatusGetAllServer
 });
 var getApplicableForTypesCached = createTaxonomyResolver({
   cacheKey: "applicable-for-types",
+  cacheFamily: "documentTypes",
   defaultQuery: defaultMetadataQuery,
   fetch: informationTypesGetAllServer
 });
 var getPlanningTimesCached = createTaxonomyResolver({
   cacheKey: "planning-times",
+  cacheFamily: "planningTimes",
   defaultQuery: defaultMetadataQuery,
   fetch: planningTimesGetAllServer
 });
 var getFunctionalMetadataCached = createTaxonomyResolver({
   cacheKey: "functional-metadata",
+  cacheFamily: "functionalMetadata",
   defaultQuery: defaultMetadataQuery,
   fetch: functionalMetadatasGetAllServer
 });
 var getProductFeaturesCached = createTaxonomyResolver({
   cacheKey: "product-features",
+  cacheFamily: "productFeatures",
   defaultQuery: defaultMetadataQuery,
   fetch: productFeaturesGetAllServer
 });
 var getProductLifeCyclePhasesCached = createTaxonomyResolver({
   cacheKey: "product-life-cycle-phases",
+  cacheFamily: "productLifeCyclePhases",
   defaultQuery: defaultMetadataQuery,
   fetch: productLifeCyclePhasesGetAllServer
 });
 var getProductMetadataCached = createTaxonomyResolver({
   cacheKey: "product-metadata",
+  cacheFamily: "productMetadata",
   defaultQuery: defaultMetadataQuery,
   fetch: productMetadataGetAllServer
 });
 var getProductVariantsCached = createTaxonomyResolver({
   cacheKey: "product-variants",
+  cacheFamily: "productVariants",
   defaultQuery: defaultMetadataQuery,
   fetch: productVariantsGetAllServer
 });
 var getQualificationsCached = createTaxonomyResolver({
   cacheKey: "qualifications",
+  cacheFamily: "qualifications",
   defaultQuery: defaultMetadataQuery,
   fetch: qualificationsGetAllServer
 });
 var getSuppliesCached = createTaxonomyResolver({
   cacheKey: "supplies",
+  cacheFamily: "supplies",
   defaultQuery: defaultMetadataQuery,
   fetch: suppliesGetAllServer
 });
@@ -476,6 +602,18 @@ var toRoleRef = (party, uiLanguage) => {
     label: resolveLocalizedLabel(role?.labels || [], uiLanguage) || role?.shortId?.trim() || "Unknown role"
   };
 };
+var mergeRoleRef = (current, candidate) => {
+  if (current.id !== candidate.id) {
+    return current;
+  }
+  const preferCurrentLabel = current.label.trim().length > 0 && current.label !== "Unknown role";
+  const preferCurrentShortId = Boolean(current.shortId?.trim());
+  return {
+    id: current.id,
+    shortId: preferCurrentShortId ? current.shortId : candidate.shortId,
+    label: preferCurrentLabel ? current.label : candidate.label
+  };
+};
 var getPartiesCached = (0, import_cache.unstable_cache)(
   async (_queryKey, query, uiLanguage) => {
     const items = await withServerRequestContext(
@@ -487,15 +625,23 @@ var getPartiesCached = (0, import_cache.unstable_cache)(
       const id = party.id?.trim();
       if (!id) return;
       const role = toRoleRef(party, uiLanguage);
-      if (!groups.has(role.id)) {
+      const existingGroup = groups.get(role.id);
+      if (!existingGroup) {
         groups.set(role.id, { role, parties: [] });
+      } else {
+        const mergedRole = mergeRoleRef(existingGroup.role, role);
+        existingGroup.role = mergedRole;
+        existingGroup.parties.forEach((groupedParty) => {
+          groupedParty.role = mergedRole;
+        });
       }
       const label = resolveLocalizedLabel(party.labels || [], uiLanguage) || party.shortId?.trim() || id;
+      const resolvedRole = groups.get(role.id)?.role || role;
       groups.get(role.id)?.parties.push({
         id,
         shortId: party.shortId?.trim() || void 0,
         label,
-        role,
+        role: resolvedRole,
         vcardId: party.vcard?.id?.trim() || void 0
       });
     });
@@ -513,17 +659,19 @@ var getPartiesCached = (0, import_cache.unstable_cache)(
     tags: [import_requests2.CREX_API_CACHE_TAG, import_requests2.CREX_READMODEL_CACHE_TAG, import_requests2.CREX_READMODEL_CACHE_METADATA_TAG, import_requests2.CREX_READMODEL_CACHE_PARTIES_TAG]
   }
 );
-var getInformationSubjects = async (options) => {
-  const readOptions = { includeOnlyUsed: options?.includeOnlyUsed === true };
+var getInformationSubjects = async () => {
   try {
-    const categories = await getCategoriesCached(void 0, readOptions);
+    const categories = await getCategoriesCached();
+    if (isMetadataPropertyRuntimeSuppressed("informationSubjects")) {
+      return categories;
+    }
     if (categories.roots.length > 0) {
       return categories;
     }
   } catch (error) {
     console.warn("[MetadataReadModels] Categories endpoint unavailable, falling back to InformationSubjects.", error);
   }
-  return getInformationSubjectsLegacyCached(void 0, readOptions);
+  return getInformationSubjectsLegacyCached();
 };
 var getDocumentTypes = async () => {
   return getDocumentTypesCached();
@@ -537,8 +685,7 @@ var getParties = async () => {
     PageNumber: 1,
     PageSize: READMODEL_PAGE_SIZE,
     Fields: ["labels", "partyRole", "vcard", "class"],
-    Sort: ["shortId"],
-    Embed: ["vcard"]
+    Sort: ["shortId"]
   };
   return getPartiesCached(stableSerialize({ query, uiLanguage }), query, uiLanguage);
 };
@@ -737,8 +884,8 @@ var INFORMATION_UNIT_PROPERTY_PRESENTATION = {
   },
   applicableForTypes: {
     valueKind: "objectRefArray",
-    facet: { supported: true, sectionStrategy: "class" },
-    metadataDisplay: { supported: true, sectionStrategy: "class" }
+    facet: { supported: true, sectionStrategy: "none" },
+    metadataDisplay: { supported: true, sectionStrategy: "none" }
   },
   planningTimes: {
     valueKind: "objectRefArray",
@@ -795,23 +942,70 @@ var INFORMATION_UNIT_PROPERTY_PRESENTATION = {
 // src/read-models/metadata-presentation.ts
 var import_cache2 = require("next/cache");
 var import_requests3 = require("@c-rex/core/requests");
-var addTaxonomyNodeOverride = (node, map, sectionLabel) => {
-  if (!node.shortId) return;
-  map[node.shortId] = {
+var UNKNOWN_SECTION_LABELS = {
+  en: {
+    components: "Unknown component",
+    informationSubjects: "Unknown information subject",
+    topicTypes: "Unknown topic type",
+    documentTypes: "Unknown document type",
+    contentLifeCycleStatus: "Unknown content life cycle status",
+    applicableForTypes: "Unknown document type",
+    planningTimes: "Unknown planning time",
+    functionalMetadata: "Unknown functional metadata",
+    productFeatures: "Unknown product feature",
+    productLifeCyclePhases: "Unknown product life cycle phase",
+    productMetadata: "Unknown product metadata",
+    productVariants: "Unknown product variant",
+    qualifications: "Unknown qualification",
+    supplies: "Unknown supply"
+  },
+  de: {
+    components: "Unbekannte Komponente",
+    informationSubjects: "Unbekanntes Informationsthema",
+    topicTypes: "Unbekannter Topictyp",
+    documentTypes: "Unbekannte Dokumentart",
+    contentLifeCycleStatus: "Unbekannter Inhaltslebenszyklusstatus",
+    applicableForTypes: "Unbekannte Dokumentart",
+    planningTimes: "Unbekannte Planungszeit",
+    functionalMetadata: "Unbekannte funktionale Metadaten",
+    productFeatures: "Unbekanntes Produktmerkmal",
+    productLifeCyclePhases: "Unbekannte Produktlebenszyklusphase",
+    productMetadata: "Unbekannte Produktmetadaten",
+    productVariants: "Unbekannte Produktvariante",
+    qualifications: "Unbekannte Qualifikation",
+    supplies: "Unbekannter Lieferumfang"
+  }
+};
+var resolveUnknownSectionLabel = (property, uiLanguage) => {
+  const normalizedLanguage = uiLanguage.toLowerCase();
+  const baseLanguage = normalizedLanguage.split("-")[0];
+  return UNKNOWN_SECTION_LABELS[baseLanguage]?.[property] || UNKNOWN_SECTION_LABELS.en[property] || "Unknown metadata";
+};
+var addTaxonomyNodePresentation = (node, map, sectionLabel, options) => {
+  const presentation = {
     label: node.label,
-    sectionLabel
+    sectionLabel,
+    hidden: options?.hidden
   };
+  if (node.shortId) {
+    map[node.shortId] = presentation;
+  }
+  if (node.id) {
+    map[node.id] = presentation;
+  }
 };
-var createClassSectionOverrides = (nodes, options) => {
-  const overrides = {};
+var createClassSectionPresentation = (property, nodes, uiLanguage, options) => {
+  const presentation = {};
+  const unknownSectionLabel = resolveUnknownSectionLabel(property, uiLanguage);
   Object.values(nodes).forEach((node) => {
     const classId = node.classRef?.id?.trim();
-    const sectionLabel = node.classRef?.label || (classId ? options?.classLabelsById?.[classId] : void 0);
-    addTaxonomyNodeOverride(node, overrides, sectionLabel);
+    const hidden = isMetadataGroupDenied(property, { classId });
+    const sectionLabel = node.classRef?.label || (classId ? options?.classLabelsById?.[classId] : void 0) || unknownSectionLabel;
+    addTaxonomyNodePresentation(node, presentation, sectionLabel, { hidden });
   });
-  return overrides;
+  return presentation;
 };
-var resolveMissingClassLabels = async (nodes, uiLanguage) => {
+var resolveMissingClassLabels2 = async (nodes, uiLanguage) => {
   const classIds = Array.from(
     new Set(
       Object.values(nodes).map((node) => node.classRef?.id?.trim()).filter((value) => Boolean(value))
@@ -849,7 +1043,7 @@ var resolveLocalizedLabel2 = (labels, uiLanguage) => {
   if (english) return english;
   return normalized[0]?.value;
 };
-var isNotFoundError = (error) => {
+var isNotFoundError2 = (error) => {
   if (!(error instanceof Error)) {
     return false;
   }
@@ -866,7 +1060,7 @@ var getDomainEntitySectionLabelUncached = async (id, uiLanguage) => {
     );
     return resolveLocalizedLabel2(entity.labels || [], uiLanguage);
   } catch (error) {
-    if (isNotFoundError(error)) {
+    if (isNotFoundError2(error)) {
       return void 0;
     }
     throw error;
@@ -891,7 +1085,7 @@ var getDomainEntitySectionLabel = async (id, uiLanguage) => {
   inFlightDomainEntityLabelRequests.set(inFlightKey, promise);
   return promise;
 };
-var getMetadataFacetLabelOverrides = async (properties, uiLanguage = "en-US", options) => {
+var getMetadataFacetPresentation = async (properties, uiLanguage = "en-US", options) => {
   const defaultProperties = Object.keys(INFORMATION_UNIT_PROPERTY_PRESENTATION).filter((property) => INFORMATION_UNIT_PROPERTY_PRESENTATION[property].facet.supported);
   const propertySet = new Set(properties && properties.length > 0 ? properties : defaultProperties);
   const result = {};
@@ -899,7 +1093,10 @@ var getMetadataFacetLabelOverrides = async (properties, uiLanguage = "en-US", op
     components: getComponents,
     informationSubjects: getInformationSubjects,
     documentTypes: getDocumentTypes,
-    applicableForTypes: getApplicableForTypes,
+    // API facets for `applicableForTypes` contain document type refs.
+    // Resolve them through DocumentTypes so section labels come from the
+    // referenced object class instead of the predicate label.
+    applicableForTypes: getDocumentTypes,
     planningTimes: getPlanningTimes,
     functionalMetadata: getFunctionalMetadata,
     contentLifeCycleStatus: getContentLifeCycleStatus,
@@ -917,43 +1114,56 @@ var getMetadataFacetLabelOverrides = async (properties, uiLanguage = "en-US", op
     const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[property];
     if (!config?.facet.supported) continue;
     if (config.facet.sectionStrategy === "partyRole" && property === "parties") {
+      if (isMetadataPropertyRuntimeSuppressed("parties")) {
+        continue;
+      }
       partiesTask = (async () => {
         const parties = await getParties();
-        const partyOverrides = {};
+        const partyPresentation = {};
         parties.groups.forEach((group) => {
+          const hidden = isMetadataGroupDenied("parties", { partyRoleId: group.role.id });
           const sectionLabel = group.role.label;
           group.parties.forEach((party) => {
             if (!party.shortId) return;
-            partyOverrides[party.shortId] = {
+            partyPresentation[party.shortId] = {
               label: party.label,
-              sectionLabel
+              sectionLabel,
+              hidden
             };
+            if (party.id) {
+              partyPresentation[party.id] = {
+                label: party.label,
+                sectionLabel,
+                hidden
+              };
+            }
           });
         });
-        result.parties = partyOverrides;
+        result.parties = partyPresentation;
       })();
       continue;
     }
     if (config.facet.sectionStrategy === "class") {
+      if (isMetadataPropertyRuntimeSuppressed(property)) {
+        continue;
+      }
       const resolver = classResolvers[property];
       if (!resolver) continue;
       classTasks.push(
         (async () => {
-          const taxonomy = property === "informationSubjects" && options?.includeOnlyUsedByProperty?.informationSubjects === true ? await getInformationSubjects({ includeOnlyUsed: true }) : await resolver();
+          const taxonomy = await resolver();
           if (property === "topicTypes" || property === "contentLifeCycleStatus") {
             const domainEntityId = property === "topicTypes" ? TOPIC_TYPE_DOMAIN_ENTITY_ID : CONTENT_LIFECYCLE_STATUS_DOMAIN_ENTITY_ID;
-            const sectionLabel = await getDomainEntitySectionLabel(domainEntityId, uiLanguage);
-            const overrides = createClassSectionOverrides(taxonomy.nodesById);
-            if (sectionLabel) {
-              Object.values(overrides).forEach((entry) => {
-                entry.sectionLabel = sectionLabel;
-              });
-            }
-            result[property] = overrides;
+            const sectionLabel = await getDomainEntitySectionLabel(domainEntityId, uiLanguage) || resolveUnknownSectionLabel(property, uiLanguage);
+            const presentation = createClassSectionPresentation(property, taxonomy.nodesById, uiLanguage);
+            Object.values(presentation).forEach((entry) => {
+              entry.sectionLabel = sectionLabel;
+            });
+            result[property] = presentation;
             return;
           }
-          const classLabelsById = await resolveMissingClassLabels(taxonomy.nodesById, uiLanguage);
-          result[property] = createClassSectionOverrides(taxonomy.nodesById, { classLabelsById });
+          const classLabelsById = await resolveMissingClassLabels2(taxonomy.nodesById, uiLanguage);
+          result[property] = createClassSectionPresentation(property, taxonomy.nodesById, uiLanguage, { classLabelsById });
         })()
       );
     }
@@ -961,13 +1171,54 @@ var getMetadataFacetLabelOverrides = async (properties, uiLanguage = "en-US", op
   await Promise.all([...classTasks, ...partiesTask ? [partiesTask] : []]);
   return result;
 };
+var getMetadataFacetLabelOverrides = getMetadataFacetPresentation;
 
-// src/read-models/metadata-display.ts
-var import_utils = require("@c-rex/utils");
+// src/read-models/metadata-display-builder.ts
+var DEFAULT_IGNORED_FORMATS = [
+  "application/xhtml+xml",
+  "application/json",
+  "application/llm+xml",
+  "text/html"
+];
+var normalizeLanguageCode = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return trimmed;
+  const [rawLang, rawCountry, ...rest] = trimmed.split("-");
+  const lang = (rawLang || "").toLowerCase();
+  if (!rawCountry) return lang;
+  const country = rawCountry.toUpperCase();
+  const suffix = rest.length > 0 ? `-${rest.join("-")}` : "";
+  return `${lang}-${country}${suffix}`;
+};
+var sortAndDeduplicateLanguages = (languages) => {
+  const normalized = languages.map((item) => (item || "").trim()).filter((item) => item.length > 0).map((item) => normalizeLanguageCode(item));
+  return Array.from(new Set(normalized)).sort((a, b) => a.localeCompare(b));
+};
+var resolvePreferredLanguage = (languages, uiLanguage) => {
+  if (!languages || languages.length === 0) return void 0;
+  const normalizedUiLanguage = normalizeLanguageCode(uiLanguage);
+  const baseLanguage = normalizedUiLanguage.split("-")[0];
+  const normalized = sortAndDeduplicateLanguages(languages);
+  const exact = normalized.find((item) => item === normalizedUiLanguage);
+  if (exact) return exact;
+  const base = normalized.find((item) => item === baseLanguage || item.startsWith(`${baseLanguage}-`));
+  if (base) return base;
+  const english = normalized.find((item) => item === "en" || item === "en-US" || item.startsWith("en-"));
+  if (english) return english;
+  return normalized[0];
+};
+var getFirstLinkByRel = (item, rel) => item.links?.find((link) => link.rel === rel)?.href;
+var hasRenderableFileRenditions = (renditions) => {
+  if (!renditions || renditions.length === 0) return false;
+  return renditions.some((item) => {
+    if (!item.format || DEFAULT_IGNORED_FORMATS.includes(item.format)) return false;
+    return Boolean(getFirstLinkByRel(item, "download") || getFirstLinkByRel(item, "view"));
+  });
+};
 var resolveLiteralLabel = (labels, uiLanguage) => {
   if (!labels || labels.length === 0) return void 0;
   const language = uiLanguage || "en";
-  const preferred = (0, import_utils.resolvePreferredLanguage)(
+  const preferred = resolvePreferredLanguage(
     labels.map((item) => item.language || ""),
     language
   );
@@ -980,6 +1231,9 @@ var resolveLiteralLabel = (labels, uiLanguage) => {
 var resolveObjectRefLabel = (item, uiLanguage) => {
   return resolveLiteralLabel(item.labels || [], uiLanguage) || item.shortId || item.id || void 0;
 };
+var resolveObjectRefClassLabel = (item, uiLanguage) => {
+  return resolveLiteralLabel(item.class?.labels || [], uiLanguage) || item.class?.shortId || item.class?.id || void 0;
+};
 var asObjectRefArray = (value) => {
   if (!Array.isArray(value)) return [];
   return value.filter((item) => Boolean(item && typeof item === "object"));
@@ -988,29 +1242,27 @@ var asLiteralArray = (value) => {
   if (!Array.isArray(value)) return [];
   return value.filter((item) => Boolean(item && typeof item === "object"));
 };
-var shouldUseOverrides = (strategy) => {
+var shouldUseFacetPresentation = (strategy) => {
   return strategy === "class" || strategy === "partyRole";
 };
-var getMetadataDisplayRows = async (data, options) => {
-  const includeProperties = options.includeProperties || Object.keys(INFORMATION_UNIT_PROPERTY_PRESENTATION);
-  const uiLanguage = options.uiLanguage;
-  const preferredTitle = resolveLiteralLabel(data.titles || [], uiLanguage) || resolveLiteralLabel(data.labels || [], uiLanguage);
-  const objectRefProperties = includeProperties.filter((key) => {
+var resolveFacetPresentationProperties = (includeProperties) => {
+  return includeProperties.filter((key) => {
     const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
     if (!config?.metadataDisplay?.supported) return false;
-    return config.valueKind === "objectRefArray" || config.valueKind === "objectRef";
+    if (config.valueKind !== "objectRefArray" && config.valueKind !== "objectRef") return false;
+    return shouldUseFacetPresentation(config.metadataDisplay.sectionStrategy);
   });
-  const overrideProperties = objectRefProperties.filter(
-    (key) => shouldUseOverrides(INFORMATION_UNIT_PROPERTY_PRESENTATION[key].metadataDisplay.sectionStrategy)
-  );
-  const labelOverrides = options.overrides || (overrideProperties.length > 0 ? await getMetadataFacetLabelOverrides(overrideProperties, uiLanguage) : {});
+};
+var resolveOverrideProperties = resolveFacetPresentationProperties;
+var buildMetadataDisplayRows = (data, options) => {
+  const uiLanguage = options.uiLanguage;
+  const preferredTitle = resolveLiteralLabel(data.titles || [], uiLanguage) || resolveLiteralLabel(data.labels || [], uiLanguage);
   const rows = [];
-  for (const key of includeProperties) {
+  for (const key of options.includeProperties) {
     const config = INFORMATION_UNIT_PROPERTY_PRESENTATION[key];
     if (!config?.metadataDisplay?.supported) continue;
-    if (key === "labels") {
-      continue;
-    }
+    if (isMetadataPropertyRuntimeSuppressed(key)) continue;
+    if (key === "labels") continue;
     if (key === "titles") {
       if (preferredTitle) {
         rows.push({
@@ -1026,7 +1278,7 @@ var getMetadataDisplayRows = async (data, options) => {
     const value = data[key];
     if (value === null || value === void 0) continue;
     if (key === "languages") {
-      const languages = (0, import_utils.sortAndDeduplicateLanguages)(value || []);
+      const languages = sortAndDeduplicateLanguages(value || []);
       if (languages.length > 0) {
         rows.push({
           key,
@@ -1049,7 +1301,7 @@ var getMetadataDisplayRows = async (data, options) => {
       continue;
     }
     if (config.valueKind === "stringArray") {
-      const values = Array.from(new Set(value.map((item) => String(item)).filter((item) => item.length > 0)));
+      const values = Array.from(new Set(value.map((item) => String(item)).filter(Boolean)));
       if (values.length > 0) {
         rows.push({
           key,
@@ -1062,8 +1314,7 @@ var getMetadataDisplayRows = async (data, options) => {
       continue;
     }
     if (config.valueKind === "literalArray") {
-      const literals = asLiteralArray(value);
-      const preferred = resolveLiteralLabel(literals, uiLanguage);
+      const preferred = resolveLiteralLabel(asLiteralArray(value), uiLanguage);
       if (preferred) {
         rows.push({
           key,
@@ -1076,8 +1327,7 @@ var getMetadataDisplayRows = async (data, options) => {
       continue;
     }
     if (config.valueKind === "objectRef") {
-      const ref = value;
-      const label = resolveObjectRefLabel(ref, uiLanguage);
+      const label = resolveObjectRefLabel(value, uiLanguage);
       if (label) {
         rows.push({
           key,
@@ -1092,26 +1342,28 @@ var getMetadataDisplayRows = async (data, options) => {
     if (config.valueKind === "objectRefArray") {
       const refs = asObjectRefArray(value);
       if (refs.length === 0) continue;
-      const grouped = /* @__PURE__ */ new Map();
-      const strategy = config.metadataDisplay.sectionStrategy;
+      const groupedValues = /* @__PURE__ */ new Map();
       refs.forEach((ref) => {
         const shortId = ref.shortId || "";
-        const override = shortId ? labelOverrides[key]?.[shortId] : void 0;
-        const label = override?.label || resolveObjectRefLabel(ref, uiLanguage);
-        if (!label) return;
-        const section = strategy === "none" ? key : override?.sectionLabel || key;
-        if (!grouped.has(section)) grouped.set(section, []);
-        grouped.get(section)?.push(label);
+        const presentationMap = (options.presentation || options.overrides)?.[key];
+        const presentationItem = (shortId ? presentationMap?.[shortId] : void 0) || (ref.id ? presentationMap?.[ref.id] : void 0);
+        if (presentationItem?.hidden) return;
+        if (isMetadataGroupDenied(key, { classId: ref.class?.id })) return;
+        const valueLabel = presentationItem?.label || resolveObjectRefLabel(ref, uiLanguage);
+        if (!valueLabel) return;
+        const sectionLabel = config.metadataDisplay.sectionStrategy === "none" ? key : presentationItem?.sectionLabel || resolveObjectRefClassLabel(ref, uiLanguage) || key;
+        const existing = groupedValues.get(sectionLabel) || /* @__PURE__ */ new Set();
+        existing.add(valueLabel);
+        groupedValues.set(sectionLabel, existing);
       });
-      Array.from(grouped.entries()).sort((a, b) => a[0].localeCompare(b[0])).forEach(([section, values]) => {
-        const uniqueValues = Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
-        if (uniqueValues.length === 0) return;
-        const isDirect = section !== key;
+      Array.from(groupedValues.entries()).sort(([left], [right]) => left.localeCompare(right)).forEach(([sectionLabel, valueSet]) => {
+        const values = Array.from(valueSet).sort((a, b) => a.localeCompare(b));
+        if (values.length === 0) return;
         rows.push({
           key,
-          label: section,
-          labelSource: isDirect ? "direct" : "translationKey",
-          values: uniqueValues,
+          label: sectionLabel,
+          labelSource: sectionLabel === key ? "translationKey" : "direct",
+          values,
           valueType: "text"
         });
       });
@@ -1120,7 +1372,7 @@ var getMetadataDisplayRows = async (data, options) => {
     if (config.valueKind === "renditionArray") {
       const renditions = Array.isArray(value) ? value.filter((item) => Boolean(item && typeof item === "object")) : [];
       if (renditions.length === 0) continue;
-      if ((0, import_utils.getFileRenditionGroups)({ renditions }).length === 0) continue;
+      if (!hasRenderableFileRenditions(renditions)) continue;
       rows.push({
         key,
         label: "files",
@@ -1134,9 +1386,21 @@ var getMetadataDisplayRows = async (data, options) => {
   return rows;
 };
 
+// src/read-models/metadata-display.ts
+var getMetadataDisplayRows = async (data, options) => {
+  const includeProperties = options.includeProperties || Object.keys(INFORMATION_UNIT_PROPERTY_PRESENTATION);
+  const presentationProperties = resolveFacetPresentationProperties(includeProperties);
+  const facetPresentation = options.presentation || options.overrides || (presentationProperties.length > 0 ? await getMetadataFacetPresentation(presentationProperties, options.uiLanguage) : {});
+  return buildMetadataDisplayRows(data, {
+    uiLanguage: options.uiLanguage,
+    includeProperties,
+    presentation: facetPresentation
+  });
+};
+
 // src/read-models/version-availability.ts
 var import_requests4 = require("@c-rex/core/requests");
-var import_utils2 = require("@c-rex/utils");
+var import_utils = require("@c-rex/utils");
 var import_cache3 = require("next/cache");
 var stableSerialize2 = (value) => {
   const normalize = (input) => {
@@ -1157,7 +1421,7 @@ var normalizeVersionItems = (items, uiLanguage) => {
   items.forEach((item) => {
     const shortId = item.shortId?.trim();
     if (!shortId) return;
-    const language = (0, import_utils2.resolvePreferredLanguage)(item.languages, uiLanguage);
+    const language = (0, import_utils.resolvePreferredLanguage)(item.languages, uiLanguage);
     if (!language) return;
     uniqueByShortId.set(shortId, {
       shortId,
@@ -1267,7 +1531,9 @@ var resolveFacetTags = (options) => {
     toInformationUnitPropertyKeys(options?.includeProperties),
     toInformationUnitPropertyKeys(options?.excludeProperties)
   );
-  const tagSet = new Set(runtimeScoped);
+  const tagSet = new Set(
+    runtimeScoped.filter((property) => !isMetadataPropertyRuntimeSuppressed(property))
+  );
   (facetConfig?.extraTags || []).forEach((tag) => tagSet.add(tag));
   (options?.extraTags || []).forEach((tag) => tagSet.add(tag));
   return Array.from(tagSet);
@@ -1285,13 +1551,16 @@ var resolveMetadataDisplayProperties = (options) => {
     profileScoped,
     toInformationUnitPropertyKeys(options?.includeProperties),
     toInformationUnitPropertyKeys(options?.excludeProperties)
-  );
+  ).filter((property) => !isMetadataPropertyRuntimeSuppressed(property));
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   INFORMATION_UNIT_PROPERTY_PRESENTATION,
   METADATA_VIEW_PROFILES,
+  METADATA_VISIBILITY_POLICY,
   READMODEL_CACHE_POLICY,
+  buildMetadataDisplayRows,
+  clearMetadataCacheFamilyRuntimeSuppression,
   getApplicableForTypes,
   getAvailableLanguagesByVersionOf,
   getComponents,
@@ -1299,8 +1568,10 @@ var resolveMetadataDisplayProperties = (options) => {
   getDocumentTypes,
   getFunctionalMetadata,
   getInformationSubjects,
+  getMetadataCacheFamily,
   getMetadataDisplayRows,
   getMetadataFacetLabelOverrides,
+  getMetadataFacetPresentation,
   getMetadataPropertyResolvers,
   getParties,
   getPlanningTimes,
@@ -1309,9 +1580,19 @@ var resolveMetadataDisplayProperties = (options) => {
   getProductMetadata,
   getProductVariants,
   getQualifications,
+  getRuntimeSuppressedMetadataFamilies,
   getSupplies,
   getTopicTypes,
+  isMetadataGroupDenied,
+  isMetadataPropertyRuntimeSuppressed,
+  resetRuntimeSuppressedMetadataFamiliesForTests,
+  resolveFacetPresentationProperties,
   resolveFacetTags,
-  resolveMetadataDisplayProperties
+  resolveLiteralLabel,
+  resolveMetadataDisplayProperties,
+  resolveObjectRefClassLabel,
+  resolveObjectRefLabel,
+  resolveOverrideProperties,
+  suppressMetadataCacheFamilyRuntime
 });
 //# sourceMappingURL=index.js.map