@okf/ootils 1.42.0 → 1.44.0

package/dist/node.mjs

@@ -940,7 +940,7 @@ var init_Tpl = __esm({
 var require_MongoConnector = __commonJS({
   "src/db/MongoConnector.js"(exports, module) {
     "use strict";
-    var mongoose5 = __require("mongoose");
+    var mongoose10 = __require("mongoose");
     var { ServerApiVersion } = __require("mongodb");
     var AnnotationsSchema = (init_Annotations(), __toCommonJS(Annotations_exports));
     var PlatformConfigsSchema2 = (init_PlatformConfigs(), __toCommonJS(PlatformConfigs_exports));
@@ -1004,7 +1004,7 @@ var require_MongoConnector = __commonJS({
               `Missing CLUSTER_NAME or CLUSTER_URI in cluster conf: ${JSON.stringify(clusterConf)}`
             );
           }
-          this.clusterConnections[CLUSTER_NAME] = mongoose5.createConnection(
+          this.clusterConnections[CLUSTER_NAME] = mongoose10.createConnection(
             CLUSTER_URI,
             this.mongoOptions
           );
@@ -1031,7 +1031,7 @@ var require_MongoConnector = __commonJS({
               this.skippedClusters.add(CLUSTER_NAME);
               return;
             }
-            const connection = mongoose5.createConnection(CLUSTER_URI, this.mongoOptions);
+            const connection = mongoose10.createConnection(CLUSTER_URI, this.mongoOptions);
             this.clusterConnections[CLUSTER_NAME] = connection;
             this.initiateConnectionEventListeners(CLUSTER_NAME);
             await new Promise((resolve, reject) => {
@@ -1496,7 +1496,7 @@ var require_getModelByTenant = __commonJS({
     "use strict";
     var { getDbByTenant: getDbByTenant2 } = (init_getDbByTenant(), __toCommonJS(getDbByTenant_exports));
     var { AIChatSchema: AIChatSchema2, AnnotationSchema: AnnotationSchema2, PlatformConfigsSchema: PlatformConfigsSchema2, TplSchema: TplSchema2, GeneratedTopicsSchema: GeneratedTopicsSchema2, GeneratedEntitiesSchema: GeneratedEntitiesSchema2 } = (init_models(), __toCommonJS(models_exports));
-    var getModelByTenant3 = ({ tenant, modelName, schema, env }) => {
+    var getModelByTenant4 = ({ tenant, modelName, schema, env }) => {
       if (!tenant) {
         throw new Error("tenant id has not been provided");
       }
@@ -1506,48 +1506,48 @@ var require_getModelByTenant = __commonJS({
       }
       return db.model(modelName);
     };
-    var getAnnotationsModelByTenant2 = ({ tenant, env, mongodb, modelName }) => getModelByTenant3({
+    var getAnnotationsModelByTenant2 = ({ tenant, env, mongodb, modelName }) => getModelByTenant4({
       tenant,
       modelName: modelName || "annotations",
       schema: AnnotationSchema2,
       env
     });
-    var getPlatformConfigsModelByTenant2 = ({ tenant, env, mongodb }) => getModelByTenant3({
+    var getPlatformConfigsModelByTenant2 = ({ tenant, env, mongodb }) => getModelByTenant4({
       tenant,
       modelName: "platformConfigs",
       schema: PlatformConfigsSchema2,
       env
     });
-    var getTplModelByTenant2 = ({ tenant, env, mongodb }) => getModelByTenant3({
+    var getTplModelByTenant3 = ({ tenant, env, mongodb }) => getModelByTenant4({
       tenant,
       modelName: "tpl",
       schema: TplSchema2,
       env
     });
-    var getAIChatModelByTenant2 = ({ tenant, env, mongodb }) => getModelByTenant3({
+    var getAIChatModelByTenant2 = ({ tenant, env, mongodb }) => getModelByTenant4({
       tenant,
       modelName: "aiChat",
       schema: AIChatSchema2,
       env
     });
-    var getGeneratedTopicsModelByTenant2 = ({ tenant, env }) => getModelByTenant3({
+    var getGeneratedTopicsModelByTenant2 = ({ tenant, env }) => getModelByTenant4({
       tenant,
       modelName: "generatedTopics",
       schema: GeneratedTopicsSchema2,
       env
     });
-    var getGeneratedEntitiesModelByTenant2 = ({ tenant, env }) => getModelByTenant3({
+    var getGeneratedEntitiesModelByTenant2 = ({ tenant, env }) => getModelByTenant4({
       tenant,
       modelName: "generatedEntities",
       schema: GeneratedEntitiesSchema2,
       env
     });
     module.exports = {
-      getModelByTenant: getModelByTenant3,
+      getModelByTenant: getModelByTenant4,
       getAIChatModelByTenant: getAIChatModelByTenant2,
       getAnnotationsModelByTenant: getAnnotationsModelByTenant2,
       getPlatformConfigsModelByTenant: getPlatformConfigsModelByTenant2,
-      getTplModelByTenant: getTplModelByTenant2,
+      getTplModelByTenant: getTplModelByTenant3,
       getGeneratedTopicsModelByTenant: getGeneratedTopicsModelByTenant2,
       getGeneratedEntitiesModelByTenant: getGeneratedEntitiesModelByTenant2
     };
@@ -5019,8 +5019,771 @@ RedisCacheConnector.instance = null;
 // src/node.ts
 init_SecretManagerConnector();
 init_getDbByTenant();
+var import_getModelByTenant4 = __toESM(require_getModelByTenant());
+
+// src/contentSchema/genContentTypeSchema.js
+import mongoose9 from "mongoose";
+
+// src/contentSchema/components/_backOfficeFields__contr.js
+import mongoose5 from "mongoose";
+var _backOfficeFields__contr = (thisContentModelRef) => ({
+  //----- (USUSED AT THE MOMENT) version 2 properties for better tracking & interlinking of document clones ---- //
+  isPrimaryDoc: Boolean,
+  cloneStack: [mongoose5.Schema.Types.ObjectId],
+  // the last item in the array being the last clone
+  ogStack: [mongoose5.Schema.Types.ObjectId],
+  // the last item in the array being the og-est og ( the primaryDoc )
+  //----- END version 2 properties ---- //
+  tagId: String,
+  kp_published_status: {
+    type: String,
+    // options : draft | published | editPublished | awaitingModeration | underModeration
+    default: "draft",
+    required: true
+  },
+  warnings: [Object],
+  kp_og_published_doc: {
+    type: mongoose5.Schema.Types.ObjectId,
+    ref: thisContentModelRef
+  },
+  // -----  mod rel --- //
+  kp_pre_mod_doc: {
+    type: mongoose5.Schema.Types.ObjectId
+  },
+  kp_is_pbl_taken_into_mod: Boolean,
+  kp_is_mod_clone: Boolean,
+  kp_moderator: {
+    type: mongoose5.Schema.Types.ObjectId,
+    ref: "user"
+  },
+  kp_date_mod_begin: Date,
+  kp_date_mod_end: Date,
+  kp_date_submitted: Date,
+  // -----  END mod rel --- //
+  kp_date_created: Date,
+  kp_date_last_saved: Date,
+  kp_date_published: {
+    type: Date
+  },
+  editPublishedDocId: {
+    //only comes on og docs that have an editPbl clone
+    type: mongoose5.Schema.Types.ObjectId,
+    ref: thisContentModelRef
+  },
+  currentEditor: {
+    type: mongoose5.Schema.Types.ObjectId,
+    //relevant for segments : staticPages & collection, where author dont matter.
+    ref: "user"
+  },
+  lastActivity: {
+    date: {
+      type: Date
+    }
+  }
+});
+
+// src/contentSchema/components/_comments__contr.js
+import mongoose6 from "mongoose";
+var baseCommentsObj = {
+  user: {
+    userId: { type: mongoose6.Schema.Types.ObjectId, ref: "user" },
+    profileType: String,
+    name: String,
+    avatar: Object
+  },
+  text: Object,
+  dateCreated: Date,
+  dateModified: [Date]
+  //the start of tracking mod dates on things..experiment...
+};
+var _comments__contr = {
+  comments: [
+    {
+      ...baseCommentsObj,
+      responses: [baseCommentsObj]
+    }
+  ]
+};
+
+// src/contentSchema/components/_reaction_contr.js
+import mongoose7 from "mongoose";
+var baseSchema = {
+  type: {
+    type: String,
+    enum: ["like", "celebrate", "inspiring", "learnings"]
+  },
+  dateCreated: Date,
+  userId: { type: mongoose7.Schema.Types.ObjectId, ref: "user" }
+};
+var _reaction_contr = {
+  reactions: [
+    {
+      ...baseSchema
+    }
+  ]
+};
+
+// src/contentSchema/components/_constantMeta__contr.js
+import mongoose8 from "mongoose";
+var _constantMeta__contr = {
+  kp_contributed_by: {
+    type: mongoose8.Schema.Types.ObjectId,
+    ref: "user",
+    required: true
+  },
+  kp_content_type: {
+    type: String,
+    required: true
+  },
+  // "thematic" or "attribute" — distinguishes thematic sub-themes/tags from
+  // attribute classification categories (speech act, emotion, etc.).
+  taxonomyRole: {
+    type: String
+  },
+  // Only meaningful on sub-theme docs. When false, new tags cannot be created under
+  // this sub-theme (by humans via API or by the inductive AI annotator).
+  // Absent/true = allowed (default).
+  allowNewTags: {
+    type: Boolean
+  },
+  // Only meaningful on attribute-role sub-themes. "single" = pick one tag,
+  // "multi" = pick one or more. Default "multi".
+  selectMode: {
+    type: String
+  },
+  // "autoAI" | "humanInTheLoop" — absent means human editor (default).
+  createdVia: {
+    type: String
+  }
+};
+
+// src/contentSchema/components/_fixedMainFields__contr.js
+var _fixedMainFields__contr = {
+  /**
+   * hard coding title & subtitle is required because,
+   * in tpl categories like 'researchNotes' the title comp is never defined in the template.
+   * instead, it is hardcoded in the code, and it expects a 'main.title' value path.
+   * Hence the hardcode below. Besides its not a problem, since, if in the template a
+   * main.title component is indeed defined, then these hardcodes would be overwritten by
+   * mainExtract. Which is what we want.
+   */
+  title: {
+    type: String,
+    cast: (v) => typeof v === "string" ? String(v) : Object(v)
+  },
+  subtitle: {
+    type: String,
+    cast: (v) => typeof v === "string" ? String(v) : Object(v)
+  },
+  titleInfo: String
+  // this is used to show the meta text ("This story is supported by AI-assisted bot") on the published page
+};
+
+// src/contentSchema/extractAllUniqueAnnoTagTypesFromTpl.js
+var extractAllUniqueAnnoTagTypesFromTpl = (extractedBlocks, { smTagTypesConfig } = {}) => {
+  return Array.from(
+    new Set(
+      blockRegistry.getAnnotationEnabledBlocks(extractedBlocks).flatMap((bl) => [
+        ...blockRegistry.getTagTypesConfig(bl, smTagTypesConfig).map((tt) => tt.tagType),
+        ...bl.props?.annotation?.toggleTagTypesConfig?.map((tt) => tt.tagType) || []
+      ])
+    )
+  );
+};
+
+// src/contentSchema/getTypesForSchemaFromTpl/compToTypeMap/getConditionalDataType.js
+var getConditionalDataType = ({ block }) => {
+  if (block.props?.saveValueAsString)
+    return {
+      type: Number,
+      cast: (v) => {
+        if (typeof v === "number" && !isNaN(v)) {
+          return Number(v);
+        } else if (typeof v === "string") {
+          return String(v);
+        } else {
+          return Boolean(v);
+        }
+      }
+    };
+  else {
+    const returnValue = ["DropdownMulti", "CheckboxList"].includes(block.comp) ? { type: Array } : { type: Object };
+    return returnValue;
+  }
+};
+
+// src/contentSchema/utils/extractNumberFromValue.js
+var extractNumberFromValue = (value) => {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "number") return isNaN(value) ? void 0 : value;
+  const str = String(value).trim();
+  if (str === "") return void 0;
+  const directParse = Number(str);
+  if (!isNaN(directParse)) return directParse;
+  const commaNumberMatch = str.match(/-?\d[\d,]*\d(?:\.\d+)?/);
+  if (commaNumberMatch && commaNumberMatch[0].includes(",")) {
+    const num = Number(commaNumberMatch[0].replace(/,/g, ""));
+    if (!isNaN(num)) return num;
+  }
+  const numberMatch = str.match(/-?\d+(?:\.\d+)?/);
+  if (numberMatch) {
+    const num = Number(numberMatch[0]);
+    return isNaN(num) ? void 0 : num;
+  }
+  return void 0;
+};
+
+// src/contentSchema/getTypesForSchemaFromTpl/compToTypeMap/index.js
+var compToTypeMap = ({ block }) => {
+  const comp = block.comp;
+  const blockDef = blockRegistry.getBlock(comp);
+  if (blockDef) return blockDef.mongoSchemaType;
+  switch (comp) {
+    case "SummaryInput":
+    case "KPRichInput":
+    //deprecated
+    case "RichTextEditor":
+    //deprecated
+    case "StaticRichText":
+    case "CardRadioInput":
+    case "NumberRangeInput":
+    case "KPLikeContactChannelsBlock":
+    case "TitleInput":
+    case "SubtitleInput":
+    case "PluginSentinel":
+    case "DynamicRefetchDropdown":
+    case "VideoInput":
+    // data type for videoinput should actually be array, but since the old version of the comp used a string data type, we are currently setting it to object to avoid error
+    case "SimpleTable":
+    case "GroupQuestionsInputSingle":
+      return { type: Object };
+    case "ProfileImageInput":
+    case "ResourceInput":
+    case "ImageInput":
+    case "VideoInput":
+    case "Repeater":
+    case "RepeaterTabs":
+    case "PDFInput":
+    case "TextInputToArray":
+      return { type: Array };
+    case "RichTextAsPlainText":
+    case "PasswordInput":
+    case "EmailInput":
+    case "TextInput":
+    case "URLInput":
+    case "PhoneInput":
+    case "KPMetaPrimary":
+    case "IFrameInput":
+    case "JSONInput":
+      return { type: String };
+    case "NumberInput":
+      return {
+        type: Number,
+        // Smart extraction of numbers from messy values (e.g. "18+", "18 years old", "$100")
+        // Uses extractNumberFromValue utility for consistent behavior with direct import
+        set: extractNumberFromValue
+      };
+    case "DropdownSingleLanguage":
+    case "ComboboxSingleLanguage":
+      return {
+        type: [
+          {
+            display: String,
+            value: String
+          }
+        ]
+      };
+    case "DatePicker":
+      return { type: Date };
+    case "DateTimePicker":
+      return { type: Date };
+    case "TimePicker":
+      return {
+        type: String,
+        // Validates time is in 24-hour format (00:00-23:59) with hours 00-23, a colon, and minutes 00-59
+        validate: {
+          validator: function(v) {
+            return /^([01]\d|2[0-3]):([0-5]\d)$/.test(v);
+          },
+          message: (props) => `${props.value} is not a valid time format!`
+        }
+      };
+    case "CheckboxButton":
+      return { type: Boolean };
+    case "TagsInputMulti":
+    case "FragmentsSet":
+    case "FragmentsDict":
+    case "TagsInputSingle":
+      return {
+        type: {
+          collectionId: String,
+          data: [
+            {
+              _id: {
+                type: String,
+                index: block.index === true
+              },
+              display: String,
+              tagId: String
+            }
+          ]
+        }
+      };
+    case "SPECIAL_AnnotationTagsField":
+      return {
+        /**
+         * very important that we wrap the whole thing in type,
+         * because, if the tag name itself is type (like in the case of noora),
+         * then it completely confuses mongoose, since type is a reserved word,
+         * and causes all sorts of bugs.
+         */
+        type: {
+          collectionId: String,
+          data: Array
+          //leaving this weakly typed for now cuz annotations have several other properties in here which i am not aware of..
+        }
+      };
+    case "LinkEmbedWithInput":
+      return {
+        type: {
+          url: String,
+          metadata: Object
+        }
+      };
+    case "CheckboxList":
+    //new
+    case "RadioList":
+    //new
+    case "DropdownSingle":
+    //new
+    case "DropdownMulti":
+    //new
+    case "SwitchDouble":
+    case "SwitchSingle":
+      return getConditionalDataType({ block });
+    case "DateTimeRangePicker":
+      return {
+        type: {
+          date: Date,
+          timeRange: Array
+        }
+      };
+    case "DateRangePicker":
+      return { type: Array };
+  }
+};
+
+// src/contentSchema/getTypesForSchemaFromTpl/index.js
+var getTypesForSchemaFromTpl = (options = {}) => {
+  const { tpl, smTagTypesConfig } = options;
+  const defaultSchemaFieldsByTplLayout = {
+    researchNotes2: {
+      tags: {
+        quotes: {
+          collectionId: String,
+          data: Array
+        },
+        vocabs: {
+          collectionId: String,
+          data: Array
+        }
+      }
+    }
+  };
+  let mainExtract = {};
+  let metaExtract = {};
+  let tagsExtract = {};
+  let rootExtract = {};
+  let annoExtract = {
+    ...defaultSchemaFieldsByTplLayout[tpl?.category] || {}
+  };
+  const extractedBlocks = extractAllBlocksFromTpl({ tpl });
+  const annotationTagTypes = extractAllUniqueAnnoTagTypesFromTpl(extractedBlocks, {
+    smTagTypesConfig
+  });
+  annotationTagTypes.forEach((annoTagType) => {
+    const annotationFieldDef = compToTypeMap({
+      block: { comp: "SPECIAL_AnnotationTagsField" }
+    });
+    annoExtract = setVal(annoExtract, `tags.${annoTagType}`, annotationFieldDef);
+  });
+  extractedBlocks.forEach((block) => {
+    const { valuePath } = block;
+    if (!valuePath) return;
+    const pathSegments = valuePath.split(".");
+    const [prefix, ...remainingPath] = pathSegments;
+    const nestedPath = remainingPath.join(".");
+    const fieldDefinition = compToTypeMap({ block });
+    switch (prefix) {
+      case "meta":
+        metaExtract = setVal(
+          metaExtract,
+          nestedPath,
+          // "author.name" (without "meta" prefix)
+          fieldDefinition
+        );
+        break;
+      case "main":
+        mainExtract = setVal(
+          mainExtract,
+          nestedPath,
+          // "content.title" (without "main" prefix)
+          fieldDefinition
+        );
+        break;
+      case "tags":
+        tagsExtract = setVal(
+          tagsExtract,
+          nestedPath,
+          // "categories.primary" (without "tags" prefix)
+          fieldDefinition
+        );
+        break;
+      default:
+        if (block.comp && block.comp !== "TplMetaBlock" && valuePath !== ".") {
+          rootExtract = setVal(
+            rootExtract,
+            valuePath,
+            // Use full path since it's not prefixed
+            fieldDefinition
+          );
+        }
+        break;
+    }
+  });
+  return {
+    metaExtract,
+    mainExtract,
+    tagsExtract,
+    rootExtract,
+    annoExtract
+  };
+};
+
+// src/contentSchema/genContentTypeSchema.js
+var genContentTypeSchema = ({ contentType, segment, contentTypeConfig, smTagTypesConfig }) => {
+  let SchemaToReturn;
+  let {
+    mainExtract = {},
+    metaExtract = {},
+    tagsExtract = {},
+    rootExtract = {},
+    annoExtract = {}
+  } = getTypesForSchemaFromTpl({ tpl: contentTypeConfig, smTagTypesConfig });
+  const schemaDef = {
+    /**
+     * this metadata is v.important from an optimization point of view.
+     * it helps with getAllContrModelsByTenant, without having to
+     * query the database for content type configurations.
+     */
+    metadata: {
+      isContentType: { type: String, default: true },
+      contentType: { type: String, default: contentType },
+      segment: { type: String, default: segment }
+    },
+    ..._backOfficeFields__contr(contentType),
+    ...rootExtract,
+    tags: {
+      ...tagsExtract
+    },
+    annotations: {
+      ...annoExtract
+    },
+    meta: {
+      ..._constantMeta__contr,
+      ...metaExtract
+    },
+    main: {
+      ..._fixedMainFields__contr,
+      ...mainExtract
+    },
+    archive: Object,
+    //burial ground for past fields that have eventually been removed from the tpl (and therefore the schema)
+    translations: Object,
+    reviewerNotes: Object,
+    ..._reaction_contr,
+    ..._comments__contr,
+    ...segment === "publishing" && {
+      shares: {
+        count: {
+          type: Number,
+          default: 0
+        }
+      },
+      views: {
+        count: {
+          type: Number,
+          default: 0
+        }
+      }
+    },
+    updates: Object
+    // DEPRECATED. DONT USE IT. DONT DELETE EITHER. ELSE WE WILL HAVE TO MAKE DATA UPDATES
+  };
+  SchemaToReturn = new mongoose9.Schema(schemaDef, {
+    collection: contentType,
+    toJSON: { virtuals: true },
+    // So `res.json()` and other `JSON.stringify()` functions include virtuals
+    toObject: { virtuals: true },
+    // So `toObject()` output includes virtuals
+    strict: "throw"
+    //will throw an error if we try to add properties that arent on this schema
+  });
+  SchemaToReturn.index(
+    { tagId: 1 },
+    ...segment === "collections" ? [
+      {
+        unique: true,
+        partialFilterExpression: {
+          kp_published_status: { $eq: "published" }
+        }
+      }
+    ] : []
+  );
+  SchemaToReturn.index({
+    kp_published_status: 1,
+    kp_date_published: -1,
+    _id: -1
+  });
+  SchemaToReturn.index(
+    { kp_published_status: 1, "main.title": 1, _id: 1 },
+    { collation: { locale: "en", numericOrdering: true } }
+  );
+  SchemaToReturn.index({ kp_published_status: 1, kp_is_mod_clone: 1 });
+  return SchemaToReturn;
+};
+
+// src/TenantRegistry.js
+import { Storage } from "@google-cloud/storage";
+var BUCKET_NAME = "dots-system-configs";
+var FILE_NAME = "tenantRegistry.json";
+var TenantRegistry = class {
+  // ─── Initialization ─────────────────────────────────
+  /**
+   * Must be awaited at startup before any sync getter is called.
+   * Uses Application Default Credentials (ADC) for GCS auth.
+   */
+  static async init() {
+    this._data = await this._load();
+    this._rebuildCaches();
+    this._lastRefreshAt = Date.now();
+  }
+  /**
+   * Reload from GCS when this instance sees an unknown tenant/origin — likely one
+   * provisioned on another instance after startup. Rate-limited; on failure keeps
+   * the existing cache (never throws). Returns true if a reload actually ran.
+   */
+  static async refreshIfStale() {
+    const now = Date.now();
+    if (now - this._lastRefreshAt < this.REFRESH_COOLDOWN_MS) return false;
+    this._lastRefreshAt = now;
+    try {
+      this._data = await this._load();
+      this._rebuildCaches();
+      return true;
+    } catch (err) {
+      console.error(`[TenantRegistry] refresh failed (keeping cache): ${err.message}`);
+      return false;
+    }
+  }
+  // ─── Storage layer (swap only these to change backend) ───
+  static async _load() {
+    const storage = new Storage();
+    const file = storage.bucket(BUCKET_NAME).file(FILE_NAME);
+    const [buffer] = await file.download();
+    const { data } = JSON.parse(buffer.toString("utf-8"));
+    console.log(`[TenantRegistry] Loaded ${data.length} tenants from GCS`);
+    return data;
+  }
+  static async _save() {
+    const storage = new Storage();
+    const file = storage.bucket(BUCKET_NAME).file(FILE_NAME);
+    await file.save(JSON.stringify({ data: this._data }, null, 2), {
+      contentType: "application/json"
+    });
+  }
+  // ─── End storage layer ──────────────────────────────
+  static _rebuildCaches() {
+    this._byEnv = {};
+    this._selfManagedSet = /* @__PURE__ */ new Set();
+    for (const entry of this._data) {
+      const { tenantId, urls, isSelfManaged } = entry;
+      if (isSelfManaged) this._selfManagedSet.add(tenantId);
+      for (const env of ["dev", "staging", "prod"]) {
+        if (!urls[env]) continue;
+        if (!this._byEnv[env]) this._byEnv[env] = {};
+        this._byEnv[env][tenantId] = urls[env];
+      }
+    }
+  }
+  // ─── Sync getters ───────────────────────────────────
+  /** { tenantId: url } for the given env */
+  static getMappingsForEnv(env) {
+    return this._byEnv[env] || {};
+  }
+  /** [url, url, ...] for the given env */
+  static getUrlsForEnv(env) {
+    return Object.values(this._byEnv[env] || {});
+  }
+  /** [tenantId, tenantId, ...] for the given env */
+  static getTenantIdsForEnv(env) {
+    return Object.keys(this._byEnv[env] || {});
+  }
+  /** Single URL for a tenant+env, or undefined */
+  static getUrl(tenant, env) {
+    return (this._byEnv[env] || {})[tenant];
+  }
+  static isSelfManaged(tenant) {
+    return this._selfManagedSet.has(tenant);
+  }
+  static getSelfManagedTenantIds() {
+    return [...this._selfManagedSet];
+  }
+  /** Full registry data array (read-only snapshot) */
+  static getData() {
+    return this._data;
+  }
+  // ─── Mutator ────────────────────────────────────────
+  /**
+   * Idempotent: removes existing entry for tenantId (if any), then adds.
+   * Persists to GCS and updates in-memory caches.
+   */
+  static async addTenant({ tenantId, urls, isSelfManaged = false }) {
+    this._data = this._data.filter((e) => e.tenantId !== tenantId);
+    this._data.push({ tenantId, urls, isSelfManaged });
+    await this._save();
+    this._rebuildCaches();
+  }
+  /**
+   * Idempotent inverse of addTenant: drops the tenant's entry from the registry,
+   * persists to GCS, and rebuilds in-memory caches (so the tenant stops resolving
+   * on THIS instance immediately). Returns true if an entry was actually removed.
+   * Other running instances pick up the removal via refreshIfStale() on their next
+   * unknown-origin miss.
+   */
+  static async removeTenant(tenantId) {
+    const before = this._data.length;
+    this._data = this._data.filter((e) => e.tenantId !== tenantId);
+    const removed = this._data.length < before;
+    if (removed) {
+      await this._save();
+      this._rebuildCaches();
+    }
+    return removed;
+  }
+};
+// ─── In-memory state ────────────────────────────────
+__publicField(TenantRegistry, "_data", null);
+// [{ tenantId, urls: { dev, staging, prod }, isSelfManaged }]
+__publicField(TenantRegistry, "_byEnv", {});
+// { dev: { tenantId: url }, staging: {...}, prod: {...} }
+__publicField(TenantRegistry, "_selfManagedSet", /* @__PURE__ */ new Set());
+// On-miss refresh rate-limit (see refreshIfStale).
+__publicField(TenantRegistry, "_lastRefreshAt", 0);
+__publicField(TenantRegistry, "REFRESH_COOLDOWN_MS", 3e4);
+
+// src/contentSchema/selfManagedAnnotationTagTypesConfig.js
+var SM_ANNOTATION_TAG_TYPES_CONFIG = [{ tagType: "tags" }];
+var getSmTagTypesConfigForTenant = async (tenant) => {
+  return TenantRegistry.isSelfManaged(tenant) ? SM_ANNOTATION_TAG_TYPES_CONFIG : null;
+};
+
+// src/db/getContrModelByTenant.js
+var import_getModelByTenant3 = __toESM(require_getModelByTenant());
+init_getDbByTenant();
+
+// src/db/getTpl.js
 var import_getModelByTenant2 = __toESM(require_getModelByTenant());
+var getTpl = async ({ tenant, contentType, env, source = "db" }) => {
+  if (source === "cache") {
+    return RedisCacheConnector.findOneConfigInCache({
+      tenant,
+      modelName: "tpl",
+      type: contentType,
+      env
+    });
+  }
+  return (0, import_getModelByTenant2.getTplModelByTenant)({ tenant, env }).findOne({ kp_content_type: contentType }).lean();
+};
+
+// src/db/getContrModelByTenant.js
+var getContrModelByTenant = async ({
+  tenant,
+  contentType,
+  env = process.env.ENV,
+  // v.imp, else the reuse check below always fails when env isn't passed (env is meant to be optional)
+  tpl,
+  //optional : if passed uses it instead of fetching the tpl for this contenttype from db. important in the case of _createTpl, where, within a transaction we create a tpl and then use this tpl to create some content against it. since this is within a transaction, this newly created tpl wont be available in the db just yet.
+  tplSource = "db",
+  // "db" (okf-be default, original semantics) | "cache" (okf-sub — tpl cache is kept in sync on every tpl write)
+  /**
+   * When true, the registered-model reuse is SKIPPED — the schema is rebuilt
+   * from the current tpl on every call (~5-10ms CPU + the tpl read).
+   *
+   * okf-sub passes this on every collab call: unlike okf-be — which
+   * invalidates registered models on tpl change via
+   * reRegisterModelInLocalCache + the '${env}-tpl-model-recache' Pub/Sub —
+   * okf-sub subscribes to nothing, so a reused model could carry a stale
+   * schema after a tpl edit, and strict:"throw" would reject collab flushes
+   * for newly added fields. Rebuilding every time is correct by
+   * construction: no freshness bookkeeping for tpl write paths (or raw
+   * mongodbscripts that mutate tpls + recache) to ever get wrong.
+   */
+  rebuild = false
+}) => {
+  try {
+    const db = getDbByTenant({ tenant });
+    if (!rebuild && db.models[contentType] && env === process.env.ENV && !tpl) {
+      const modelToReturn = db.model(contentType);
+      if (modelToReturn.schema.obj.metadata && modelToReturn.schema.obj.metadata.isContentType && modelToReturn.schema.obj.metadata.isContentType.default === true) {
+        return modelToReturn;
+      }
+      return void 0;
+    }
+    const contentTypeConfig = tpl || await getTpl({ tenant, contentType, env, source: tplSource });
+    if (!contentTypeConfig) return void 0;
+    const smTagTypesConfig = await getSmTagTypesConfigForTenant(tenant);
+    const thisSchema = genContentTypeSchema({
+      contentType,
+      segment: contentTypeConfig.general?.segment,
+      contentTypeConfig,
+      smTagTypesConfig
+    });
+    if (rebuild && db.models[contentType]) {
+      db.deleteModel(contentType);
+    }
+    return (0, import_getModelByTenant3.getModelByTenant)({
+      tenant,
+      modelName: contentType,
+      schema: thisSchema,
+      env
+    });
+  } catch (err) {
+    throw err;
+  }
+};
+
+// src/node.ts
 init_models();
+
+// src/collab/liveCollabDocMarker.js
+var TTL_SECONDS = 300;
+var LIVE_COLLAB_DOC_REFRESH_MS = 12e4;
+var buildKey = ({ env, tenant, contentType, docId }) => `${env || RedisCacheConnector.getEnv()}:liveCollabDoc:${tenant}:${contentType}:${docId}`;
+var markLiveCollabDoc = async ({ tenant, contentType, docId, env }) => {
+  const client = RedisCacheConnector.getClient(env || RedisCacheConnector.getEnv());
+  await client.set(buildKey({ env, tenant, contentType, docId }), Date.now(), "EX", TTL_SECONDS);
+};
+var clearLiveCollabDoc = async ({ tenant, contentType, docId, env }) => {
+  const client = RedisCacheConnector.getClient(env || RedisCacheConnector.getEnv());
+  await client.del(buildKey({ env, tenant, contentType, docId }));
+};
+var isLiveCollabDoc = async ({ tenant, contentType, docId, env }) => {
+  const client = RedisCacheConnector.getClient(env || RedisCacheConnector.getEnv());
+  return await client.exists(buildKey({ env, tenant, contentType, docId })) === 1;
+};
+
+// src/node.ts
 var import_WorkerManager = __toESM(require_WorkerManager());
 var import_ProducerManager = __toESM(require_ProducerManager());
 var import_BaseProducer = __toESM(require_BaseProducer());
@@ -5041,13 +5804,13 @@ var export_GET_GLOBAL_BULLMQ_CONFIG = import_GET_GLOBAL_BULLMQ_CONFIG.GET_GLOBAL
 var export_MongoConnector = import_MongoConnector3.MongoConnector;
 var export_ProducerManager = import_ProducerManager.ProducerManager;
 var export_WorkerManager = import_WorkerManager.WorkerManager;
-var export_getAIChatModelByTenant = import_getModelByTenant2.getAIChatModelByTenant;
-var export_getAnnotationsModelByTenant = import_getModelByTenant2.getAnnotationsModelByTenant;
-var export_getGeneratedEntitiesModelByTenant = import_getModelByTenant2.getGeneratedEntitiesModelByTenant;
-var export_getGeneratedTopicsModelByTenant = import_getModelByTenant2.getGeneratedTopicsModelByTenant;
-var export_getModelByTenant = import_getModelByTenant2.getModelByTenant;
-var export_getPlatformConfigsModelByTenant = import_getModelByTenant2.getPlatformConfigsModelByTenant;
-var export_getTplModelByTenant = import_getModelByTenant2.getTplModelByTenant;
+var export_getAIChatModelByTenant = import_getModelByTenant4.getAIChatModelByTenant;
+var export_getAnnotationsModelByTenant = import_getModelByTenant4.getAnnotationsModelByTenant;
+var export_getGeneratedEntitiesModelByTenant = import_getModelByTenant4.getGeneratedEntitiesModelByTenant;
+var export_getGeneratedTopicsModelByTenant = import_getModelByTenant4.getGeneratedTopicsModelByTenant;
+var export_getModelByTenant = import_getModelByTenant4.getModelByTenant;
+var export_getPlatformConfigsModelByTenant = import_getModelByTenant4.getPlatformConfigsModelByTenant;
+var export_getTplModelByTenant = import_getModelByTenant4.getTplModelByTenant;
 export {
   AIChat_default as AIChatSchema,
   export_AnnosElasticSyncProducer as AnnosElasticSyncProducer,
@@ -5066,6 +5829,7 @@ export {
   export_GET_GLOBAL_BULLMQ_CONFIG as GET_GLOBAL_BULLMQ_CONFIG,
   GeneratedEntities_default as GeneratedEntitiesSchema,
   GeneratedTopics_default as GeneratedTopicsSchema,
+  LIVE_COLLAB_DOC_REFRESH_MS,
   MONGO_SCHEMA_PRESETS,
   export_MongoConnector as MongoConnector,
   PlatformConfigs_default as PlatformConfigsSchema,
@@ -5073,9 +5837,13 @@ export {
   RedisCacheConnector,
   SecretManagerConnector,
   TEMP_removeDuplicateFilters,
+  TenantRegistry,
   Tpl_default as TplSchema,
   UI_CONTENT,
   export_WorkerManager as WorkerManager,
+  _backOfficeFields__contr,
+  _constantMeta__contr,
+  _fixedMainFields__contr,
   _self_managed_buildAnnoHierarchyConfig,
   _self_managed_buildDocHierarchyConfig,
   _self_managed_getFixedAnnoRollupBlocks,
@@ -5083,17 +5851,22 @@ export {
   autoGenFilterConfigsFromTpl,
   blockRegistry,
   buildFilterConfigurations,
+  clearLiveCollabDoc,
   collectMarkIdsInOrder,
   compareAndGroupBlocks,
   deleteVal,
   extractAllBlocksFromTpl,
+  extractAllUniqueAnnoTagTypesFromTpl,
   extractAndOrganizeBlocks,
+  extractNumberFromValue,
   genCleanCamelCaseId,
+  genContentTypeSchema,
   genTagId,
   generateFilterKey,
   export_getAIChatModelByTenant as getAIChatModelByTenant,
   getAnnoFilterBucketKey,
   export_getAnnotationsModelByTenant as getAnnotationsModelByTenant,
+  getContrModelByTenant,
   getDbByTenant,
   getFilterKeyForBlock,
   export_getGeneratedEntitiesModelByTenant as getGeneratedEntitiesModelByTenant,
@@ -5110,9 +5883,13 @@ export {
   getRoutePathToReviewDashboard,
   getRoutePathToTCI,
   getRoutePathToTagCategoryLanding,
+  getTpl,
   export_getTplModelByTenant as getTplModelByTenant,
+  getTypesForSchemaFromTpl,
   getVal,
+  isLiveCollabDoc,
   isTplAnnotationEnabled,
+  markLiveCollabDoc,
   mergeAnnoDataIntoAnnotationsTags,
   parseSpecialConfigSyntax,
   plainTextToLexical,