@gmb/bitmark-parser-generator 5.22.0 → 5.24.0

package/dist/browser/esm/index.js

@@ -278,6 +278,7 @@ var BitType2 = {
   footNote: "foot-note",
   formFreeText: "form-free-text",
   formula: "formula",
+  formulaImage: "formula-image",
   gapText: "gap-text",
   gapTextInstructionGrouped: "gap-text-instruction-grouped",
   glossaryTerm: "glossary-term",
@@ -702,8 +703,10 @@ var TagFormat = {
   // If the value is treated as a boolean
   invertedBoolean: "invertedBoolean",
   // If the value is treated as a boolean with the value inverted (e.g. isLongAnswer ==> isShortAnswer = false)
-  enumeration: "enumeration"
+  enumeration: "enumeration",
   // If the value is treated as an enumeration (the value is a string that must be one of a predefined set of values)
+  coordinates: "coordinates"
+  // Comma-separated list of 4 numbers (e.g. bounding-box x, y, x1, y1)
 };
 
 // src/model/enum/TextFormat.ts
@@ -726,10 +729,12 @@ var TextFormat2 = {
 import "@ncoderz/superenum";
 var CardSetConfigKey = {
   flashcard: "flashcard",
+  flashcard1: "flashcard1",
   definitionList: "definitionList",
   elements: "elements",
   statements: "statements",
   quiz: "quiz",
+  quizResponses: "quizResponses",
   feedback: "feedback",
   questions: "questions",
   matchPairs: "matchPairs",
@@ -741,6 +746,7 @@ var CardSetConfigKey = {
   pronunciationTable: "pronunciationTable",
   botActionResponses: "botActionResponses",
   exampleBitList: "exampleBitList",
+  pageFooterSections: "pageFooterSections",
   clozeList: "clozeList",
   ingredients: "ingredients",
   // DEPRECATED - TO BE REMOVED IN THE FUTURE
@@ -788,7 +794,11 @@ var AbstractTagConfig = class {
     // Default: 0
     __publicField(this, "chain");
     __publicField(this, "jsonKey");
-    // If the json key is different from the tag
+    // Legacy string-form jsonKey
+    __publicField(this, "exportJsonKey");
+    // New JSON-pattern jsonKey (export-only)
+    __publicField(this, "hasExportJsonKey");
+    // True iff exportJsonKey was explicitly set
     __publicField(this, "deprecated");
     this.type = params.type;
     this.configKey = params.configKey;
@@ -797,6 +807,8 @@ var AbstractTagConfig = class {
     this.minCount = params.minCount;
     this.chain = params.chain;
     this.jsonKey = params.jsonKey;
+    this.exportJsonKey = params.exportJsonKey;
+    this.hasExportJsonKey = params.hasExportJsonKey;
     this.deprecated = params.deprecated;
   }
 };
@@ -806,7 +818,6 @@ var MarkupTagConfig = class extends AbstractTagConfig {
   constructor(params) {
     super({
       type: BitTagConfigKeyType.tag,
-      jsonKey: void 0,
       ...params
     });
     __publicField(this, "type", BitTagConfigKeyType.tag);
@@ -918,8 +929,8 @@ var ResourceTagConfig = class extends AbstractTagConfig {
 
 // src/model/config/CardVariantConfig.ts
 var CardVariantConfig = class {
-  // JSON path for body text
-  constructor(tags2, bodyAllowed, bodyRequired, repeatCount, jsonKey) {
+  // Body text format. Default: bitmark++
+  constructor(tags2, bodyAllowed, bodyRequired, repeatCount, jsonKey, exportJsonKey, hasExportJsonKey = false, format) {
     __publicField(this, "tags");
     __publicField(this, "bodyAllowed");
     // Default: true
@@ -929,11 +940,19 @@ var CardVariantConfig = class {
     // Default: 1
     // JSON mapping fields
     __publicField(this, "jsonKey");
+    // JSON path for body text (legacy)
+    __publicField(this, "exportJsonKey");
+    // New JSON-pattern jsonKey
+    __publicField(this, "hasExportJsonKey");
+    __publicField(this, "format");
     this.tags = tags2;
     this.bodyAllowed = bodyAllowed == null ? true : bodyAllowed;
     this.bodyRequired = bodyRequired;
     this.repeatCount = repeatCount;
     this.jsonKey = jsonKey;
+    this.exportJsonKey = exportJsonKey;
+    this.hasExportJsonKey = hasExportJsonKey;
+    this.format = format;
   }
   toString(options) {
     const opts = Object.assign({}, options);
@@ -957,14 +976,18 @@ ${tag.toString(opts)}`;
 
 // src/model/config/CardSideConfig.ts
 var CardSideConfig = class {
-  constructor(name, repeat, variants, jsonKey) {
+  constructor(name, repeat, variants, jsonKey, exportJsonKey, hasExportJsonKey = false) {
     __publicField(this, "name");
     __publicField(this, "repeat");
     __publicField(this, "jsonKey");
+    __publicField(this, "exportJsonKey");
+    __publicField(this, "hasExportJsonKey");
     __publicField(this, "variants");
     this.name = name;
     this.repeat = repeat;
     this.jsonKey = jsonKey;
+    this.exportJsonKey = exportJsonKey;
+    this.hasExportJsonKey = hasExportJsonKey;
     this.variants = variants;
   }
   toString(options) {
@@ -986,13 +1009,17 @@ var CardSideConfig = class {
 
 // src/model/config/CardSetConfig.ts
 var CardSetConfig = class {
-  constructor(configKey, jsonKey, sections, sides) {
+  constructor(configKey, jsonKey, exportJsonKey, hasExportJsonKey, sections, sides) {
     __publicField(this, "configKey");
     __publicField(this, "jsonKey");
+    __publicField(this, "exportJsonKey");
+    __publicField(this, "hasExportJsonKey");
     __publicField(this, "sections");
     __publicField(this, "sides");
     this.configKey = configKey;
     this.jsonKey = jsonKey;
+    this.exportJsonKey = exportJsonKey;
+    this.hasExportJsonKey = hasExportJsonKey;
     this.sections = sections;
     this.sides = sides;
   }
@@ -1136,12 +1163,17 @@ var groupKeys = {
   group_standardAllBits: "group_standardAllBits",
   group_standardItemLead: "group_standardItemLead",
   group_standardItemLeadInstructionHint: "group_standardItemLeadInstructionHint",
+  group_standardInstructionHint: "group_standardInstructionHint",
   group_standardTags: "group_standardTags",
+  group_standardTagsNoItemLead: "group_standardTagsNoItemLead",
   group_imageSource: "group_imageSource",
   group_technicalTerm: "group_technicalTerm",
   group_person: "group_person",
   group_gap: "group_gap",
   group_trueFalse: "group_trueFalse",
+  group_trueFalseInlineHighlight: "group_trueFalseInlineHighlight",
+  group_trueFalseInlineSelect: "group_trueFalseInlineSelect",
+  group_trueFalseResponses: "group_trueFalseResponses",
   group_markConfig: "group_markConfig",
   group_mark: "group_mark",
   group_bookCommon: "group_bookCommon",
@@ -1149,14 +1181,18 @@ var groupKeys = {
   group_advertisingCommon: "group_advertisingCommon",
   group_platformStylesCommon: "group_platformStylesCommon",
   group_quizCommon: "group_quizCommon",
+  group_backgroundWallpaper: "group_backgroundWallpaper",
+  group_imageNoZoom: "group_imageNoZoom",
   group_resourceBitTags: "group_resourceBitTags",
   group_resourceCommon: "group_resourceCommon",
   group_resourceImageCommon: "group_resourceImageCommon",
+  group_resourceImageCommonNoZoom: "group_resourceImageCommonNoZoom",
   group_resourceAudioCommon: "group_resourceAudioCommon",
   group_resourceVideoCommon: "group_resourceVideoCommon",
   group_resourceIcon: "group_resourceIcon",
   // Alias for image
   group_resourceImage: "group_resourceImage",
+  group_resourceImageNoZoom: "group_resourceImageNoZoom",
   group_resourceImageEmbed: "group_resourceImageEmbed",
   group_resourceImageLink: "group_resourceImageLink",
   group_resourceImageResponsive: "group_resourceImageResponsive",
@@ -1287,6 +1323,7 @@ var propertyKeys = {
   property_formula: "@formula",
   property_fullName: "@fullName",
   property_groupTag: "@groupTag",
+  property_gUri: "@gUri",
   property_handInAcceptFileType: "@handInAcceptFileType",
   property_handInInstruction: "@handInInstruction",
   property_handInRequirement: "@handInRequirement",
@@ -1422,6 +1459,7 @@ var propertyKeys = {
   property_siteName: "@siteName",
   property_size: "@size",
   property_slug: "@slug",
+  property_sourceBB: "@sourceBB",
   property_sourceDocument: "@sourceDocument",
   property_sourceRL: "@sourceRL",
   property_spaceId: "@spaceId",
@@ -1431,6 +1469,7 @@ var propertyKeys = {
   property_src4x: "@src4x",
   property_srcAlt: "@srcAlt",
   property_stripePricingTableId: "@stripePricingTableId",
+  property_stripePricingTableDescriptiveName: "@stripePricingTableDescriptiveName",
   property_stripePublishableKey: "@stripePublishableKey",
   property_subject: "@subject",
   property_subtype: "@subtype",
@@ -2175,25 +2214,159 @@ var CARDSETS = {
   //
   [CardSetConfigKey.flashcard]: {
     jsonKey: "cards",
+    exportJsonKey: { cards: "$" },
+    sides: [
+      {
+        name: "question",
+        variants: [
+          {
+            jsonKey: "question.text",
+            exportJsonKey: [{ "@absent": { question: {} } }, { question: { text: "$" } }],
+            tags: [
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for the flashcard."
+              },
+              {
+                exportJsonKey: { title: "$" },
+                key: ConfigKey.tag_title,
+                description: "Title of the flashcard."
+              },
+              {
+                key: ConfigKey.group_resourceIcon,
+                description: "Icon resource for the flashcard.",
+                jsonKey: "question.icon|resource(type=image, key=image)",
+                exportJsonKey: { question: { icon: { type: "image", image: { src: "$" } } } }
+              },
+              {
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the flashcard question.",
+                format: TagFormat.bitmarkText,
+                nullable: true
+              }
+            ]
+          }
+        ]
+      },
+      {
+        name: "answer",
+        variants: [
+          {
+            jsonKey: "answer.text",
+            exportJsonKey: [{ "@absent": { answer: {} } }, { answer: { text: "$" } }],
+            tags: [
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for the flashcard."
+              },
+              {
+                exportJsonKey: { title: "$" },
+                key: ConfigKey.tag_title,
+                description: "Title of the flashcard."
+              },
+              {
+                key: ConfigKey.group_resourceIcon,
+                description: "Icon resource for the flashcard.",
+                jsonKey: "answer.icon|resource(type=image, key=image)",
+                exportJsonKey: { answer: { icon: { type: "image", image: { src: "$" } } } }
+              },
+              {
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the flashcard answer.",
+                format: TagFormat.bitmarkText,
+                nullable: true
+              }
+            ]
+          },
+          {
+            jsonKey: "alternativeAnswers[].text",
+            exportJsonKey: { alternativeAnswers: [{ text: "$" }] },
+            tags: [
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for the flashcard."
+              },
+              {
+                exportJsonKey: { title: "$" },
+                key: ConfigKey.tag_title,
+                description: "Title of the flashcard."
+              },
+              {
+                key: ConfigKey.group_resourceIcon,
+                description: "Icon resource for the flashcard.",
+                jsonKey: "alternativeAnswers[].icon|resource(type=image, key=image)",
+                exportJsonKey: {
+                  alternativeAnswers: [{ icon: { type: "image", image: { src: "$" } } }]
+                }
+              }
+            ],
+            repeatCount: Count.infinity
+          }
+        ]
+      }
+    ]
+  },
+  //
+  // flashcard1 — single-card variant of flashcard. Same shape, but capped
+  // at one card via `sections.default.maxCount = 1` (PLAN-085). Used by
+  // the `flashcard-1` bit type; the multi-card `flashcard` and
+  // `q-and-a-card` bit types continue to use the unbounded `flashcard`
+  // cardset.
+  //
+  [CardSetConfigKey.flashcard1]: {
+    jsonKey: "cards",
+    exportJsonKey: { cards: "$" },
+    sections: {
+      default: {
+        jsonKey: "cards",
+        exportJsonKey: { cards: "$" },
+        isDefault: true,
+        maxCount: 1
+      }
+    },
     sides: [
       {
         name: "question",
         variants: [
           {
             jsonKey: "question.text",
+            exportJsonKey: [{ "@absent": { question: {} } }, { question: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the flashcard."
               },
               {
+                exportJsonKey: { title: "$" },
                 key: ConfigKey.tag_title,
                 description: "Title of the flashcard."
               },
               {
                 key: ConfigKey.group_resourceIcon,
                 description: "Icon resource for the flashcard.",
-                jsonKey: "question.icon|resource(type=image, key=image)"
+                jsonKey: "question.icon|resource(type=image, key=image)",
+                exportJsonKey: { question: { icon: { type: "image", image: { src: "$" } } } }
+              },
+              {
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the flashcard question.",
+                format: TagFormat.bitmarkText,
+                nullable: true
               }
             ]
           }
@@ -2204,37 +2377,56 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "answer.text",
+            exportJsonKey: [{ "@absent": { answer: {} } }, { answer: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the flashcard."
               },
               {
+                exportJsonKey: { title: "$" },
                 key: ConfigKey.tag_title,
                 description: "Title of the flashcard."
               },
               {
                 key: ConfigKey.group_resourceIcon,
                 description: "Icon resource for the flashcard.",
-                jsonKey: "answer.icon|resource(type=image, key=image)"
+                jsonKey: "answer.icon|resource(type=image, key=image)",
+                exportJsonKey: { answer: { icon: { type: "image", image: { src: "$" } } } }
+              },
+              {
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the flashcard answer.",
+                format: TagFormat.bitmarkText,
+                nullable: true
               }
             ]
           },
           {
             jsonKey: "alternativeAnswers[].text",
+            exportJsonKey: { alternativeAnswers: [{ text: "$" }] },
             tags: [
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the flashcard."
               },
               {
+                exportJsonKey: { title: "$" },
                 key: ConfigKey.tag_title,
                 description: "Title of the flashcard."
               },
               {
                 key: ConfigKey.group_resourceIcon,
                 description: "Icon resource for the flashcard.",
-                jsonKey: "alternativeAnswers[].icon|resource(type=image, key=image)"
+                jsonKey: "alternativeAnswers[].icon|resource(type=image, key=image)",
+                exportJsonKey: {
+                  alternativeAnswers: [{ icon: { type: "image", image: { src: "$" } } }]
+                }
               }
             ],
             repeatCount: Count.infinity
@@ -2248,12 +2440,14 @@ var CARDSETS = {
   //
   [CardSetConfigKey.definitionList]: {
     jsonKey: "definitions",
+    exportJsonKey: { definitions: "$" },
     sides: [
       {
         name: "term",
         variants: [
           {
             jsonKey: "term.text",
+            exportJsonKey: [{ "@absent": { term: {} } }, { term: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2263,13 +2457,26 @@ var CARDSETS = {
                 key: ConfigKey.tag_title,
                 description: "Title of the definition.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forKeys"
+                jsonKey: "^heading.forKeys",
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
               },
               {
                 key: ConfigKey.group_resourceIcon,
                 description: "Icon resource for the definition.",
                 format: TagFormat.plainText,
-                jsonKey: "term.icon|resource(type=image, key=image)"
+                jsonKey: "term.icon|resource(type=image, key=image)",
+                exportJsonKey: { term: { icon: { type: "image", image: { src: "$" } } } }
+              },
+              {
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the definition term.",
+                format: TagFormat.bitmarkText,
+                nullable: true
               }
             ]
           }
@@ -2280,6 +2487,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "definition.text",
+            exportJsonKey: [{ "@absent": { definition: {} } }, { definition: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2289,30 +2497,48 @@ var CARDSETS = {
                 key: ConfigKey.tag_title,
                 description: "Title of the definition.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forValues"
+                jsonKey: "^heading.forValues",
+                exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
               },
               {
                 key: ConfigKey.group_resourceIcon,
                 description: "Icon resource for the definition.",
-                jsonKey: "definition.icon|resource(type=image, key=image)"
+                jsonKey: "definition.icon|resource(type=image, key=image)",
+                exportJsonKey: { definition: { icon: { type: "image", image: { src: "$" } } } }
+              },
+              {
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the definition.",
+                format: TagFormat.bitmarkText,
+                nullable: true
               }
             ]
           },
           {
             jsonKey: "alternativeDefinitions[].text",
+            exportJsonKey: { alternativeDefinitions: [{ text: "$" }] },
             tags: [
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the definition."
               },
               {
+                exportJsonKey: { title: "$" },
                 key: ConfigKey.tag_title,
                 description: "Title of the definition."
               },
               {
                 key: ConfigKey.group_resourceIcon,
                 description: "Icon resource for the definition.",
-                jsonKey: "alternativeDefinitions[].icon|resource(type=image, key=image)"
+                jsonKey: "alternativeDefinitions[].icon|resource(type=image, key=image)",
+                exportJsonKey: {
+                  alternativeDefinitions: [{ icon: { type: "image", image: { src: "$" } } }]
+                }
               }
             ],
             repeatCount: Count.infinity
@@ -2326,37 +2552,96 @@ var CARDSETS = {
   //
   [CardSetConfigKey.matchPairs]: {
     jsonKey: "pairs",
+    exportJsonKey: { pairs: "$" },
     sides: [
       {
         name: "key",
         variants: [
           {
             jsonKey: "key",
+            exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the match pair."
               },
+              {
+                // Pair-level example: emit `isExample` alongside `example`
+                // (matches OLD parser's per-pair allow-list behaviour).
+                //
+                // PLAN-074: a valued cascade source (`[@example:V]` anywhere
+                // in the cardset) fills each pair's `example` with `V`
+                // once per pair from the keys-side cascade fire (single
+                // parsed_variant per pair — no per-value duplication).
+                //
+                // PLAN-076 NOTE: matchPairs (TAG 415) KEEPS `example: '$'`
+                // at the pair-object level. BPG `parseMatchPairs`
+                // (`CardContentProcessor.ts:714-723`) emits ONE example
+                // per PAIR (the `exampleCard` accumulator), placed at the
+                // pair object. Unlike matchMatrix (per-cell example),
+                // matchPairs has no nested per-cell layer, so the pair-key
+                // `[@example:V]` must double-emit as the visible field.
+                // Confirmed via `chaining` fixture: `match-solution-grouped`
+                // expects `example: "packen"` at pair-object level from
+                // `die Koffer[%1][@example:packen]`. Original PLAN-076
+                // draft applied to both keys-side tags; the matchPairs
+                // half was reverted after fixture parity testing.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, "@bit": { isExample: true } } },
+                  {
+                    predicates: ["@absent", { $cascade: "*" }],
+                    rule: {
+                      isExample: true,
+                      example: "$cascade",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  { "@absent": { isExample: true } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker / value on the match pair.",
+                format: TagFormat.bitmarkText,
+                nullable: true
+              },
               {
                 key: ConfigKey.tag_title,
                 description: "Title of the match pair.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forKeys"
+                jsonKey: "^heading.forKeys",
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
               },
               {
+                // PLAN-084: gate the key-side `@absent → $ancestor` cascade
+                // synth with `@variantLacksTag=isCaseSensitive` so the rule
+                // only fires when NO variant in the active card explicitly
+                // carries `[@isCaseSensitive]`. When a value-side variant
+                // carries the tag (e.g. `[@isCaseSensitive:false]`), the
+                // synth is skipped here; the value-side explicit fire owns
+                // the pair-level emission.
                 key: ConfigKey.property_isCaseSensitive,
+                exportJsonKey: [
+                  {
+                    predicates: ["@absent", { "@variantLacksTag": "@isCaseSensitive" }],
+                    rule: { isCaseSensitive: "$ancestor" }
+                  },
+                  { isCaseSensitive: "$" }
+                ],
                 description: "Property to indicate if the match is case sensitive.",
                 format: TagFormat.boolean
               },
               {
                 key: ConfigKey.resource_audio,
                 description: "Audio resource for the match pair.",
-                jsonKey: "keyAudio"
+                jsonKey: "keyAudio",
+                exportJsonKey: { keyAudio: "$" }
               },
               {
                 key: ConfigKey.resource_image,
                 description: "Image resource for the match pair.",
-                jsonKey: "keyImage"
+                jsonKey: "keyImage",
+                exportJsonKey: { keyImage: "$" }
               }
             ]
           }
@@ -2368,19 +2653,104 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "values[]",
+            exportJsonKey: { values: ["$"] },
+            format: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardTags,
-                description: "Standard tags for the match pair."
+                // PLAN-084: value-side excludes item/lead/pageNumber/marginNumber.
+                // BPG `parseMatchPairs` does `delete tags.item; delete tags.lead;`
+                // for sideIdx > 0; the schema-side equivalent is to use a
+                // group_standardTags variant that omits group_standardItemLead.
+                key: ConfigKey.group_standardTagsNoItemLead,
+                description: "Standard tags for the match pair (values side, no item/lead)."
+              },
+              {
+                // PLAN-072 + ALIGN-EXAMPLE-CASCADE §3.6: cascade-fired
+                // `@example` from the bit header fills each pair's
+                // `example` with the pair's first value (mirrors BPG's
+                // `fillStringExample(pairs, __defaultExample=values[0])`).
+                //
+                // PLAN-074: the cascade-source-VALUE branch is handled by
+                // TAG 415 (keys side) which fires once per pair — keeping
+                // it here would emit `example` twice per pair (one per
+                // values-side parsed_variant) and merge them into a
+                // multi-paragraph array.
+                //
+                // PLAN-075: bare `$parent` reads the parent variant fire's
+                // source `$` value (the current `++`-iteration's value
+                // text). For single-value pairs this matches the old
+                // `$parent.values[0]`; for multi-value pairs with
+                // `[@example]` attached to a non-first value, it correctly
+                // resolves to that value.
+                //
+                // PLAN-077: dual `[@absent, { '$cascade': '*' }]` rule
+                // routes pair-key `[@example:V]` (a per-pair cascade
+                // source, bound via per-card CascadeCounters scope) and
+                // bit-header `[@example:V]` (cardset cascade) into the
+                // pair-level `example` via `$cascade`. The aggregator in
+                // `populate_variants` fires this rule ONCE per pair (BPG
+                // `parseMatchPairs` `exampleCard` precedence), avoiding
+                // per-iter pollution.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  // PLAN-084: bare `[@example]` on a values-side variant fires
+                  // once per pair (first-wins, mirrors BPG `parseMatchPairs`
+                  // `exampleCard` + `pushDownTree` set-if-null semantic).
+                  // `maxEmits: 1` enforced inside the per-pair cascade-counter
+                  // scope opened by `build_card_item`.
+                  {
+                    predicates: ["@keyonly"],
+                    maxEmits: 1,
+                    rule: {
+                      isExample: true,
+                      example: "$parent",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  {
+                    predicates: ["@absent", { $cascade: "*" }],
+                    rule: {
+                      isExample: true,
+                      example: "$cascade",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  {
+                    "@absent": {
+                      isExample: true,
+                      example: "$parent",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  // PLAN-084: same cap applies to the explicit-value `[@example:V]`
+                  // form so per-`++`-iter values-side fires also first-win.
+                  {
+                    predicates: [],
+                    maxEmits: 1,
+                    rule: { isExample: true, example: "$", "@bit": { isExample: true } }
+                  }
+                ],
+                description: "Example marker / value on the match pair (values side).",
+                format: TagFormat.bitmarkText,
+                nullable: true
               },
               {
                 key: ConfigKey.tag_title,
                 description: "Title of the match pair.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forValues"
+                jsonKey: "^heading.forValues",
+                exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
               },
               {
+                // PLAN-084: symmetric @variantLacksTag gating with the key-side.
                 key: ConfigKey.property_isCaseSensitive,
+                exportJsonKey: [
+                  {
+                    predicates: ["@absent", { "@variantLacksTag": "@isCaseSensitive" }],
+                    rule: { isCaseSensitive: "$ancestor" }
+                  },
+                  { isCaseSensitive: "$" }
+                ],
                 description: "Property to indicate if the match is case sensitive.",
                 format: TagFormat.boolean
               }
@@ -2396,12 +2766,15 @@ var CARDSETS = {
   //
   [CardSetConfigKey.matchAudioPairs]: {
     jsonKey: "pairs",
+    exportJsonKey: { pairs: "$" },
     sides: [
       {
         name: "key",
         variants: [
           {
             jsonKey: "key",
+            exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2411,12 +2784,14 @@ var CARDSETS = {
                 key: ConfigKey.tag_title,
                 description: "Title of the audio match pair.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forKeys"
+                jsonKey: "^heading.forKeys",
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
               },
               {
                 key: ConfigKey.resource_audio,
                 description: "Audio resource for the match pair.",
-                jsonKey: "keyAudio"
+                jsonKey: "keyAudio",
+                exportJsonKey: { keyAudio: "$" }
               }
             ]
           }
@@ -2428,16 +2803,20 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "values[]",
+            exportJsonKey: { values: ["$"] },
+            format: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardTags,
-                description: "Standard tags for the audio match pair."
+                // PLAN-084: value-side excludes item/lead/pageNumber/marginNumber.
+                key: ConfigKey.group_standardTagsNoItemLead,
+                description: "Standard tags for the audio match pair (values side, no item/lead)."
               },
               {
                 key: ConfigKey.tag_title,
                 description: "Title of the audio match pair.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forValues"
+                jsonKey: "^heading.forValues",
+                exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
               },
               {
                 key: ConfigKey.resource_audio,
@@ -2455,12 +2834,15 @@ var CARDSETS = {
   //
   [CardSetConfigKey.matchImagePairs]: {
     jsonKey: "pairs",
+    exportJsonKey: { pairs: "$" },
     sides: [
       {
         name: "key",
         variants: [
           {
             jsonKey: "key",
+            exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2470,12 +2852,14 @@ var CARDSETS = {
                 key: ConfigKey.tag_title,
                 description: "Title of the image match pair.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forKeys"
+                jsonKey: "^heading.forKeys",
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
               },
               {
                 key: ConfigKey.resource_image,
                 description: "Image resource for the match pair.",
-                jsonKey: "keyImage"
+                jsonKey: "keyImage",
+                exportJsonKey: { keyImage: "$" }
               }
             ]
           }
@@ -2487,16 +2871,20 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "values[]",
+            exportJsonKey: { values: ["$"] },
+            format: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardTags,
-                description: "Standard tags for the image match pair."
+                // PLAN-084: value-side excludes item/lead/pageNumber/marginNumber.
+                key: ConfigKey.group_standardTagsNoItemLead,
+                description: "Standard tags for the image match pair (values side, no item/lead)."
               },
               {
                 key: ConfigKey.tag_title,
                 description: "Title of the image match pair.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forValues"
+                jsonKey: "^heading.forValues",
+                exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
               },
               {
                 key: ConfigKey.resource_image,
@@ -2514,30 +2902,71 @@ var CARDSETS = {
   //
   [CardSetConfigKey.matchMatrix]: {
     jsonKey: "matrix",
+    exportJsonKey: { matrix: "$" },
     sides: [
       {
         name: "key",
         variants: [
           {
             jsonKey: "key",
+            exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
                 description: "Standard tags for lead, instruction, and hint."
               },
               {
+                // PLAN-076: drop `example: '$'` from valued rule — pair-key
+                // `[@example:V]` is consumed as the per-pair cascade source.
+                // PLAN-077 R14 follow-up: investigation showed the fixture
+                // reference is INCONSISTENT — bits without a cardset-level
+                // cascade (e.g. bit 3 `[@example:Y]should be...`) expect
+                // pair-level `example: V` at pair scope, but bits WITH a
+                // cardset cascade (e.g. bit 8 `[@example:99]` in title-row
+                // PLUS pair-key `[@example:Y]`) expect NO pair-level
+                // example. Emitting `example: $` here satisfies bit 3 but
+                // breaks bit 8; dropping it satisfies bit 8 but breaks bit
+                // 3. Conditional emission would require runtime gating on
+                // the cardset cascade scope state. Left dropped pending a
+                // dedicated plan — accepted divergence on bit 3's pair-
+                // level emission (cells still get the per-cell `example`
+                // correctly via PLAN-077 §4.2 + §4.3).
                 key: ConfigKey.property_example,
+                exportJsonKey: [
+                  {
+                    "@keyonly": {
+                      isExample: true,
+                      "@bit": { isExample: true },
+                      "@card": { isExample: true }
+                    }
+                  },
+                  {
+                    "@absent": {
+                      isExample: true,
+                      "@bit": { isExample: true },
+                      "@card": { isExample: true }
+                    }
+                  },
+                  { isExample: true, "@bit": { isExample: true }, "@card": { isExample: true } }
+                ],
                 description: "Example text for the match matrix.",
-                format: TagFormat.plainText
+                format: TagFormat.plainText,
+                nullable: true
               },
               {
                 key: ConfigKey.tag_title,
                 description: "Title of the match matrix.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forKeys"
+                jsonKey: "^heading.forKeys",
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
               },
               {
                 key: ConfigKey.property_isCaseSensitive,
+                exportJsonKey: [
+                  { "@absent": { isCaseSensitive: "$ancestor" } },
+                  { isCaseSensitive: "$" }
+                ],
                 description: "Property to indicate if the match is case sensitive.",
                 format: TagFormat.boolean
               }
@@ -2551,24 +2980,103 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "cells[{s}].values[]",
+            exportJsonKey: [
+              // PLAN-085 / R14: the positional-blank emission for an
+              // effectively-absent cell side fires ONLY when the active
+              // card has at least one `[#]` variant fire. This matches
+              // BPG `extractHeadingCard`'s `isHeading` gate: when no
+              // `[#]` exists anywhere in the title card, BPG returns
+              // undefined and no `heading` is emitted. The phantom
+              // `forValues:['']` placeholder is appropriate only when
+              // the card is being treated as a title-row.
+              {
+                predicates: ["@absent", { "@variantHasTag": "#" }],
+                rule: { "@bit": { heading: { forValues: [""] } } }
+              },
+              { cells: { $s: { values: ["$"] } } }
+            ],
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
                 description: "Standard tags for lead, instruction, and hint."
               },
               {
+                // PLAN-075: bare `$parent` reads the parent variant fire's
+                // source `$` value (the current `++`-iteration's cell text).
+                // Replaces `$parent.values[0]` which pinned to position 0
+                // regardless of which `++`-value `[@example]` was on.
+                //
+                // PLAN-077: dual `[@absent, { '$cascade': '*' }]` rule
+                // routes pair-key `[@example:V]` (a per-pair cascade
+                // source, bound via per-card CascadeCounters scope) and
+                // bit-header `[@example:V]` (cardset cascade) into the
+                // per-cell `example` via `$cascade`. The aggregator in
+                // `populate_variants` fires this rule ONCE per cell (BPG
+                // `parseMatchMatrix` `exampleSide` precedence), avoiding
+                // per-iter pollution.
+                // @card scope-shift writes matrix-row container isExample.
                 key: ConfigKey.property_example,
+                exportJsonKey: [
+                  {
+                    "@keyonly": {
+                      cells: { $s: { isExample: true, example: "$parent" } },
+                      "@bit": { isExample: true },
+                      "@card": { isExample: true }
+                    }
+                  },
+                  {
+                    predicates: ["@absent", { $cascade: "*" }],
+                    rule: {
+                      cells: { $s: { isExample: true, example: "$cascade" } },
+                      "@bit": { isExample: true },
+                      "@card": { isExample: true }
+                    }
+                  },
+                  {
+                    "@absent": {
+                      cells: { $s: { isExample: true, example: "$parent" } },
+                      "@bit": { isExample: true },
+                      "@card": { isExample: true }
+                    }
+                  },
+                  {
+                    cells: { $s: { isExample: true, example: "$" } },
+                    "@bit": { isExample: true },
+                    "@card": { isExample: true }
+                  }
+                ],
                 description: "Example text for the match matrix.",
-                format: TagFormat.plainText
+                format: TagFormat.bitmarkText,
+                nullable: true
               },
               {
+                // PLAN-085 / R14: bare `[#]` on a value-side emits the
+                // empty-string positional blank into `forValues` so the
+                // array stays aligned with the cell positions (matches BPG
+                // `extractHeadingCard`'s "all value-side headings present"
+                // shape). The `@keyonly` rule is required for two reasons:
+                // 1) it provides an emission for bare `[#]` (the `$` sigil
+                //    in the unconditional rule has no source for bare); and
+                // 2) the presence of any `@keyonly` rule disables the
+                //    optimised-mode `should_suppress_outcome` strip (see
+                //    `forward_emit.rs`) so the resulting `forValues: [""]`
+                //    survives the all-natural-defaults check.
                 key: ConfigKey.tag_title,
                 description: "Title of the match matrix.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forValues"
+                jsonKey: "^heading.forValues",
+                exportJsonKey: [
+                  { "@keyonly": { "@bit": { heading: { forValues: [""] } } } },
+                  { "@bit": { heading: { forValues: ["$"] } } }
+                ]
               },
               {
                 key: ConfigKey.property_isCaseSensitive,
+                exportJsonKey: [
+                  { "@absent": { isCaseSensitive: "$ancestor" } },
+                  { isCaseSensitive: "$" }
+                ],
                 description: "Property to indicate if the match is case sensitive.",
                 format: TagFormat.boolean
               }
@@ -2584,28 +3092,61 @@ var CARDSETS = {
   //
   [CardSetConfigKey.statements]: {
     jsonKey: "statements",
+    exportJsonKey: { statements: "$" },
     sides: [
       {
         name: "statement",
         variants: [
           {
             jsonKey: "statement",
+            exportJsonKey: { statement: "$" },
             tags: [
               {
                 key: ConfigKey.tag_true,
                 description: "Tag for true statements.",
                 jsonKey: "statement|set(isCorrect=true)",
+                exportJsonKey: { statement: "$", isCorrect: true },
                 maxCount: 1
               },
               {
                 key: ConfigKey.tag_false,
                 description: "Tag for false statements.",
                 jsonKey: "statement|set(isCorrect=false)",
+                exportJsonKey: { statement: "$", isCorrect: false },
                 maxCount: 1
               },
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the statement."
+              },
+              {
+                // PLAN-072: cascade-fired `@example` from the bit header
+                // fills each statement entry's `example` with the entry's
+                // own `isCorrect`, mirroring BPG's `pushExampleDownTree`
+                // for the statements cardset. Per-array-item strip removes
+                // `example: false` from incorrect entries so only correct
+                // entries retain `example: true`.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  {
+                    "@keyonly": {
+                      isExample: true,
+                      example: true,
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  {
+                    "@absent": {
+                      isExample: true,
+                      example: "$parent.isCorrect",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker on the statement. Bare `[@example]` emits the boolean marker; valued `[@example:true|false]` emits the literal value. Cascade from bit-header fills `example` with the entry\u2019s own `isCorrect`.",
+                format: TagFormat.boolean,
+                nullable: true
               }
             ],
             bodyAllowed: false
@@ -2619,6 +3160,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.quiz]: {
     jsonKey: "quizzes",
+    exportJsonKey: { quizzes: "$" },
     sides: [
       {
         name: "choices",
@@ -2633,6 +3175,71 @@ var CARDSETS = {
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the quiz."
+              },
+              {
+                // ALIGN-EXAMPLE-CASCADE §3.2: variant-level cascade for
+                // quiz choices is delegated to group_trueFalse's
+                // chain-child `@example` (`+` chain with maxEmits:1 +
+                // `@parent.isCorrect=true`). Variant-level `@absent`
+                // would over-fire on subsequent correct choices and on
+                // incorrect ones — drop it.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, "@bit": { isExample: true } } },
+                  { isExample: true, "@bit": { isExample: true } }
+                ],
+                description: "Example marker on the quiz choice (entry-local only; cascade handled by group_trueFalse chain-children).",
+                format: TagFormat.boolean,
+                nullable: true
+              }
+            ],
+            bodyAllowed: false
+          }
+        ]
+      }
+    ]
+  },
+  //
+  // quiz (responses)
+  //
+  [CardSetConfigKey.quizResponses]: {
+    jsonKey: "quizzes",
+    exportJsonKey: { quizzes: "$" },
+    sides: [
+      {
+        name: "responses",
+        variants: [
+          {
+            jsonKey: null,
+            tags: [
+              {
+                key: ConfigKey.group_trueFalseResponses,
+                description: "Group for true/false questions."
+              },
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for the quiz."
+              },
+              {
+                // PLAN-072: cascade-fired `@example` from the bit header
+                // fills each response entry's `example` with the entry's
+                // own `isCorrect`, mirroring BPG's `pushExampleDownTree`
+                // for the quiz-responses cardset (statements-style).
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, "@bit": { isExample: true } } },
+                  {
+                    "@absent": {
+                      isExample: true,
+                      example: "$parent.isCorrect",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  { isExample: true, "@bit": { isExample: true } }
+                ],
+                description: "Example marker on the quiz response; cascade from bit-header fills `example` with the entry\u2019s own `isCorrect`.",
+                format: TagFormat.boolean,
+                nullable: true
               }
             ],
             bodyAllowed: false
@@ -2646,6 +3253,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.feedback]: {
     jsonKey: "feedbacks",
+    exportJsonKey: { feedbacks: "$" },
     sides: [
       {
         name: "choices",
@@ -2657,6 +3265,73 @@ var CARDSETS = {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
                 description: "Standard tags for lead, instruction, and hint."
               },
+              {
+                // Feedback choices: `[+]` / `[-]` map to choice + `requireReason`
+                // (NOT `isCorrect` like trueFalse). Shadow the inherited
+                // `tag_true` / `tag_false` from `group_trueFalse` to emit the
+                // feedback-specific shape.
+                //
+                // Chain @example: `[+ X][@example]` writes
+                // `isExample/example` onto the X choice only. BPG's
+                // `setIsExampleFlags` (Builder.ts:4041-4172) does NOT
+                // iterate `cardNode.feedbacks` — so unlike multipleChoice,
+                // there is no bubble to bit-level or feedbacks-level
+                // isExample. Pattern omits `@bit` scope-shift accordingly.
+                // No `@absent`/`@parent.isCorrect` cascade rules either:
+                // BPG's `pushExampleDownTree` (Builder.ts:3777-3849) has
+                // no feedback dispatch, so bit-header `[@example]` does
+                // not flow into feedback choices.
+                key: ConfigKey.tag_true,
+                exportJsonKey: { choices: [{ choice: "$", requireReason: true }] },
+                description: "Reason-required choice for feedback (`[+]`).",
+                maxCount: Count.infinity,
+                format: TagFormat.plainText,
+                chain: [
+                  {
+                    key: ConfigKey.property_example,
+                    exportJsonKey: [
+                      { "@keyonly": { isExample: true, example: true } },
+                      { isExample: true, example: "$" }
+                    ],
+                    description: "Per-choice example marker for feedback `[+]`.",
+                    format: TagFormat.boolean,
+                    maxCount: 1,
+                    nullable: true
+                  },
+                  {
+                    // `[+ X][! foo]` chains `!` (instruction) onto the
+                    // choice; same for `[?]` (hint), `[%]` (item),
+                    // `[%2]`/`[%3]`/`[%4]` (lead/pageNumber/marginNumber).
+                    // Mirrors group_trueFalse's `+` chain shape.
+                    key: ConfigKey.group_standardItemLeadInstructionHint,
+                    description: "Item, lead, page number, margin number, instruction and hint chained onto the feedback choice."
+                  }
+                ]
+              },
+              {
+                key: ConfigKey.tag_false,
+                exportJsonKey: { choices: [{ choice: "$", requireReason: false }] },
+                description: "Reason-not-required choice for feedback (`[-]`).",
+                maxCount: Count.infinity,
+                format: TagFormat.plainText,
+                chain: [
+                  {
+                    key: ConfigKey.property_example,
+                    exportJsonKey: [
+                      { "@keyonly": { isExample: true, example: true } },
+                      { isExample: true, example: "$" }
+                    ],
+                    description: "Per-choice example marker for feedback `[-]`.",
+                    format: TagFormat.boolean,
+                    maxCount: 1,
+                    nullable: true
+                  },
+                  {
+                    key: ConfigKey.group_standardItemLeadInstructionHint,
+                    description: "Item, lead, page number, margin number, instruction and hint chained onto the feedback choice."
+                  }
+                ]
+              },
               {
                 key: ConfigKey.group_trueFalse,
                 description: "Group for true/false feedback."
@@ -2665,7 +3340,8 @@ var CARDSETS = {
                 key: ConfigKey.tag_title,
                 description: "Title of the feedback.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forKeys"
+                jsonKey: "^heading.forKeys",
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
               }
             ],
             bodyAllowed: false
@@ -2676,27 +3352,78 @@ var CARDSETS = {
         name: "reason",
         variants: [
           {
+            // PLAN: feedback.reason — Object-only variant pattern. Per
+            // SYNTAX.md §8.1, sibling tag emissions do NOT auto-wrap
+            // under `reason.*`; each tag here spells out the full path.
+            // Body is a plain string (BPG `parseFeedback` uses
+            // `cardBodyStr ?? ''` for `reason.text`).
             jsonKey: "reason.text",
+            exportJsonKey: { reason: { text: "$" } },
+            format: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardItemLeadInstructionHint,
-                description: "Standard tags for lead, instruction, and hint."
+                // Instruction lands under reason. Hint/item/lead/etc.
+                // omitted: not exercised by any fixture and BPG's
+                // `parseFeedback` spreads only the tags actually present
+                // — adding the rest can be done lazily as fixtures
+                // require them, with the same `{reason: {…}}` wrapper.
+                key: ConfigKey.tag_instruction,
+                exportJsonKey: { reason: { instruction: "$" } },
+                description: "Instruction for the feedback reason.",
+                format: TagFormat.bitmarkText
               },
               {
                 key: ConfigKey.property_reasonableNumOfChars,
+                exportJsonKey: [
+                  { "@absent": { reason: { reasonableNumOfChars: "$ancestor" } } },
+                  { reason: { reasonableNumOfChars: "$" } }
+                ],
                 description: "Property for reasonable number of characters.",
                 format: TagFormat.number
               },
               {
+                // ALIGN-EXAMPLE-CASCADE §3.9: `feedback.reason` is NOT in
+                // BPG's `pushExampleDownTree` dispatch — no bit-header
+                // cascade. Local emission only.
+                //
+                // Both `reason.example` and `feedbacks[].example` are
+                // `TextAst` per BPG's schema — paragraph arrays. Format
+                // here is `bitmarkText` so `$` coerces to a paragraph
+                // array at both write sites.
                 key: ConfigKey.property_example,
-                description: "Example text for the feedback.",
-                format: TagFormat.plainText
+                exportJsonKey: [
+                  {
+                    // Bare `[@example]`: reason.example is TextAst — BPG
+                    // coerces the boolean default to a paragraph
+                    // containing the string "true". feedbacks[].example
+                    // is not TextAst, stays a boolean. Two literal writes.
+                    "@keyonly": {
+                      reason: {
+                        isExample: true,
+                        example: [{ type: "paragraph", content: [{ text: "true", type: "text" }] }]
+                      },
+                      isExample: true,
+                      example: true,
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  {
+                    reason: { isExample: true, example: "$" },
+                    isExample: true,
+                    example: "$",
+                    "@bit": { isExample: true }
+                  }
+                ],
+                description: "Example text for the feedback reason (entry-local only; no bit-header cascade).",
+                format: TagFormat.bitmarkText,
+                nullable: true
               },
               {
                 key: ConfigKey.tag_title,
                 description: "Title of the feedback.",
                 format: TagFormat.plainText,
-                jsonKey: "^heading.forValues"
+                jsonKey: "^heading.forValues",
+                exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
               }
             ],
             bodyAllowed: true
@@ -2710,21 +3437,29 @@ var CARDSETS = {
   //
   [CardSetConfigKey.questions]: {
     jsonKey: "questions",
+    exportJsonKey: { questions: "$" },
     sides: [
       {
         name: "question",
         variants: [
           {
             jsonKey: "question",
+            exportJsonKey: { question: "$" },
             tags: [
               {
                 key: ConfigKey.property_reasonableNumOfChars,
+                exportJsonKey: [
+                  { "@absent": { reasonableNumOfChars: "$ancestor" } },
+                  { reasonableNumOfChars: "$" }
+                ],
                 description: "Property for reasonable number of characters.",
                 format: TagFormat.number
               },
               {
+                exportJsonKey: { sampleSolution: "$" },
                 key: ConfigKey.tag_sampleSolution,
-                description: "Sample solution for the question."
+                description: "Sample solution for the question.",
+                format: TagFormat.plainText
               },
               {
                 key: ConfigKey.property_sampleSolution,
@@ -2745,6 +3480,22 @@ var CARDSETS = {
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the question."
+              },
+              {
+                // ALIGN-EXAMPLE-CASCADE §3.10: `questions` is NOT in BPG's
+                // `pushExampleDownTree` dispatch — bit-header `[@example]`
+                // does not propagate `example`/`isExample` onto question
+                // entries. Only entry-local `[@example]` fires (handled by
+                // `@keyonly` and the unconditional fallback). No `@absent`
+                // rule.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the question (entry-local only; no bit-header cascade).",
+                format: TagFormat.bitmarkText,
+                nullable: true
               }
             ]
           }
@@ -2764,15 +3515,23 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "elements[]",
+            exportJsonKey: { elements: ["$"] },
             tags: [
               {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
                 description: "Standard tags for lead, instruction, and hint."
               },
               {
+                // ALIGN-EXAMPLE-CASCADE §3.11: `elements` is NOT in BPG's
+                // `pushExampleDownTree` dispatch — no bit-header cascade.
                 key: ConfigKey.property_example,
-                description: "Example text for the element.",
-                format: TagFormat.plainText
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example text for the element (entry-local only; no bit-header cascade).",
+                format: TagFormat.plainText,
+                nullable: true
               }
             ],
             repeatCount: Count.infinity
@@ -2784,8 +3543,57 @@ var CARDSETS = {
   //
   // table
   //
+  // PLAN-079: supports BOTH source formats and collapses to the same basic
+  // output (`{ columns?, data, columnWidths? }`):
+  //
+  // 1. Basic format — first card carries `[#X]` markers (fire `tag_title`
+  //    → `^table.columns[]`); subsequent cards are body rows. Cards have
+  //    no qualifier, so they route to the `table-body` (default) section.
+  //
+  // 2. Extended format — `==== table-header ====` / `==== table-footer ====`
+  //    qualifiers. The `table-header` section uses `@cardIndex=0` to route
+  //    the first header card's cells to `columns` and demote remaining
+  //    header cards (rows) into `data`. Per-cell `[@tableRowSpan]` /
+  //    `[@tableScope]` / `[@tableCellType]` tags are valid-but-unmapped
+  //    here (no per-cell metadata in basic shape) — declared on the cell
+  //    variant below.
+  //
   [CardSetConfigKey.table]: {
-    jsonKey: "table.data",
+    jsonKey: null,
+    exportJsonKey: null,
+    sections: {
+      "table-header": {
+        // First header card's row of cells → `columns`. Subsequent header
+        // cards' rows → `data` (per-card append; `[$]` shape because
+        // per-card emission fires once per card, multiple fires deep_merge-
+        // append). PLAN-079 + PLAN-080: predicates inside exportJsonKey
+        // both ROUTE cards to this section (when no explicit `==== table-
+        // header ====` qualifier) and SELECT the rule body once routed.
+        // First rule = first card with any `[#]` → `columns`; second rule
+        // = subsequent cards in this section → `data` (per-row append).
+        jsonKey: "table.columns",
+        exportJsonKey: [
+          {
+            predicates: [{ "@cardIndex": 0 }, { "@variantHasTag": "#" }],
+            rule: { "@bit": { table: { columns: "$" } } }
+          },
+          { "@cardIndex=0": { "@bit": { table: { columns: "$" } } } },
+          { "@bit": { table: { data: ["$"] } } }
+        ]
+      },
+      "table-body": {
+        // Batched emission: `$` is the entire 2D array of body card rows.
+        // This is the default section (no qualifier → cards land here).
+        jsonKey: "table.data",
+        exportJsonKey: { "@bit": { table: { data: "$" } } },
+        isDefault: true
+      },
+      "table-footer": {
+        // Batched emission: `$` is the entire 2D array of footer rows.
+        jsonKey: "table.data",
+        exportJsonKey: { "@bit": { table: { data: "$" } } }
+      }
+    },
     sides: [
       {
         name: "cell",
@@ -2801,6 +3609,7 @@ var CARDSETS = {
               {
                 key: ConfigKey.tag_title,
                 jsonKey: "^table.columns[]",
+                exportJsonKey: { "@bit": { table: { columns: ["$"] } } },
                 description: "Title of the table."
               },
               {
@@ -2825,6 +3634,8 @@ var CARDSETS = {
               },
               {
                 key: ConfigKey.property_tableColWidth,
+                jsonKey: "^table.columnWidths[{s}]",
+                exportJsonKey: { "@bit": { table: { columnWidths: { $s: "$" } } } },
                 description: "Width for the column.",
                 format: TagFormat.number
               }
@@ -2841,18 +3652,49 @@ var CARDSETS = {
   [CardSetConfigKey.tableExtended]: {
     jsonKey: null,
     sections: {
-      "table-header": { jsonKey: "table.header.rows", sideJsonKey: "cells[{s}]|set(title=true)" },
-      "table-body": { jsonKey: "table.body.rows", isDefault: true },
-      "table-footer": { jsonKey: "table.footer.rows", sideJsonKey: "cells[{s}]|set(title=true)" }
+      "table-header": {
+        jsonKey: "table.header.rows",
+        // PLAN-080: section dispatch via predicates inside exportJsonKey.
+        // Cards with no explicit `==== table-header ====` qualifier
+        // route here if FIRST CARD contains any `[#]` tag in any
+        // variant. Explicit-qualifier cards fall through to the
+        // unconditional fallback rule. Both rules use the per-card
+        // append shape `rows: ['$']` — the runtime triggers per-card
+        // emission whenever the pattern carries predicates, and each
+        // fire appends a single-element array (multi-fire deep-merge
+        // concatenates).
+        exportJsonKey: [
+          {
+            predicates: [{ "@cardIndex": 0 }, { "@variantHasTag": "#" }],
+            rule: { table: { header: { rows: ["$"] } } }
+          },
+          { table: { header: { rows: ["$"] } } }
+        ],
+        sideJsonKey: "cells[{s}]|set(title=true)",
+        sideExportJsonKey: { cells: { $s: { title: true, $: "$" } } }
+      },
+      "table-body": {
+        jsonKey: "table.body.rows",
+        exportJsonKey: { table: { body: { rows: "$" } } },
+        isDefault: true
+      },
+      "table-footer": {
+        jsonKey: "table.footer.rows",
+        exportJsonKey: { table: { footer: { rows: "$" } } },
+        sideJsonKey: "cells[{s}]|set(title=true)",
+        sideExportJsonKey: { cells: { $s: { title: true, $: "$" } } }
+      }
     },
     sides: [
       {
         name: "cell",
         repeat: true,
         jsonKey: "cells[{s}]",
+        exportJsonKey: { cells: { $s: "$" } },
         variants: [
           {
             jsonKey: "content",
+            exportJsonKey: { content: "$" },
             tags: [
               {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
@@ -2860,35 +3702,47 @@ var CARDSETS = {
               },
               {
                 key: ConfigKey.tag_title,
-                jsonKey: ".",
-                description: "Title of the table cell."
+                // PLAN-080: the `[#]` tag writes its text to the cell's
+                // `content` field. When the card is in the `table-header`
+                // section, the section's sideExportJsonKey wraps each
+                // cell with `title: true` automatically.
+                jsonKey: "content",
+                exportJsonKey: { content: "$" },
+                description: "Title text of the table cell (header rows)."
               },
               {
                 key: ConfigKey.property_tableCellType,
                 jsonKey: "title|bool(th)",
+                exportJsonKey: [{ "@value=th": { title: true } }],
                 description: "Table cell type (th/td).",
                 format: TagFormat.plainText
               },
               {
                 key: ConfigKey.property_tableRowSpan,
                 jsonKey: "rowspan",
+                exportJsonKey: { rowspan: "$" },
                 description: "Number of rows the cell spans.",
                 format: TagFormat.number
               },
               {
                 key: ConfigKey.property_tableColSpan,
                 jsonKey: "colspan",
+                exportJsonKey: { colspan: "$" },
                 description: "Number of columns the cell spans.",
                 format: TagFormat.number
               },
               {
                 key: ConfigKey.property_tableScope,
                 jsonKey: "scope",
+                exportJsonKey: { scope: "$" },
                 description: "Scope attribute for header cells.",
                 format: TagFormat.plainText
               },
               {
                 key: ConfigKey.property_tableColWidth,
+                // PLAN-080: write to the cell's `colwidth` field.
+                jsonKey: "colwidth",
+                exportJsonKey: { colwidth: "$" },
                 description: "Width for the column.",
                 format: TagFormat.number
               }
@@ -2904,6 +3758,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.pronunciationTable]: {
     jsonKey: "pronunciationTable.data",
+    exportJsonKey: { pronunciationTable: { data: "$" } },
     sides: [
       {
         name: "cell",
@@ -2911,19 +3766,22 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "body",
+            exportJsonKey: { body: "$" },
             tags: [
               {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
                 description: "Standard tags for lead, instruction, and hint."
               },
               {
+                exportJsonKey: { title: "$" },
                 key: ConfigKey.tag_title,
                 description: "Title of the pronunciation table."
               },
               {
                 key: ConfigKey.resource_audio,
                 description: "Audio resource for the pronunciation table.",
-                jsonKey: "audio"
+                jsonKey: "audio",
+                exportJsonKey: { audio: { type: "audio", audio: { src: "$" } } }
               }
             ],
             repeatCount: Count.infinity
@@ -2937,12 +3795,15 @@ var CARDSETS = {
   //
   [CardSetConfigKey.botActionResponses]: {
     jsonKey: "responses",
+    exportJsonKey: { responses: "$" },
     sides: [
       {
         name: "response",
         variants: [
           {
             jsonKey: "feedback",
+            exportJsonKey: { feedback: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.property_reaction,
@@ -2950,18 +3811,58 @@ var CARDSETS = {
                 format: TagFormat.plainText
               },
               {
-                key: ConfigKey.group_standardItemLead,
-                description: "Item, lead, page number, and margin number for the bot action response."
+                key: ConfigKey.tag_item,
+                jsonKey: "item",
+                exportJsonKey: { item: "$" },
+                format: TagFormat.plainText,
+                description: "The item for the bit",
+                chain: [
+                  {
+                    key: ConfigKey.tag_item,
+                    jsonKey: "lead",
+                    exportJsonKey: { lead: "$" },
+                    description: "The lead for the bit",
+                    maxCount: 1,
+                    chain: [
+                      {
+                        key: ConfigKey.tag_item,
+                        jsonKey: "pageNumber",
+                        exportJsonKey: { pageNumber: "$" },
+                        description: "The page number for the bit",
+                        maxCount: 1,
+                        chain: [
+                          {
+                            key: ConfigKey.tag_item,
+                            jsonKey: "marginNumber",
+                            exportJsonKey: { marginNumber: "$" },
+                            description: "The margin number for the bit",
+                            maxCount: 1
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                ]
               },
               {
                 key: ConfigKey.tag_instruction,
                 description: "The response label for the bot action.",
-                jsonKey: "response"
+                jsonKey: "response",
+                exportJsonKey: { response: "$" },
+                format: TagFormat.plainText
               },
               {
+                // ALIGN-EXAMPLE-CASCADE §3.12: `bot-action-responses` is
+                // NOT in BPG's `pushExampleDownTree` dispatch — no bit-
+                // header cascade.
                 key: ConfigKey.property_example,
-                description: "Example text for the bot action response.",
-                format: TagFormat.plainText
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example text for the bot action response (entry-local only; no bit-header cascade).",
+                format: TagFormat.plainText,
+                nullable: true
               }
             ]
           }
@@ -2974,12 +3875,14 @@ var CARDSETS = {
   //
   [CardSetConfigKey.clozeList]: {
     jsonKey: "listItems",
+    exportJsonKey: { listItems: "$" },
     sides: [
       {
         name: "content",
         variants: [
           {
             jsonKey: "body",
+            exportJsonKey: { body: "$" },
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -3000,18 +3903,21 @@ var CARDSETS = {
   //
   [CardSetConfigKey.exampleBitList]: {
     jsonKey: "listItems",
+    exportJsonKey: { listItems: "$" },
     sides: [
       {
         name: "item",
         variants: [
           {
             jsonKey: "body",
+            exportJsonKey: { body: "$" },
             tags: [
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for example bits."
               },
               {
+                exportJsonKey: { title: "$" },
                 key: ConfigKey.tag_title,
                 description: "Title of the example bit."
               }
@@ -3022,18 +3928,53 @@ var CARDSETS = {
     ]
   },
   //
+  // page-footer-sections — mirrors example-bit-list but emits cards under
+  // `sections` instead of `listItems`. BPG's JsonGenerator special-cases
+  // BitType.pageFooter in code; this dedicated cardSet expresses the same
+  // routing as pure config so the Rust serializer can pick it up.
+  //
+  [CardSetConfigKey.pageFooterSections]: {
+    jsonKey: "sections",
+    exportJsonKey: { sections: "$" },
+    sides: [
+      {
+        name: "item",
+        variants: [
+          {
+            jsonKey: "body",
+            exportJsonKey: { body: "$" },
+            tags: [
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for page-footer section bits."
+              },
+              {
+                exportJsonKey: { title: "$" },
+                key: ConfigKey.tag_title,
+                description: "Title of the page-footer section."
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  //
   // ingredients
   //
   [CardSetConfigKey.ingredients]: {
     jsonKey: "ingredients",
+    exportJsonKey: { ingredients: "$" },
     sides: [
       {
         name: "ingredient",
         variants: [
           {
             jsonKey: "ingredient",
+            exportJsonKey: { ingredient: "$" },
             tags: [
               {
+                exportJsonKey: { title: "$" },
                 key: ConfigKey.tag_title,
                 description: "Title of the ingredient."
               },
@@ -3041,6 +3982,7 @@ var CARDSETS = {
                 key: ConfigKey.tag_true,
                 description: "Checked state for the ingredient.",
                 jsonKey: "|set(checked=true)",
+                exportJsonKey: { checked: true, $: "$" },
                 maxCount: 1
                 // nullable: true,
               },
@@ -3048,6 +3990,7 @@ var CARDSETS = {
                 key: ConfigKey.tag_false,
                 description: "Unchecked state for the ingredient.",
                 jsonKey: "|set(checked=false)",
+                exportJsonKey: { checked: false, $: "$" },
                 maxCount: 1
                 // nullable: true,
               },
@@ -3059,9 +4002,11 @@ var CARDSETS = {
                 key: ConfigKey.tag_instruction,
                 description: "The quantity of the ingredient.",
                 jsonKey: "quantity",
+                exportJsonKey: { quantity: "$" },
                 format: TagFormat.number
               },
               {
+                exportJsonKey: { hint: "$" },
                 key: ConfigKey.tag_hint,
                 description: "The hint for the ingredient."
               },
@@ -3097,6 +4042,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.bookReferenceList]: {
     jsonKey: "bookReferences",
+    exportJsonKey: { bookReferences: "$" },
     sides: [
       {
         name: "reference",
@@ -3156,6 +4102,11 @@ var GROUPS = {
         format: TagFormat.plainText,
         maxCount: Count.infinity
       },
+      {
+        key: ConfigKey.property_gUri,
+        description: "Global URI for the bit",
+        format: TagFormat.plainText
+      },
       {
         key: ConfigKey.property_customerId,
         description: "The customer-specific identifier for the bit",
@@ -3339,12 +4290,18 @@ var GROUPS = {
       {
         key: ConfigKey.property_groupTag,
         jsonKey: "groupTag.name",
+        // PLAN-063: starter-array shape with `@id` declares entity-merge
+        // semantics — repeated `[@groupTag: name]` occurrences with the
+        // same value fold into one entry; chained `@tag` children's
+        // arrays merge as sets.
+        exportJsonKey: { groupTag: [{ "@id": "name", name: "$" }] },
         description: "The group tag(s) for the bit",
         format: TagFormat.plainText,
         maxCount: Count.infinity,
         chain: [
           {
             key: ConfigKey.property_tag,
+            exportJsonKey: { tags: ["$"] },
             description: "The tag(s) for the group",
             format: TagFormat.plainText,
             maxCount: Count.infinity
@@ -3375,6 +4332,12 @@ var GROUPS = {
         format: TagFormat.plainText,
         maxCount: Count.infinity
       },
+      {
+        key: ConfigKey.property_sourceBB,
+        description: "The source bounding box(es) for the bit (x, y, x1, y1)",
+        format: TagFormat.coordinates,
+        maxCount: Count.infinity
+      },
       {
         key: ConfigKey.property_levelCEFRp,
         description: "The CEFRp level for the bit",
@@ -3412,6 +4375,7 @@ var GROUPS = {
         maxCount: Count.infinity
       },
       {
+        exportJsonKey: { anchor: "$" },
         key: ConfigKey.tag_anchor,
         name: "Anchor",
         format: TagFormat.plainText,
@@ -3449,23 +4413,27 @@ var GROUPS = {
       {
         key: ConfigKey.tag_item,
         jsonKey: "item",
+        exportJsonKey: { item: "$" },
         description: "The item for the bit",
         chain: [
           {
             key: ConfigKey.tag_item,
             jsonKey: "lead",
+            exportJsonKey: { lead: "$" },
             description: "The lead for the bit",
             maxCount: 1,
             chain: [
               {
                 key: ConfigKey.tag_item,
                 jsonKey: "pageNumber",
+                exportJsonKey: { pageNumber: "$" },
                 description: "The page number for the bit",
                 maxCount: 1,
                 chain: [
                   {
                     key: ConfigKey.tag_item,
                     jsonKey: "marginNumber",
+                    exportJsonKey: { marginNumber: "$" },
                     description: "The margin number for the bit",
                     maxCount: 1
                   }
@@ -3486,11 +4454,31 @@ var GROUPS = {
         description: "Item, lead, page number, and margin number tags"
       },
       {
+        exportJsonKey: { instruction: "$" },
+        key: ConfigKey.tag_instruction,
+        name: "Instruction",
+        description: "The instruction for the bit"
+      },
+      {
+        exportJsonKey: { hint: "$" },
+        key: ConfigKey.tag_hint,
+        name: "Hint",
+        description: "The hint for the bit"
+      }
+    ]
+  },
+  [ConfigKey.group_standardInstructionHint]: {
+    type: GroupConfigType.standard,
+    description: "Standard group for instruction and hint tags only (no item/lead/pageNumber/marginNumber chain). Used by sides where item/lead are owned by another side (e.g. matchPairs value-side, which BPG strips item/lead from at sideIdx > 0).",
+    tags: [
+      {
+        exportJsonKey: { instruction: "$" },
         key: ConfigKey.tag_instruction,
         name: "Instruction",
         description: "The instruction for the bit"
       },
       {
+        exportJsonKey: { hint: "$" },
         key: ConfigKey.tag_hint,
         name: "Hint",
         description: "The hint for the bit"
@@ -3510,9 +4498,45 @@ var GROUPS = {
         description: "Item, lead, page number, margin number, instruction and hint tags"
       },
       {
+        // Bit-level example tag (default — non-`isTopLevelExample` bits):
+        // - bare `[@example]`: consume only (records cascade marker, emits
+        //   nothing at bit-level — OLD parser scrubs bit-level isExample
+        //   for bits NOT in its `isTopLevelExample` allow-list).
+        // - synthesized (descendant cascade): still emits `isExample: true`
+        //   at the descendant scope.
+        // - valued `[@example:text]`: emit the example value only; bit-level
+        //   `isExample` is left to bubble from descendants.
+        // Bits in the OLD parser's allow-list (flashcard, definitionList,
+        // sequence, multipleChoice, trueFalse, cloze*, mark, interview,
+        // matchMatrix, match, essay, etc.) override this entry with the
+        // legacy emit-isExample shape.
         key: ConfigKey.property_example,
+        exportJsonKey: [{ "@keyonly": {} }, { "@absent": { isExample: true } }, { example: "$" }],
         description: "The example(s) for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.bitmarkText,
+        nullable: true
+      }
+    ]
+  },
+  [ConfigKey.group_standardTagsNoItemLead]: {
+    type: GroupConfigType.standard,
+    description: "Standard tags mirror of group_standardTags but excluding the item/lead/pageNumber/marginNumber chain. Used by sides where item/lead are owned by another side (e.g. matchPairs value-side \u2014 BPG `parseMatchPairs` strips tags.item / tags.lead for sideIdx > 0).",
+    tags: [
+      {
+        key: ConfigKey.group_standardAllBits,
+        description: "All standard tags which apply to all bits"
+      },
+      {
+        key: ConfigKey.group_standardInstructionHint,
+        description: "Instruction and hint tags only (no item/lead chain)."
+      },
+      {
+        // Mirror of group_standardTags property_example entry.
+        key: ConfigKey.property_example,
+        exportJsonKey: [{ "@keyonly": {} }, { "@absent": { isExample: true } }, { example: "$" }],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
@@ -3523,6 +4547,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_imageSource,
         jsonKey: "imageSource.url",
+        exportJsonKey: { imageSource: { url: "$" } },
         description: "The source of an image",
         format: TagFormat.plainText,
         chain: [
@@ -3557,6 +4582,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_technicalTerm,
         jsonKey: "technicalTerm.technicalTerm",
+        exportJsonKey: { technicalTerm: { technicalTerm: "$" } },
         description: "The technical term",
         format: TagFormat.plainText,
         chain: [
@@ -3575,7 +4601,8 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.property_person,
-        jsonKey: "partner.name",
+        jsonKey: "person.name",
+        exportJsonKey: { person: { name: "$" } },
         description: "A person",
         format: TagFormat.plainText,
         chain: [
@@ -3587,6 +4614,7 @@ var GROUPS = {
           {
             key: ConfigKey.group_resourceImage,
             jsonKey: "avatarImage|resource(type=image, key=image)",
+            exportJsonKey: { avatarImage: { type: "image", image: { src: "$" } } },
             description: "The image of the person"
           }
         ]
@@ -3594,7 +4622,8 @@ var GROUPS = {
       {
         // Deprecated (parter renamed to person)
         key: ConfigKey.property_partner,
-        jsonKey: "partner.name",
+        jsonKey: "person.name",
+        exportJsonKey: { person: { name: "$" } },
         description: "A partner",
         format: TagFormat.plainText,
         chain: [
@@ -3606,6 +4635,7 @@ var GROUPS = {
           {
             key: ConfigKey.group_resourceImage,
             jsonKey: "avatarImage|resource(type=image, key=image)",
+            exportJsonKey: { avatarImage: { type: "image", image: { src: "$" } } },
             description: "The image of the partner"
           }
         ]
@@ -3617,29 +4647,66 @@ var GROUPS = {
     description: "Gap chain",
     tags: [
       {
+        exportJsonKey: {
+          "@body-inline": { type: "gap", attrs: { solutions: ["$"] } }
+        },
         key: ConfigKey.tag_gap,
         description: "The value of a gap in the content",
         maxCount: Count.infinity,
+        format: TagFormat.plainText,
         chain: [
           {
             key: ConfigKey.tag_gap,
             jsonKey: "solutions[]",
+            exportJsonKey: { solutions: ["$"] },
             description: "Alternative values for the gaps in the content",
-            maxCount: Count.infinity
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
           },
           {
             key: ConfigKey.group_standardItemLeadInstructionHint,
             description: "Item, lead, page number, margin number, instruction and hint tags"
           },
           {
+            // BPG ExampleTagContentProcessor.ts:91-95 reads
+            // `__solutionsAst[length - 1]` — the solution closest to the
+            // `[@example]` tag at parse time. Our chain accumulator is built
+            // incrementally (scope.rs `parent.merge` after each tag), so at
+            // the moment `[@example]` fires, `solutions` only contains the
+            // preceding `[_x]` entries — `[-1]` resolves to the closest one.
+            // E.g. `[_cloze][_gap][@example]` → solutions=["cloze","gap"],
+            // `[-1]`="gap"; `[_solution][@example][_problem]` →
+            // solutions=["solution"], `[-1]`="solution".
             key: ConfigKey.property_example,
             jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.solutions[-1]",
+                  "@bit": { isExample: true }
+                }
+              },
+              {
+                "@absent": {
+                  isExample: true,
+                  example: "$parent.solutions[-1]",
+                  "@bit": { isExample: true }
+                }
+              },
+              { isExample: true, example: "$", "@bit": { isExample: true } }
+            ],
             description: "An example for the gap",
-            format: TagFormat.plainText
+            format: TagFormat.bitmarkText,
+            nullable: true
           },
           {
             key: ConfigKey.property_isCaseSensitive,
             jsonKey: "isCaseSensitive",
+            exportJsonKey: [
+              { "@absent": { isCaseSensitive: "$ancestor" } },
+              { isCaseSensitive: "$" }
+            ],
             description: "If true, the gap text is case sensitive",
             format: TagFormat.boolean,
             defaultValue: "true"
@@ -3653,60 +4720,587 @@ var GROUPS = {
     description: "True/False chain",
     tags: [
       {
+        exportJsonKey: { choices: [{ choice: "$", isCorrect: true }] },
         key: ConfigKey.tag_true,
         description: "True value for a true/false statement/question",
         maxCount: Count.infinity,
+        format: TagFormat.plainText,
         chain: [
           {
             key: ConfigKey.tag_true,
             jsonKey: "choices[]|set(isCorrect=true)",
+            exportJsonKey: { choices: [{ choice: "$", isCorrect: true }] },
             description: "True values for a true/false statement/question",
-            maxCount: Count.infinity
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
           },
           {
             key: ConfigKey.tag_false,
             jsonKey: "choices[]|set(isCorrect=false)",
+            exportJsonKey: { choices: [{ choice: "$", isCorrect: false }] },
             description: "False values for a true/false statement/question",
-            maxCount: Count.infinity
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
           },
           {
             key: ConfigKey.group_standardItemLeadInstructionHint,
             description: "Item, lead, page number, margin number, instruction and hint tags"
           },
           {
+            // PLAN-072 + ALIGN-EXAMPLE-CASCADE §3.2: cascade-fired
+            // `@example` from the bit header marks EVERY choice with
+            // `isExample: true` (matches BPG output), but only the
+            // FIRST correct choice gets `example: true` (BPG
+            // `fillBooleanExample(..., firstCorrectOnly=true)`).
+            //
+            // Two `@absent` rules, picked first-match-wins:
+            //   1. Verbose form gated on `@parent.isCorrect=true` with
+            //      `maxEmits:1` — fires once for the first correct.
+            //   2. Plain `@absent` — fires on every remaining entry
+            //      (subsequent corrects and all incorrects), emitting
+            //      `isExample` only.
+            // The `serialize_cards` cascade-counter scope holds the cap
+            // across the whole cardset.
+            // @card scope-shift writes choice-container isExample (e.g.
+            // `quizzes[i].isExample`) — was previously provided by the
+            // universal `bubble_is_example` post-walk, which was removed
+            // in favour of explicit per-tag config. SYNTAX.md §8.
             key: ConfigKey.property_example,
             jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                predicates: ["@absent", { "@parent.isCorrect": true }],
+                maxEmits: 1,
+                rule: {
+                  isExample: true,
+                  example: true,
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                "@absent": {
+                  isExample: true,
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@card": { isExample: true }
+              }
+            ],
             description: "An example for the true/false statement/question",
-            format: TagFormat.plainText
+            format: TagFormat.boolean,
+            nullable: true
           }
         ]
       },
       {
+        exportJsonKey: { choices: [{ choice: "$", isCorrect: false }] },
         key: ConfigKey.tag_false,
         description: "False value for a true/false statement/question",
         maxCount: Count.infinity,
+        format: TagFormat.plainText,
         chain: [
           {
             key: ConfigKey.tag_true,
             jsonKey: "choices[]|set(isCorrect=true)",
+            exportJsonKey: { choices: [{ choice: "$", isCorrect: true }] },
             description: "True values for a true/false statement/question",
-            maxCount: Count.infinity
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
           },
           {
             key: ConfigKey.tag_false,
             jsonKey: "choices[]|set(isCorrect=false)",
+            exportJsonKey: { choices: [{ choice: "$", isCorrect: false }] },
             description: "False values for a true/false statement/question",
-            maxCount: Count.infinity
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.group_standardItemLeadInstructionHint,
+            description: "Item, lead, page number, margin number, instruction and hint tags"
+          },
+          {
+            // PLAN-072 + ALIGN-EXAMPLE-CASCADE §3.2: cascade-fired
+            // `@example` on a `-` (incorrect choice) emits
+            // `isExample: true` only — no `example` (BPG fixtures show
+            // `isExample` on every choice, but `example` only on the
+            // first correct via firstCorrectOnly cascade).
+            // @card scope-shift writes choice-container isExample.
+            key: ConfigKey.property_example,
+            jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                "@absent": {
+                  isExample: true,
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@card": { isExample: true }
+              }
+            ],
+            description: "An example for the true/false statement/question (incorrect entry \u2014 isExample only on cascade)",
+            format: TagFormat.boolean,
+            nullable: true
+          }
+        ]
+      }
+    ]
+  },
+  [ConfigKey.group_trueFalseResponses]: {
+    type: GroupConfigType.standard,
+    description: "True/False Responses chain",
+    tags: [
+      {
+        exportJsonKey: { responses: [{ response: "$", isCorrect: true }] },
+        key: ConfigKey.tag_true,
+        description: "True value for a true/false statement/question",
+        maxCount: Count.infinity,
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_true,
+            jsonKey: "responses[]|set(isCorrect=true)",
+            exportJsonKey: { responses: [{ response: "$", isCorrect: true }] },
+            description: "True values for a true/false statement/question",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.tag_false,
+            jsonKey: "responses[]|set(isCorrect=false)",
+            exportJsonKey: { responses: [{ response: "$", isCorrect: false }] },
+            description: "False values for a true/false statement/question",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.group_standardItemLeadInstructionHint,
+            description: "Item, lead, page number, margin number, instruction and hint tags"
+          },
+          {
+            // @card scope-shift writes response-container isExample.
+            key: ConfigKey.property_example,
+            jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                "@absent": {
+                  isExample: "$parent.isCorrect",
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: "$parent.isCorrect" },
+                  "@card": { isExample: "$parent.isCorrect" }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@card": { isExample: true }
+              }
+            ],
+            description: "An example for the true/false statement/question",
+            format: TagFormat.boolean,
+            nullable: true
+          }
+        ]
+      },
+      {
+        exportJsonKey: { responses: [{ response: "$", isCorrect: false }] },
+        key: ConfigKey.tag_false,
+        description: "False value for a true/false statement/question",
+        maxCount: Count.infinity,
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_true,
+            jsonKey: "responses[]|set(isCorrect=true)",
+            exportJsonKey: { responses: [{ response: "$", isCorrect: true }] },
+            description: "True values for a true/false statement/question",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.tag_false,
+            jsonKey: "responses[]|set(isCorrect=false)",
+            exportJsonKey: { responses: [{ response: "$", isCorrect: false }] },
+            description: "False values for a true/false statement/question",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
           },
           {
             key: ConfigKey.group_standardItemLeadInstructionHint,
             description: "Item, lead, page number, margin number, instruction and hint tags"
           },
           {
+            // @card scope-shift writes response-container isExample.
             key: ConfigKey.property_example,
             jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                "@absent": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@card": { isExample: true }
+              }
+            ],
             description: "An example for the true/false statement/question",
+            format: TagFormat.boolean,
+            nullable: true
+          }
+        ]
+      }
+    ]
+  },
+  [ConfigKey.group_trueFalseInlineSelect]: {
+    type: GroupConfigType.standard,
+    description: "True/False chain composed inline (select body-bit). +/- tags are consume-only at bit level.",
+    tags: [
+      {
+        exportJsonKey: {
+          "@body-inline": {
+            type: "select",
+            attrs: { options: [{ text: "$", isCorrect: true }] }
+          }
+        },
+        key: ConfigKey.tag_true,
+        description: "True value for an inline select body bit",
+        maxCount: Count.infinity,
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_true,
+            exportJsonKey: {},
+            description: "True values for an inline select body bit",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.tag_false,
+            exportJsonKey: {},
+            description: "False values for an inline select body bit",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.group_standardItemLeadInstructionHint,
+            description: "Item, lead, page number, margin number, instruction and hint tags"
+          },
+          {
+            // PLAN-083: cascade-fired `@example` from bit header fires
+            // `isExample:true, example:true` on the FIRST CORRECT option
+            // only (BPG `fillBooleanExample(select.options,
+            // firstCorrectOnly=true)`). Mirrors group_trueFalseInlineHighlight.
+            // Every rule also bubbles `@bit:{isExample:true}` (idempotent
+            // OR — any cascade ⇒ bit marked) and
+            // `@body-inline:{attrs:{isExample:true}}` (node-level marker
+            // on the select node).
+            key: ConfigKey.property_example,
+            jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                predicates: ["@absent", { "@parent.isCorrect": true }],
+                maxEmits: 1,
+                rule: {
+                  isExample: true,
+                  example: true,
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@body-inline": { attrs: { isExample: true } }
+              }
+            ],
+            description: "An example for the inline select option (first correct only)",
+            format: TagFormat.boolean,
+            nullable: true
+          }
+        ]
+      },
+      {
+        exportJsonKey: {
+          "@body-inline": {
+            type: "select",
+            attrs: { options: [{ text: "$", isCorrect: false }] }
+          }
+        },
+        key: ConfigKey.tag_false,
+        description: "False value for an inline select body bit",
+        maxCount: Count.infinity,
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_true,
+            exportJsonKey: {},
+            description: "True values for an inline select body bit",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.tag_false,
+            exportJsonKey: {},
+            description: "False values for an inline select body bit",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.group_standardItemLeadInstructionHint,
+            description: "Item, lead, page number, margin number, instruction and hint tags"
+          },
+          {
+            // PLAN-083: identical to the `+` lead's chain @example —
+            // cascade reaches the first correct option regardless of
+            // which lead (+/-) opens the chain. Every firing rule bubbles
+            // `@bit:{isExample:true}` and `@body-inline:{attrs:{isExample:true}}`.
+            key: ConfigKey.property_example,
+            jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                predicates: ["@absent", { "@parent.isCorrect": true }],
+                maxEmits: 1,
+                rule: {
+                  isExample: true,
+                  example: true,
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@body-inline": { attrs: { isExample: true } }
+              }
+            ],
+            description: "An example for the inline select option (first correct only)",
+            format: TagFormat.boolean,
+            nullable: true
+          }
+        ]
+      }
+    ]
+  },
+  [ConfigKey.group_trueFalseInlineHighlight]: {
+    type: GroupConfigType.standard,
+    description: 'True/False chain composed inline (highlight body-bit). +/- tags emit `{type:"highlight", attrs:{texts:[{text,isCorrect?}]}}` inline body nodes. Used by highlight-text bit.',
+    tags: [
+      {
+        exportJsonKey: {
+          "@body-inline": {
+            type: "highlight",
+            attrs: { texts: [{ text: "$", isCorrect: true }] }
+          }
+        },
+        key: ConfigKey.tag_true,
+        description: "Highlighted span in the body (correct)",
+        maxCount: Count.infinity,
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_true,
+            exportJsonKey: {},
+            description: "Highlighted span values (correct)",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.tag_false,
+            exportJsonKey: {},
+            description: "Highlighted span values (incorrect)",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.group_standardItemLeadInstructionHint,
+            description: "Item, lead, page number, margin number, instruction and hint tags"
+          },
+          {
+            // PLAN-072 + ALIGN-EXAMPLE-CASCADE §3.13: cascade-fired
+            // `@example` from the bit header fires `example: true` +
+            // `isExample: true` on the FIRST correct highlight only
+            // (BPG `fillBooleanExample(highlight.texts,
+            // firstCorrectOnly=true)`). Incorrect highlights get
+            // nothing (unlike choices, the highlight-text fixture
+            // shows no `isExample` on incorrect entries).
+            key: ConfigKey.property_example,
+            jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                predicates: ["@absent", { "@parent.isCorrect": true }],
+                maxEmits: 1,
+                rule: {
+                  isExample: true,
+                  example: true,
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@body-inline": { attrs: { isExample: true } }
+              }
+            ],
+            description: "An example for the highlighted span (first correct only)",
+            format: TagFormat.boolean,
+            nullable: true
+          }
+        ]
+      },
+      {
+        // PLAN-083 follow-up (2026-05-22): mirror the select `-` lead shape
+        // by writing `isCorrect: false`. Without it, `$parent.isCorrect` in
+        // chain-child @example rules resolves to ParentPathMissing for `-`
+        // entries (e.g. `[-fish][@example]`), so the @keyonly rule falls
+        // through and nothing fires. The natural-default strip removes
+        // `isCorrect: false` from the final texts entries (matches fixture).
+        exportJsonKey: {
+          "@body-inline": {
+            type: "highlight",
+            attrs: { texts: [{ text: "$", isCorrect: false }] }
+          }
+        },
+        key: ConfigKey.tag_false,
+        description: "Highlighted span in the body (incorrect)",
+        maxCount: Count.infinity,
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_true,
+            exportJsonKey: {},
+            description: "Highlighted span values (correct)",
+            maxCount: Count.infinity,
             format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.tag_false,
+            exportJsonKey: {},
+            description: "Highlighted span values (incorrect)",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.group_standardItemLeadInstructionHint,
+            description: "Item, lead, page number, margin number, instruction and hint tags"
+          },
+          {
+            // PLAN-072 + ALIGN-EXAMPLE-CASCADE §3.13: cascade-fired
+            // `@example` on a `-` (incorrect highlight) emits nothing
+            // (highlight-text fixture has no `isExample` on incorrect
+            // entries; firstCorrectOnly cascade skips them entirely).
+            // No `@absent` rule.
+            // PLAN-083: identical to the `+` lead's chain @example —
+            // cascade reaches the first correct option regardless of
+            // which lead (+/-) opens the chain.
+            key: ConfigKey.property_example,
+            jsonKey: "example",
+            exportJsonKey: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                predicates: ["@absent", { "@parent.isCorrect": true }],
+                maxEmits: 1,
+                rule: {
+                  isExample: true,
+                  example: true,
+                  "@bit": { isExample: true },
+                  "@body-inline": { attrs: { isExample: true } }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@body-inline": { attrs: { isExample: true } }
+              }
+            ],
+            description: "An example for the highlighted span (first correct only)",
+            format: TagFormat.boolean,
+            nullable: true
           }
         ]
       }
@@ -3719,6 +5313,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_mark,
         jsonKey: "marks.mark",
+        exportJsonKey: { marks: [{ mark: "$" }] },
         description: "The mark configuration",
         format: TagFormat.plainText,
         maxCount: Count.infinity,
@@ -3742,21 +5337,32 @@ var GROUPS = {
     description: "Mark chain",
     tags: [
       {
+        exportJsonKey: {
+          "@body-inline": { type: "mark", attrs: { solution: "$" } }
+        },
         key: ConfigKey.tag_mark,
         description: "The marked content",
         maxCount: Count.infinity,
+        format: TagFormat.plainText,
         chain: [
           {
             key: ConfigKey.property_mark,
             jsonKey: "mark",
+            exportJsonKey: { mark: "$" },
             description: "The mark configuration",
             format: TagFormat.plainText
           },
           {
             key: ConfigKey.property_example,
             jsonKey: "example",
+            exportJsonKey: [
+              { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+              { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+              { isExample: true, example: "$", "@bit": { isExample: true } }
+            ],
             description: "An example for the marked content",
-            format: TagFormat.plainText
+            format: TagFormat.bitmarkText,
+            nullable: true
           }
         ]
       }
@@ -3845,7 +5451,8 @@ var GROUPS = {
         name: "Title",
         description: "The title of the book",
         maxCount: 2,
-        jsonKey: "title|multi(count=2, key=subtitle)"
+        jsonKey: "title|multi(count=2, key=subtitle)",
+        exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }]
       },
       {
         key: ConfigKey.property_subtype,
@@ -3861,6 +5468,7 @@ var GROUPS = {
       {
         key: ConfigKey.resource_coverImage,
         jsonKey: "coverImage|resource(type=image, key=image)",
+        exportJsonKey: { coverImage: { type: "image", image: { src: "$" } } },
         description: "The cover image of the book",
         chain: [
           {
@@ -3878,6 +5486,7 @@ var GROUPS = {
       {
         key: ConfigKey.resource_backgroundImage,
         jsonKey: "backgroundImage|resource(type=image, key=image)",
+        exportJsonKey: { backgroundImage: { type: "image", image: { src: "$" } } },
         description: "The background image of the book",
         chain: [
           {
@@ -4037,10 +5646,21 @@ var GROUPS = {
         format: TagFormat.plainText,
         chain: [
           {
+            exportJsonKey: { reference: "$" },
             key: ConfigKey.tag_reference,
             format: TagFormat.plainText,
-            description: "The reference(s) for the book(s) in the learning path",
-            maxCount: 2
+            description: "The reference for the book(s) in the learning path",
+            maxCount: 1,
+            chain: [
+              {
+                key: ConfigKey.tag_reference,
+                jsonKey: "referenceEnd",
+                exportJsonKey: { referenceEnd: "$" },
+                format: TagFormat.plainText,
+                description: "The referenceEnd for the book(s) in the learning path",
+                maxCount: 1
+              }
+            ]
           }
         ]
       }
@@ -4171,6 +5791,42 @@ var GROUPS = {
       }
     ]
   },
+  [ConfigKey.group_backgroundWallpaper]: {
+    type: GroupConfigType.standard,
+    description: "Background wallpaper tags",
+    tags: [
+      {
+        key: ConfigKey.resource_backgroundWallpaper,
+        exportJsonKey: { backgroundWallpaper: { type: "image", image: { src: "$" } } },
+        description: "Background wallpaper for the image, used to set a background for the image",
+        chain: [
+          {
+            key: ConfigKey.group_resourceImageCommon,
+            description: "Common resource image tags for images"
+          }
+        ]
+      }
+    ]
+  },
+  [ConfigKey.group_imageNoZoom]: {
+    type: GroupConfigType.standard,
+    description: "Image bit tags",
+    tags: [
+      {
+        key: ConfigKey.group_backgroundWallpaper,
+        description: "Background wallpaper tags for images, used to define background properties for images"
+      },
+      {
+        key: ConfigKey.group_resourceBitTags,
+        description: "Resource bit tags for images, used to define additional properties for images"
+      },
+      {
+        key: ConfigKey.group_resourceImageNoZoom,
+        description: "Resource image tags for images, used to attach images to the bit",
+        minCount: 1
+      }
+    ]
+  },
   //
   // Resource groups
   //
@@ -4180,6 +5836,8 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imagePlaceholder,
+        jsonKey: "imagePlaceholder|resource(type=image, key=image)",
+        exportJsonKey: { imagePlaceholder: { type: "image", image: { src: "$" } } },
         description: "Placeholder image for the resource",
         chain: [
           {
@@ -4288,6 +5946,58 @@ var GROUPS = {
       }
     ]
   },
+  [ConfigKey.group_resourceImageCommonNoZoom]: {
+    type: GroupConfigType.standard,
+    description: "Common properties for image resources where @zoomDisabled defaults to true",
+    tags: [
+      {
+        key: ConfigKey.group_resourceCommon,
+        description: "Common resource properties"
+      },
+      {
+        key: ConfigKey.property_src1x,
+        description: "The source URL for the image at 1x resolution",
+        format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.property_src2x,
+        description: "The source URL for the image at 2x resolution",
+        format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.property_src3x,
+        description: "The source URL for the image at 3x resolution",
+        format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.property_src4x,
+        description: "The source URL for the image at 4x resolution",
+        format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.property_width,
+        description: "The width of the image",
+        format: TagFormat.number
+      },
+      {
+        key: ConfigKey.property_height,
+        description: "The height of the image",
+        format: TagFormat.number
+      },
+      {
+        key: ConfigKey.property_alt,
+        description: "The alternative text for the image",
+        format: TagFormat.plainText
+      },
+      // @zoomDisabled with a true default
+      {
+        key: ConfigKey.property_zoomDisabled,
+        description: "If true, zooming is disabled for the image (defaults to true)",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      }
+    ]
+  },
   [ConfigKey.group_resourceAudioCommon]: {
     type: GroupConfigType.standard,
     description: "Common properties for audio resources",
@@ -4364,6 +6074,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_posterImage,
         jsonKey: "posterImage.src",
+        exportJsonKey: { posterImage: { src: "$" } },
         description: "The poster image for the video",
         format: TagFormat.plainText,
         chain: [
@@ -4376,22 +6087,26 @@ var GROUPS = {
       {
         key: ConfigKey.property_src1x,
         description: "The source URL for the video at 1x resolution",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        exportJsonKey: { thumbnails: [{ src: "$" }] }
       },
       {
         key: ConfigKey.property_src2x,
         description: "The source URL for the video at 2x resolution",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        exportJsonKey: { thumbnails: [{ src: "$" }] }
       },
       {
         key: ConfigKey.property_src3x,
         description: "The source URL for the video at 3x resolution",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        exportJsonKey: { thumbnails: [{ src: "$" }] }
       },
       {
         key: ConfigKey.property_src4x,
         description: "The source URL for the video at 4x resolution",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        exportJsonKey: { thumbnails: [{ src: "$" }] }
       }
     ]
   },
@@ -4404,6 +6119,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_icon,
+        exportJsonKey: { resource: { type: "icon", icon: { src: "$" } } },
         description: "The icon resource",
         chain: [
           {
@@ -4420,6 +6136,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_image,
+        exportJsonKey: { resource: { type: "image", image: { src: "$" } } },
         description: "The image resource",
         chain: [
           {
@@ -4430,12 +6147,30 @@ var GROUPS = {
       }
     ]
   },
+  [ConfigKey.group_resourceImageNoZoom]: {
+    type: GroupConfigType.resource,
+    description: "Image resource where @zoomDisabled defaults to true",
+    tags: [
+      {
+        key: ConfigKey.resource_image,
+        exportJsonKey: { resource: { type: "image", image: { src: "$" } } },
+        description: "The image resource (no-zoom default)",
+        chain: [
+          {
+            key: ConfigKey.group_resourceImageCommonNoZoom,
+            description: "Common image properties with @zoomDisabled defaulting to true"
+          }
+        ]
+      }
+    ]
+  },
   [ConfigKey.group_resourceImagePortrait]: {
     type: GroupConfigType.resource,
     description: "Portrait image resource",
     tags: [
       {
         key: ConfigKey.resource_imagePortrait,
+        exportJsonKey: { resource: { type: "image-portrait", imagePortrait: { src: "$" } } },
         description: "The portrait image resource",
         chain: [
           {
@@ -4452,6 +6187,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageLandscape,
+        exportJsonKey: { resource: { type: "image-landscape", imageLandscape: { src: "$" } } },
         description: "The landscape image resource",
         chain: [
           {
@@ -4468,6 +6204,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageEmbed,
+        exportJsonKey: { resource: { type: "image-embed", imageEmbed: { src: "$" } } },
         description: "The embedded image resource",
         chain: [
           {
@@ -4484,6 +6221,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageLink,
+        exportJsonKey: { resource: { type: "image-link", imageLink: { url: "$" } } },
         description: "The link to the image resource",
         chain: [
           {
@@ -4500,6 +6238,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_audio,
+        exportJsonKey: { resource: { type: "audio", audio: { src: "$" } } },
         description: "The audio resource",
         chain: [
           {
@@ -4516,6 +6255,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_audioEmbed,
+        exportJsonKey: { resource: { type: "audio-embed", audioEmbed: { src: "$" } } },
         description: "The embedded audio resource",
         chain: [
           {
@@ -4532,6 +6272,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_audioLink,
+        exportJsonKey: { resource: { type: "audio-link", audioLink: { url: "$" } } },
         description: "The link to the audio resource",
         chain: [
           {
@@ -4548,6 +6289,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_video,
+        exportJsonKey: { resource: { type: "video", video: { src: "$" } } },
         description: "The video resource",
         chain: [
           {
@@ -4564,6 +6306,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_videoEmbed,
+        exportJsonKey: { resource: { type: "video-embed", videoEmbed: { url: "$" } } },
         description: "The embedded video resource",
         chain: [
           {
@@ -4580,6 +6323,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_videoLink,
+        exportJsonKey: { resource: { type: "video-link", videoLink: { url: "$" } } },
         description: "The link to the video resource",
         chain: [
           {
@@ -4596,6 +6340,9 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_stillImageFilmEmbed,
+        exportJsonKey: {
+          resource: { type: "still-image-film-embed", stillImageFilmEmbed: { url: "$" } }
+        },
         description: "The embedded still image film resource",
         chain: [
           {
@@ -4612,6 +6359,9 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_stillImageFilmLink,
+        exportJsonKey: {
+          resource: { type: "still-image-film-link", stillImageFilmLink: { url: "$" } }
+        },
         description: "The link to the still image film resource",
         chain: [
           {
@@ -4628,6 +6378,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_article,
+        exportJsonKey: { resource: { type: "article", article: { body: "$" } } },
         description: "The article resource",
         chain: [
           {
@@ -4644,6 +6395,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleEmbed,
+        exportJsonKey: { resource: { type: "article-embed", articleEmbed: { url: "$" } } },
         description: "The embedded article resource",
         chain: [
           {
@@ -4660,6 +6412,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleLink,
+        exportJsonKey: { resource: { type: "article-link", articleLink: { url: "$" } } },
         description: "The link to the article resource",
         chain: [
           {
@@ -4676,6 +6429,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_document,
+        exportJsonKey: { resource: { type: "document", document: { url: "$" } } },
         description: "The document resource",
         chain: [
           {
@@ -4692,6 +6446,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_documentEmbed,
+        exportJsonKey: { resource: { type: "document-embed", documentEmbed: { url: "$" } } },
         description: "The embedded document resource",
         chain: [
           {
@@ -4708,6 +6463,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_documentLink,
+        exportJsonKey: { resource: { type: "document-link", documentLink: { url: "$" } } },
         description: "The link to the document resource",
         chain: [
           {
@@ -4724,6 +6480,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_documentDownload,
+        exportJsonKey: { resource: { type: "document-download", documentDownload: { url: "$" } } },
         description: "The downloadable document resource",
         chain: [
           {
@@ -4740,6 +6497,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_appLink,
+        exportJsonKey: { resource: { type: "app-link", appLink: { url: "$" } } },
         description: "The link to the app resource",
         chain: [
           {
@@ -4756,6 +6514,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_websiteLink,
+        exportJsonKey: { resource: { type: "website-link", websiteLink: { url: "$" } } },
         description: "The link to the website resource",
         chain: [
           {
@@ -4814,6 +6573,7 @@ var GROUPS = {
       {
         key: ConfigKey.resource_previewImage,
         jsonKey: "previewImage|resource(type=image, key=image)",
+        exportJsonKey: { previewImage: { type: "image", image: { src: "$" } } },
         description: "The preview image resource",
         chain: [
           {
@@ -4831,6 +6591,7 @@ var GROUPS = {
       {
         key: ConfigKey.resource_previewVideo,
         jsonKey: "previewVideo|resource(type=video, key=video)",
+        exportJsonKey: { previewVideo: { type: "video", video: { src: "$" } } },
         description: "The preview video resource",
         chain: [
           {
@@ -4895,20 +6656,53 @@ var ConfigHydrator = class {
         _side.name,
         _side.repeat ?? false,
         variantsOfSide,
-        _side.jsonKey
+        _side.jsonKey,
+        _side.exportJsonKey,
+        Object.prototype.hasOwnProperty.call(_side, "exportJsonKey")
       );
       sides.push(sideConfig);
     }
     const cardSetConfig = new CardSetConfig(
       _cardSet,
       _cardSetConfig.jsonKey,
-      _cardSetConfig.sections,
+      _cardSetConfig.exportJsonKey,
+      Object.prototype.hasOwnProperty.call(_cardSetConfig, "exportJsonKey"),
+      this.hydrateCardSections(_cardSetConfig.sections),
       sides
     );
     return cardSetConfig;
   }
+  hydrateCardSections(sections) {
+    if (!sections) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(sections)) {
+      out[k] = {
+        jsonKey: v.jsonKey,
+        exportJsonKey: v.exportJsonKey,
+        hasExportJsonKey: Object.prototype.hasOwnProperty.call(v, "exportJsonKey"),
+        isDefault: v.isDefault,
+        sideJsonKey: v.sideJsonKey,
+        sideExportJsonKey: v.sideExportJsonKey,
+        hasSideExportJsonKey: Object.prototype.hasOwnProperty.call(v, "sideExportJsonKey"),
+        // PLAN-085: cardinality fields pass through; defaults applied
+        // downstream by the config consumer (Rust treats `0` / undefined
+        // as unbounded).
+        minCount: v.minCount,
+        maxCount: v.maxCount
+      };
+    }
+    return out;
+  }
   hydrateTagConfig(_tag) {
-    const { key: _configKey, maxCount, minCount, chain: _chain, deprecated } = _tag;
+    const {
+      key: _configKey,
+      maxCount,
+      minCount,
+      chain: _chain,
+      deprecated,
+      jsonKey,
+      exportJsonKey
+    } = _tag;
     const configKey = Enum2(ConfigKey).fromValue(_configKey) || ConfigKey._unknown;
     if (!configKey) throw new Error(`No tag key found for config key '${configKey}'`);
     const tag = Enum2(Tag).fromValue(configKey);
@@ -4923,6 +6717,9 @@ var ConfigHydrator = class {
       maxCount: maxCount ?? MAX_COUNT_DEFAULT,
       minCount: minCount ?? MIN_COUNT_DEFAULT,
       chain,
+      jsonKey,
+      exportJsonKey,
+      hasExportJsonKey: Object.prototype.hasOwnProperty.call(_tag, "exportJsonKey"),
       deprecated
     });
     return {
@@ -4941,7 +6738,8 @@ var ConfigHydrator = class {
       format,
       values,
       defaultValue,
-      jsonKey
+      jsonKey,
+      exportJsonKey
     } = _tag;
     const configKey = Enum2(ConfigKey).fromValue(_configKey) || ConfigKey._unknown;
     if (!configKey) throw new Error(`No property key found for config key '${configKey}'`);
@@ -4957,6 +6755,8 @@ var ConfigHydrator = class {
       minCount: minCount ?? MIN_COUNT_DEFAULT,
       chain,
       jsonKey,
+      exportJsonKey,
+      hasExportJsonKey: Object.prototype.hasOwnProperty.call(_tag, "exportJsonKey"),
       format,
       values,
       defaultValue,
@@ -4969,7 +6769,15 @@ var ConfigHydrator = class {
     };
   }
   hydrateResourceTagConfig(_tag) {
-    const { key: _configKey, maxCount, minCount, chain: _chain, deprecated, jsonKey } = _tag;
+    const {
+      key: _configKey,
+      maxCount,
+      minCount,
+      chain: _chain,
+      deprecated,
+      jsonKey,
+      exportJsonKey
+    } = _tag;
     const configKey = Enum2(ConfigKey).fromValue(_configKey) || ConfigKey._unknown;
     if (!configKey) throw new Error(`No resource key found for config key '${configKey}'`);
     const tag = _configKey.substring(1);
@@ -4984,6 +6792,8 @@ var ConfigHydrator = class {
       minCount: minCount ?? MIN_COUNT_DEFAULT,
       chain,
       jsonKey,
+      exportJsonKey,
+      hasExportJsonKey: Object.prototype.hasOwnProperty.call(_tag, "exportJsonKey"),
       deprecated
     });
     return {
@@ -5015,14 +6825,25 @@ var ConfigHydrator = class {
     };
   }
   hydrateCardVariantConfig(_variant) {
-    const { tags: _tags, bodyAllowed, bodyRequired, repeatCount, jsonKey } = _variant;
+    const {
+      tags: _tags,
+      bodyAllowed,
+      bodyRequired,
+      repeatCount,
+      jsonKey,
+      exportJsonKey,
+      format
+    } = _variant;
     const tags2 = this.hydrateTagsConfig(_tags);
     const cardSetConfig = new CardVariantConfig(
       tags2.tags,
       bodyAllowed,
       bodyRequired,
       repeatCount,
-      jsonKey
+      jsonKey,
+      exportJsonKey,
+      Object.prototype.hasOwnProperty.call(_variant, "exportJsonKey"),
+      format
     );
     return cardSetConfig;
   }
@@ -5060,6 +6881,7 @@ var BITS = {
         description: "Common tags for quiz bits"
       },
       {
+        exportJsonKey: { title: "$" },
         key: ConfigKey.tag_title,
         description: "The title of the flashcard quiz"
       },
@@ -5068,6 +6890,21 @@ var BITS = {
         description: "The flashcard set to use for the app flashcards",
         format: TagFormat.plainText,
         maxCount: Count.infinity
+      },
+      {
+        // Override inherited @example from group_standardTags: string root
+        // example. Bare/synthesized emits `example: "true"` (a text literal
+        // that field-coerces to a paragraph "true" in bitmark+ contexts);
+        // valued [@example:text] emits the user's text via `$`.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: "true" } },
+          { "@absent": { isExample: true, example: "true" } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example text for the bit",
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -5149,6 +6986,7 @@ var BITS = {
     description: "Article bit, used for articles / paragraphs",
     tags: [
       {
+        exportJsonKey: { title: "$" },
         key: ConfigKey.tag_title,
         description: "The title of the article"
       }
@@ -5256,7 +7094,8 @@ var BITS = {
         key: ConfigKey.tag_title,
         description: "Title and subtitle of the catalog item",
         maxCount: 2,
-        jsonKey: "title|multi(count=2, key=subtitle)"
+        jsonKey: "title|multi(count=2, key=subtitle)",
+        exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }]
       },
       {
         key: ConfigKey.property_coverImage,
@@ -5266,6 +7105,7 @@ var BITS = {
       {
         key: ConfigKey.resource_coverImage,
         jsonKey: "coverImage|resource(type=image, key=image)",
+        exportJsonKey: { coverImage: { type: "image", image: { src: "$" } } },
         description: "Cover image of the catalog item",
         chain: [
           {
@@ -5393,6 +7233,18 @@ var BITS = {
         key: ConfigKey.group_previewVideos,
         description: "Array of preview videos for the catalog item",
         maxCount: Count.infinity
+      },
+      {
+        // Override inherited @example from group_standardTags: string root example.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: "true" } },
+          { "@absent": { isExample: true, example: "true" } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example text for the bit",
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -5406,7 +7258,8 @@ var BITS = {
         key: ConfigKey.tag_title,
         description: "Title and subtitle of the catalog item",
         maxCount: 2,
-        jsonKey: "title|multi(count=2, key=subtitle)"
+        jsonKey: "title|multi(count=2, key=subtitle)",
+        exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }]
       },
       {
         key: ConfigKey.property_coverImage,
@@ -5416,6 +7269,7 @@ var BITS = {
       {
         key: ConfigKey.resource_coverImage,
         jsonKey: "coverImage|resource(type=image, key=image)",
+        exportJsonKey: { coverImage: { type: "image", image: { src: "$" } } },
         description: "Cover image of the catalog item",
         chain: [
           {
@@ -5543,6 +7397,18 @@ var BITS = {
         key: ConfigKey.group_previewVideos,
         description: "Array of preview videos for the catalog item",
         maxCount: Count.infinity
+      },
+      {
+        // Override inherited @example from group_standardTags: string root example.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: "true" } },
+          { "@absent": { isExample: true, example: "true" } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example text for the bit",
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -5556,7 +7422,8 @@ var BITS = {
         key: ConfigKey.tag_title,
         description: "Title and subtitle of the catalog item",
         maxCount: 2,
-        jsonKey: "title|multi(count=2, key=subtitle)"
+        jsonKey: "title|multi(count=2, key=subtitle)",
+        exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }]
       },
       {
         key: ConfigKey.property_coverImage,
@@ -5682,6 +7549,18 @@ var BITS = {
         key: ConfigKey.group_previewVideos,
         description: "Array of preview videos for the catalog item",
         maxCount: Count.infinity
+      },
+      {
+        // Override inherited @example from group_standardTags: string root example.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: "true" } },
+          { "@absent": { isExample: true, example: "true" } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example text for the bit",
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -5883,11 +7762,13 @@ var BITS = {
     description: "Bit alias, used to create an alias for a bit",
     tags: [
       {
+        exportJsonKey: { reference: "$" },
         key: ConfigKey.tag_reference,
         format: TagFormat.plainText,
         description: "The reference to the bit that this alias points to"
       },
       {
+        exportJsonKey: { anchor: "$" },
         key: ConfigKey.tag_anchor,
         format: TagFormat.plainText,
         description: "The anchor for the bit alias, used for linking"
@@ -6089,7 +7970,8 @@ var BITS = {
         description: "The title of the book cover",
         maxCount: 2,
         // title & subtitle
-        jsonKey: "title|multi(count=2, key=subtitle)"
+        jsonKey: "title|multi(count=2, key=subtitle)",
+        exportJsonKey: [{ "@level=1": { title: "$" } }, { "@level=2": { subtitle: "$" } }]
       },
       {
         key: ConfigKey.property_coverColor,
@@ -6233,6 +8115,7 @@ var BITS = {
     description: "Chapter bit, used to define chapters in books or articles",
     tags: [
       {
+        exportJsonKey: { anchor: "$" },
         key: ConfigKey.tag_anchor,
         format: TagFormat.plainText,
         description: "The anchor for the chapter, used for linking"
@@ -6240,7 +8123,8 @@ var BITS = {
       {
         key: ConfigKey.tag_title,
         description: "The title of the chapter",
-        jsonKey: "title|setMulti(level)"
+        jsonKey: "title|setMulti(level)",
+        exportJsonKey: { title: "$", level: "$level" }
       },
       {
         key: ConfigKey.property_toc,
@@ -6271,8 +8155,31 @@ var BITS = {
         description: "Tags for gaps in cloze and multiple choice text bits"
       },
       {
-        key: ConfigKey.group_trueFalse,
+        key: ConfigKey.group_trueFalseInlineSelect,
         description: "Tags for true/false questions in cloze and multiple choice text bits"
+      },
+      {
+        // Bit-level @isCaseSensitive — empty exportJsonKey (no bit-level emission);
+        // defaultValue 'true' phantom-fires onto the ancestor stack so the gap chain's
+        // `@absent: $ancestor` rule resolves to true. Mirrors BPG Builder.ts:1643-1652
+        // `pushDownTree(... 'isCaseSensitive', data.isCaseSensitive ?? true)` for cloze bits.
+        key: ConfigKey.property_isCaseSensitive,
+        exportJsonKey: {},
+        description: "If the cloze answers are case sensitive",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
@@ -6293,6 +8200,7 @@ var BITS = {
       },
       {
         key: ConfigKey.property_isCaseSensitive,
+        exportJsonKey: {},
         description: "If the cloze answers are case sensitive",
         format: TagFormat.boolean,
         defaultValue: "true"
@@ -6310,18 +8218,56 @@ var BITS = {
       {
         key: ConfigKey.group_gap,
         description: "Tags for gaps in cloze bits"
+      },
+      {
+        // Override inherited @example: cloze is in OLD parser's
+        // `isTopLevelExample` allow-list, so [@example] at bit-header
+        // emits `isExample: true`.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
   [BitType2.clozeInstructionGrouped]: {
     since: "1.3.0",
     baseBitType: BitType2.cloze,
-    description: "Cloze instruction grouped bit, used for cloze questions with grouped instructions"
+    description: "Cloze instruction grouped bit, used for cloze questions with grouped instructions",
+    tags: [
+      {
+        key: ConfigKey.property_quizCountItems,
+        description: "The number of items in the cloze quiz (instruction-grouped default: true)",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      }
+      // Note: quizStrikethroughSolutions defaults to false for instruction-grouped per OLD
+      // JsonGenerator.ts:1689-1690, which equals the Boolean natural default → no override needed.
+    ]
   },
   [BitType2.clozeSolutionGrouped]: {
     since: "1.3.0",
     baseBitType: BitType2.cloze,
-    description: "Cloze solution grouped bit, used for cloze questions with grouped solutions"
+    description: "Cloze solution grouped bit, used for cloze questions with grouped solutions",
+    tags: [
+      {
+        key: ConfigKey.property_quizCountItems,
+        description: "The number of items in the cloze quiz (solution-grouped default: true)",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      },
+      {
+        key: ConfigKey.property_quizStrikethroughSolutions,
+        description: "If the cloze solutions should be strikethrough (solution-grouped default: true)",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      }
+    ]
   },
   [BitType2.clozeSeveral]: {
     since: "3.5.0",
@@ -6357,6 +8303,17 @@ var BITS = {
       {
         key: ConfigKey.group_quizCommon,
         description: "Common tags for quiz bits"
+      },
+      {
+        // PLAN-084 (R12): bit-level @isCaseSensitive — empty exportJsonKey
+        // (no bit-level emission); defaultValue 'true' phantom-fires onto
+        // the ancestor stack so each listItem's gap chain `@absent: $ancestor`
+        // rule resolves to true. Mirrors the cloze bit (bits.ts:1326-1336).
+        key: ConfigKey.property_isCaseSensitive,
+        exportJsonKey: {},
+        description: "If the cloze answers are case sensitive",
+        format: TagFormat.boolean,
+        defaultValue: "true"
       }
     ],
     cardSet: CardSetConfigKey.clozeList
@@ -6390,6 +8347,11 @@ var BITS = {
     description: "Formula bit, used for mathematical formulas in articles or documents",
     textFormatDefault: TextFormat2.latex
   },
+  [BitType2.formulaImage]: {
+    since: "5.23.0",
+    baseBitType: BitType2.formula,
+    description: "Formula image bit, used for mathematical formulas rendered as images"
+  },
   [BitType2.smartStandardFormula]: {
     since: "3.11.0",
     baseBitType: BitType2.formula,
@@ -6518,6 +8480,7 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.group_person,
+        exportJsonKey: { partner: { name: "$" } },
         description: "Tags for the person in the conversation"
       }
     ]
@@ -6742,6 +8705,7 @@ var BITS = {
       {
         key: ConfigKey.property_servings,
         jsonKey: "servings.servings",
+        exportJsonKey: { servings: { servings: "$" } },
         description: "The number of servings for the ingredients",
         format: TagFormat.number,
         chain: [
@@ -6767,6 +8731,7 @@ var BITS = {
             format: TagFormat.boolean
           },
           {
+            exportJsonKey: { hint: "$" },
             key: ConfigKey.tag_hint,
             description: "Hint for the ingredient, used to provide additional information",
             format: TagFormat.plainText
@@ -6944,6 +8909,18 @@ var BITS = {
         description: "Reference for the essay, used to link to external resources",
         format: TagFormat.plainText,
         maxCount: Count.infinity
+      },
+      {
+        // Override inherited @example from group_standardTags: string root example.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: "true" } },
+          { "@absent": { isExample: true, example: "true" } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example text for the essay bit",
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -6964,8 +8941,21 @@ var BITS = {
     description: "Example bit, used to provide examples in articles or books",
     tags: [
       {
+        exportJsonKey: { title: "$" },
         key: ConfigKey.tag_title,
         description: "The title of the example"
+      },
+      {
+        // Override inherited @example from group_standardTags: string root example.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: "true" } },
+          { "@absent": { isExample: true, example: "true" } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example text for the example bit",
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -7051,7 +9041,19 @@ var BITS = {
   [BitType2.articleAi]: {
     since: "1.3.0",
     baseBitType: BitType2.article,
-    description: "Article AI bit, used to create AI-generated articles"
+    description: "Article AI bit, used to create AI-generated articles",
+    tags: [
+      {
+        // Shadows the inherited @aiGenerated from the standard group: this
+        // bit type forces aiGenerated:true regardless of source value or
+        // absence. Literal `true` in the export pattern ignores `$`.
+        key: ConfigKey.property_aiGenerated,
+        description: "AI-generated flag, forced true for article-ai bits",
+        format: TagFormat.boolean,
+        defaultValue: "true",
+        exportJsonKey: { aiGenerated: true }
+      }
+    ]
   },
   [BitType2.articleAttachment]: {
     since: "1.3.0",
@@ -7376,7 +9378,19 @@ var BITS = {
   [BitType2.noteAi]: {
     since: "1.3.0",
     baseBitType: BitType2.note,
-    description: "Note AI bit, used to create AI-generated notes in articles or books"
+    description: "Note AI bit, used to create AI-generated notes in articles or books",
+    tags: [
+      {
+        // Shadows the inherited @aiGenerated from the standard group: this
+        // bit type forces aiGenerated:true regardless of source value or
+        // absence. Literal `true` in the export pattern ignores `$`.
+        key: ConfigKey.property_aiGenerated,
+        description: "AI-generated flag, forced true for article-ai bits",
+        format: TagFormat.boolean,
+        defaultValue: "true",
+        exportJsonKey: { aiGenerated: true }
+      }
+    ]
   },
   [BitType2.notebookArticle]: {
     since: "1.3.0",
@@ -7501,7 +9515,19 @@ var BITS = {
   [BitType2.summaryAi]: {
     since: "1.3.0",
     baseBitType: BitType2.summary,
-    description: "AI-generated summary bit"
+    description: "AI-generated summary bit",
+    tags: [
+      {
+        // Shadows the inherited @aiGenerated from the standard group: this
+        // bit type forces aiGenerated:true regardless of source value or
+        // absence. Literal `true` in the export pattern ignores `$`.
+        key: ConfigKey.property_aiGenerated,
+        description: "AI-generated flag, forced true for article-ai bits",
+        format: TagFormat.boolean,
+        defaultValue: "true",
+        exportJsonKey: { aiGenerated: true }
+      }
+    ]
   },
   [BitType2.videoTranscript]: {
     since: "1.3.0",
@@ -7775,7 +9801,7 @@ var BITS = {
         description: "Product ID for the module product, used to link to a specific product",
         format: TagFormat.plainText,
         minCount: 1,
-        maxCount: Count.infinity
+        maxCount: 1
       }
     ]
   },
@@ -7828,9 +9854,13 @@ var BITS = {
         description: "Resource bit tags for logo grave images, used to define additional properties"
       },
       {
-        // Image resource
-        key: ConfigKey.group_resourceImage,
+        // Image resource — fully-expanded shape so each `&image` emission
+        // produces a complete `{type, image: {src}}` object inside the
+        // `images[]` array. Chain attrs like `[@zoomDisabled]` fold under
+        // `images[].image` via the `[]` last-element-merge semantic.
+        key: ConfigKey.group_resourceImageNoZoom,
         description: "Resource image tags for logo grave images, used to attach images",
+        exportJsonKey: { images: [{ type: "image", image: { src: "$" } }] },
         minCount: 1,
         maxCount: Count.infinity
       }
@@ -7994,15 +10024,27 @@ var BITS = {
         format: TagFormat.plainText,
         chain: [
           {
+            exportJsonKey: { reference: "$" },
             key: ConfigKey.tag_reference,
             format: TagFormat.plainText,
             description: "Reference tag for the book, used to link to the book in the system",
-            maxCount: 2
+            maxCount: 1,
+            chain: [
+              {
+                key: ConfigKey.tag_reference,
+                jsonKey: "referenceEnd",
+                exportJsonKey: { referenceEnd: "$" },
+                format: TagFormat.plainText,
+                description: "End reference tag for the book, used to specify a range",
+                maxCount: 1
+              }
+            ]
           }
         ]
       },
       {
         /* Allow incorrectly chained reference tag */
+        exportJsonKey: { reference: "$" },
         key: ConfigKey.tag_reference,
         format: TagFormat.plainText,
         description: "Reference tag for the book, used to link to the book in the system"
@@ -8049,18 +10091,41 @@ var BITS = {
         format: TagFormat.plainText,
         chain: [
           {
+            exportJsonKey: { reference: "$" },
             key: ConfigKey.tag_reference,
             format: TagFormat.plainText,
             description: "Reference tag for the book, used to link to the book in the system",
-            maxCount: 2
+            maxCount: 1,
+            chain: [
+              {
+                key: ConfigKey.tag_reference,
+                jsonKey: "referenceEnd",
+                exportJsonKey: { referenceEnd: "$" },
+                format: TagFormat.plainText,
+                description: "End reference tag for the book, used to specify a range",
+                maxCount: 1
+              }
+            ]
           }
         ]
       },
       {
         /* Allow incorrectly chained reference tag */
+        exportJsonKey: { reference: "$" },
         key: ConfigKey.tag_reference,
         format: TagFormat.plainText,
-        description: "Reference tag for the book, used to link to the book in the system"
+        description: "Reference tag for the book, used to link to the book in the system",
+        maxCount: 1,
+        chain: [
+          {
+            key: ConfigKey.tag_reference,
+            jsonKey: "referenceEnd",
+            exportJsonKey: { referenceEnd: "$" },
+            format: TagFormat.plainText,
+            description: "End reference tag for the book, used to specify a range",
+            maxCount: 1
+          }
+        ]
       },
       {
         key: ConfigKey.property_buttonCaption,
@@ -8085,14 +10150,29 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.property_book,
+        // Starter-array shape: each `[@book:value]` chain appends a fresh
+        // `{ book, reference }` entry. The chained `►` (tag_reference) lands
+        // inside the most-recently-appended entry as `reference: $`.
+        exportJsonKey: { book: [{ book: "$" }] },
         description: "Book reference for the page, used to link to a specific book",
         maxCount: Count.infinity,
         chain: [
           {
+            exportJsonKey: { reference: "$" },
             key: ConfigKey.tag_reference,
             format: TagFormat.plainText,
             description: "Reference tag for the book, used to link to the book in the system",
-            maxCount: 2
+            maxCount: 1,
+            chain: [
+              {
+                key: ConfigKey.tag_reference,
+                jsonKey: "referenceEnd",
+                exportJsonKey: { referenceEnd: "$" },
+                format: TagFormat.plainText,
+                description: "End reference tag for the book, used to specify a range",
+                maxCount: 1
+              }
+            ]
           }
         ]
       },
@@ -8141,7 +10221,9 @@ var BITS = {
         format: TagFormat.plainText
       }
     ],
-    cardSet: CardSetConfigKey.exampleBitList
+    // page-footer emits cards under `sections` (vs `listItems` for the
+    // sibling exampleList / assignmentList bits) — see JsonGenerator.ts.
+    cardSet: CardSetConfigKey.pageFooterSections
   },
   [BitType2.legend]: {
     since: "3.12.0",
@@ -8183,6 +10265,20 @@ var BITS = {
     since: "1.34.0",
     baseBitType: BitType2._standard,
     description: "Definition list bit, used to create lists of definitions in articles or books",
+    tags: [
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
+      }
+    ],
     cardSet: CardSetConfigKey.definitionList
   },
   [BitType2.metaSearchDefaultTerms]: {
@@ -8205,6 +10301,18 @@ var BITS = {
       {
         key: ConfigKey.group_quizCommon,
         description: "Common quiz tags for flashcards"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ],
     cardSet: CardSetConfigKey.flashcard
@@ -8212,7 +10320,11 @@ var BITS = {
   [BitType2.flashcard1]: {
     since: "1.3.0",
     baseBitType: BitType2.flashcard,
-    description: "Flashcard 1 bit"
+    description: "Flashcard 1 bit",
+    // PLAN-085: use the flashcard1 cardset (sections.default.maxCount=1)
+    // instead of inheriting `flashcard`'s unbounded cardset, since this
+    // bit type structurally allows only a single card.
+    cardSet: CardSetConfigKey.flashcard1
   },
   [BitType2.qAndACard]: {
     since: "3.25.0",
@@ -8247,8 +10359,24 @@ var BITS = {
         description: "Common quiz tags for highlighted text"
       },
       {
-        key: ConfigKey.group_trueFalse,
-        description: "True/False quiz tags for highlighted text"
+        // Dedicated highlight inline-select chain: tag_true / tag_false
+        // emit `{type:"highlight", attrs:{texts:[{text,isCorrect?}]}}`
+        // inline body nodes via @body-inline. Bit shares no tag IDs with
+        // multiple-choice / multiple-choice-1 (which use group_trueFalse).
+        key: ConfigKey.group_trueFalseInlineHighlight,
+        description: "True/False quiz tags for highlighted text (inline body nodes)"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
@@ -8258,14 +10386,8 @@ var BITS = {
     description: "Image bit, used to create images in articles or books",
     tags: [
       {
-        key: ConfigKey.resource_backgroundWallpaper,
-        description: "Background wallpaper for the image, used to set a background for the image",
-        chain: [
-          {
-            key: ConfigKey.group_resourceImageCommon,
-            description: "Common resource image tags for images"
-          }
-        ]
+        key: ConfigKey.group_backgroundWallpaper,
+        description: "Background wallpaper tags for images, used to define background properties for images"
       },
       {
         key: ConfigKey.group_resourceBitTags,
@@ -8368,8 +10490,15 @@ var BITS = {
   },
   [BitType2.imageSeparator]: {
     since: "1.4.15",
-    baseBitType: BitType2.image,
-    description: "Image separator bit, used to create separators in articles or books"
+    baseBitType: BitType2._standard,
+    description: "Image separator bit, used to create separators in articles or books",
+    tags: [
+      {
+        key: ConfigKey.group_imageNoZoom,
+        description: "Image no zoom tags for images, used to define whether images should have zoom functionality"
+      }
+    ],
+    resourceAttachmentAllowed: false
   },
   [BitType2.imageSeparatorAlt]: {
     since: "1.16.0",
@@ -8408,15 +10537,20 @@ var BITS = {
   },
   [BitType2.pageBanner]: {
     since: "1.4.3",
-    baseBitType: BitType2.image,
+    baseBitType: BitType2._standard,
     description: "Page banner bit, used to create banners for pages in articles or books",
     tags: [
       {
         key: ConfigKey.property_slug,
         description: "Slug for the page banner, used to identify the banner in the system",
         format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.group_imageNoZoom,
+        description: "Image no zoom tags for images, used to define whether images should have zoom functionality"
       }
-    ]
+    ],
+    resourceAttachmentAllowed: false
   },
   [BitType2.pageHero]: {
     since: "1.11.0",
@@ -8431,7 +10565,7 @@ var BITS = {
   },
   [BitType2.tableImage]: {
     since: "1.5.15",
-    baseBitType: BitType2.table,
+    baseBitType: BitType2.tableExtended,
     description: "Table image bit, used to create images in tables in articles or books",
     tags: [
       {
@@ -8440,14 +10574,8 @@ var BITS = {
         format: TagFormat.bitmarkText
       },
       {
-        key: ConfigKey.resource_backgroundWallpaper,
-        description: "Background wallpaper for the image, used to set a background for the image",
-        chain: [
-          {
-            key: ConfigKey.group_resourceImageCommon,
-            description: "Common resource image tags for images"
-          }
-        ]
+        key: ConfigKey.group_backgroundWallpaper,
+        description: "Background wallpaper tags for images, used to define background properties for images"
       },
       {
         key: ConfigKey.group_resourceBitTags,
@@ -8590,9 +10718,10 @@ var BITS = {
         description: "Resource bit tags for logo grave images, used to define additional properties"
       },
       {
-        // Image resource
-        key: ConfigKey.group_resourceImage,
+        // Image resource — fully-expanded shape (see BitType.extractorImage).
+        key: ConfigKey.group_resourceImageNoZoom,
         description: "Resource image tags for logo grave images, used to attach images",
+        exportJsonKey: { logos: [{ type: "image", image: { src: "$" } }] },
         minCount: 1,
         maxCount: Count.infinity
       }
@@ -8602,7 +10731,17 @@ var BITS = {
   [BitType2.prototypeImages]: {
     since: "1.6.1",
     baseBitType: BitType2.imagesLogoGrave,
-    description: "Prototype images bit, used to create prototype images in articles or books"
+    description: "Prototype images bit, used to create prototype images in articles or books",
+    tags: [
+      {
+        // Override inherited `logos` wrapper with `images` for this bit type.
+        key: ConfigKey.group_resourceImageNoZoom,
+        description: "Resource image tags for prototype images",
+        exportJsonKey: { images: [{ type: "image", image: { src: "$" } }] },
+        minCount: 1,
+        maxCount: Count.infinity
+      }
+    ]
   },
   [BitType2.internalLink]: {
     since: "1.3.0",
@@ -8610,6 +10749,7 @@ var BITS = {
     description: "Internal link bit, used to create links to other bits in articles or books",
     tags: [
       {
+        exportJsonKey: { reference: "$" },
         key: ConfigKey.tag_reference,
         format: TagFormat.plainText,
         description: "Reference tag for the internal link, used to link to the target bit"
@@ -8628,8 +10768,21 @@ var BITS = {
       },
       {
         key: ConfigKey.property_reasonableNumOfChars,
+        exportJsonKey: {},
         description: "Reasonable number of characters for the interview, used to limit input size",
         format: TagFormat.number
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ],
     cardSet: CardSetConfigKey.questions
@@ -8988,6 +11141,18 @@ var BITS = {
       {
         key: ConfigKey.group_mark,
         description: "Mark tags, used to define the content of marks"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
@@ -9003,9 +11168,27 @@ var BITS = {
       },
       {
         key: ConfigKey.property_isCaseSensitive,
+        exportJsonKey: {},
         description: "Case sensitivity for matching pairs, used to define if matches are case-sensitive",
         format: TagFormat.boolean,
         defaultValue: "true"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list
+        // (covers match, matchAll, matchReverse, matchAllReverse,
+        // matchSolutionGrouped, matchMatrix, matchAudio, matchPicture).
+        // Bit-level fires emit only `isExample`; the @example value (when
+        // provided) is recorded in the ancestor stack and consumed by
+        // per-pair/per-cell variant overrides — not surfaced at bit scope.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ],
     cardSet: CardSetConfigKey.matchPairs
@@ -9055,6 +11238,7 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.property_reasonableNumOfChars,
+        exportJsonKey: {},
         description: "Reasonable number of characters for feedback, used to limit input size",
         format: TagFormat.number
       }
@@ -9089,6 +11273,18 @@ var BITS = {
       {
         key: ConfigKey.group_trueFalse,
         description: "True/False tags for multiple choice 1 questions"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
@@ -9110,8 +11306,20 @@ var BITS = {
       {
         key: ConfigKey.group_trueFalse,
         description: "True/False tags for multiple choice questions"
-      }
+      },
       // This is actually for multiple-choice-1, but we support it here as well (as many bits are wrong)
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
+      }
     ],
     cardSet: CardSetConfigKey.quiz
   },
@@ -9131,8 +11339,20 @@ var BITS = {
         description: "Common quiz tags for multiple choice text questions"
       },
       {
-        key: ConfigKey.group_trueFalse,
+        key: ConfigKey.group_trueFalseInlineSelect,
         description: "True/False tags for multiple choice text questions"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
@@ -9157,8 +11377,20 @@ var BITS = {
         description: "Common quiz tags for multiple response 1 questions"
       },
       {
-        key: ConfigKey.group_trueFalse,
+        key: ConfigKey.group_trueFalseResponses,
         description: "True/False tags for multiple response 1 questions"
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
@@ -9178,12 +11410,24 @@ var BITS = {
         description: "Common quiz tags for multiple response questions"
       },
       {
-        key: ConfigKey.group_trueFalse,
+        key: ConfigKey.group_trueFalseResponses,
         description: "True/False tags for multiple response questions"
-      }
+      },
       // This is actually for multiple-response-1, but we support it here as well (as many bits are wrong)
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
+      }
     ],
-    cardSet: CardSetConfigKey.quiz
+    cardSet: CardSetConfigKey.quizResponses
   },
   [BitType2.coachSelfReflectionMultipleResponse]: {
     since: "1.3.0",
@@ -9196,6 +11440,7 @@ var BITS = {
     description: "Page bit, used to create pages in articles or books",
     tags: [
       {
+        exportJsonKey: { title: "$" },
         key: ConfigKey.tag_title,
         description: "Title of the page, used to display the page title"
       },
@@ -9432,6 +11677,8 @@ var BITS = {
       },
       {
         key: ConfigKey.resource_platformIcon,
+        jsonKey: "platformIcon|resource(type=image, key=image)",
+        exportJsonKey: { platformIcon: { type: "image", image: { src: "$" } } },
         description: "The platform icon",
         chain: [
           {
@@ -9467,6 +11714,8 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.resource_platformLogo,
+        jsonKey: "platformLogo|resource(type=image, key=image)",
+        exportJsonKey: { platformLogo: { type: "image", image: { src: "$" } } },
         description: "The platform logo",
         chain: [
           {
@@ -9555,6 +11804,7 @@ var BITS = {
       {
         key: ConfigKey.resource_platformBackgroundImage,
         jsonKey: "platformBackgroundImage|resource(type=image, key=image)",
+        exportJsonKey: { platformBackgroundImage: { type: "image", image: { src: "$" } } },
         description: "The platform section chat background image",
         chain: [
           {
@@ -9648,6 +11898,7 @@ var BITS = {
     description: "Review note bit, used to create review notes in articles or books",
     tags: [
       {
+        exportJsonKey: { title: "$" },
         key: ConfigKey.tag_title,
         description: "Title of the review note, used to display the note title"
       },
@@ -9666,6 +11917,18 @@ var BITS = {
         key: ConfigKey.property_resolvedBy,
         description: "Resolved by for the review note, used to define who resolved the note",
         format: TagFormat.plainText
+      },
+      {
+        // Override inherited @example from group_standardTags: string root example.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: "true" } },
+          { "@absent": { isExample: true, example: "true" } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example text for the review note bit",
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -9718,11 +11981,13 @@ var BITS = {
     tags: [
       // Not sure if these are actually valid here, but include them as they are in the test bit.
       {
+        exportJsonKey: { anchor: "$" },
         key: ConfigKey.tag_anchor,
         format: TagFormat.plainText,
         description: "Anchor for the sample solution, used to link to the solution"
       },
       {
+        exportJsonKey: { reference: "$" },
         key: ConfigKey.tag_reference,
         format: TagFormat.plainText,
         description: "Reference for the sample solution, used to link to the source of the solution"
@@ -9738,6 +12003,20 @@ var BITS = {
       {
         key: ConfigKey.group_quizCommon,
         description: "Common quiz tags for sequences"
+      },
+      {
+        // Override inherited @example from group_standardTags: this bit has
+        // a boolean root example (rootExampleType: boolean), so bit-level
+        // [@example] writes `example: true` in addition to `isExample: true`.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: true } },
+          { "@absent": { isExample: true, example: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example flag for the bit (boolean)",
+        format: TagFormat.boolean,
+        nullable: true
       }
     ],
     cardSet: CardSetConfigKey.elements,
@@ -9845,6 +12124,7 @@ var BITS = {
       {
         key: ConfigKey.property_ratingLevelStart,
         jsonKey: "ratingLevelStart.level",
+        exportJsonKey: { ratingLevelStart: { level: "$" } },
         description: "Start level for the rating survey, used to define the lowest rating",
         format: TagFormat.number,
         chain: [
@@ -9858,6 +12138,7 @@ var BITS = {
       {
         key: ConfigKey.property_ratingLevelEnd,
         jsonKey: "ratingLevelEnd.level",
+        exportJsonKey: { ratingLevelEnd: { level: "$" } },
         description: "End level for the rating survey, used to define the highest rating",
         format: TagFormat.number,
         chain: [
@@ -10009,14 +12290,8 @@ var BITS = {
         format: TagFormat.bitmarkText
       },
       {
-        key: ConfigKey.resource_backgroundWallpaper,
-        description: "Background wallpaper for the image, used to set a background for the image",
-        chain: [
-          {
-            key: ConfigKey.group_resourceImageCommon,
-            description: "Common resource image tags for images"
-          }
-        ]
+        key: ConfigKey.group_backgroundWallpaper,
+        description: "Background wallpaper tags for images, used to define background properties for images"
       },
       {
         key: ConfigKey.group_resourceBitTags,
@@ -10393,12 +12668,48 @@ var BITS = {
         format: TagFormat.plainText
       },
       {
+        // PLAN-067 Edit #1: true-false-1's `+` / `-` emit a flat
+        // `{ statement, isCorrect }` at bit root (single-statement bit),
+        // not a `choices[]` array. Format is bitmarkText so the statement
+        // body renders as a ProseMirror tree, matching reference fixtures.
+        exportJsonKey: { statement: "$", isCorrect: true },
         key: ConfigKey.tag_true,
-        description: "Tag for the true option in the true/false question"
+        description: "Tag for the true option in the true/false question",
+        format: TagFormat.bitmarkText
       },
       {
+        exportJsonKey: { statement: "$", isCorrect: false },
         key: ConfigKey.tag_false,
-        description: "Tag for the false option in the true/false question"
+        description: "Tag for the false option in the true/false question",
+        format: TagFormat.bitmarkText
+      },
+      {
+        // Override inherited @example from group_standardTags: boolean root
+        // example. Note: the legacy reference parser ties the bare-form
+        // example value to `statement.isCorrect`, but the statement is not
+        // yet emitted when this tag fires at bit-header. The pattern below
+        // emits a literal `true` for bare/synthesized and `$` for valued —
+        // sufficient for `[+...]` (correct) statements which dominate the
+        // fixtures; `[-...]` (incorrect) bits with bare `[@example]` would
+        // need either a runtime extension or an explicit `[@example:false]`.
+        //
+        // Format is `boolean` so `[@example:false]` coerces to JSON `false`
+        // (a natural default that gets stripped in optimised mode, matching
+        // BPG's `rootExampleType: boolean`). PlainText would emit the
+        // STRING `"false"` which doesn't strip.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true, example: true } },
+          { "@absent": { isExample: true, example: true } },
+          // `[@example:false]`: emit `isExample: true` only — `example: false`
+          // is the natural default for boolean, stripped in optimised mode.
+          // Mirrors BPG `removeUnwantedProperties` `ignoreAllFalse: true`.
+          { "@value=false": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example flag for the bit (boolean)",
+        format: TagFormat.boolean,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.boolean
@@ -10422,6 +12733,18 @@ var BITS = {
         key: ConfigKey.property_labelFalse,
         description: "Label for the false option in the true/false question",
         format: TagFormat.plainText
+      },
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ],
     cardSet: CardSetConfigKey.statements
@@ -10611,6 +12934,11 @@ var BITS = {
     baseBitType: BitType2.vendorStripePricingTable,
     description: "Stripe pricing table bit with print-on-request customer/product IDs, used to embed Stripe pricing tables tied to a specific print-on-request customer and product",
     tags: [
+      {
+        key: ConfigKey.property_stripePricingTableDescriptiveName,
+        description: "Descriptive name for the Stripe pricing table",
+        format: TagFormat.plainText
+      },
       {
         key: ConfigKey.property_printOnRequestCustomerId,
         description: "Print-on-request customer ID, used to identify the customer for the print-on-request flow",
@@ -10981,6 +13309,8 @@ var Config = class {
               maxCount: 1,
               chain: tag.chain,
               jsonKey: tag.jsonKey,
+              exportJsonKey: tag.exportJsonKey,
+              hasExportJsonKey: tag.hasExportJsonKey,
               deprecated: tag.deprecated
             });
             finalResourceTags[k] = newTag;
@@ -11085,7 +13415,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.22.0",
+  "version": "5.24.0",
   "author": "Get More Brain Ltd",
   "license": "ISC",
   "description": "A bitmark parser and generator using Peggy.js"
@@ -11679,6 +14009,8 @@ var NodeType = {
   gmbExternalShopItems: "gmbExternalShopItems",
   groupTag: "groupTag",
   groupTagValue: "groupTagValue",
+  gUri: "gUri",
+  gUriValue: "gUriValue",
   handInAcceptFileType: "handInAcceptFileType",
   handInAcceptFileTypeValue: "handInAcceptFileTypeValue",
   handInInstruction: "handInInstruction",
@@ -12021,6 +14353,8 @@ var NodeType = {
   solution: "solution",
   solutions: "solutions",
   solutionsValue: "solutionsValue",
+  sourceBB: "sourceBB",
+  sourceBBValue: "sourceBBValue",
   sourceDocument: "sourceDocument",
   sourceDocumentValue: "sourceDocumentValue",
   sourceRL: "sourceRL",
@@ -12046,6 +14380,8 @@ var NodeType = {
   stillImageFilmLink: "stillImageFilmLink",
   stripePricingTableId: "stripePricingTableId",
   stripePricingTableIdValue: "stripePricingTableIdValue",
+  stripePricingTableDescriptiveName: "stripePricingTableDescriptiveName",
+  stripePricingTableDescriptiveNameValue: "stripePricingTableDescriptiveNameValue",
   stripePublishableKey: "stripePublishableKey",
   stripePublishableKeyValue: "stripePublishableKeyValue",
   subject: "subject",
@@ -24901,6 +27237,7 @@ var Builder = class extends BaseBuilder {
       isCommented: data.isCommented,
       // Properties
       id: this.toAstProperty(bitType, ConfigKey.property_id, data.id, options),
+      gUri: this.toAstProperty(bitType, ConfigKey.property_gUri, data.gUri, options),
       internalComment: this.toAstProperty(
         bitType,
         ConfigKey.property_internalComment,
@@ -25112,6 +27449,7 @@ var Builder = class extends BaseBuilder {
         data.extractorInternal,
         options
       ),
+      sourceBB: this.normaliseSourceBB(data.sourceBB),
       levelCEFRp: this.toAstProperty(
         bitType,
         ConfigKey.property_levelCEFRp,
@@ -25469,6 +27807,12 @@ var Builder = class extends BaseBuilder {
         data.stripePricingTableId,
         options
       ),
+      stripePricingTableDescriptiveName: this.toAstProperty(
+        bitType,
+        ConfigKey.property_stripePricingTableDescriptiveName,
+        data.stripePricingTableDescriptiveName,
+        options
+      ),
       stripePublishableKey: this.toAstProperty(
         bitType,
         ConfigKey.property_stripePublishableKey,
@@ -26132,6 +28476,19 @@ var Builder = class extends BaseBuilder {
     nodes = Object.values(combinedNodes);
     return nodes.length > 0 ? nodes : void 0;
   }
+  /**
+   * Normalise a sourceBB input into the AST shape (always number[][]).
+   * Accepts a single 4-number tuple or an array of tuples; returns undefined when empty.
+   */
+  normaliseSourceBB(data) {
+    if (data == null) return void 0;
+    if (!Array.isArray(data) || data.length === 0) return void 0;
+    const isNested = data.some(Array.isArray);
+    const tuples = (isNested ? data : [data]).filter(
+      (t) => Array.isArray(t) && t.length === 4 && t.every((n) => typeof n === "number")
+    );
+    return tuples.length > 0 ? tuples : void 0;
+  }
   /**
    * Build groupTag node
    *
@@ -28451,6 +30808,23 @@ var BitmarkGenerator = class extends AstWalkerGenerator {
       format: TagFormat.plainText
     });
   }
+  // bitmarkAst -> bits -> bitsValue -> sourceBB
+  enter_sourceBB(node, route) {
+    const parent = this.getParentNode(route);
+    if (parent?.key !== NodeType.bitsValue) return false;
+    const tuples = node.value;
+    if (!Array.isArray(tuples) || tuples.length === 0) return false;
+    this.writeProperty(
+      "sourceBB",
+      tuples.map((t) => t.join(", ")),
+      route,
+      {
+        format: TagFormat.plainText,
+        array: true
+      }
+    );
+    return false;
+  }
   // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> additionalSolutions -> additionalSolutionsValue
   leaf_additionalSolutionsValue(node, route) {
     const parent = this.getParentNode(route, 2);
@@ -30574,6 +32948,16 @@ var JsonGenerator = class extends AstWalkerGenerator {
   enter_ratingLevelEnd(node, route) {
     return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
   }
+  // bitmarkAst -> bits -> bitsValue -> sourceBB
+  enter_sourceBB(node, route) {
+    const tuples = node.value;
+    const parent = this.getParentNode(route);
+    if (parent?.key !== NodeType.bitsValue) return false;
+    if (tuples && tuples.length > 0) {
+      this.bitJson.sourceBB = tuples.length === 1 ? tuples[0] : tuples;
+    }
+    return false;
+  }
   // bitmarkAst -> bits -> bitsValue -> productId
   enter_productId(node, route) {
     const productIds = node.value;
@@ -33656,6 +36040,7 @@ function buildCards(context, bitType, textFormat, parsedCardSet, statementV1, st
   const cardSetType = bitConfig.cardSet?.configKey;
   switch (cardSetType) {
     case CardSetConfigKey.flashcard:
+    case CardSetConfigKey.flashcard1:
     case CardSetConfigKey.definitionList:
       result = parseFlashcardOrDefinitionList(context, bitType, processedCardSet);
       break;
@@ -33669,6 +36054,7 @@ function buildCards(context, bitType, textFormat, parsedCardSet, statementV1, st
       result = parseFeedback(context, bitType, processedCardSet);
       break;
     case CardSetConfigKey.quiz:
+    case CardSetConfigKey.quizResponses:
       result = parseQuiz(context, bitType, processedCardSet, choicesV1, responsesV1);
       break;
     case CardSetConfigKey.questions:
@@ -33695,6 +36081,7 @@ function buildCards(context, bitType, textFormat, parsedCardSet, statementV1, st
       break;
     case CardSetConfigKey.clozeList:
     case CardSetConfigKey.exampleBitList:
+    case CardSetConfigKey.pageFooterSections:
     case CardSetConfigKey.bookReferenceList:
       result = parseCardBits(context, bitType, textFormat, processedCardSet);
       break;
@@ -35252,6 +37639,17 @@ function propertyContentProcessor(context, contentDepth, tagsConfig, content, ta
               format: TextFormat2.bitmarkText,
               location: TextLocation2.tag
             });
+          case TagFormat.coordinates:
+            const coordRaw = instance3.unbreakscape(v2, {
+              format: TextFormat2.plainText,
+              location: TextLocation2.tag
+            });
+            if (coordRaw == null) return void 0;
+            const coordParts = coordRaw.split(",").map((p) => instance6.asNumber(p.trim()));
+            if (coordParts.length !== 4 || coordParts.some((n) => n == null)) {
+              return void 0;
+            }
+            return coordParts;
         }
       }
       return instance3.unbreakscape(v2, {
@@ -35288,6 +37686,8 @@ function propertyContentProcessor(context, contentDepth, tagsConfig, content, ta
         minCount: 1,
         chain: void 0,
         jsonKey: void 0,
+        exportJsonKey: void 0,
+        hasExportJsonKey: false,
         format: TagFormat.bitmarkText,
         values: void 0,
         defaultValue: void 0,
@@ -35298,19 +37698,18 @@ function propertyContentProcessor(context, contentDepth, tagsConfig, content, ta
 }
 
 // src/parser/bitmark/peg/contentProcessors/ReferenceTagContentProcessor.ts
-function referenceTagContentProcessor(_context, _contentDepth, _tagsConfig, content, target, isReferenceEnd) {
-  const { value } = content;
+function referenceTagContentProcessor(context, _contentDepth, tagsConfig, content, target) {
+  const { value, chain } = content;
   const trimmedStringValue = stringUtils.trimmedString(value);
-  if (isReferenceEnd) {
-    target.referenceEnd = instance3.unbreakscape(trimmedStringValue, {
-      format: TextFormat2.bitmarkText,
-      location: TextLocation2.tag
-    });
-  } else {
-    target.reference = instance3.unbreakscape(trimmedStringValue, {
-      format: TextFormat2.bitmarkText,
-      location: TextLocation2.tag
-    });
+  target.reference = instance3.unbreakscape(trimmedStringValue, {
+    format: TextFormat2.bitmarkText,
+    location: TextLocation2.tag
+  });
+  if (Array.isArray(chain) && chain.length > 0) {
+    const sub = context.bitContentProcessor(ContentDepth.Chain, tagsConfig, chain);
+    if (sub.reference != null) {
+      target.referenceEnd = sub.reference;
+    }
   }
 }
 
@@ -35996,7 +38395,6 @@ var BitmarkPegParserProcessor = class {
     result.markConfig = [];
     result.extraProperties = {};
     result.internalComments = [];
-    let seenReference = false;
     let inFooter = false;
     const bodyParts = [];
     let bodyTextPart = instance3.EMPTY_STRING;
@@ -36032,15 +38430,7 @@ var BitmarkPegParserProcessor = class {
           defaultTagContentProcessor(this.context, contentDepth, tagsConfig, content, result);
           break;
         case TypeKey.Reference:
-          referenceTagContentProcessor(
-            this.context,
-            contentDepth,
-            tagsConfig,
-            content,
-            result,
-            seenReference
-          );
-          seenReference = true;
+          referenceTagContentProcessor(this.context, contentDepth, tagsConfig, content, result);
           break;
         case TypeKey.Title:
           titleTagContentProcessor(this.context, contentDepth, tagsConfig, content, result);
@@ -40420,6 +42810,117 @@ var JsonStringGenerator = class {
   }
 };
 
+// src/utils/BoundingBox.ts
+function toBbox(arr) {
+  if (!Array.isArray(arr) || arr.length !== 4) return null;
+  if (!arr.every(Number.isFinite)) return null;
+  return [arr[0], arr[1], arr[2], arr[3]];
+}
+function parseSourceBB(sourceBB) {
+  if (sourceBB == null) return [];
+  if (!Array.isArray(sourceBB) || sourceBB.length === 0) return [];
+  const isNested = sourceBB.some(Array.isArray);
+  const candidates = isNested ? sourceBB : [sourceBB];
+  const out = [];
+  for (const candidate of candidates) {
+    const box = toBbox(candidate);
+    if (box) out.push(box);
+  }
+  return out;
+}
+function boundingBoxIntersects(a, b) {
+  return a[0] < b[2] && a[2] > b[0] && a[1] < b[3] && a[3] > b[1];
+}
+function boundingBoxUnion(boxes) {
+  if (boxes.length === 0) return null;
+  let [x0, y0, x1, y1] = boxes[0];
+  for (let i = 1; i < boxes.length; i++) {
+    const b = boxes[i];
+    if (b[0] < x0) x0 = b[0];
+    if (b[1] < y0) y0 = b[1];
+    if (b[2] > x1) x1 = b[2];
+    if (b[3] > y1) y1 = b[3];
+  }
+  return [x0, y0, x1, y1];
+}
+var BoundingBoxIndex = class _BoundingBoxIndex {
+  constructor(entries) {
+    __publicField(this, "_entries");
+    __publicField(this, "bitmarkParser", new BitmarkParserGenerator());
+    this._entries = entries;
+  }
+  /**
+   * Build an index from already-parsed bits. Bits without a parseable
+   * `sourceBB` are dropped. Order of the input is preserved.
+   *
+   * Pass `options.sourceRL` to scope the index to a single source page —
+   * bits whose `sourceRL` doesn't match (or is absent) are excluded.
+   */
+  static fromBits(wrappers, options) {
+    const filterSourceRL = options?.sourceRL;
+    const entries = [];
+    for (const wrapper of wrappers) {
+      if (!wrapper?.bit) continue;
+      if (filterSourceRL !== void 0 && wrapper.bit.sourceRL !== filterSourceRL) {
+        continue;
+      }
+      const boxes = parseSourceBB(wrapper.bit.sourceBB);
+      if (boxes.length === 0) continue;
+      entries.push({ bit: wrapper.bit, wrapper, boxes });
+    }
+    return new _BoundingBoxIndex(entries);
+  }
+  /** All bits with at least one valid `sourceBB`, in input order. */
+  get entries() {
+    return this._entries;
+  }
+  /**
+   * Bits whose ANY `sourceBB` box intersects `query` (strict overlap —
+   * touching-only edges do NOT count as an intersection).
+   */
+  intersecting(query) {
+    const matches = [];
+    for (const entry of this._entries) {
+      if (entry.boxes.some((box) => boundingBoxIntersects(query, box))) {
+        matches.push(entry);
+      }
+    }
+    return matches;
+  }
+  /**
+   * Flat list of every individual `sourceBB` box that intersects `query`.
+   * For a multi-box bit, only the boxes that themselves intersected are
+   * returned.
+   */
+  intersectingBoxes(query) {
+    const matches = [];
+    for (const entry of this._entries) {
+      for (const box of entry.boxes) {
+        if (boundingBoxIntersects(query, box)) matches.push(box);
+      }
+    }
+    return matches;
+  }
+  /**
+   * Smallest axis-aligned box that fully encloses every individual `sourceBB`
+   * box that intersected the query. For a multi-box bit, only the boxes that
+   * themselves intersected contribute to the union — non-intersecting boxes
+   * from the same bit are ignored. Returns `null` if no box matches.
+   */
+  enclosingBoundingBox(query) {
+    return boundingBoxUnion(this.intersectingBoxes(query));
+  }
+  /** Render selected bits back to bitmark text. Empty input returns `''`. */
+  toBitmark(entries) {
+    if (entries.length === 0) return "";
+    const wrappers = entries.map((e) => e.wrapper);
+    return this.bitmarkParser.convert(wrappers, {
+      outputFormat: Output.bitmark,
+      bitmarkOptions: { prettifyJson: true }
+    });
+  }
+};
+
 // src/index.ts
 init();
 export {
@@ -40432,6 +42933,7 @@ export {
   BitmarkStringGenerator,
   BitmarkVersion,
   BodyTextFormat,
+  BoundingBoxIndex,
   Builder,
   CardSetVersion,
   InfoFormat,