@gmb/bitmark-parser-generator 5.35.0 → 5.36.0

package/dist/index.js

@@ -1351,6 +1351,7 @@ var propertyKeys = {
   property_dateEnd: "@dateEnd",
   property_decimalPlaces: "@decimalPlaces",
   property_deeplink: "@deeplink",
+  property_displayName: "@displayName",
   property_diffContext: "@diffContext",
   property_diffOp: "@diffOp",
   property_diffRef: "@diffRef",
@@ -2500,9 +2501,30 @@ var CARDSETS = {
   [CardSetConfigKey.definitionList]: {
     jsonKey: "definitions",
     exportJsonKey: { definitions: "$" },
+    // PLAN-141 F1 (NISO import): each <def-item> is one card; the sides
+    // read <term>/<def>; the enclosing <legend>'s <title> lands on the
+    // term side's heading tag ([#Key] header card).
+    // PLAN-141 F3: a <tbx:langSet> is ALSO one card (a terminology entry —
+    // its enclosing <tbx:termEntry> is a transparent claim wrapper); its
+    // children compose the term/definition sides via the side rules below.
+    mappingKeys: {
+      "xml-niso-iec": [
+        { "@el": "def-item", "@children": "$" },
+        { "@el": "tbx:langSet", "@children": "$" }
+      ]
+    },
     sides: [
       {
         name: "term",
+        // F3: every <tbx:tig>'s <tbx:term> STACKS one-per-line onto the
+        // single term side (the "$\n" template's authored separator; the
+        // trailing one is trimmed) — the PDF's Maus/Mus/M/Müsli stack.
+        mappingKeys: {
+          "xml-niso-iec": [
+            { "@el": "term", "@text": "$" },
+            { "@el": "tbx:tig", "@children": { "@el": "tbx:term", "@text": "$\n" } }
+          ]
+        },
         variants: [
           {
             jsonKey: "term.text",
@@ -2518,7 +2540,8 @@ var CARDSETS = {
                 format: TagFormat.plainText,
                 nullable: true,
                 jsonKey: "^heading.forKeys",
-                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } },
+                mappingKeys: { "xml-niso-iec": { "@el": "title", "@text": "$" } }
               },
               {
                 key: ConfigKey.group_resourceIcon,
@@ -2544,6 +2567,24 @@ var CARDSETS = {
       },
       {
         name: "definition",
+        // F3: the definition side COMPOSES from the entry's fields in
+        // document order, with the ES-rendered locale affixes AUTHORED as
+        // value-position templates (never engine text): the subject field
+        // in ⟨⟩ glues (trailing space) onto the definition line; example /
+        // notes / source follow as blank-line-separated lines. The TBX
+        // grammar flags (normativeAuthorization, termType, partOfSpeech,
+        // grammaticalNumber) are unrendered machine-only data — dropped and
+        // recorded (catalog R-2, reviewed under D7 max-preservation).
+        mappingKeys: {
+          "xml-niso-iec": [
+            { "@el": "def", "@children": "$" },
+            { "@el": "tbx:subjectField", "@text": "\u27E8$\u27E9 " },
+            { "@el": "tbx:definition", "@children": "$" },
+            { "@el": "tbx:example", "@children": "BEISPIEL $" },
+            { "@el": "tbx:note", "@children": "Anmerkung zu Begriff: $" },
+            { "@el": "tbx:source", "@text": "[QUELLE: $]" }
+          ]
+        },
         variants: [
           {
             jsonKey: "definition.text",
@@ -3934,6 +3975,11 @@ var CARDSETS = {
           { table: { header: { rows: ["$"] } } }
         ],
         htmlKey: { "@el": "thead", "@children": { "@el": "tr", "@children": "$" } },
+        // PLAN-141 F2 (NISO import): the XHTML table model NISO uses — a
+        // <thead> SECTION whose <tr> rows are the header cards.
+        mappingKeys: {
+          "xml-niso-iec": { "@el": "thead", "@children": { "@el": "tr", "@children": "$" } }
+        },
         sideJsonKey: "cells[{s}]|set(title=true)",
         sideExportJsonKey: { cells: { $s: { title: true, $: "$" } } },
         // Header cells are `<th>`. The `width` attribute is contributed by the
@@ -3945,12 +3991,21 @@ var CARDSETS = {
         jsonKey: "table.body.rows",
         exportJsonKey: { table: { body: { rows: "$" } } },
         htmlKey: { "@el": "tbody", "@children": { "@el": "tr", "@children": "$" } },
+        // PLAN-141 F2 (NISO import): <tbody> rows are the (default) data cards.
+        mappingKeys: {
+          "xml-niso-iec": { "@el": "tbody", "@children": { "@el": "tr", "@children": "$" } }
+        },
         isDefault: true
       },
       "table-footer": {
         jsonKey: "table.footer.rows",
         exportJsonKey: { table: { footer: { rows: "$" } } },
         htmlKey: { "@el": "tfoot", "@children": { "@el": "tr", "@children": "$" } },
+        // PLAN-141 F2 (NISO import): NISO has no <tfoot> — the footer card's
+        // source is the <table-wrap-foot> block (CONTENT-shaped: no rows; its
+        // prose/notes flatten into one footer card — catalog table-wrap-foot
+        // row; a contained <def-list> promotes as a sibling legend bit).
+        mappingKeys: { "xml-niso-iec": { "@el": "table-wrap-foot", "@children": "$" } },
         sideJsonKey: "cells[{s}]|set(title=true)",
         sideExportJsonKey: { cells: { $s: { title: true, $: "$" } } },
         // Footer cells render as `<th>` (mirrors the header `title: true`
@@ -3967,6 +4022,8 @@ var CARDSETS = {
         // Default (body) cell → `<td>`; the header/footer sections override the
         // side to `<th>` via their sideHtmlKey (HTML.md §8).
         htmlKey: { "@el": "td", "@children": "$" },
+        // PLAN-141 F2 (NISO import): a <td> row child is a body cell side.
+        mappingKeys: { "xml-niso-iec": { "@el": "td", "@children": "$" } },
         variants: [
           {
             jsonKey: "content",
@@ -3984,7 +4041,11 @@ var CARDSETS = {
                 // cell with `title: true` automatically.
                 jsonKey: "content",
                 exportJsonKey: { content: "$" },
-                description: "Title text of the table cell (header rows)."
+                description: "Title text of the table cell (header rows).",
+                // PLAN-141 F2 (NISO import): a <th> row child is a TITLE cell —
+                // its content lands in the `[#…]` tag (an empty <th> keeps its
+                // slot as a bare `[#]`).
+                mappingKeys: { "xml-niso-iec": { "@el": "th", "@children": "$" } }
               },
               {
                 key: ConfigKey.property_tableCellType,
@@ -4003,6 +4064,9 @@ var CARDSETS = {
                 // HTML-C2: contribute a `rowspan` attribute onto the enclosing
                 // cell element (`<th>`/`<td>`).
                 htmlKey: { "@el": { "@attr": { rowspan: "$" } } },
+                // PLAN-141 F2 (NISO import): recover the source cell's own
+                // `rowspan` attribute (element-scope attr form).
+                mappingKeys: { "xml-niso-iec": { "@el": { "@attr": { rowspan: "$" } } } },
                 description: "Number of rows the cell spans.",
                 format: TagFormat.number
               },
@@ -4013,6 +4077,9 @@ var CARDSETS = {
                 // HTML-C2: contribute a `colspan` attribute onto the enclosing
                 // cell element (`<th>`/`<td>`).
                 htmlKey: { "@el": { "@attr": { colspan: "$" } } },
+                // PLAN-141 F2 (NISO import): recover the source cell's own
+                // `colspan` attribute (element-scope attr form).
+                mappingKeys: { "xml-niso-iec": { "@el": { "@attr": { colspan: "$" } } } },
                 description: "Number of columns the cell spans.",
                 format: TagFormat.number
               },
@@ -4034,6 +4101,13 @@ var CARDSETS = {
                 // HTML.md §8 + HTML-C2: contribute a `width` attribute onto the
                 // enclosing cell element (`<th>`/`<td>`).
                 htmlKey: { "@el": { "@attr": { width: "$" } } },
+                // PLAN-141 F2 (NISO import): NISO carries widths as PER-COLUMN
+                // <col width="…"> descriptors at container level, not on cells.
+                // The matched values distribute positionally onto the first
+                // (header) card's sides. Number format ⇒ only an integral
+                // percentage survives ("20.0000%" → 20); a fractional one
+                // (renderer-equalised "4.7619%") is dropped — catalog `col` row.
+                mappingKeys: { "xml-niso-iec": { "@el": "col", "@attr": { width: "$" } } },
                 description: "Width for the column.",
                 format: TagFormat.number
               }
@@ -4407,7 +4481,22 @@ var GROUPS = {
         key: ConfigKey.property_externalId,
         description: "The external identifier for the bit",
         format: TagFormat.plainText,
-        maxCount: Count.infinity
+        maxCount: Count.infinity,
+        // PLAN-140 refs family (NISO import): the machine identifier of a
+        // referenced standard. NESTED content slot — the tag reads (and
+        // consumes) ONLY the <std-id> inside a <std> child; the remaining
+        // designation/title text stays bit body. A <std> without <std-id>
+        // does not fire the key.
+        // PLAN-141 F5: on the [.book] bit, the DATED <std-ref> designation
+        // is the document's external id. Safe rule order: <std-ref> is a
+        // direct bit-element child only under <std-meta> (everywhere else
+        // it nests inside <std>, which the tag spine never reaches).
+        mappingKeys: {
+          "xml-niso-iec": [
+            { "@el": "std", "@children": { "@el": "std-id", "@text": "$" } },
+            { "@el": "std-ref", "@attr": { type: "dated" }, "@text": "$" }
+          ]
+        }
       },
       {
         key: ConfigKey.property_sourceRL,
@@ -4548,7 +4637,8 @@ var GROUPS = {
       {
         key: ConfigKey.property_diffTime,
         description: "The diff time for the bit",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_ageRange,
@@ -4559,7 +4649,18 @@ var GROUPS = {
       {
         key: ConfigKey.property_lang,
         description: "The language for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        // PLAN-141 F3 (NISO import): a term-sec's language rides
+        // <tbx:termEntry><tbx:langSet xml:lang> — a nested content slot
+        // whose leaf is a $-in-ATTR-position slot (the nested counterpart
+        // of the value-attr slot). Only termEntry elements match, so the
+        // shared tag is inert everywhere else.
+        mappingKeys: {
+          "xml-niso-iec": {
+            "@el": "tbx:termEntry",
+            "@children": { "@el": "tbx:langSet", "@attr": { "xml:lang": "$" } }
+          }
+        }
       },
       {
         key: ConfigKey.property_publisher,
@@ -4758,6 +4859,9 @@ var GROUPS = {
         key: ConfigKey.tag_item,
         jsonKey: "item",
         exportJsonKey: { item: "$" },
+        // PLAN-140 W3 (NISO import): the clause/note label of a mapped
+        // source element ([%1], [%ANMERKUNG 1]).
+        mappingKeys: { "xml-niso-iec": { "@el": "label", "@text": "$" } },
         description: "The item for the bit",
         chain: [
           {
@@ -5720,7 +5824,20 @@ var GROUPS = {
         key: ConfigKey.property_language,
         description: "The language of the book",
         format: TagFormat.plainText,
-        maxCount: Count.infinity
+        maxCount: Count.infinity,
+        // PLAN-141 F5 (NISO import): only the PRIMARY (first)
+        // <content-language> survives — the maxEmits cap realises the
+        // catalog's document-language rule (extras drop, R-4).
+        mappingKeys: {
+          "xml-niso-iec": [
+            { predicates: [], maxEmits: 1, rule: { "@el": "content-language", "@text": "$" } }
+          ]
+        }
+      },
+      {
+        key: ConfigKey.property_displayName,
+        description: "The display name of the book",
+        format: TagFormat.plainText
       },
       {
         key: ConfigKey.property_customerExternalId,
@@ -5796,7 +5913,18 @@ var GROUPS = {
         description: "The title of the book",
         maxCount: 2,
         jsonKey: "title|multi(count=2, key=subtitle)",
-        exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }]
+        exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }],
+        // PLAN-141 F5 (NISO import): the PRIMARY (first) <title-wrap>'s
+        // assembled <full> title → [#]; the per-language extras drop (R-4).
+        mappingKeys: {
+          "xml-niso-iec": [
+            {
+              predicates: [],
+              maxEmits: 1,
+              rule: { "@el": "title-wrap", "@children": { "@el": "full", "@text": "$" } }
+            }
+          ]
+        }
       },
       {
         key: ConfigKey.property_subtype,
@@ -6109,17 +6237,20 @@ var GROUPS = {
       {
         key: ConfigKey.property_platformMargin,
         description: "The platform margin",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_platformBorderRadius,
         description: "The platform border radius",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_platformSelectionBorderRadius,
         description: "The platform selection border radius",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_platformNeedsShadow,
@@ -6226,7 +6357,13 @@ var GROUPS = {
       {
         key: ConfigKey.property_caption,
         description: "The caption for the resource",
-        format: TagFormat.bitmarkText
+        format: TagFormat.bitmarkText,
+        // PLAN-141 F1 (NISO import): a figure's <caption><title> — the
+        // nested content slot reads the title text; the caption rides the
+        // resource chain ([&image:…][@caption:…], catalog D5).
+        mappingKeys: {
+          "xml-niso-iec": { "@el": "caption", "@children": { "@el": "title", "@text": "$" } }
+        }
       },
       {
         key: ConfigKey.property_showInIndex,
@@ -6500,6 +6637,10 @@ var GROUPS = {
       {
         key: ConfigKey.resource_image,
         exportJsonKey: { resource: { type: "image", image: { src: "$" } } },
+        // PLAN-141 F1 (NISO import): the image URL rides the `$`-in-attr
+        // value slot — a <graphic xlink:href> child of the mapped bit
+        // element roots the [&image:URL] chain.
+        mappingKeys: { "xml-niso-iec": { "@el": "graphic", "@attr": { "xlink:href": "$" } } },
         description: "The image resource",
         chain: [
           {
@@ -7374,6 +7515,8 @@ var BITS = {
         maxCount: 2,
         jsonKey: "title|multi(count=2, key=subtitle)",
         exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }],
+        // PLAN-140 W3 (NISO import): the title of a mapped source element.
+        mappingKeys: { "xml-niso-iec": { "@el": "title", "@text": "$" } },
         key: ConfigKey.tag_title,
         description: "The title of the article"
       }
@@ -7415,12 +7558,56 @@ var BITS = {
   [BitType.smartStandardArticleNormative]: {
     since: "1.28.0",
     baseBitType: BitType.standardArticleNormative,
-    description: "Smart standard normative article bit"
+    description: "Smart standard normative article bit",
+    // PLAN-140 W3 (NISO import, tranche 1): one article bit per NISO
+    // paragraph (catalog D1). CONTENT keys (@children): the subtree is the
+    // bit's body; nothing inside it promotes. (Ancestor-context normativity
+    // is the non-normative sibling's @ancestor key — plan Q4, resolved.)
+    //
+    // Second rule (catalog D1 push-down): a NUMBERED-PARAGRAPH sec is an
+    // article, not a chapter — the sec-type literal outranks the chapter
+    // key's plain sec|app rule (most-specific-wins). Content key: the sec's
+    // label rides [%] via the label tag key, its inner <p> is the body, its
+    // id is the bit's customerId, and the anchor slot marks it
+    // anchor-bearing.
+    mappingKeys: {
+      "xml-niso-iec": [
+        { "@el": "p", "@attr": { id: "$customerId" }, "@children": "$" },
+        {
+          "@el": "sec",
+          "@attr": { "sec-type": "numbered-paragraph", id: "$customerId" },
+          "@children": "$",
+          "\u25BC": "$anchor"
+        }
+      ]
+    }
   },
   [BitType.smartStandardArticleNonNormative]: {
     since: "1.28.0",
     baseBitType: BitType.standardArticleNonNormative,
-    description: "Smart standard non-normative article bit"
+    description: "Smart standard non-normative article bit",
+    // PLAN-140 Q4 (normativity inheritance): a <p> is non-normative because
+    // of an ANCESTOR element — a foreword/intro sec or an informative annex.
+    // @ancestor is a reverse-match-only constraint (forward emission ignores
+    // it); the rules are alternatives, first-satisfied wins, and the
+    // @ancestor literals give this key higher specificity than the plain
+    // normative-article <p> key wherever the context applies.
+    mappingKeys: {
+      "xml-niso-iec": [
+        {
+          "@el": "p",
+          "@attr": { id: "$customerId" },
+          "@ancestor": { "@attr": { "sec-type": "foreword|intro" } },
+          "@children": "$"
+        },
+        {
+          "@el": "p",
+          "@attr": { id: "$customerId" },
+          "@ancestor": { "@attr": { "content-type": "informative" } },
+          "@children": "$"
+        }
+      ]
+    }
   },
   [BitType.smartStandardArticleNormativeCollapsible]: {
     since: "1.28.0",
@@ -8051,7 +8238,8 @@ var BITS = {
       {
         key: ConfigKey.property_maxCreatedBits,
         description: "The maximum number of bits that can be created from this bit",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       }
     ],
     textFormatDefault: TextFormat.plainText
@@ -8181,6 +8369,13 @@ var BITS = {
     since: "1.3.0",
     baseBitType: BitType._standard,
     description: "Book bit, used to represent a book",
+    // PLAN-141 F5 (NISO import): the <std-meta> front-matter container is
+    // the [.book] bit (STRUCTURAL, first in document order): primary
+    // title-wrap → [#], primary content-language → [@language], dated
+    // std-ref → [@externalId] (tag keys with maxEmits caps — the NISO
+    // convention puts the document language first). std-meta has no id, so
+    // no anchor/customerId. Remaining leaves drop as recorded loss (R-4).
+    mappingKeys: { "xml-niso-iec": { "@el": "std-meta" } },
     tags: [
       {
         key: ConfigKey.group_bookCommon,
@@ -8467,12 +8662,14 @@ var BITS = {
       {
         key: ConfigKey.property_focusX,
         description: "The X coordinate for focusing the image in the browser",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_focusY,
         description: "The Y coordinate for focusing the image in the browser",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       }
     ]
   },
@@ -8503,6 +8700,15 @@ var BITS = {
     since: "1.3.0",
     baseBitType: BitType._standard,
     description: "Chapter bit, used to define chapters in books or articles",
+    // PLAN-140 W3 (NISO import, tranche 1): recover a chapter from a NISO
+    // section or annex. STRUCTURAL key (no @children content slot): the
+    // element carries no body of its own — tag children (label/title) map
+    // via tag keys, every mapped descendant promotes to a following sibling
+    // bit, and the chapter level derives from nesting depth (catalog D1).
+    // The source id lands as [@customerId] (two-id model, D2).
+    mappingKeys: {
+      "xml-niso-iec": { "@el": "sec|app", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" }
+    },
     tags: [
       {
         exportJsonKey: { anchor: "$" },
@@ -8514,7 +8720,10 @@ var BITS = {
         key: ConfigKey.tag_title,
         description: "The title of the chapter",
         jsonKey: "title|setMulti(level)",
-        exportJsonKey: { title: "$", level: "$level" }
+        exportJsonKey: { title: "$", level: "$level" },
+        // PLAN-140 W3 (NISO import): the section/annex title; the heading
+        // level rides the normalizer-derived nesting depth (plan Q2).
+        mappingKeys: { "xml-niso-iec": { "@el": "title", "@text": "$" } }
       },
       {
         key: ConfigKey.property_toc,
@@ -8720,11 +8929,28 @@ var BITS = {
     since: "1.3.0",
     baseBitType: BitType._standard,
     description: "Code bit, used for code snippets in articles or documents",
+    // PLAN-141 F4 (NISO import): a <code> block is a CONTENT bit with a
+    // literal text body; @language recovers as [@computerLanguage] (absent
+    // attr → no tag). Anchor = the source id (D2 revised).
+    mappingKeys: {
+      "xml-niso-iec": {
+        "@el": "code",
+        "@attr": { id: "$customerId", language: "$computerLanguage" },
+        "\u25BC": "$anchor",
+        "@text": "$"
+      }
+    },
     tags: [
       {
         key: ConfigKey.property_computerLanguage,
         description: "The programming language of the code snippet",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        // PLAN-141 F4 (NISO import): the bit key's `language` sigil recovers
+        // a present attr; this `@absent` rule supplies the AUTHORED default
+        // when the source carries none (catalog code row — an untyped block
+        // is `[@computerLanguage:text]`). Fires only on foreign imports,
+        // never the carrier round-trip.
+        mappingKeys: { "xml-niso-iec": [{ "@absent": "text" }] }
       },
       {
         key: ConfigKey.property_codeLineNumbers,
@@ -8763,7 +8989,20 @@ var BITS = {
   [BitType.smartStandardFormulaNormative]: {
     since: "3.11.0",
     baseBitType: BitType.formula,
-    description: "Smart standard normative formula bit, used for mathematical formulas in smart standards that are normative"
+    description: "Smart standard normative formula bit, used for mathematical formulas in smart standards that are normative",
+    // PLAN-141 F4 (NISO import): a <disp-formula> is a CONTENT bit whose
+    // latex-format body carries the <mml:math> subtree VERBATIM (G1 — no
+    // MathML↔LaTeX transform; ids stripped); <label> → [%]; a contained
+    // <legend> PROMOTES as a sibling legend bit (cards cannot nest in a
+    // body). Anchor = the source id (D2 revised).
+    mappingKeys: {
+      "xml-niso-iec": {
+        "@el": "disp-formula",
+        "@attr": { id: "$customerId" },
+        "\u25BC": "$anchor",
+        "@children": "$"
+      }
+    }
   },
   [BitType.smartStandardRemarkFormula]: {
     since: "3.11.0",
@@ -9290,7 +9529,8 @@ var BITS = {
       {
         key: ConfigKey.property_reasonableNumOfChars,
         description: "The reasonable number of characters for the essay",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_sampleSolution,
@@ -9723,7 +9963,14 @@ var BITS = {
   [BitType.smartStandardList]: {
     since: "1.28.0",
     baseBitType: BitType.standardList,
-    description: "Smart standard list bit, used to create smart standard lists in articles or books"
+    description: "Smart standard list bit, used to create smart standard lists in articles or books",
+    // PLAN-140 refs family (NISO import): a reference list is a STRUCTURAL
+    // bit (no @children — it takes a path ordinal anchor and its <ref>
+    // children promote to sibling list-item bits); its <title> rides [#]
+    // via the title tag key.
+    mappingKeys: {
+      "xml-niso-iec": { "@el": "ref-list", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" }
+    }
   },
   [BitType.smartStandardListCollapsible]: {
     since: "1.28.0",
@@ -9768,7 +10015,17 @@ var BITS = {
   [BitType.smartStandardNoteNonNormative]: {
     since: "1.28.0",
     baseBitType: BitType.standardNoteNonNormative,
-    description: "Smart standard non-normative note bit, used to provide non-normative notes in smart standards"
+    description: "Smart standard non-normative note bit, used to provide non-normative notes in smart standards",
+    // PLAN-140 W3 (NISO import, tranche 1). CONTENT key (@children): a
+    // note's inner paragraphs are note body, never separate bits.
+    mappingKeys: {
+      "xml-niso-iec": {
+        "@el": "non-normative-note",
+        "@attr": { id: "$customerId" },
+        "@children": "$",
+        "\u25BC": "$anchor"
+      }
+    }
   },
   [BitType.smartStandardNoteNormativeCollapsible]: {
     since: "1.28.0",
@@ -9875,7 +10132,19 @@ var BITS = {
   [BitType.smartStandardRemarkNonNormative]: {
     since: "1.28.0",
     baseBitType: BitType.standardRemarkNonNormative,
-    description: "Smart standard non-normative remark bit, used to provide non-normative remarks in smart standards"
+    description: "Smart standard non-normative remark bit, used to provide non-normative remarks in smart standards",
+    // PLAN-140 Q4 rider: a warning/caution note routes to the remark bit —
+    // the same element as the note key, distinguished by the content-type
+    // attr literal (alias value: forward emits the first alternative,
+    // reverse accepts any). Most-specific-wins beats the plain note key.
+    mappingKeys: {
+      "xml-niso-iec": {
+        "@el": "non-normative-note",
+        "@attr": { "content-type": "warning|caution", id: "$customerId" },
+        "@children": "$",
+        "\u25BC": "$anchor"
+      }
+    }
   },
   [BitType.smartStandardRemarkNormativeCollapsible]: {
     since: "1.28.0",
@@ -10331,7 +10600,8 @@ var BITS = {
       {
         key: ConfigKey.property_pageNo,
         description: "Page number for the block, used to indicate the page on which the block appears",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_x,
@@ -10348,17 +10618,20 @@ var BITS = {
       {
         key: ConfigKey.property_width,
         description: "Width of the block, used to define the size of the block on the page",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_height,
         description: "Height of the block, used to define the size of the block on the page",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_index,
         description: "Index of the block, used to order blocks within the extractor page",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_classification,
@@ -10668,7 +10941,20 @@ var BITS = {
   [BitType.smartStandardLegendNormative]: {
     since: "3.12.0",
     baseBitType: BitType.legend,
-    description: "Smart standard normative legend bit, used to provide normative smart standard legends in articles or books"
+    description: "Smart standard normative legend bit, used to provide normative smart standard legends in articles or books",
+    // PLAN-141 F2 (NISO import): a free-standing <legend> (a formula's) or
+    // bare <def-list> (a table footer's — no <legend> wrapper there) that is
+    // NOT the claimed card content of its enclosing bit is a legend bit:
+    // STRUCTURAL-shaped, its <title> and <def-item>s build the
+    // definition-list cards via the card set's authored keys. A <legend>
+    // inside a figure/table bit stays that bit's claimed card content and
+    // never reaches this key. Anchor = the source id (D2 revised).
+    mappingKeys: {
+      "xml-niso-iec": [
+        { "@el": "legend", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" },
+        { "@el": "def-list", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" }
+      ]
+    }
   },
   [BitType.smartStandardRemarkLegend]: {
     since: "3.12.0",
@@ -10723,7 +11009,16 @@ var BITS = {
   [BitType.smartStandardDefinitionListNormative]: {
     since: "5.24.0",
     baseBitType: BitType.standardDefinitionListNormative,
-    description: "Smart standard normative definition list bit, used to create normative smart standard definition lists in articles or books"
+    description: "Smart standard normative definition list bit, used to create normative smart standard definition lists in articles or books",
+    // PLAN-141 F3 (NISO import): a terms-and-definitions clause. STRUCTURAL-
+    // shaped: <label> → [%], the tbx:termEntry/langSet subtree builds the
+    // definition-list card via the card set's authored keys (all tig terms
+    // stacked on the term side; definition/example/notes/source composed on
+    // the definition side with authored locale affixes), langSet @xml:lang →
+    // [@lang] (nested attr slot on the tag key). Anchor = the source id.
+    mappingKeys: {
+      "xml-niso-iec": { "@el": "term-sec", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" }
+    }
   },
   [BitType.smartStandardDefinitionListNonNormative]: {
     since: "5.24.0",
@@ -10792,12 +11087,14 @@ var BITS = {
       {
         key: ConfigKey.property_focusX,
         description: "X-coordinate for the focus point, used to define the focus area in the image",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_focusY,
         description: "Y-coordinate for the focus point, used to define the focus area in the image",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       }
     ]
   },
@@ -10904,7 +11201,15 @@ var BITS = {
   [BitType.smartStandardImageFigureNormative]: {
     since: "1.28.0",
     baseBitType: BitType.standardImageFigureNormative,
-    description: "Smart standard normative image figure bit, used to create smart standard normative image figures in articles or books"
+    description: "Smart standard normative image figure bit, used to create smart standard normative image figures in articles or books",
+    // PLAN-141 F1 (NISO import): a figure is STRUCTURAL-shaped (no
+    // @children — no body): <label> → [%], <caption>/<graphic> ride the
+    // [&image] resource chain, the <legend> def-list becomes the bit's
+    // definition-list cards, and an inner note PROMOTES as a sibling bit.
+    // Anchor = the source id (D2 revised).
+    mappingKeys: {
+      "xml-niso-iec": { "@el": "fig", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" }
+    }
   },
   [BitType.smartStandardImageFigureNonNormative]: {
     since: "1.28.0",
@@ -11632,7 +11937,19 @@ var BITS = {
   [BitType.smartStandardListItem]: {
     since: "1.28.0",
     baseBitType: BitType.standardListItem,
-    description: "Smart standard list item bit, used to create smart standard list items in articles or books"
+    description: "Smart standard list item bit, used to create smart standard list items in articles or books",
+    // PLAN-140 refs family (NISO import): one list-item bit per <ref> —
+    // CONTENT key (its citation subtree is the body), counter anchor scoped
+    // to the containing list, <label> → [%], nested <std-id> → [@externalId]
+    // (the externalId tag key's nested content slot).
+    mappingKeys: {
+      "xml-niso-iec": {
+        "@el": "ref",
+        "@attr": { id: "$customerId" },
+        "@children": "$",
+        "\u25BC": "$anchor"
+      }
+    }
   },
   [BitType.smartStandardListItemCollapsible]: {
     since: "1.28.0",
@@ -12739,7 +13056,13 @@ var BITS = {
         // `<caption>` — placed inside the idiomatic `<table>` container as
         // its first child. Outside a table context it falls back to the
         // residual carrier.
-        htmlKey: { "@el": "caption", "@children": "$" }
+        htmlKey: { "@el": "caption", "@children": "$" },
+        // PLAN-141 F2 (NISO import): a table-wrap's <caption><title> — the
+        // nested content slot reads the title text (catalog D5: the caption
+        // is a TOP-LEVEL bit property on table bits).
+        mappingKeys: {
+          "xml-niso-iec": { "@el": "caption", "@children": { "@el": "title", "@text": "$" } }
+        }
       },
       {
         key: ConfigKey.property_tableFixedHeader,
@@ -12912,7 +13235,16 @@ var BITS = {
   [BitType.smartStandardTableExtendedNormative]: {
     since: "1.28.0",
     baseBitType: BitType.standardTableExtendedNormative,
-    description: "Smart standard normative extended table bit, used to create smart standard normative extended tables in articles or books"
+    description: "Smart standard normative extended table bit, used to create smart standard normative extended tables in articles or books",
+    // PLAN-141 F2 (NISO import): a table-wrap is STRUCTURAL-shaped (no
+    // @children — no body): <label> → [%], <caption><title> → the bit-level
+    // [@caption] (D5), the inner <table>/<table-wrap-foot> build the
+    // table-extended card grid via the card set's authored keys, and a
+    // footer <def-list> PROMOTES as a sibling legend bit. Anchor = the
+    // source id (D2 revised).
+    mappingKeys: {
+      "xml-niso-iec": { "@el": "table-wrap", "@attr": { id: "$customerId" }, "\u25BC": "$anchor" }
+    }
   },
   [BitType.smartStandardTableExtendedNonNormative]: {
     since: "1.28.0",
@@ -12987,7 +13319,8 @@ var BITS = {
       {
         key: ConfigKey.property_maxDisplayLevel,
         description: "Maximum display level for the chapter in the table of contents",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       }
     ]
   },
@@ -12999,7 +13332,8 @@ var BITS = {
       {
         key: ConfigKey.property_maxTocChapterLevel,
         description: "Maximum chapter level for the inline table of contents",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       }
     ]
   },
@@ -13422,13 +13756,15 @@ var BITS = {
         key: ConfigKey.property_width,
         // Same as image
         description: "Width for the embedded content, used to define the width in pixels",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_height,
         // Same as image
         description: "Height for the embedded content, used to define the height in pixels",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       },
       {
         key: ConfigKey.property_vendorUrl,
@@ -13466,7 +13802,8 @@ var BITS = {
       {
         key: ConfigKey.property_jupyterExecutionCount,
         description: "Execution count for the Jupyter output, used to define the execution order",
-        format: TagFormat.number
+        format: TagFormat.number,
+        nullable: true
       }
     ],
     textFormatDefault: TextFormat.plainText
@@ -14016,7 +14353,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.35.0",
+  "version": "5.36.0",
   "author": "Get More Brain Ltd",
   "license": "ISC",
   "description": "A bitmark parser and generator using Peggy.js"
@@ -14545,6 +14882,8 @@ var NodeType = {
   definition: "definition",
   definitions: "definitions",
   definitionsValue: "definitionsValue",
+  displayName: "displayName",
+  displayNameValue: "displayNameValue",
   diffContext: "diffContext",
   diffContextValue: "diffContextValue",
   diffOp: "diffOp",
@@ -28467,6 +28806,12 @@ var Builder = class extends BaseBuilder {
         data.publisherName,
         options
       ),
+      displayName: this.toAstProperty(
+        bitType,
+        ConfigKey.property_displayName,
+        data.displayName,
+        options
+      ),
       theme: this.toAstProperty(bitType, ConfigKey.property_theme, data.theme, options),
       rtl: this.toAstProperty(bitType, ConfigKey.property_rtl, data.rtl, options),
       computerLanguage: this.toAstProperty(
@@ -44629,7 +44974,7 @@ var ConfigBuilder = class {
     }
     const outputFolder = opts.outputDir ?? "assets/config";
     const outputFolderBits = path3.join(outputFolder, "bits");
-    const outputFolderGroups = path3.join(outputFolder, "partials");
+    const outputFolderGroups = path3.join(outputFolder, "groups");
     const outputFolderCards = path3.join(outputFolder, "cards");
     fs3.ensureDirSync(outputFolderBits);
     fs3.ensureDirSync(outputFolderGroups);
@@ -44664,6 +45009,15 @@ var ConfigBuilder = class {
       }
       return [{ key: groupKey }];
     };
+    const mappingKeysField = (base, json, html) => {
+      const record = {};
+      for (const [id, value] of Object.entries(base ?? {})) {
+        if (value != null) record[id] = value;
+      }
+      if (json.present && json.value != null) record.json = json.value;
+      if (html.present && html.value != null) record.html = html.value;
+      return Object.keys(record).length > 0 ? { mappingKeys: record } : {};
+    };
     const bareKeyForProperty = (key) => {
       if (key.startsWith("@") || key.startsWith("&")) return key.substring(1);
       return void 0;
@@ -44684,22 +45038,20 @@ var ConfigBuilder = class {
         if (tag.format === TagFormat.plainText) {
           format = "string";
         } else if (tag.format === TagFormat.boolean) {
-          format = "bool";
-        } else if (tag.format === TagFormat.bitmarkText) {
-          format = "bitmark";
+          format = "boolean";
         } else if (tag.format === TagFormat.number) {
           format = "number";
         } else {
-          format = "bitmark--";
+          format = "bitmark+";
         }
       } else if (tagType === BitTagConfigKeyType.property) {
         tagName = tag.key;
         if (tag.format === TagFormat.plainText) {
           format = "string";
         } else if (tag.format === TagFormat.boolean) {
-          format = "bool";
+          format = "boolean";
         } else if (tag.format === TagFormat.bitmarkText) {
-          format = "bitmark";
+          format = "bitmark+";
         } else if (tag.format === TagFormat.number) {
           format = "number";
         } else if (tag.format === TagFormat.coordinates) {
@@ -44731,8 +45083,11 @@ var ConfigBuilder = class {
           tags2.push({
             type: "group",
             key: ref.key,
-            ...hasExportChosen ? { jsonKey: exportJsonKeyChosen } : {},
-            ...hasHtmlChosen ? { htmlKey: htmlKeyChosen } : {},
+            ...mappingKeysField(
+              { ...ref.extraKeys ?? {}, ...tag.mappingKeys ?? {} },
+              { value: exportJsonKeyChosen, present: hasExportChosen },
+              { value: htmlKeyChosen, present: hasHtmlChosen }
+            ),
             ...min != null ? { min } : {},
             ...max != null ? { max } : {},
             ...description ? { description } : {}
@@ -44749,53 +45104,48 @@ var ConfigBuilder = class {
         chain = chainTags;
       }
       const hasExport = Object.prototype.hasOwnProperty.call(tag, "exportJsonKey");
-      let exportJsonKeyField;
-      if (hasExport) {
-        exportJsonKeyField = { jsonKey: tag.exportJsonKey };
-      } else if (legacyIsTrivialDefault(tag)) {
-        exportJsonKeyField = {};
-      } else {
+      if (!hasExport && !legacyIsTrivialDefault(tag)) {
         const headingPath = [...pathStack, `tags.${tag.key}`].join(" / ");
         exportJsonKeyErrors.push(
           `Missing exportJsonKey for non-default jsonKey at ${headingPath}` + (tag.jsonKey ? ` (legacy: \`${tag.jsonKey}\`)` : ` (symbol-mapped tag \`${tag.key}\`)`)
         );
-        exportJsonKeyField = {};
       }
       const hasHtml = Object.prototype.hasOwnProperty.call(tag, "htmlKey");
-      const htmlKeyField = hasHtml ? { htmlKey: tag.htmlKey } : {};
       const t = {
         type: "tag",
         key: tagName,
-        ...exportJsonKeyField,
-        ...htmlKeyField,
-        format,
-        default: tag.defaultValue ?? null,
+        ...mappingKeysField(
+          tag.mappingKeys,
+          { value: tag.exportJsonKey, present: hasExport },
+          { value: tag.htmlKey, present: hasHtml }
+        ),
+        ...format && format !== "string" ? { format } : {},
+        ...tag.defaultValue != null ? { default: tag.defaultValue } : {},
         ...tag.nullable ? { nullable: true } : {},
-        min: tag.minCount == null ? 0 : tag.minCount,
-        max: tag.maxCount == null ? 1 : tag.maxCount,
+        ...tag.minCount != null && tag.minCount !== 0 ? { min: tag.minCount } : {},
+        ...tag.maxCount != null && tag.maxCount !== 1 ? { max: tag.maxCount } : {},
         description: tag.description ?? "",
         tags: chain
       };
       tags2.push(t);
       return tags2;
     };
-    const cardJsonKeyField = (container, legacyKey, exportKey, pathHeading) => {
+    const cardMappingKeysField = (container, base, legacyKey, exportKey, htmlExportKey, pathHeading) => {
       const c = container;
       const hasExport = Object.prototype.hasOwnProperty.call(c, exportKey);
-      if (hasExport) return { jsonKey: c[exportKey] };
-      const legacy = c[legacyKey];
-      if (legacy == null) return {};
-      exportJsonKeyErrors.push(
-        `Missing exportJsonKey for non-default jsonKey at ${pathHeading} (legacy: \`${legacy}\`)`
-      );
-      return {};
-    };
-    const cardHtmlKeyField = (container, htmlExportKey) => {
-      const c = container;
-      if (Object.prototype.hasOwnProperty.call(c, htmlExportKey)) {
-        return { htmlKey: c[htmlExportKey] };
+      if (!hasExport && c[legacyKey] != null) {
+        exportJsonKeyErrors.push(
+          `Missing exportJsonKey for non-default jsonKey at ${pathHeading} (legacy: \`${c[legacyKey]}\`)`
+        );
       }
-      return {};
+      return mappingKeysField(
+        base,
+        { value: c[exportKey], present: hasExport },
+        {
+          value: c[htmlExportKey],
+          present: Object.prototype.hasOwnProperty.call(c, htmlExportKey)
+        }
+      );
     };
     const serializeCardSet = (cardSetKey) => {
       const variantBodyFormat = (variant) => variant.format ?? TextFormat.bitmarkText;
@@ -44826,11 +45176,17 @@ var ConfigBuilder = class {
             variantTags.push(...processTagEntries(variantTag, [variantPath]));
           }
           return {
-            ...cardJsonKeyField(variant, "jsonKey", "exportJsonKey", variantPath),
-            ...cardHtmlKeyField(variant, "htmlKey"),
-            format: variantBodyFormat(variant),
+            ...cardMappingKeysField(
+              variant,
+              void 0,
+              "jsonKey",
+              "exportJsonKey",
+              "htmlKey",
+              variantPath
+            ),
+            bodyFormat: variantBodyFormat(variant),
             tags: variantTags,
-            repeatCount: variant.repeatCount ?? 1,
+            ...variant.repeatCount != null && variant.repeatCount !== 1 ? { repeatCount: variant.repeatCount } : {},
             ...variant.bodyRequired ? { bodyRequired: true } : {},
             ...variant.bodyAllowed === false ? { bodyForbidden: true } : {}
           };
@@ -44838,8 +45194,14 @@ var ConfigBuilder = class {
         return {
           name: side.name,
           ...side.repeat ? { repeat: side.repeat } : {},
-          ...cardJsonKeyField(side, "jsonKey", "exportJsonKey", sidePath),
-          ...cardHtmlKeyField(side, "htmlKey"),
+          ...cardMappingKeysField(
+            side,
+            side.mappingKeys,
+            "jsonKey",
+            "exportJsonKey",
+            "htmlKey",
+            sidePath
+          ),
           variants
         };
       });
@@ -44850,20 +45212,40 @@ var ConfigBuilder = class {
           const hasSideHtml = Object.prototype.hasOwnProperty.call(section, "sideHtmlKey");
           let cardSides = sides;
           if (hasSideExport || section.sideJsonKey != null || hasSideHtml) {
-            const sideOverride = cardJsonKeyField(
-              section,
-              "sideJsonKey",
-              "sideExportJsonKey",
-              `${sectionPath} / sides.*`
-            );
-            const sideHtmlOverride = cardHtmlKeyField(section, "sideHtmlKey");
-            cardSides = sides.map((s) => ({ ...s, ...sideOverride, ...sideHtmlOverride }));
+            if (!hasSideExport && section.sideJsonKey != null) {
+              exportJsonKeyErrors.push(
+                `Missing exportJsonKey for non-default jsonKey at ${sectionPath} / sides.* (legacy: \`${section.sideJsonKey}\`)`
+              );
+            }
+            cardSides = sides.map((s) => {
+              const record = { ...s.mappingKeys ?? {} };
+              if (hasSideExport) {
+                if (section.sideExportJsonKey != null) record.json = section.sideExportJsonKey;
+                else delete record.json;
+              }
+              if (hasSideHtml) {
+                if (section.sideHtmlKey != null) record.html = section.sideHtmlKey;
+                else delete record.html;
+              }
+              return {
+                name: s.name,
+                ...s.repeat ? { repeat: s.repeat } : {},
+                ...Object.keys(record).length > 0 ? { mappingKeys: record } : {},
+                variants: s.variants
+              };
+            });
           }
           return {
             name: sectionName,
             ...section.isDefault ? { isDefault: true } : {},
-            ...cardJsonKeyField(section, "jsonKey", "exportJsonKey", sectionPath),
-            ...cardHtmlKeyField(section, "htmlKey"),
+            ...cardMappingKeysField(
+              section,
+              section.mappingKeys,
+              "jsonKey",
+              "exportJsonKey",
+              "htmlKey",
+              sectionPath
+            ),
             // PLAN-085: per-section cardinality. Emit only when non-default
             // (treat `0` / undefined as "unbounded — omit").
             ...section.minCount != null && section.minCount !== 0 ? { min: section.minCount } : {},
@@ -44871,7 +45253,18 @@ var ConfigBuilder = class {
             sides: cardSides
           };
         });
-        return { name: normalizedKey, ...cardHtmlKeyField(cardSetConfig, "htmlKey"), cards };
+        return {
+          name: normalizedKey,
+          ...mappingKeysField(
+            void 0,
+            { present: false },
+            {
+              value: cardSetConfig.htmlKey,
+              present: Object.prototype.hasOwnProperty.call(cardSetConfig, "htmlKey")
+            }
+          ),
+          cards
+        };
       }
       const cardSetPath = `cardSets.${normalizedKey} / cards.default`;
       return {
@@ -44880,8 +45273,14 @@ var ConfigBuilder = class {
           {
             name: "default",
             isDefault: true,
-            ...cardJsonKeyField(cardSetConfig, "jsonKey", "exportJsonKey", cardSetPath),
-            ...cardHtmlKeyField(cardSetConfig, "htmlKey"),
+            ...cardMappingKeysField(
+              cardSetConfig,
+              cardSetConfig.mappingKeys,
+              "jsonKey",
+              "exportJsonKey",
+              "htmlKey",
+              cardSetPath
+            ),
             sides
           }
         ]
@@ -44917,14 +45316,19 @@ var ConfigBuilder = class {
             ...t.max != null ? { max: t.max } : {},
             ...t.description ? { description: t.description } : {}
           };
-          if (Object.prototype.hasOwnProperty.call(t, "jsonKey")) {
-            ref.exportJsonKey = t.jsonKey;
+          const record = t.mappingKeys ?? {};
+          if (Object.prototype.hasOwnProperty.call(record, "json")) {
+            ref.exportJsonKey = record.json;
             ref.hasExportJsonKey = true;
           }
-          if (Object.prototype.hasOwnProperty.call(t, "htmlKey")) {
-            ref.htmlKey = t.htmlKey;
+          if (Object.prototype.hasOwnProperty.call(record, "html")) {
+            ref.htmlKey = record.html;
             ref.hasHtmlKey = true;
           }
+          const extras = Object.fromEntries(
+            Object.entries(record).filter(([id]) => id !== "json" && id !== "html")
+          );
+          if (Object.keys(extras).length > 0) ref.extraKeys = extras;
           replacements.push(ref);
         }
         squashedGroups.set(groupKey, replacements);
@@ -44958,8 +45362,11 @@ var ConfigBuilder = class {
           pushOrReplace({
             type: "group",
             key: ref.key,
-            ...ref.hasExportJsonKey ? { jsonKey: ref.exportJsonKey } : {},
-            ...ref.hasHtmlKey ? { htmlKey: ref.htmlKey } : {},
+            ...mappingKeysField(
+              ref.extraKeys,
+              { value: ref.exportJsonKey, present: !!ref.hasExportJsonKey },
+              { value: ref.htmlKey, present: !!ref.hasHtmlKey }
+            ),
             ...ref.min != null ? { min: ref.min } : {},
             ...ref.max != null ? { max: ref.max } : {},
             ...ref.description ? { description: ref.description } : {}
@@ -44972,8 +45379,11 @@ var ConfigBuilder = class {
             pushOrReplace({
               type: "group",
               key: ref.key,
-              ...ref.hasExportJsonKey ? { jsonKey: ref.exportJsonKey } : {},
-              ...ref.hasHtmlKey ? { htmlKey: ref.htmlKey } : {},
+              ...mappingKeysField(
+                ref.extraKeys,
+                { value: ref.exportJsonKey, present: !!ref.hasExportJsonKey },
+                { value: ref.htmlKey, present: !!ref.hasHtmlKey }
+              ),
               ...ref.min != null ? { min: ref.min } : {},
               ...ref.max != null ? { max: ref.max } : {},
               ...ref.description ? { description: ref.description } : {}
@@ -45000,20 +45410,17 @@ var ConfigBuilder = class {
         description: b.description ?? "",
         since: resolvedBitConfig.since,
         deprecated: resolvedBitConfig.deprecated,
-        history: [
-          {
-            version: resolvedBitConfig.since,
-            changes: ["Initial version"]
-          }
-        ],
-        format: resolvedBitConfig.textFormatDefault ?? "bitmark--",
-        bodyRequired: resolvedBitConfig.bodyRequired ?? false,
-        bodyForbidden: !(resolvedBitConfig.bodyAllowed ?? true),
-        footerRequired: resolvedBitConfig.footerRequired ?? false,
-        footerForbidden: !(resolvedBitConfig.footerAllowed ?? true),
-        resourceAttachmentAllowed: resolvedBitConfig.resourceAttachmentAllowed ?? true,
+        bodyFormat: resolvedBitConfig.textFormatDefault ?? "bitmark--",
+        ...resolvedBitConfig.bodyRequired ? { bodyRequired: true } : {},
+        ...resolvedBitConfig.bodyAllowed === false ? { bodyForbidden: true } : {},
+        ...resolvedBitConfig.footerRequired ? { footerRequired: true } : {},
+        ...resolvedBitConfig.footerAllowed === false ? { footerForbidden: true } : {},
+        ...resolvedBitConfig.resourceAttachmentAllowed === false ? { resourceAttachmentAllowed: false } : {},
+        // Bit-level named key mappings (element keys for markup import),
+        // carried verbatim from the raw config.
+        ...mappingKeysField(b.mappingKeys, { present: false }, { present: false }),
         tags: tags2,
-        ...cardRef ? { card: cardRef } : {}
+        ...cardRef ? { cardSet: cardRef } : {}
       };
       const output = path3.join(outputFolderBits, `${b.bitType}.jsonc`);
       const str = JSON.stringify(bitJson, null, 2);
@@ -45041,14 +45448,7 @@ var ConfigBuilder = class {
         const bitJson = {
           name: groupKey,
           description: g.description ?? "",
-          since: "UNKNOWN",
           deprecated: g.deprecated,
-          history: [
-            {
-              version: "UNKNOWN",
-              changes: ["Initial version"]
-            }
-          ],
           tags: tags2
           // cards: [
           //   {
@@ -45102,8 +45502,11 @@ var ConfigBuilder = class {
             tags2.push({
               type: "group",
               key: ref.key,
-              ...ref.hasExportJsonKey ? { jsonKey: ref.exportJsonKey } : {},
-              ...ref.hasHtmlKey ? { htmlKey: ref.htmlKey } : {},
+              ...mappingKeysField(
+                ref.extraKeys,
+                { value: ref.exportJsonKey, present: !!ref.hasExportJsonKey },
+                { value: ref.htmlKey, present: !!ref.hasHtmlKey }
+              ),
               ...ref.min != null ? { min: ref.min } : {},
               ...ref.max != null ? { max: ref.max } : {},
               ...ref.description ? { description: ref.description } : {}
@@ -45124,14 +45527,7 @@ var ConfigBuilder = class {
         const bitJson = {
           name: groupKey,
           description: b.description ?? "",
-          since: "UNKNOWN",
           deprecated: b.deprecated,
-          history: [
-            {
-              version: "UNKNOWN",
-              changes: ["Initial version"]
-            }
-          ],
           tags: tags2
         };
         const output = path3.join(outputFolderGroups, `${groupKey}.jsonc`);
@@ -45172,7 +45568,7 @@ var ConfigBuilder = class {
   validateConfigTree(outputFolder) {
     const errors = [];
     const outputFolderBits = path3.join(outputFolder, "bits");
-    const outputFolderGroups = path3.join(outputFolder, "partials");
+    const outputFolderGroups = path3.join(outputFolder, "groups");
     const outputFolderCards = path3.join(outputFolder, "cards");
     const availableGroups = /* @__PURE__ */ new Set();
     if (fs3.existsSync(outputFolderGroups)) {
@@ -45246,7 +45642,7 @@ var ConfigBuilder = class {
           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);
+            checkTags(config.tags, `groups/${file}`, 15);
           }
         } catch (err) {
           errors.push(`Failed to parse ${file}: ${err}`);