@okf/ootils 1.39.3 → 1.41.0

package/dist/node.d.ts

@@ -3,6 +3,7 @@ import * as mongoose from 'mongoose';
 import mongoose__default, { Document, Types, Schema } from 'mongoose';
 import * as bullmq from 'bullmq';
 import { Queue } from 'bullmq/dist/esm/classes/queue';
+import { FlowProducer } from 'bullmq/dist/esm/classes/flow-producer';
 import { Worker } from 'bullmq/dist/esm/classes/worker';
 
 declare const deleteVal: (data: any, valuePath: string) => any;
@@ -292,9 +293,10 @@ declare const collectMarkIdsInOrder: (editorState: any) => string[];
  *   }
  * ]
  */
-declare function getRollupPossibilities({ tagType, allTpls }: {
+declare function getRollupPossibilities({ tagType, allTpls, includeSelfHead, }: {
     tagType: string;
     allTpls: any[];
+    includeSelfHead?: boolean;
 }): any[];
 
 declare namespace BASE_BULLMQ_CONFIG {
@@ -1248,6 +1250,27 @@ declare const processAuthorAndCommonFilters: (allTpls: any[], filterScopes: stri
 
 declare const _self_managed_getFixedAnnoTagBlock: (selectedTpls: any[], annotationTagsCount: any) => any[];
 
+/**
+ * FOLLOWUP (consolidate the count->rollupPath rule into one source of truth):
+ *
+ * The rule "given annotationTagsCount, which self-managed anno rollupPaths exist"
+ * (subThemes>0 -> ['tags','subThemes']; subThemes>0 && themes>0 -> ['tags','subThemes','themes'])
+ * is currently duplicated in THREE places and will drift:
+ *   1. here (_self_managed_getFixedAnnoRollupBlocks)            -> filter blocks
+ *   2. _self_managed_buildAnnoHierarchyConfig                   -> anno hierarchy filter UI
+ *   3. okf-fe _extractAllAnnoBasedDimensionsAsOptions.js        -> reports dimension dropdown
+ *
+ * (#3 was added to fix a crash: the reports widget previously discovered these rollups
+ *  from publishing-segment tpls via getRollupPossibilities, but self-managed taxonomy lives
+ *  on `collections`-segment tpls which isTplAnnotationEnabled excludes -> empty list ->
+ *  unguarded .find('subThemes') returned undefined -> crash. The FE now builds them from the
+ *  count, mirroring this function.)
+ *
+ * Extract a pure helper here in ootils:
+ *   export const getSelfManagedAnnoRollupPaths = (annotationTagsCount): string[][] => [...]
+ * then have all three call sites consume it (each maps paths -> its own shape:
+ * filter-blocks / hierarchy levels / dropdown options). One rule, three presentations.
+ */
 declare const _self_managed_getFixedAnnoRollupBlocks: ({ selectedTpls, allTpls, annotationTagsCount }: {
     selectedTpls: any[];
     allTpls: any[];
@@ -1349,6 +1372,7 @@ declare const _self_managed_buildDocHierarchyConfig: ({ combinedDocumentBlocks,
             display: any;
             filters: any[];
             rollups: any[];
+            rollupDisplayMap: Record<string, string>;
         }[];
     };
     target: {
@@ -1508,6 +1532,7 @@ declare const autoGenFilterConfigsFromTpl: ({ selectedTpls, allTpls, filterScope
                     display: any;
                     filters: any[];
                     rollups: any[];
+                    rollupDisplayMap: Record<string, string>;
                 }[];
             };
             target: {
@@ -2592,6 +2617,100 @@ declare class BaseProducer {
     stop(): Promise<void>;
 }
 
+/**
+ * BaseFlowProducer — the flow-equivalent of BaseProducer.
+ *
+ * A BullMQ Flow adds its parent + children jobs straight into each queue's
+ * Redis keys WITHOUT going through a Queue instance. That means flow nodes do
+ * NOT inherit their queue's `defaultJobOptions` the way `BaseProducer` jobs do
+ * (BaseProducer gets them for free via `new Queue(id, queueConfig)`). Left
+ * unhandled, options like removeOnComplete/removeOnFail are never applied and
+ * completed/failed jobs accumulate unbounded.
+ *
+ * This base centralises the one thing that must happen for every flow: each
+ * node's `opts` is layered as `{ ...queueDefaultJobOptions, ...nodeOpts }`,
+ * mirroring exactly how BullMQ layers defaultJobOptions under per-`add` opts
+ * for normal queues. So subclasses declare ONLY structure + job-specific opts
+ * (e.g. failParentOnFailure); retention and other defaults flow from the same
+ * GLOBAL_BULLMQ_CONFIG that the queues/workers already read — single source of
+ * truth, no per-call-site restatement.
+ *
+ * Construction takes the SAME config objects (entries of GET_GLOBAL_BULLMQ_CONFIG)
+ * that BaseProducer/BaseWorker consume, so a flow is configured declaratively
+ * alongside its queues.
+ *
+ * @param {Object} params
+ * @param {Object} params.parentConfig
+ * The GLOBAL_BULLMQ_CONFIG entry for the parent queue (has .id, .queueConfig).
+ * @param {Object} params.childConfigs
+ * Map keyed by an arbitrary childKey →
+ * the GLOBAL_BULLMQ_CONFIG entry for that
+ * child queue. Subclasses reference a child
+ * node's queue by this key, never by id.
+ */
+declare class BaseFlowProducer {
+    constructor({ parentConfig, childConfigs }: {
+        parentConfig: any;
+        childConfigs?: {} | undefined;
+    });
+    parentConfig: any;
+    childConfigs: {};
+    flow: FlowProducer;
+    /**
+     * Build & enqueue a flow declaratively.
+     *
+     * @param {Object} params
+     * @param {string} [params.name]        Parent job name.
+     * @param {Object} params.parentData    Parent job data.
+     * @param {Object} [params.parentOpts]  Per-node opts for the parent, layered
+     *                                       over the parent queue's defaults.
+     * @param {Array}  params.children      One entry per child node:
+     *   @param {string} children[].childKey  Key into childConfigs (which queue).
+     *   @param {string} [children[].name]    Child job name.
+     *   @param {Object} children[].data      Child job data.
+     *   @param {Object} [children[].opts]    Job-specific opts (e.g.
+     *                                        failParentOnFailure); layered over
+     *                                        that child queue's defaults.
+     * @returns {Promise<{ parentJobId, childJobIds }>}
+     */
+    addFlow({ name, parentData, parentOpts, children }: {
+        name?: string | undefined;
+        parentData: Object;
+        parentOpts?: Object | undefined;
+        children: any[];
+    }): Promise<{
+        parentJobId: any;
+        childJobIds: any;
+    }>;
+    /**
+     * Find the FIRST parent job in the given states whose data matches the
+     * predicate — e.g. an in-flight lock check ("is a run already pending for
+     * this tenant?"). Opens a short-lived Queue on the parent queue and closes
+     * it before returning, so callers don't have to reach into config internals
+     * to construct one themselves.
+     *
+     * Returns the first match or null. BullMQ can't filter by job.data
+     * server-side, so this still fetches the in-flight set and scans in JS; the
+     * contract is intentionally first-match (not a list) because that's the only
+     * thing the lock-check use case needs.
+     *
+     * @param {Object} params
+     * @param {string[]} params.states
+     *   Job states to scan, e.g. ["waiting", "active", "delayed"].
+     * @param {(data: any, job: any) => boolean} params.matchData
+     *   Required function; receives job.data (and the job). Without it there's
+     *   no meaningful "match", so this throws — returning an arbitrary in-flight
+     *   job would be a silent caller bug.
+     * @returns {Promise<Object|null>} The first matching parent job, or null.
+     */
+    findParentJob({ states, matchData }: {
+        states: string[];
+        matchData: (data: any, job: any) => boolean;
+    }): Promise<Object | null>;
+    stop(): Promise<void>;
+    #private;
+}
+
 declare class BaseWorker {
     constructor(config: any);
     config: any;
@@ -2648,4 +2767,4 @@ declare function GET_GLOBAL_BULLMQ_CONFIG({ env, redisCredentials }: {
     };
 }): Object;
 
-export { AIChatSchema, AnnosElasticSyncProducer, AnnotationSchema, BASE_BULLMQ_CONFIG, BaseProducer, BaseWorker, type BlockCapabilities, type BlockDef, BlockRegistry, CHUNKING_PRESETS, ChunksElasticSyncProducer, ELASTIC_MAPPING_PRESETS, ElasticSearchConnector, FILTER_IDS, GET_GLOBAL_BULLMQ_CONFIG, GeneratedEntitiesSchema, GeneratedTopicsSchema, MONGO_SCHEMA_PRESETS, MongoConnector, PlatformConfigsSchema, ProducerManager, RedisCacheConnector, SecretManagerConnector, TEMP_removeDuplicateFilters, TplSchema, UI_CONTENT, WorkerManager, _self_managed_buildAnnoHierarchyConfig, _self_managed_buildDocHierarchyConfig, _self_managed_getFixedAnnoRollupBlocks, _self_managed_getFixedAnnoTagBlock, autoGenFilterConfigsFromTpl, blockRegistry, buildFilterConfigurations, collectMarkIdsInOrder, compareAndGroupBlocks, deleteVal, extractAllBlocksFromTpl, extractAndOrganizeBlocks, genCleanCamelCaseId, genTagId, generateFilterKey, getAIChatModelByTenant, getAnnoFilterBucketKey, getAnnotationsModelByTenant, getDbByTenant, getFilterKeyForBlock, getGeneratedEntitiesModelByTenant, getGeneratedTopicsModelByTenant, getModelByTenant, getPlatformConfigsModelByTenant, getPlatformContextContent, getRollupPossibilities, getRoutePathToContentTypeLanding, getRoutePathToEditContent, getRoutePathToModerateContent, getRoutePathToMyContent, getRoutePathToPublishedContent, getRoutePathToReviewDashboard, getRoutePathToTCI, getRoutePathToTagCategoryLanding, getTplModelByTenant, getVal, isTplAnnotationEnabled, mergeAnnoDataIntoAnnotationsTags, parseSpecialConfigSyntax, plainTextToLexical, processAuthorAndCommonFilters, _recursExtractBlocks as recursivelyExtractBlocks, segrigateDocs, setVal, toArray };
+export { AIChatSchema, AnnosElasticSyncProducer, AnnotationSchema, BASE_BULLMQ_CONFIG, BaseFlowProducer, BaseProducer, BaseWorker, type BlockCapabilities, type BlockDef, BlockRegistry, CHUNKING_PRESETS, ChunksElasticSyncProducer, ELASTIC_MAPPING_PRESETS, ElasticSearchConnector, FILTER_IDS, GET_GLOBAL_BULLMQ_CONFIG, GeneratedEntitiesSchema, GeneratedTopicsSchema, MONGO_SCHEMA_PRESETS, MongoConnector, PlatformConfigsSchema, ProducerManager, RedisCacheConnector, SecretManagerConnector, TEMP_removeDuplicateFilters, TplSchema, UI_CONTENT, WorkerManager, _self_managed_buildAnnoHierarchyConfig, _self_managed_buildDocHierarchyConfig, _self_managed_getFixedAnnoRollupBlocks, _self_managed_getFixedAnnoTagBlock, autoGenFilterConfigsFromTpl, blockRegistry, buildFilterConfigurations, collectMarkIdsInOrder, compareAndGroupBlocks, deleteVal, extractAllBlocksFromTpl, extractAndOrganizeBlocks, genCleanCamelCaseId, genTagId, generateFilterKey, getAIChatModelByTenant, getAnnoFilterBucketKey, getAnnotationsModelByTenant, getDbByTenant, getFilterKeyForBlock, getGeneratedEntitiesModelByTenant, getGeneratedTopicsModelByTenant, getModelByTenant, getPlatformConfigsModelByTenant, getPlatformContextContent, getRollupPossibilities, getRoutePathToContentTypeLanding, getRoutePathToEditContent, getRoutePathToModerateContent, getRoutePathToMyContent, getRoutePathToPublishedContent, getRoutePathToReviewDashboard, getRoutePathToTCI, getRoutePathToTagCategoryLanding, getTplModelByTenant, getVal, isTplAnnotationEnabled, mergeAnnoDataIntoAnnotationsTags, parseSpecialConfigSyntax, plainTextToLexical, processAuthorAndCommonFilters, _recursExtractBlocks as recursivelyExtractBlocks, segrigateDocs, setVal, toArray };

package/dist/node.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -34,6 +37,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/bullmq/GLOBAL_BULLMQ_CONFIG.js
 var GLOBAL_BULLMQ_CONFIG_exports = {};
@@ -1912,6 +1918,133 @@ var require_BaseProducer = __commonJS({
   }
 });
 
+// src/bullmq/BaseFlowProducer.js
+var require_BaseFlowProducer = __commonJS({
+  "src/bullmq/BaseFlowProducer.js"(exports2, module2) {
+    "use strict";
+    var { FlowProducer, Queue } = require("bullmq");
+    var _BaseFlowProducer_instances, mergeOpts_fn, childConfig_fn;
+    var BaseFlowProducer2 = class {
+      constructor({ parentConfig, childConfigs = {} }) {
+        __privateAdd(this, _BaseFlowProducer_instances);
+        if (!parentConfig) {
+          throw new Error("BaseFlowProducer requires a parentConfig");
+        }
+        this.parentConfig = parentConfig;
+        this.childConfigs = childConfigs;
+        this.flow = new FlowProducer({
+          connection: parentConfig.queueConfig.connection
+        });
+      }
+      /**
+       * Build & enqueue a flow declaratively.
+       *
+       * @param {Object} params
+       * @param {string} [params.name]        Parent job name.
+       * @param {Object} params.parentData    Parent job data.
+       * @param {Object} [params.parentOpts]  Per-node opts for the parent, layered
+       *                                       over the parent queue's defaults.
+       * @param {Array}  params.children      One entry per child node:
+       *   @param {string} children[].childKey  Key into childConfigs (which queue).
+       *   @param {string} [children[].name]    Child job name.
+       *   @param {Object} children[].data      Child job data.
+       *   @param {Object} [children[].opts]    Job-specific opts (e.g.
+       *                                        failParentOnFailure); layered over
+       *                                        that child queue's defaults.
+       * @returns {Promise<{ parentJobId, childJobIds }>}
+       */
+      async addFlow({ name, parentData, parentOpts = {}, children = [] }) {
+        const flowJob = await this.flow.add({
+          name,
+          queueName: this.parentConfig.id,
+          data: parentData,
+          opts: __privateMethod(this, _BaseFlowProducer_instances, mergeOpts_fn).call(this, this.parentConfig, parentOpts),
+          children: children.map((child) => {
+            const childCfg = __privateMethod(this, _BaseFlowProducer_instances, childConfig_fn).call(this, child.childKey);
+            return {
+              name: child.name,
+              queueName: childCfg.id,
+              data: child.data,
+              opts: __privateMethod(this, _BaseFlowProducer_instances, mergeOpts_fn).call(this, childCfg, child.opts)
+            };
+          })
+        });
+        const parentJobId = flowJob?.job?.id;
+        const childJobIds = (flowJob?.children || []).map((c) => c?.job?.id).filter(Boolean);
+        return { parentJobId, childJobIds };
+      }
+      /**
+       * Find the FIRST parent job in the given states whose data matches the
+       * predicate — e.g. an in-flight lock check ("is a run already pending for
+       * this tenant?"). Opens a short-lived Queue on the parent queue and closes
+       * it before returning, so callers don't have to reach into config internals
+       * to construct one themselves.
+       *
+       * Returns the first match or null. BullMQ can't filter by job.data
+       * server-side, so this still fetches the in-flight set and scans in JS; the
+       * contract is intentionally first-match (not a list) because that's the only
+       * thing the lock-check use case needs.
+       *
+       * @param {Object} params
+       * @param {string[]} params.states
+       *   Job states to scan, e.g. ["waiting", "active", "delayed"].
+       * @param {(data: any, job: any) => boolean} params.matchData
+       *   Required function; receives job.data (and the job). Without it there's
+       *   no meaningful "match", so this throws — returning an arbitrary in-flight
+       *   job would be a silent caller bug.
+       * @returns {Promise<Object|null>} The first matching parent job, or null.
+       */
+      async findParentJob({ states, matchData }) {
+        if (typeof matchData !== "function") {
+          throw new Error("BaseFlowProducer.findParentJob requires a matchData function");
+        }
+        const parentQueue = new Queue(
+          this.parentConfig.id,
+          this.parentConfig.queueConfig
+        );
+        try {
+          const jobs = await parentQueue.getJobs(states, 0, -1);
+          return jobs.find((job) => matchData(job?.data, job)) || null;
+        } finally {
+          await parentQueue.close();
+        }
+      }
+      async stop() {
+        if (this.flow) {
+          try {
+            await this.flow.close();
+          } catch (err) {
+            console.warn(`[${this.constructor.name}] flow close failed: ${err.message}`);
+          }
+        }
+      }
+    };
+    _BaseFlowProducer_instances = new WeakSet();
+    /**
+     * Layer a queue config's defaultJobOptions under per-node opts — identical
+     * to how BullMQ merges defaultJobOptions under per-`add` opts for a Queue.
+     * Config is the base; anything the node explicitly sets wins.
+     */
+    mergeOpts_fn = function(queueConfig, nodeOpts = {}) {
+      const defaults = queueConfig?.queueConfig?.defaultJobOptions || {};
+      return { ...defaults, ...nodeOpts };
+    };
+    /**
+     * Resolve the GLOBAL_BULLMQ_CONFIG entry for a declared child key.
+     */
+    childConfig_fn = function(childKey) {
+      const cfg = this.childConfigs[childKey];
+      if (!cfg) {
+        throw new Error(
+          `BaseFlowProducer: no child queue declared under key "${childKey}". Declared keys: [${Object.keys(this.childConfigs).join(", ")}]`
+        );
+      }
+      return cfg;
+    };
+    module2.exports = { BaseFlowProducer: BaseFlowProducer2 };
+  }
+});
+
 // src/bullmq/BaseWorker.js
 var require_BaseWorker = __commonJS({
   "src/bullmq/BaseWorker.js"(exports2, module2) {
@@ -2102,6 +2235,7 @@ __export(node_exports, {
   AnnosElasticSyncProducer: () => import_AnnosElasticSyncProducer.AnnosElasticSyncProducer,
   AnnotationSchema: () => Annotations_default,
   BASE_BULLMQ_CONFIG: () => BASE_BULLMQ_CONFIG,
+  BaseFlowProducer: () => import_BaseFlowProducer.BaseFlowProducer,
   BaseProducer: () => import_BaseProducer.BaseProducer,
   BaseWorker: () => import_BaseWorker.BaseWorker,
   BlockRegistry: () => BlockRegistry,
@@ -2825,7 +2959,8 @@ var collectMarkIdsInOrder = (editorState) => {
 var MAX_DEPTH_ROLLUP_POSSIBILITIES = 10;
 function getRollupPossibilities({
   tagType,
-  allTpls
+  allTpls,
+  includeSelfHead = false
 }) {
   const thisTagTpl = allTpls.find((d) => d.kp_content_type === tagType);
   if (!thisTagTpl) return [];
@@ -2857,7 +2992,8 @@ function getRollupPossibilities({
         chains.push({
           rollupType: "tagType",
           tagTypeCollectionToRollup: tagType,
-          rollupPath: [...visited, startTagType, nextTagType]
+          rollupPath: [...visited, startTagType, nextTagType],
+          filterDisplay: block.props?.shortLabel || block.props?.label
         });
         if (visited.length < maxDepth - 1) {
           const nextChains = findTagChains(
@@ -2903,7 +3039,8 @@ function getRollupPossibilities({
     const directChain = {
       rollupType: "tagType",
       tagTypeCollectionToRollup: tagType,
-      rollupPath: [tagType, block.props.tagType]
+      rollupPath: [tagType, block.props.tagType],
+      filterDisplay: block.props?.shortLabel || block.props?.label
     };
     const deeperChains = findTagChains(
       block.props?.tagType,
@@ -2912,7 +3049,14 @@ function getRollupPossibilities({
     );
     return [directChain, ...deeperChains];
   });
-  return [...singleLevelValuePathRollups, ...nestedTagRollups];
+  const selfHeadRollup = includeSelfHead && nestedTagRollups.length > 0 && singleLevelValuePathRollups.length === 0 ? [
+    {
+      rollupType: "tagType",
+      tagTypeCollectionToRollup: tagType,
+      rollupPath: [tagType]
+    }
+  ] : [];
+  return [...singleLevelValuePathRollups, ...selfHeadRollup, ...nestedTagRollups];
 }
 
 // src/universal.ts
@@ -3320,6 +3464,7 @@ var buildFilterConfigurations = ({ groups, type, selectedTpls, allTpls, isRollup
           if (isTerminalValuePath) {
             return element.filterDisplay || lastItemInPath;
           }
+          if (element.filterDisplay) return element.filterDisplay;
           const lastTag = rollupPath[rollupPath.length - 1];
           const lastTagTpl = allTpls.find(
             (tpl) => tpl.kp_content_type === lastTag
@@ -3586,7 +3731,7 @@ var extractAndOrganizeBlocks = (selectedTpls, allTpls, { smTagTypesConfig } = {}
     return {
       contentType: tpl.kp_content_type,
       blocks: allBlocks.filter((block) => block.valuePath.startsWith("tags.") && ["TagsInputSingle", "TagsInputMulti"].includes(block.comp)).flatMap((block) => {
-        const possibilities = getRollupPossibilities({ tagType: block.props.tagType, allTpls });
+        const possibilities = getRollupPossibilities({ tagType: block.props.tagType, allTpls, includeSelfHead: true });
         return possibilities.map((p) => ({
           ...p,
           filterType: p.rollupPath ? "nestedRollupTagType" : "rollupValuePathType"
@@ -3919,13 +4064,16 @@ var buildTagTypeParentMap = (tagTypesInGroup, allTpls) => {
     const tagBlocks = blocks.filter(
       (block) => block.valuePath?.startsWith("tags.") && block.props?.tagType
     );
+    const referencedTagTypes = /* @__PURE__ */ new Set();
     for (const block of tagBlocks) {
       const referencedTagType = block.props.tagType;
       if (tagTypeSet.has(referencedTagType) && referencedTagType !== tagType) {
-        parentMap.set(tagType, referencedTagType);
-        break;
+        referencedTagTypes.add(referencedTagType);
       }
     }
+    if (referencedTagTypes.size === 1) {
+      parentMap.set(tagType, [...referencedTagTypes][0]);
+    }
   }
   for (const child of parentMap.keys()) {
     const visited = /* @__PURE__ */ new Set();
@@ -3999,6 +4147,34 @@ var sortFiltersHierarchically = (filters) => {
   return sorted;
 };
 
+// src/utils/autoGenFilterConfigsFromTpl/utils/deduplicateRollupTagFilters.ts
+var deduplicateRollupTagFilters = (rollups) => {
+  const tagTerminals = [];
+  const nonTag = [];
+  for (const r of rollups) {
+    const rp = r.target?.rollupPath;
+    if (rp?.length && !rp[rp.length - 1].startsWith("main.")) {
+      tagTerminals.push(r);
+    } else {
+      nonTag.push({ ...r, isTagRollup: false });
+    }
+  }
+  if (tagTerminals.length === 0) return nonTag;
+  const byTerminal = /* @__PURE__ */ new Map();
+  for (const r of tagTerminals) {
+    const terminal = r.target.rollupPath[r.target.rollupPath.length - 1];
+    const existing = byTerminal.get(terminal);
+    if (!existing || r.target.rollupPath.length < existing.target.rollupPath.length) {
+      byTerminal.set(terminal, r);
+    }
+  }
+  const dedupedTags = [...byTerminal.values()].map((r) => ({
+    ...r,
+    isTagRollup: true
+  }));
+  return [...nonTag, ...dedupedTags];
+};
+
 // src/utils/autoGenFilterConfigsFromTpl/utils/_self_managed_buildDocHierarchyConfig.ts
 var injectFilterOptionsBy = (filters) => filters.map(
   (f) => f.parentFilterId ? { ...f, source: { ...f.source, filterOptionsBy: { filterId: f.parentFilterId } } } : f
@@ -4105,24 +4281,34 @@ var _self_managed_buildDocHierarchyConfig = ({
     const dedupedFilters = filtersWithCommonFlag.filter(
       (f) => !rollupSourceKeys.has(JSON.stringify(f.source))
     );
-    const combined = [...dedupedFilters, ...rollupConfigs];
+    const dedupedRollupConfigs = deduplicateRollupTagFilters(rollupConfigs);
+    const combined = [...dedupedFilters, ...dedupedRollupConfigs];
     const combinedWithParents = injectFilterOptionsBy(
       sortFiltersHierarchically(
         attachParentFields(combined, allTpls)
       )
     );
-    const rollupFilterIds = new Set(rollupConfigs.map((r) => r.filterId));
+    const rollupFilterIds = new Set(dedupedRollupConfigs.map((r) => r.filterId));
     const filtersWithParents = combinedWithParents.filter(
       (f) => !rollupFilterIds.has(f.filterId)
     );
     const rollupsWithParents = combinedWithParents.filter(
       (f) => rollupFilterIds.has(f.filterId)
     );
+    const rollupContentTypes = new Set(
+      rollupsWithParents.filter((r) => r.target?.rollupPath).flatMap((r) => r.target.rollupPath)
+    );
+    const rollupDisplayMap = {};
+    for (const ct of rollupContentTypes) {
+      const t = allTpls.find((tp) => tp.kp_content_type === ct);
+      if (t?.general?.content?.title) rollupDisplayMap[ct] = t.general.content.title;
+    }
     return {
       contentType: tpl.kp_content_type,
       display: tplData?.general?.content?.title || tpl.kp_content_type,
       filters: filtersWithParents,
-      rollups: rollupsWithParents
+      rollups: rollupsWithParents,
+      rollupDisplayMap
     };
   });
   const filteredPerDataset = perDataset.filter(
@@ -4767,6 +4953,7 @@ init_models();
 var import_WorkerManager = __toESM(require_WorkerManager());
 var import_ProducerManager = __toESM(require_ProducerManager());
 var import_BaseProducer = __toESM(require_BaseProducer());
+var import_BaseFlowProducer = __toESM(require_BaseFlowProducer());
 var import_BaseWorker = __toESM(require_BaseWorker());
 var import_ChunksElasticSyncProducer = __toESM(require_ChunksElasticSyncProducer());
 var import_AnnosElasticSyncProducer = __toESM(require_AnnosElasticSyncProducer());
@@ -4777,6 +4964,7 @@ var import_GET_GLOBAL_BULLMQ_CONFIG = __toESM(require_GET_GLOBAL_BULLMQ_CONFIG()
   AnnosElasticSyncProducer,
   AnnotationSchema,
   BASE_BULLMQ_CONFIG,
+  BaseFlowProducer,
   BaseProducer,
   BaseWorker,
   BlockRegistry,