@gmb/bitmark-parser-generator 5.22.0 → 5.24.0

package/dist/browser/cjs/index.cjs

@@ -31,6 +31,7 @@ __export(index_exports, {
   BitmarkStringGenerator: () => BitmarkStringGenerator,
   BitmarkVersion: () => BitmarkVersion,
   BodyTextFormat: () => BodyTextFormat,
+  BoundingBoxIndex: () => BoundingBoxIndex,
   Builder: () => Builder,
   CardSetVersion: () => CardSetVersion,
   InfoFormat: () => InfoFormat,
@@ -326,6 +327,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",
@@ -750,8 +752,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
@@ -774,10 +778,12 @@ var TextFormat2 = {
 var import_superenum7 = require("@ncoderz/superenum");
 var CardSetConfigKey = {
   flashcard: "flashcard",
+  flashcard1: "flashcard1",
   definitionList: "definitionList",
   elements: "elements",
   statements: "statements",
   quiz: "quiz",
+  quizResponses: "quizResponses",
   feedback: "feedback",
   questions: "questions",
   matchPairs: "matchPairs",
@@ -789,6 +795,7 @@ var CardSetConfigKey = {
   pronunciationTable: "pronunciationTable",
   botActionResponses: "botActionResponses",
   exampleBitList: "exampleBitList",
+  pageFooterSections: "pageFooterSections",
   clozeList: "clozeList",
   ingredients: "ingredients",
   // DEPRECATED - TO BE REMOVED IN THE FUTURE
@@ -836,7 +843,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;
@@ -845,6 +856,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;
   }
 };
@@ -854,7 +867,6 @@ var MarkupTagConfig = class extends AbstractTagConfig {
   constructor(params) {
     super({
       type: BitTagConfigKeyType.tag,
-      jsonKey: void 0,
       ...params
     });
     __publicField(this, "type", BitTagConfigKeyType.tag);
@@ -966,8 +978,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
@@ -977,11 +989,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);
@@ -1005,14 +1025,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) {
@@ -1034,13 +1058,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;
   }
@@ -1184,12 +1212,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",
@@ -1197,14 +1230,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",
@@ -1335,6 +1372,7 @@ var propertyKeys = {
   property_formula: "@formula",
   property_fullName: "@fullName",
   property_groupTag: "@groupTag",
+  property_gUri: "@gUri",
   property_handInAcceptFileType: "@handInAcceptFileType",
   property_handInInstruction: "@handInInstruction",
   property_handInRequirement: "@handInRequirement",
@@ -1470,6 +1508,7 @@ var propertyKeys = {
   property_siteName: "@siteName",
   property_size: "@size",
   property_slug: "@slug",
+  property_sourceBB: "@sourceBB",
   property_sourceDocument: "@sourceDocument",
   property_sourceRL: "@sourceRL",
   property_spaceId: "@spaceId",
@@ -1479,6 +1518,7 @@ var propertyKeys = {
   property_src4x: "@src4x",
   property_srcAlt: "@srcAlt",
   property_stripePricingTableId: "@stripePricingTableId",
+  property_stripePricingTableDescriptiveName: "@stripePricingTableDescriptiveName",
   property_stripePublishableKey: "@stripePublishableKey",
   property_subject: "@subject",
   property_subtype: "@subtype",
@@ -2223,25 +2263,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
               }
             ]
           }
@@ -2252,37 +2426,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
@@ -2296,12 +2489,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,
@@ -2311,13 +2506,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
               }
             ]
           }
@@ -2328,6 +2536,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "definition.text",
+            exportJsonKey: [{ "@absent": { definition: {} } }, { definition: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2337,30 +2546,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
@@ -2374,37 +2601,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: "$" }
               }
             ]
           }
@@ -2416,19 +2702,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
               }
@@ -2444,12 +2815,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,
@@ -2459,12 +2833,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: "$" }
               }
             ]
           }
@@ -2476,16 +2852,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,
@@ -2503,12 +2883,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,
@@ -2518,12 +2901,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: "$" }
               }
             ]
           }
@@ -2535,16 +2920,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,
@@ -2562,30 +2951,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
               }
@@ -2599,24 +3029,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
               }
@@ -2632,28 +3141,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
@@ -2667,6 +3209,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.quiz]: {
     jsonKey: "quizzes",
+    exportJsonKey: { quizzes: "$" },
     sides: [
       {
         name: "choices",
@@ -2681,6 +3224,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
@@ -2694,6 +3302,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.feedback]: {
     jsonKey: "feedbacks",
+    exportJsonKey: { feedbacks: "$" },
     sides: [
       {
         name: "choices",
@@ -2705,6 +3314,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."
@@ -2713,7 +3389,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
@@ -2724,27 +3401,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
@@ -2758,21 +3486,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,
@@ -2793,6 +3529,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
               }
             ]
           }
@@ -2812,15 +3564,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
@@ -2832,8 +3592,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",
@@ -2849,6 +3658,7 @@ var CARDSETS = {
               {
                 key: ConfigKey.tag_title,
                 jsonKey: "^table.columns[]",
+                exportJsonKey: { "@bit": { table: { columns: ["$"] } } },
                 description: "Title of the table."
               },
               {
@@ -2873,6 +3683,8 @@ var CARDSETS = {
               },
               {
                 key: ConfigKey.property_tableColWidth,
+                jsonKey: "^table.columnWidths[{s}]",
+                exportJsonKey: { "@bit": { table: { columnWidths: { $s: "$" } } } },
                 description: "Width for the column.",
                 format: TagFormat.number
               }
@@ -2889,18 +3701,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,
@@ -2908,35 +3751,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
               }
@@ -2952,6 +3807,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.pronunciationTable]: {
     jsonKey: "pronunciationTable.data",
+    exportJsonKey: { pronunciationTable: { data: "$" } },
     sides: [
       {
         name: "cell",
@@ -2959,19 +3815,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
@@ -2985,12 +3844,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,
@@ -2998,18 +3860,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
               }
             ]
           }
@@ -3022,12 +3924,14 @@ var CARDSETS = {
   //
   [CardSetConfigKey.clozeList]: {
     jsonKey: "listItems",
+    exportJsonKey: { listItems: "$" },
     sides: [
       {
         name: "content",
         variants: [
           {
             jsonKey: "body",
+            exportJsonKey: { body: "$" },
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -3048,18 +3952,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."
               }
@@ -3070,18 +3977,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."
               },
@@ -3089,6 +4031,7 @@ var CARDSETS = {
                 key: ConfigKey.tag_true,
                 description: "Checked state for the ingredient.",
                 jsonKey: "|set(checked=true)",
+                exportJsonKey: { checked: true, $: "$" },
                 maxCount: 1
                 // nullable: true,
               },
@@ -3096,6 +4039,7 @@ var CARDSETS = {
                 key: ConfigKey.tag_false,
                 description: "Unchecked state for the ingredient.",
                 jsonKey: "|set(checked=false)",
+                exportJsonKey: { checked: false, $: "$" },
                 maxCount: 1
                 // nullable: true,
               },
@@ -3107,9 +4051,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."
               },
@@ -3145,6 +4091,7 @@ var CARDSETS = {
   //
   [CardSetConfigKey.bookReferenceList]: {
     jsonKey: "bookReferences",
+    exportJsonKey: { bookReferences: "$" },
     sides: [
       {
         name: "reference",
@@ -3204,6 +4151,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",
@@ -3387,12 +4339,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
@@ -3423,6 +4381,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",
@@ -3460,6 +4424,7 @@ var GROUPS = {
         maxCount: Count.infinity
       },
       {
+        exportJsonKey: { anchor: "$" },
         key: ConfigKey.tag_anchor,
         name: "Anchor",
         format: TagFormat.plainText,
@@ -3497,23 +4462,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
                   }
@@ -3534,11 +4503,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"
@@ -3558,9 +4547,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
       }
     ]
   },
@@ -3571,6 +4596,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_imageSource,
         jsonKey: "imageSource.url",
+        exportJsonKey: { imageSource: { url: "$" } },
         description: "The source of an image",
         format: TagFormat.plainText,
         chain: [
@@ -3605,6 +4631,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_technicalTerm,
         jsonKey: "technicalTerm.technicalTerm",
+        exportJsonKey: { technicalTerm: { technicalTerm: "$" } },
         description: "The technical term",
         format: TagFormat.plainText,
         chain: [
@@ -3623,7 +4650,8 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.property_person,
-        jsonKey: "partner.name",
+        jsonKey: "person.name",
+        exportJsonKey: { person: { name: "$" } },
         description: "A person",
         format: TagFormat.plainText,
         chain: [
@@ -3635,6 +4663,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"
           }
         ]
@@ -3642,7 +4671,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: [
@@ -3654,6 +4684,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"
           }
         ]
@@ -3665,29 +4696,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"
@@ -3701,60 +4769,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
           }
         ]
       }
@@ -3767,6 +5362,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_mark,
         jsonKey: "marks.mark",
+        exportJsonKey: { marks: [{ mark: "$" }] },
         description: "The mark configuration",
         format: TagFormat.plainText,
         maxCount: Count.infinity,
@@ -3790,21 +5386,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
           }
         ]
       }
@@ -3893,7 +5500,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,
@@ -3909,6 +5517,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: [
           {
@@ -3926,6 +5535,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: [
           {
@@ -4085,10 +5695,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
+              }
+            ]
           }
         ]
       }
@@ -4219,6 +5840,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
   //
@@ -4228,6 +5885,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: [
           {
@@ -4336,6 +5995,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",
@@ -4412,6 +6123,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_posterImage,
         jsonKey: "posterImage.src",
+        exportJsonKey: { posterImage: { src: "$" } },
         description: "The poster image for the video",
         format: TagFormat.plainText,
         chain: [
@@ -4424,22 +6136,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: "$" }] }
       }
     ]
   },
@@ -4452,6 +6168,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_icon,
+        exportJsonKey: { resource: { type: "icon", icon: { src: "$" } } },
         description: "The icon resource",
         chain: [
           {
@@ -4468,6 +6185,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_image,
+        exportJsonKey: { resource: { type: "image", image: { src: "$" } } },
         description: "The image resource",
         chain: [
           {
@@ -4478,12 +6196,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: [
           {
@@ -4500,6 +6236,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageLandscape,
+        exportJsonKey: { resource: { type: "image-landscape", imageLandscape: { src: "$" } } },
         description: "The landscape image resource",
         chain: [
           {
@@ -4516,6 +6253,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageEmbed,
+        exportJsonKey: { resource: { type: "image-embed", imageEmbed: { src: "$" } } },
         description: "The embedded image resource",
         chain: [
           {
@@ -4532,6 +6270,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageLink,
+        exportJsonKey: { resource: { type: "image-link", imageLink: { url: "$" } } },
         description: "The link to the image resource",
         chain: [
           {
@@ -4548,6 +6287,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_audio,
+        exportJsonKey: { resource: { type: "audio", audio: { src: "$" } } },
         description: "The audio resource",
         chain: [
           {
@@ -4564,6 +6304,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_audioEmbed,
+        exportJsonKey: { resource: { type: "audio-embed", audioEmbed: { src: "$" } } },
         description: "The embedded audio resource",
         chain: [
           {
@@ -4580,6 +6321,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_audioLink,
+        exportJsonKey: { resource: { type: "audio-link", audioLink: { url: "$" } } },
         description: "The link to the audio resource",
         chain: [
           {
@@ -4596,6 +6338,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_video,
+        exportJsonKey: { resource: { type: "video", video: { src: "$" } } },
         description: "The video resource",
         chain: [
           {
@@ -4612,6 +6355,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_videoEmbed,
+        exportJsonKey: { resource: { type: "video-embed", videoEmbed: { url: "$" } } },
         description: "The embedded video resource",
         chain: [
           {
@@ -4628,6 +6372,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_videoLink,
+        exportJsonKey: { resource: { type: "video-link", videoLink: { url: "$" } } },
         description: "The link to the video resource",
         chain: [
           {
@@ -4644,6 +6389,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: [
           {
@@ -4660,6 +6408,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: [
           {
@@ -4676,6 +6427,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_article,
+        exportJsonKey: { resource: { type: "article", article: { body: "$" } } },
         description: "The article resource",
         chain: [
           {
@@ -4692,6 +6444,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleEmbed,
+        exportJsonKey: { resource: { type: "article-embed", articleEmbed: { url: "$" } } },
         description: "The embedded article resource",
         chain: [
           {
@@ -4708,6 +6461,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleLink,
+        exportJsonKey: { resource: { type: "article-link", articleLink: { url: "$" } } },
         description: "The link to the article resource",
         chain: [
           {
@@ -4724,6 +6478,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_document,
+        exportJsonKey: { resource: { type: "document", document: { url: "$" } } },
         description: "The document resource",
         chain: [
           {
@@ -4740,6 +6495,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_documentEmbed,
+        exportJsonKey: { resource: { type: "document-embed", documentEmbed: { url: "$" } } },
         description: "The embedded document resource",
         chain: [
           {
@@ -4756,6 +6512,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_documentLink,
+        exportJsonKey: { resource: { type: "document-link", documentLink: { url: "$" } } },
         description: "The link to the document resource",
         chain: [
           {
@@ -4772,6 +6529,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_documentDownload,
+        exportJsonKey: { resource: { type: "document-download", documentDownload: { url: "$" } } },
         description: "The downloadable document resource",
         chain: [
           {
@@ -4788,6 +6546,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_appLink,
+        exportJsonKey: { resource: { type: "app-link", appLink: { url: "$" } } },
         description: "The link to the app resource",
         chain: [
           {
@@ -4804,6 +6563,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_websiteLink,
+        exportJsonKey: { resource: { type: "website-link", websiteLink: { url: "$" } } },
         description: "The link to the website resource",
         chain: [
           {
@@ -4862,6 +6622,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: [
           {
@@ -4879,6 +6640,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: [
           {
@@ -4943,20 +6705,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 = (0, import_superenum15.Enum)(ConfigKey).fromValue(_configKey) || ConfigKey._unknown;
     if (!configKey) throw new Error(`No tag key found for config key '${configKey}'`);
     const tag = (0, import_superenum15.Enum)(Tag).fromValue(configKey);
@@ -4971,6 +6766,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 {
@@ -4989,7 +6787,8 @@ var ConfigHydrator = class {
       format,
       values,
       defaultValue,
-      jsonKey
+      jsonKey,
+      exportJsonKey
     } = _tag;
     const configKey = (0, import_superenum15.Enum)(ConfigKey).fromValue(_configKey) || ConfigKey._unknown;
     if (!configKey) throw new Error(`No property key found for config key '${configKey}'`);
@@ -5005,6 +6804,8 @@ var ConfigHydrator = class {
       minCount: minCount ?? MIN_COUNT_DEFAULT,
       chain,
       jsonKey,
+      exportJsonKey,
+      hasExportJsonKey: Object.prototype.hasOwnProperty.call(_tag, "exportJsonKey"),
       format,
       values,
       defaultValue,
@@ -5017,7 +6818,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 = (0, import_superenum15.Enum)(ConfigKey).fromValue(_configKey) || ConfigKey._unknown;
     if (!configKey) throw new Error(`No resource key found for config key '${configKey}'`);
     const tag = _configKey.substring(1);
@@ -5032,6 +6841,8 @@ var ConfigHydrator = class {
       minCount: minCount ?? MIN_COUNT_DEFAULT,
       chain,
       jsonKey,
+      exportJsonKey,
+      hasExportJsonKey: Object.prototype.hasOwnProperty.call(_tag, "exportJsonKey"),
       deprecated
     });
     return {
@@ -5063,14 +6874,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;
   }
@@ -5108,6 +6930,7 @@ var BITS = {
         description: "Common tags for quiz bits"
       },
       {
+        exportJsonKey: { title: "$" },
         key: ConfigKey.tag_title,
         description: "The title of the flashcard quiz"
       },
@@ -5116,6 +6939,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
@@ -5197,6 +7035,7 @@ var BITS = {
     description: "Article bit, used for articles / paragraphs",
     tags: [
       {
+        exportJsonKey: { title: "$" },
         key: ConfigKey.tag_title,
         description: "The title of the article"
       }
@@ -5304,7 +7143,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,
@@ -5314,6 +7154,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: [
           {
@@ -5441,6 +7282,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
@@ -5454,7 +7307,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,
@@ -5464,6 +7318,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: [
           {
@@ -5591,6 +7446,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
@@ -5604,7 +7471,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,
@@ -5730,6 +7598,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
@@ -5931,11 +7811,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"
@@ -6137,7 +8019,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,
@@ -6281,6 +8164,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"
@@ -6288,7 +8172,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,
@@ -6319,8 +8204,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
       }
     ]
   },
@@ -6341,6 +8249,7 @@ var BITS = {
       },
       {
         key: ConfigKey.property_isCaseSensitive,
+        exportJsonKey: {},
         description: "If the cloze answers are case sensitive",
         format: TagFormat.boolean,
         defaultValue: "true"
@@ -6358,18 +8267,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",
@@ -6405,6 +8352,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
@@ -6438,6 +8396,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,
@@ -6566,6 +8529,7 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.group_person,
+        exportJsonKey: { partner: { name: "$" } },
         description: "Tags for the person in the conversation"
       }
     ]
@@ -6790,6 +8754,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: [
@@ -6815,6 +8780,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
@@ -6992,6 +8958,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
@@ -7012,8 +8990,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
@@ -7099,7 +9090,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",
@@ -7424,7 +9427,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",
@@ -7549,7 +9564,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",
@@ -7823,7 +9850,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
       }
     ]
   },
@@ -7876,9 +9903,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
       }
@@ -8042,15 +10073,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"
@@ -8097,18 +10140,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,
@@ -8133,14 +10199,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
+              }
+            ]
           }
         ]
       },
@@ -8189,7 +10270,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",
@@ -8231,6 +10314,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]: {
@@ -8253,6 +10350,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
@@ -8260,7 +10369,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",
@@ -8295,8 +10408,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
       }
     ]
   },
@@ -8306,14 +10435,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,
@@ -8416,8 +10539,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",
@@ -8456,15 +10586,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",
@@ -8479,7 +10614,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: [
       {
@@ -8488,14 +10623,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,
@@ -8638,9 +10767,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
       }
@@ -8650,7 +10780,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",
@@ -8658,6 +10798,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"
@@ -8676,8 +10817,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
@@ -9036,6 +11190,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
       }
     ]
   },
@@ -9051,9 +11217,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
@@ -9103,6 +11287,7 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.property_reasonableNumOfChars,
+        exportJsonKey: {},
         description: "Reasonable number of characters for feedback, used to limit input size",
         format: TagFormat.number
       }
@@ -9137,6 +11322,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
       }
     ]
   },
@@ -9158,8 +11355,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
   },
@@ -9179,8 +11388,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
       }
     ]
   },
@@ -9205,8 +11426,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
       }
     ]
   },
@@ -9226,12 +11459,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",
@@ -9244,6 +11489,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"
       },
@@ -9480,6 +11726,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: [
           {
@@ -9515,6 +11763,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: [
           {
@@ -9603,6 +11853,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: [
           {
@@ -9696,6 +11947,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"
       },
@@ -9714,6 +11966,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
@@ -9766,11 +12030,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"
@@ -9786,6 +12052,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,
@@ -9893,6 +12173,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: [
@@ -9906,6 +12187,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: [
@@ -10057,14 +12339,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,
@@ -10441,12 +12717,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
@@ -10470,6 +12782,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
@@ -10659,6 +12983,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",
@@ -11029,6 +13358,8 @@ var Config = class {
               maxCount: 1,
               chain: tag.chain,
               jsonKey: tag.jsonKey,
+              exportJsonKey: tag.exportJsonKey,
+              hasExportJsonKey: tag.hasExportJsonKey,
               deprecated: tag.deprecated
             });
             finalResourceTags[k] = newTag;
@@ -11133,7 +13464,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"
@@ -11727,6 +14058,8 @@ var NodeType = {
   gmbExternalShopItems: "gmbExternalShopItems",
   groupTag: "groupTag",
   groupTagValue: "groupTagValue",
+  gUri: "gUri",
+  gUriValue: "gUriValue",
   handInAcceptFileType: "handInAcceptFileType",
   handInAcceptFileTypeValue: "handInAcceptFileTypeValue",
   handInInstruction: "handInInstruction",
@@ -12069,6 +14402,8 @@ var NodeType = {
   solution: "solution",
   solutions: "solutions",
   solutionsValue: "solutionsValue",
+  sourceBB: "sourceBB",
+  sourceBBValue: "sourceBBValue",
   sourceDocument: "sourceDocument",
   sourceDocumentValue: "sourceDocumentValue",
   sourceRL: "sourceRL",
@@ -12094,6 +14429,8 @@ var NodeType = {
   stillImageFilmLink: "stillImageFilmLink",
   stripePricingTableId: "stripePricingTableId",
   stripePricingTableIdValue: "stripePricingTableIdValue",
+  stripePricingTableDescriptiveName: "stripePricingTableDescriptiveName",
+  stripePricingTableDescriptiveNameValue: "stripePricingTableDescriptiveNameValue",
   stripePublishableKey: "stripePublishableKey",
   stripePublishableKeyValue: "stripePublishableKeyValue",
   subject: "subject",
@@ -24949,6 +27286,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,
@@ -25160,6 +27498,7 @@ var Builder = class extends BaseBuilder {
         data.extractorInternal,
         options
       ),
+      sourceBB: this.normaliseSourceBB(data.sourceBB),
       levelCEFRp: this.toAstProperty(
         bitType,
         ConfigKey.property_levelCEFRp,
@@ -25517,6 +27856,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,
@@ -26180,6 +28525,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
    *
@@ -28499,6 +30857,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);
@@ -30622,6 +32997,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;
@@ -33704,6 +36089,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;
@@ -33717,6 +36103,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:
@@ -33743,6 +36130,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;
@@ -35300,6 +37688,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, {
@@ -35336,6 +37735,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,
@@ -35346,19 +37747,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;
+    }
   }
 }
 
@@ -36044,7 +38444,6 @@ var BitmarkPegParserProcessor = class {
     result.markConfig = [];
     result.extraProperties = {};
     result.internalComments = [];
-    let seenReference = false;
     let inFooter = false;
     const bodyParts = [];
     let bodyTextPart = instance3.EMPTY_STRING;
@@ -36080,15 +38479,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);
@@ -40468,6 +42859,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();
 // Annotate the CommonJS export names for ESM import in node:
@@ -40481,6 +42983,7 @@ init();
   BitmarkStringGenerator,
   BitmarkVersion,
   BodyTextFormat,
+  BoundingBoxIndex,
   Builder,
   CardSetVersion,
   InfoFormat,