@gmb/bitmark-parser-generator 5.1.0 → 5.3.0

package/dist/cli/main.js

@@ -2,7 +2,7 @@ import process2 from 'process';
 import { Command, Option, Help, Argument, InvalidArgumentError } from 'commander';
 import { Enum } from '@ncoderz/superenum';
 import path3 from 'path';
-import fs4 from 'fs-extra';
+import fs3 from 'fs-extra';
 import 'fs';
 import os from 'os';
 
@@ -270,6 +270,7 @@ var BitType = {
   flashcard1: "flashcard-1",
   focusImage: "focus-image",
   footNote: "foot-note",
+  formFreeText: "form-free-text",
   formula: "formula",
   gapText: "gap-text",
   gapTextInstructionGrouped: "gap-text-instruction-grouped",
@@ -282,6 +283,8 @@ var BitType = {
   handInFeedbackExpert: "hand-in-feedback-expert",
   handInFeedbackSelf: "hand-in-feedback-self",
   handInFile: "hand-in-file",
+  handInFreeText: "hand-in-free-text",
+  handInFreeTextExpert: "hand-in-free-text-expert",
   handInLocation: "hand-in-location",
   handInPhoto: "hand-in-photo",
   handInScan: "hand-in-scan",
@@ -594,6 +597,7 @@ var BitType = {
   trueFalse: "true-false",
   trueFalse1: "true-false-1",
   vendorAmcharts5Chart: "vendor-amcharts-5-chart",
+  vendorDatadogDashboard: "vendor-datadog-dashboard",
   vendorDatadogDashboardEmbed: "vendor-datadog-dashboard-embed",
   vendorFormbricksEmbed: "vendor-formbricks-embed",
   vendorFormbricksLink: "vendor-formbricks-link",
@@ -1198,6 +1202,7 @@ var propertyKeys = {
   property_internalComment: "@internalComment",
   property_internalPrintPdf: "@internalPrintPdf",
   property_hasPrintRestriction: "@hasPrintRestriction",
+  property_enforceUpdateOverUserInput: "@enforceUpdateOverUserInput",
   property_isCaseSensitive: "@isCaseSensitive",
   property_isInfoOnly: "@isInfoOnly",
   property_isPublic: "@isPublic",
@@ -1224,6 +1229,7 @@ var propertyKeys = {
   property_listItemIndent: "@listItemIndent",
   property_location: "@location",
   property_machineTranslated: "@machineTranslated",
+  property_translationOf: "@translationOf",
   property_spansPageBreak: "@spansPageBreak",
   property_mailingList: "@mailingList",
   property_mark: "@mark",
@@ -1256,6 +1262,7 @@ var propertyKeys = {
   property_platformMargin: "@platformMargin",
   property_platformBorderRadius: "@platformBorderRadius",
   property_platformSelectionBorderRadius: "@platformSelectionBorderRadius",
+  property_platformLogoMaxHeight: "@platformLogoMaxHeight",
   property_platformNeedsShadow: "@platformNeedsShadow",
   property_platformSeparatorColor: "@platformSeparatorColor",
   property_platformTextSelectionColor: "@platformTextSelectionColor",
@@ -2702,6 +2709,11 @@ var GROUPS = {
         description: "If true, the bit is machine-translated",
         format: TagFormat.plainText
       },
+      {
+        key: ConfigKey.property_translationOf,
+        description: "Translation source reference",
+        format: TagFormat.plainText
+      },
       {
         key: ConfigKey.property_spansPageBreak,
         description: "If true, the bit spans a page break",
@@ -3352,6 +3364,12 @@ var GROUPS = {
         description: "If true, the book has print restrictions",
         format: TagFormat.boolean,
         defaultValue: "true"
+      },
+      {
+        key: ConfigKey.property_enforceUpdateOverUserInput,
+        description: "If true, prioritize new content over legacy content from the instance API",
+        format: TagFormat.boolean,
+        defaultValue: "false"
       }
     ]
   },
@@ -8678,6 +8696,11 @@ var BITS = {
         ],
         maxCount: 1
       },
+      {
+        key: ConfigKey.property_platformLogoMaxHeight,
+        description: "Maximum height for the platform logo",
+        format: TagFormat.number
+      },
       {
         key: ConfigKey.group_platformStylesCommon,
         description: "Common platform styles"
@@ -9372,6 +9395,11 @@ var BITS = {
     baseBitType: BitType._standard,
     description: "Footnote bit, used to create footnotes in articles or books"
   },
+  [BitType.formFreeText]: {
+    since: "5.3.0",
+    baseBitType: BitType.interview,
+    description: "Form free text bit, used to create free text forms in articles or books"
+  },
   [BitType.groupBorn]: {
     since: "1.3.0",
     baseBitType: BitType._standard,
@@ -9431,6 +9459,16 @@ var BITS = {
       }
     ]
   },
+  [BitType.handInFreeText]: {
+    since: "5.3.0",
+    baseBitType: BitType.interview,
+    description: "Hand in free text bit, used to create free text submission sections in articles or books"
+  },
+  [BitType.handInFreeTextExpert]: {
+    since: "5.3.0",
+    baseBitType: BitType.interview,
+    description: "Hand in free text expert bit, used to create free text expert submission sections in articles or books"
+  },
   [BitType.handInLocation]: {
     since: "1.5.15",
     baseBitType: BitType._standard,
@@ -9540,6 +9578,11 @@ var BITS = {
     description: "AmCharts 5 chart bit, used to embed AmCharts 5 charts in articles or books",
     textFormatDefault: TextFormat.json
   },
+  [BitType.vendorDatadogDashboard]: {
+    since: "5.2.0",
+    baseBitType: BitType.nonProductionPrototypeIframe,
+    description: "A Datadog dashboard bit, used to embed Datadog dashboards"
+  },
   [BitType.vendorDatadogDashboardEmbed]: {
     since: "3.12.0",
     baseBitType: BitType.code,
@@ -10169,7 +10212,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "license": "ISC"};
 var Environment = {
   unknown: "",
@@ -10758,6 +10801,8 @@ var NodeType = {
   internalPrintPdfValue: "internalPrintPdfValue",
   hasPrintRestriction: "hasPrintRestriction",
   hasPrintRestrictionValue: "hasPrintRestrictionValue",
+  enforceUpdateOverUserInput: "enforceUpdateOverUserInput",
+  enforceUpdateOverUserInputValue: "enforceUpdateOverUserInputValue",
   isCaseSensitive: "isCaseSensitive",
   isCommented: "isCommented",
   isCorrect: "isCorrect",
@@ -10824,6 +10869,8 @@ var NodeType = {
   locationValue: "locationValue",
   machineTranslated: "machineTranslated",
   machineTranslatedValue: "machineTranslatedValue",
+  translationOf: "translationOf",
+  translationOfValue: "translationOfValue",
   spansPageBreak: "spansPageBreak",
   spansPageBreakValue: "spansPageBreakValue",
   mailingList: "mailingList",
@@ -10875,6 +10922,8 @@ var NodeType = {
   platformIconValue: "platformIconValue",
   platformLogo: "platformLogo",
   platformLogoValue: "platformLogoValue",
+  platformLogoMaxHeight: "platformLogoMaxHeight",
+  platformLogoMaxHeightValue: "platformLogoMaxHeightValue",
   platformPrimaryColor: "platformPrimaryColor",
   platformPrimaryColorValue: "platformPrimaryColorValue",
   platformSecondaryColor: "platformSecondaryColor",
@@ -11919,10 +11968,11 @@ var Stage = {
   between: "between",
   exit: "exit"
 };
-var TextGenerator = class extends AstWalkerGenerator {
+var TextGenerator = class _TextGenerator extends AstWalkerGenerator {
   ast = new Ast();
   bitmarkVersion;
   options;
+  internalTextGenerator = null;
   // State
   generateOptions = {};
   textFormat = TextFormat.bitmarkText;
@@ -11938,6 +11988,7 @@ var TextGenerator = class extends AstWalkerGenerator {
   exitedCodeBlock = false;
   inBulletList = false;
   inInline = false;
+  markDepth = 0;
   textDepth = 0;
   placeholderIndex = 0;
   placeholders = {};
@@ -11968,6 +12019,13 @@ var TextGenerator = class extends AstWalkerGenerator {
     this.between = this.between.bind(this);
     this.exit = this.exit.bind(this);
     this.leaf = this.leaf.bind(this);
+    if (!this.options.isInternal) {
+      this.internalTextGenerator = new _TextGenerator(bitmarkVersion, {
+        ...this.options,
+        writeCallback: void 0,
+        isInternal: true
+      });
+    }
   }
   /**
    * Generate text from a bitmark text AST
@@ -12024,6 +12082,7 @@ var TextGenerator = class extends AstWalkerGenerator {
     this.exitedCodeBlock = false;
     this.inBulletList = false;
     this.inInline = false;
+    this.markDepth = 0;
     this.textDepth = 0;
     this.placeholderIndex = 0;
     this.placeholders = {};
@@ -12071,8 +12130,16 @@ var TextGenerator = class extends AstWalkerGenerator {
   exit_contentValueValue(node, route) {
     return this.handleExitNode(node.value, route);
   }
+  // * -> marks
+  enter_marks(_node, _route) {
+    this.markDepth++;
+  }
+  exit_marks(_node, _route) {
+    this.markDepth--;
+  }
   // END NODE HANDLERS
   handleEnterNode(node, route) {
+    if (this.markDepth > 0) return;
     this.handleEnterNodePreTextCheck(node, route);
     this.handleIndent(node);
     switch (node.type) {
@@ -12083,7 +12150,7 @@ var TextGenerator = class extends AstWalkerGenerator {
       case TextNodeType.hardBreak:
         this.writeHardBreak(node);
         break;
-      case TextNodeType.text:
+      case TextNodeType.text: {
         this.writeMarks(node, Stage.enter);
         this.writeText(node);
         this.writeMarks(node, Stage.between);
@@ -12092,6 +12159,7 @@ var TextGenerator = class extends AstWalkerGenerator {
         }
         this.textDepth++;
         break;
+      }
       case TextNodeType.heading:
         this.writeHeading(node);
         this.inHeading = true;
@@ -12140,6 +12208,7 @@ var TextGenerator = class extends AstWalkerGenerator {
           }
   }
   handleExitNode(node, _route) {
+    if (this.markDepth > 0) return;
     switch (node.type) {
       case TextNodeType.text:
         this.textDepth--;
@@ -12443,7 +12512,7 @@ var TextGenerator = class extends AstWalkerGenerator {
    */
   writeMarks(node, stage) {
     if (node.marks) {
-      const forceSingleMark = !!(this.inInline || this.inHeading);
+      const forceSingleMark = this.generateOptions.forceInline || !!(this.inInline || this.inHeading);
       this.thisNodeIsPreText = false;
       const emptyMarks = node.marks.length === 0;
       if (emptyMarks) {
@@ -12671,13 +12740,33 @@ var TextGenerator = class extends AstWalkerGenerator {
     s += `|provider:${provider}`;
     this.write(s);
   }
-  writeFootnoteMark(_mark) {
+  writeFootnoteMark(mark) {
     const s = `footnote:`;
     this.write(s);
+    const text = this.internalTextGenerator?.generateSync(
+      mark.attrs?.content,
+      this.textFormat,
+      this.textLocation,
+      {
+        ...this.generateOptions,
+        forceInline: true
+      }
+    ) ?? "";
+    this.write(text);
   }
-  writeFootnoteStarMark(_mark) {
+  writeFootnoteStarMark(mark) {
     const s = `footnote*:`;
     this.write(s);
+    const text = this.internalTextGenerator?.generateSync(
+      mark.attrs?.content,
+      this.textFormat,
+      this.textLocation,
+      {
+        ...this.generateOptions,
+        forceInline: true
+      }
+    ) ?? "";
+    this.write(text);
   }
   writeSymbolMark(mark) {
     if (mark.attrs == null) return;
@@ -23684,6 +23773,12 @@ var Builder = class extends BaseBuilder {
         data.machineTranslated,
         options
       ),
+      translationOf: this.toAstProperty(
+        bitType,
+        ConfigKey.property_translationOf,
+        data.translationOf,
+        options
+      ),
       spansPageBreak: this.toAstProperty(
         bitType,
         ConfigKey.property_spansPageBreak,
@@ -24400,6 +24495,12 @@ var Builder = class extends BaseBuilder {
         data.hasPrintRestriction,
         options
       ),
+      enforceUpdateOverUserInput: this.toAstProperty(
+        bitType,
+        ConfigKey.property_enforceUpdateOverUserInput,
+        data.enforceUpdateOverUserInput,
+        options
+      ),
       tocResource: this.toAstProperty(
         bitType,
         ConfigKey.property_tocResource,
@@ -24427,6 +24528,12 @@ var Builder = class extends BaseBuilder {
       ),
       platformIcon: this.toImageResource(context, data.platformIcon),
       platformLogo: this.toImageResource(context, data.platformLogo),
+      platformLogoMaxHeight: this.toAstProperty(
+        bitType,
+        ConfigKey.property_platformLogoMaxHeight,
+        data.platformLogoMaxHeight,
+        options
+      ),
       platformPrimaryColor: this.toAstProperty(
         bitType,
         ConfigKey.property_platformPrimaryColor,
@@ -30075,6 +30182,7 @@ var JsonGenerator = class extends AstWalkerGenerator {
       if (instance2.isOfBitType(bitType, BitType.book)) {
         if (bitJson.maxTocChapterLevel == null) bitJson.maxTocChapterLevel = -1;
         if (bitJson.hasPrintRestriction == null) bitJson.hasPrintRestriction = true;
+        if (bitJson.enforceUpdateOverUserInput == null) bitJson.enforceUpdateOverUserInput = false;
         if (bitJson.hasMarkAsDone == null) bitJson.hasMarkAsDone = false;
         if (bitJson.processHandIn == null) bitJson.processHandIn = false;
         if (bitJson.isPublic == null) bitJson.isPublic = false;
@@ -30155,6 +30263,9 @@ var JsonGenerator = class extends AstWalkerGenerator {
       if (instance2.isOfBitType(bitType, BitType.platformBrandTarget)) {
         if (bitJson.platformBrandTarget == null) bitJson.platformBrandTarget = "none";
       }
+      if (instance2.isOfBitType(bitType, BitType.platformHeader)) {
+        if (bitJson.platformLogoMaxHeight == null) bitJson.platformLogoMaxHeight = 40;
+      }
       if (isTopLevelExample) {
         if (bitJson.isExample == null) bitJson.isExample = false;
       } else {
@@ -32368,6 +32479,9 @@ function parseFeedback(_context, _bitType, cardSet) {
               const choice = {
                 choice: tfTags.choice,
                 requireReason: tfTags.isCorrect,
+                item: tfTags.item,
+                lead: tfTags.lead,
+                instruction: tfTags.instruction,
                 __isDefaultExample,
                 example
               };
@@ -38162,8 +38276,8 @@ var FileWriter = class extends StreamWriter {
   async open() {
     return new Promise((resolve, reject) => {
       const flags = this._append ? "a" : "w";
-      fs4.ensureDirSync(path3.dirname(this._path.toString()));
-      const stream = fs4.createWriteStream(this._path, {
+      fs3.ensureDirSync(path3.dirname(this._path.toString()));
+      const stream = fs3.createWriteStream(this._path, {
         flags,
         encoding: "utf8"
       });
@@ -38237,8 +38351,8 @@ var SyncFileWriter = class {
   }
   openSync() {
     const flag = this._append ? "a" : "w";
-    fs4.ensureDirSync(path3.dirname(this._path.toString()));
-    fs4.writeFileSync(this._path, "", {
+    fs3.ensureDirSync(path3.dirname(this._path.toString()));
+    fs3.writeFileSync(this._path, "", {
       flag,
       encoding: this._encoding
     });
@@ -38255,7 +38369,7 @@ var SyncFileWriter = class {
     } else {
       line = this.endOfLineString;
     }
-    fs4.appendFileSync(this._path, line, {
+    fs3.appendFileSync(this._path, line, {
       encoding: this._encoding
     });
     this.lastWrite = line;
@@ -38273,7 +38387,7 @@ var SyncFileWriter = class {
       }
       str += this.endOfLineString;
     }
-    fs4.appendFileSync(this._path, str, {
+    fs3.appendFileSync(this._path, str, {
       encoding: this._encoding
     });
     this.lastWrite = str;
@@ -38283,7 +38397,7 @@ var SyncFileWriter = class {
     if (!this._open) return this;
     if (value == null) return this;
     if (value) this.lastWrite = value;
-    fs4.appendFileSync(this._path, value, {
+    fs3.appendFileSync(this._path, value, {
       encoding: this._encoding
     });
     return this;
@@ -38374,8 +38488,20 @@ var ConfigBuilder = class {
     this.buildFlat(opts);
     const bitConfigs = [];
     const groupConfigs = [];
-    const bitGroupConfigKeys = [];
+    const bitGroupConfigKeys = /* @__PURE__ */ new Set();
     const bitGroupConfigs = [];
+    for (const bt of Enum(BitType).values()) {
+      const bitType = instance2.getBitType(bt);
+      const _bitConfig = BITS[bitType];
+      if (_bitConfig?.baseBitType) {
+        let currentBitType = _bitConfig.baseBitType;
+        while (currentBitType) {
+          bitGroupConfigKeys.add(currentBitType);
+          const parentConfig = BITS[currentBitType];
+          currentBitType = parentConfig?.baseBitType;
+        }
+      }
+    }
     for (const bt of Enum(BitType).values()) {
       const bitType = instance2.getBitType(bt);
       const _bitConfig = BITS[bitType];
@@ -38396,9 +38522,24 @@ var ConfigBuilder = class {
     const outputFolder = opts.outputDir ?? "assets/config";
     const outputFolderBits = path3.join(outputFolder, "bits");
     const outputFolderGroups = path3.join(outputFolder, "partials");
-    fs4.ensureDirSync(outputFolderBits);
-    fs4.ensureDirSync(outputFolderGroups);
+    fs3.ensureDirSync(outputFolderBits);
+    fs3.ensureDirSync(outputFolderGroups);
+    const bitsFiles = fs3.readdirSync(outputFolderBits).filter((f) => f.endsWith(".jsonc"));
+    for (const file of bitsFiles) {
+      fs3.removeSync(path3.join(outputFolderBits, file));
+    }
+    const partialsFiles = fs3.readdirSync(outputFolderGroups).filter((f) => f.endsWith(".jsonc"));
+    for (const file of partialsFiles) {
+      fs3.removeSync(path3.join(outputFolderGroups, file));
+    }
     const fileWrites = [];
+    const resolveGroupReferences = (groupKey) => {
+      if (squashedGroups.has(groupKey)) {
+        const replacements = squashedGroups.get(groupKey);
+        return replacements.flatMap((r) => resolveGroupReferences(r));
+      }
+      return [groupKey];
+    };
     const keyToJsonKey = (key, tagNameChain) => {
       let jsonKey = key;
       if (key === "%") {
@@ -38462,10 +38603,13 @@ var ConfigBuilder = class {
         if (k.startsWith("group_")) k = k.substring(6);
         k = /*'_' +*/
         stringUtils.camelToKebab(k);
-        tags2.push({
-          type: "group",
-          key: k
-        });
+        const resolvedGroups = resolveGroupReferences(k);
+        for (const groupKey of resolvedGroups) {
+          tags2.push({
+            type: "group",
+            key: groupKey
+          });
+        }
         return tags2;
       }
       if (Array.isArray(tag.chain) && tag.chain.length > 0) {
@@ -38493,7 +38637,37 @@ var ConfigBuilder = class {
       tags2.push(t);
       return tags2;
     };
+    for (const bt of bitGroupConfigKeys) {
+      const bitType = instance2.getBitType(bt);
+      const _bitConfig = BITS[bitType];
+      if (_bitConfig) {
+        _bitConfig.bitType = bitType;
+        if (!bitGroupConfigs.some((c) => c.bitType === bitType)) {
+          bitGroupConfigs.push(_bitConfig);
+        }
+      }
+    }
+    const squashedGroups = /* @__PURE__ */ new Map();
+    for (const b of bitGroupConfigs) {
+      const groupKey = `group-${b.bitType}`;
+      const processedTags = [];
+      for (const [, tag] of Object.entries(b.tags ?? [])) {
+        processedTags.push(...processTagEntries(tag, []));
+      }
+      const allAreGroups = processedTags.every((t) => t.type === "group");
+      if (allAreGroups && processedTags.length > 0) {
+        const replacements = [];
+        if (b.baseBitType) {
+          replacements.push(`group-${b.baseBitType}`);
+        }
+        for (const t of processedTags) {
+          replacements.push(t.key);
+        }
+        squashedGroups.set(groupKey, replacements);
+      }
+    }
     for (const b of bitConfigs) {
+      const resolvedBitConfig = instance2.getBitConfig(b.bitType);
       const tags2 = [];
       const tagEntriesTypeOrder = [
         BitTagConfigKeyType.tag,
@@ -38510,46 +38684,51 @@ var ConfigBuilder = class {
         const typeOrder = tagEntriesTypeOrder.indexOf(typeA) - tagEntriesTypeOrder.indexOf(typeB);
         return typeOrder;
       });
-      if (b.baseBitType) {
-        tags2.push({
-          type: "group",
-          key: `group-${b.baseBitType}`
-        });
-        bitGroupConfigKeys.push(b.baseBitType);
-      }
-      for (const [_tagKey, tag] of tagEntries) {
-        tags2.push(...processTagEntries(tag, []));
+      const isInheritedFrom = bitGroupConfigKeys.has(b.bitType);
+      if (isInheritedFrom) {
+        const resolvedGroups = resolveGroupReferences(`group-${b.bitType}`);
+        for (const groupKey of resolvedGroups) {
+          tags2.push({
+            type: "group",
+            key: groupKey
+          });
+        }
+      } else {
+        if (b.baseBitType) {
+          const resolvedGroups = resolveGroupReferences(`group-${b.baseBitType}`);
+          for (const groupKey of resolvedGroups) {
+            tags2.push({
+              type: "group",
+              key: groupKey
+            });
+          }
+        }
+        for (const [_tagKey, tag] of tagEntries) {
+          tags2.push(...processTagEntries(tag, []));
+        }
       }
       const bitJson = {
         name: b.bitType,
         description: b.description ?? "",
-        since: b.since,
-        deprecated: b.deprecated,
+        since: resolvedBitConfig.since,
+        deprecated: resolvedBitConfig.deprecated,
         history: [
           {
-            version: b.since,
+            version: resolvedBitConfig.since,
             changes: ["Initial version"]
           }
         ],
-        format: b.textFormatDefault ?? "bitmark--",
-        bodyAllowed: b.bodyAllowed ?? true,
-        bodyRequired: b.bodyRequired ?? false,
-        footerAllowed: b.footerAllowed ?? true,
-        footerRequired: b.footerRequired ?? false,
-        resourceAttachmentAllowed: b.resourceAttachmentAllowed ?? true,
+        format: resolvedBitConfig.textFormatDefault ?? "bitmark--",
+        bodyAllowed: resolvedBitConfig.bodyAllowed ?? true,
+        bodyRequired: resolvedBitConfig.bodyRequired ?? false,
+        footerAllowed: resolvedBitConfig.footerAllowed ?? true,
+        footerRequired: resolvedBitConfig.footerRequired ?? false,
+        resourceAttachmentAllowed: resolvedBitConfig.resourceAttachmentAllowed ?? true,
         tags: tags2
       };
       const output = path3.join(outputFolderBits, `${b.bitType}.jsonc`);
       const str = JSON.stringify(bitJson, null, 2);
-      fileWrites.push(fs4.writeFile(output, str));
-    }
-    for (const bt of bitGroupConfigKeys) {
-      const bitType = instance2.getBitType(bt);
-      const _bitConfig = BITS[bitType];
-      if (_bitConfig) {
-        _bitConfig.bitType = bitType;
-        bitGroupConfigs.push(_bitConfig);
-      }
+      fileWrites.push(fs3.writeFile(output, str));
     }
     const writeGroupConfigs = (groupConfigs2) => {
       for (const g of groupConfigs2) {
@@ -38608,14 +38787,26 @@ var ConfigBuilder = class {
         };
         const output = path3.join(outputFolderGroups, `${groupKey}.jsonc`);
         const str = JSON.stringify(bitJson, null, 2);
-        fs4.writeFileSync(output, str);
+        fs3.writeFileSync(output, str);
       }
     };
     writeGroupConfigs(groupConfigs);
     const writeBitsAsGroupConfigs = (bitsAsGroupConfigs) => {
       for (const b of bitsAsGroupConfigs) {
         const groupKey = `group-${b.bitType}`;
+        if (squashedGroups.has(groupKey)) {
+          continue;
+        }
         const tags2 = [];
+        if (b.baseBitType) {
+          const resolvedGroups = resolveGroupReferences(`group-${b.baseBitType}`);
+          for (const gk of resolvedGroups) {
+            tags2.push({
+              type: "group",
+              key: gk
+            });
+          }
+        }
         const tagEntriesTypeOrder = [
           BitTagConfigKeyType.tag,
           BitTagConfigKeyType.property,
@@ -38649,10 +38840,88 @@ var ConfigBuilder = class {
         };
         const output = path3.join(outputFolderGroups, `${groupKey}.jsonc`);
         const str = JSON.stringify(bitJson, null, 2);
-        fs4.writeFileSync(output, str);
+        fs3.writeFileSync(output, str);
       }
     };
     writeBitsAsGroupConfigs(bitGroupConfigs);
+    Promise.all(fileWrites).then(() => {
+      const validationErrors = this.validateConfigTree(outputFolder);
+      if (validationErrors.length > 0) {
+        console.error("\n\u26A0\uFE0F  Config tree validation errors:");
+        for (const error of validationErrors) {
+          console.error(`  - ${error}`);
+        }
+        throw new Error(`Config tree validation failed with ${validationErrors.length} error(s)`);
+      } else {
+        console.log("\u2705 Config tree validation passed");
+      }
+    }).catch((err) => {
+      console.error("Error during config build or validation:", err);
+      throw err;
+    });
+  }
+  /**
+   * Validate the config tree for missing group references
+   * @param outputFolder - The folder containing the config files
+   * @returns Array of validation errors, empty if valid
+   */
+  validateConfigTree(outputFolder) {
+    const errors = [];
+    const outputFolderBits = path3.join(outputFolder, "bits");
+    const outputFolderGroups = path3.join(outputFolder, "partials");
+    const availableGroups = /* @__PURE__ */ new Set();
+    if (fs3.existsSync(outputFolderGroups)) {
+      const groupFiles = fs3.readdirSync(outputFolderGroups).filter((f) => f.endsWith(".jsonc"));
+      for (const file of groupFiles) {
+        const groupName = file.replace(".jsonc", "");
+        availableGroups.add(groupName);
+      }
+    }
+    const checkTags = (tags2, filePath, lineOffset) => {
+      for (let i = 0; i < tags2.length; i++) {
+        const tag = tags2[i];
+        if (tag.type === "group") {
+          if (!availableGroups.has(tag.key)) {
+            const line = lineOffset + i + 1;
+            errors.push(`Missing group reference '${tag.key}' in ${filePath}:${line}`);
+          }
+        }
+        if (tag.tags && Array.isArray(tag.tags)) {
+          checkTags(tag.tags, filePath, lineOffset + i + 1);
+        }
+      }
+    };
+    if (fs3.existsSync(outputFolderBits)) {
+      const bitFiles = fs3.readdirSync(outputFolderBits).filter((f) => f.endsWith(".jsonc"));
+      for (const file of bitFiles) {
+        const filePath = path3.join(outputFolderBits, file);
+        try {
+          const content = fs3.readFileSync(filePath, "utf-8");
+          const config = JSON.parse(content);
+          if (config.tags && Array.isArray(config.tags)) {
+            checkTags(config.tags, `bits/${file}`, 15);
+          }
+        } catch (err) {
+          errors.push(`Failed to parse ${file}: ${err}`);
+        }
+      }
+    }
+    if (fs3.existsSync(outputFolderGroups)) {
+      const groupFiles = fs3.readdirSync(outputFolderGroups).filter((f) => f.endsWith(".jsonc"));
+      for (const file of groupFiles) {
+        const filePath = path3.join(outputFolderGroups, file);
+        try {
+          const content = fs3.readFileSync(filePath, "utf-8");
+          const config = JSON.parse(content);
+          if (config.tags && Array.isArray(config.tags)) {
+            checkTags(config.tags, `partials/${file}`, 15);
+          }
+        } catch (err) {
+          errors.push(`Failed to parse ${file}: ${err}`);
+        }
+      }
+    }
+    return errors;
   }
   // Build flat bit configs
   buildFlat(options) {
@@ -38665,7 +38934,11 @@ var ConfigBuilder = class {
     }
     const outputFolder = opts.outputDir ?? "assets/config";
     const outputFolderBits = path3.join(outputFolder, "bits_flat");
-    fs4.ensureDirSync(outputFolderBits);
+    fs3.ensureDirSync(outputFolderBits);
+    const existingFiles = fs3.readdirSync(outputFolderBits).filter((f) => f.endsWith(".jsonc"));
+    for (const file of existingFiles) {
+      fs3.removeSync(path3.join(outputFolderBits, file));
+    }
     const processTagEntries = (tag) => {
       const tags2 = [];
       let tagName = tag.key;
@@ -38763,7 +39036,7 @@ var ConfigBuilder = class {
       };
       const output = path3.join(outputFolderBits, `${b.bitType}.jsonc`);
       const str = JSON.stringify(bitJson, null, 2);
-      fs4.writeFileSync(output, str);
+      fs3.writeFileSync(output, str);
     }
   }
 };
@@ -38901,8 +39174,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (inputIsString && fs4.existsSync(inStr)) {
-          inStr = fs4.readFileSync(inStr, {
+        if (inputIsString && fs3.existsSync(inStr)) {
+          inStr = fs3.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -39044,8 +39317,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (inputIsString && fs4.existsSync(inStr)) {
-          inStr = fs4.readFileSync(inStr, {
+        if (inputIsString && fs3.existsSync(inStr)) {
+          inStr = fs3.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -39103,8 +39376,8 @@ var BitmarkParserGenerator = class {
     const opts = Object.assign({}, options);
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (inputIsString && fs4.existsSync(inStr)) {
-          inStr = fs4.readFileSync(inStr, {
+        if (inputIsString && fs3.existsSync(inStr)) {
+          inStr = fs3.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -39164,8 +39437,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (inputIsString && fs4.existsSync(inStr)) {
-          inStr = fs4.readFileSync(inStr, {
+        if (inputIsString && fs3.existsSync(inStr)) {
+          inStr = fs3.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -39188,8 +39461,8 @@ var BitmarkParserGenerator = class {
         strRes = this.jsonStringifyPrettify(preRes, jsonOptions, true);
       }
       const flag = fileOptions.append ? "a" : "w";
-      fs4.ensureDirSync(path3.dirname(output));
-      fs4.writeFileSync(output, strRes, {
+      fs3.ensureDirSync(path3.dirname(output));
+      fs3.writeFileSync(output, strRes, {
         flag
       });
     } else {
@@ -39232,8 +39505,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (inputIsString && fs4.existsSync(inStr)) {
-          inStr = fs4.readFileSync(inStr, {
+        if (inputIsString && fs3.existsSync(inStr)) {
+          inStr = fs3.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -39246,8 +39519,8 @@ var BitmarkParserGenerator = class {
     if (opts.outputFile) {
       const output = opts.outputFile.toString();
       const flag = fileOptions.append ? "a" : "w";
-      fs4.ensureDirSync(path3.dirname(output));
-      fs4.writeFileSync(output, res, {
+      fs3.ensureDirSync(path3.dirname(output));
+      fs3.writeFileSync(output, res, {
         flag
       });
     } else {
@@ -39285,8 +39558,8 @@ var BitmarkParserGenerator = class {
     }
     if (!opts.inputFormat || opts.inputFormat === Input.file) {
       if (env.isNode) {
-        if (inputIsString && fs4.existsSync(inStr)) {
-          inStr = fs4.readFileSync(inStr, {
+        if (inputIsString && fs3.existsSync(inStr)) {
+          inStr = fs3.readFileSync(inStr, {
             encoding: "utf8"
           });
         }
@@ -39299,8 +39572,8 @@ var BitmarkParserGenerator = class {
     if (opts.outputFile) {
       const output = opts.outputFile.toString();
       const flag = fileOptions.append ? "a" : "w";
-      fs4.ensureDirSync(path3.dirname(output));
-      fs4.writeFileSync(output, res, {
+      fs3.ensureDirSync(path3.dirname(output));
+      fs3.writeFileSync(output, res, {
         flag
       });
     } else {
@@ -39345,8 +39618,8 @@ var BitmarkParserGenerator = class {
 init();
 async function readInput(input) {
   if (input !== void 0) {
-    if (await fs4.pathExists(input)) {
-      return fs4.readFile(input, "utf8");
+    if (await fs3.pathExists(input)) {
+      return fs3.readFile(input, "utf8");
     }
     return input;
   }
@@ -39359,8 +39632,8 @@ async function readInput(input) {
 async function writeOutput(content, outputFile, append = false) {
   const text = typeof content === "string" ? content : JSON.stringify(content);
   if (outputFile) {
-    await fs4.ensureDir(path3.dirname(outputFile));
-    await fs4.writeFile(outputFile, text, { flag: append ? "a" : "w" });
+    await fs3.ensureDir(path3.dirname(outputFile));
+    await fs3.writeFile(outputFile, text, { flag: append ? "a" : "w" });
   } else {
     console.log(text);
   }