@gmb/bitmark-parser-generator 5.23.0 → 5.24.0

package/dist/index.cjs

@@ -792,10 +792,12 @@ var TextFormat = {
 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",
@@ -807,6 +809,7 @@ var CardSetConfigKey = {
   pronunciationTable: "pronunciationTable",
   botActionResponses: "botActionResponses",
   exampleBitList: "exampleBitList",
+  pageFooterSections: "pageFooterSections",
   clozeList: "clozeList",
   ingredients: "ingredients",
   // DEPRECATED - TO BE REMOVED IN THE FUTURE
@@ -1223,12 +1226,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",
@@ -1236,14 +1244,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",
@@ -1520,6 +1532,7 @@ var propertyKeys = {
   property_src4x: "@src4x",
   property_srcAlt: "@srcAlt",
   property_stripePricingTableId: "@stripePricingTableId",
+  property_stripePricingTableDescriptiveName: "@stripePricingTableDescriptiveName",
   property_stripePublishableKey: "@stripePublishableKey",
   property_subject: "@subject",
   property_subtype: "@subtype",
@@ -2271,7 +2284,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "question.text",
-            exportJsonKey: { question: { text: "$" } },
+            exportJsonKey: [{ "@absent": { question: {} } }, { question: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2287,6 +2300,136 @@ var CARDSETS = {
                 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)",
+                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
               }
             ]
           }
@@ -2297,7 +2440,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "answer.text",
-            exportJsonKey: { answer: { text: "$" } },
+            exportJsonKey: [{ "@absent": { answer: {} } }, { answer: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2313,6 +2456,17 @@ var CARDSETS = {
                 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
               }
             ]
           },
@@ -2356,7 +2510,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "term.text",
-            exportJsonKey: { term: { text: "$" } },
+            exportJsonKey: [{ "@absent": { term: {} } }, { term: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2375,6 +2529,17 @@ var CARDSETS = {
                 format: TagFormat.plainText,
                 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
               }
             ]
           }
@@ -2385,7 +2550,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "definition.text",
-            exportJsonKey: { definition: { text: "$" } },
+            exportJsonKey: [{ "@absent": { definition: {} } }, { definition: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2403,6 +2568,17 @@ var CARDSETS = {
                 description: "Icon resource for the definition.",
                 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
               }
             ]
           },
@@ -2447,11 +2623,51 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat.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.",
@@ -2460,9 +2676,19 @@ var CARDSETS = {
                 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: [
-                  { "@absent": { isCaseSensitive: "$ancestor" } },
+                  {
+                    predicates: ["@absent", { "@variantLacksTag": "@isCaseSensitive" }],
+                    rule: { isCaseSensitive: "$ancestor" }
+                  },
                   { isCaseSensitive: "$" }
                 ],
                 description: "Property to indicate if the match is case sensitive.",
@@ -2491,10 +2717,85 @@ var CARDSETS = {
           {
             jsonKey: "values[]",
             exportJsonKey: { values: ["$"] },
+            format: TextFormat.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,
@@ -2504,9 +2805,13 @@ var CARDSETS = {
                 exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
               },
               {
+                // PLAN-084: symmetric @variantLacksTag gating with the key-side.
                 key: ConfigKey.property_isCaseSensitive,
                 exportJsonKey: [
-                  { "@absent": { isCaseSensitive: "$ancestor" } },
+                  {
+                    predicates: ["@absent", { "@variantLacksTag": "@isCaseSensitive" }],
+                    rule: { isCaseSensitive: "$ancestor" }
+                  },
                   { isCaseSensitive: "$" }
                 ],
                 description: "Property to indicate if the match is case sensitive.",
@@ -2532,6 +2837,7 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2561,10 +2867,12 @@ var CARDSETS = {
           {
             jsonKey: "values[]",
             exportJsonKey: { values: ["$"] },
+            format: TextFormat.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,
@@ -2597,6 +2905,7 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2626,10 +2935,12 @@ var CARDSETS = {
           {
             jsonKey: "values[]",
             exportJsonKey: { values: ["$"] },
+            format: TextFormat.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,
@@ -2662,20 +2973,49 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat.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 } } },
-                  { "@absent": { isExample: true, "@bit": { isExample: true } } },
-                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                  {
+                    "@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,
@@ -2703,35 +3043,96 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "cells[{s}].values[]",
-            exportJsonKey: { 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: TextFormat.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.values[0]" } },
-                      "@bit": { isExample: true }
+                      cells: { $s: { isExample: true, example: "$parent" } },
+                      "@bit": { isExample: true },
+                      "@card": { isExample: true }
                     }
                   },
                   {
-                    "@absent": { cells: { $s: { isExample: true, example: "$parent.values[0]" } } }
+                    predicates: ["@absent", { $cascade: "*" }],
+                    rule: {
+                      cells: { $s: { isExample: true, example: "$cascade" } },
+                      "@bit": { isExample: true },
+                      "@card": { isExample: true }
+                    }
                   },
-                  { cells: { $s: { isExample: true, example: "$" } }, "@bit": { 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",
-                exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
+                exportJsonKey: [
+                  { "@keyonly": { "@bit": { heading: { forValues: [""] } } } },
+                  { "@bit": { heading: { forValues: ["$"] } } }
+                ]
               },
               {
                 key: ConfigKey.property_isCaseSensitive,
@@ -2780,6 +3181,35 @@ var CARDSETS = {
               {
                 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
@@ -2808,6 +3238,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
@@ -2833,6 +3328,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."
@@ -2853,31 +3415,71 @@ 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: TextFormat.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": { reasonableNumOfChars: "$ancestor" } },
-                  { reasonableNumOfChars: "$" }
+                  { "@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,
                 exportJsonKey: [
-                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
-                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
-                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                  {
+                    // 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.",
-                format: TagFormat.plainText
+                description: "Example text for the feedback reason (entry-local only; no bit-header cascade).",
+                format: TagFormat.bitmarkText,
+                nullable: true
               },
               {
                 key: ConfigKey.tag_title,
@@ -2941,6 +3543,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
               }
             ]
           }
@@ -2967,14 +3585,16 @@ var CARDSETS = {
                 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,
                 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 text for the element.",
-                format: TagFormat.plainText
+                description: "Example text for the element (entry-local only; no bit-header cascade).",
+                format: TagFormat.plainText,
+                nullable: true
               }
             ],
             repeatCount: Count.infinity
@@ -2986,9 +3606,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",
-    exportJsonKey: { 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",
@@ -3029,6 +3697,8 @@ var CARDSETS = {
               },
               {
                 key: ConfigKey.property_tableColWidth,
+                jsonKey: "^table.columnWidths[{s}]",
+                exportJsonKey: { "@bit": { table: { columnWidths: { $s: "$" } } } },
                 description: "Width for the column.",
                 format: TagFormat.number
               }
@@ -3047,7 +3717,22 @@ var CARDSETS = {
     sections: {
       "table-header": {
         jsonKey: "table.header.rows",
-        exportJsonKey: { 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, $: "$" } } }
       },
@@ -3080,13 +3765,13 @@ var CARDSETS = {
               },
               {
                 key: ConfigKey.tag_title,
-                jsonKey: ".",
-                exportJsonKey: {
-                  "@bit": {
-                    table: { header: { rows: { cells: { cells: { $s: { content: "$" } } } } } }
-                  }
-                },
-                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,
@@ -3118,6 +3803,9 @@ var CARDSETS = {
               },
               {
                 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
               }
@@ -3155,7 +3843,8 @@ var CARDSETS = {
               {
                 key: ConfigKey.resource_audio,
                 description: "Audio resource for the pronunciation table.",
-                jsonKey: "audio"
+                jsonKey: "audio",
+                exportJsonKey: { audio: { type: "audio", audio: { src: "$" } } }
               }
             ],
             repeatCount: Count.infinity
@@ -3226,14 +3915,17 @@ var CARDSETS = {
                 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,
                 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 text for the bot action response.",
-                format: TagFormat.plainText
+                description: "Example text for the bot action response (entry-local only; no bit-header cascade).",
+                format: TagFormat.plainText,
+                nullable: true
               }
             ]
           }
@@ -3299,6 +3991,38 @@ 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]: {
@@ -3629,7 +4353,11 @@ var GROUPS = {
       {
         key: ConfigKey.property_groupTag,
         jsonKey: "groupTag.name",
-        exportJsonKey: { 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,
@@ -3802,6 +4530,24 @@ var GROUPS = {
       }
     ]
   },
+  [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"
+      }
+    ]
+  },
   [ConfigKey.group_standardTags]: {
     type: GroupConfigType.standard,
     description: "Standard tags which apply to MOST (but not all) bits",
@@ -3815,17 +4561,45 @@ var GROUPS = {
         description: "Item, lead, page number, margin number, instruction and hint tags"
       },
       {
-        // Bit-level example tag: bare/synthesized records the marker only;
-        // valued [@example:text] emits `isExample: true` and `example` as
-        // PM-rendered rich text (bitmark+ format).
+        // 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": { isExample: true } },
-          { "@absent": { isExample: true } },
-          { isExample: true, example: "$" }
-        ],
+        exportJsonKey: [{ "@keyonly": {} }, { "@absent": { isExample: true } }, { example: "$" }],
         description: "The example(s) for the bit",
-        format: TagFormat.bitmarkText
+        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
       }
     ]
   },
@@ -3890,8 +4664,8 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.property_person,
-        jsonKey: "partner.name",
-        exportJsonKey: { partner: { name: "$" } },
+        jsonKey: "person.name",
+        exportJsonKey: { person: { name: "$" } },
         description: "A person",
         format: TagFormat.plainText,
         chain: [
@@ -3911,8 +4685,8 @@ var GROUPS = {
       {
         // Deprecated (parter renamed to person)
         key: ConfigKey.property_partner,
-        jsonKey: "partner.name",
-        exportJsonKey: { partner: { name: "$" } },
+        jsonKey: "person.name",
+        exportJsonKey: { person: { name: "$" } },
         description: "A partner",
         format: TagFormat.plainText,
         chain: [
@@ -3936,7 +4710,9 @@ var GROUPS = {
     description: "Gap chain",
     tags: [
       {
-        exportJsonKey: { solutions: [["$"]] },
+        exportJsonKey: {
+          "@body-inline": { type: "gap", attrs: { solutions: ["$"] } }
+        },
         key: ConfigKey.tag_gap,
         description: "The value of a gap in the content",
         maxCount: Count.infinity,
@@ -3955,27 +4731,37 @@ var GROUPS = {
             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[0]",
+                  example: "$parent.solutions[-1]",
                   "@bit": { isExample: true }
                 }
               },
               {
                 "@absent": {
                   isExample: true,
-                  example: "$parent.solutions[0]",
+                  example: "$parent.solutions[-1]",
                   "@bit": { isExample: true }
                 }
               },
               { isExample: true, example: "$", "@bit": { isExample: true } }
             ],
             description: "An example for the gap",
-            format: TagFormat.bitmarkText
+            format: TagFormat.bitmarkText,
+            nullable: true
           },
           {
             key: ConfigKey.property_isCaseSensitive,
@@ -4024,6 +4810,24 @@ var GROUPS = {
             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: [
@@ -4031,20 +4835,37 @@ var GROUPS = {
                 "@keyonly": {
                   isExample: true,
                   example: "$parent.isCorrect",
-                  "@bit": { isExample: true }
+                  "@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,
-                  example: "$parent.isCorrect",
-                  "@bit": { isExample: true }
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
                 }
               },
-              { isExample: true, example: "$", "@bit": { isExample: true } }
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@card": { isExample: true }
+              }
             ],
             description: "An example for the true/false statement/question",
-            format: TagFormat.bitmarkText
+            format: TagFormat.boolean,
+            nullable: true
           }
         ]
       },
@@ -4076,6 +4897,12 @@ var GROUPS = {
             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: [
@@ -4083,20 +4910,460 @@ var GROUPS = {
                 "@keyonly": {
                   isExample: true,
                   example: "$parent.isCorrect",
-                  "@bit": { isExample: 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 (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 }
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
                 }
               },
-              { isExample: true, example: "$", "@bit": { 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.bitmarkText
+            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
           }
         ]
       }
@@ -4109,7 +5376,7 @@ var GROUPS = {
       {
         key: ConfigKey.property_mark,
         jsonKey: "marks.mark",
-        exportJsonKey: { marks: { mark: ["$"] } },
+        exportJsonKey: { marks: [{ mark: "$" }] },
         description: "The mark configuration",
         format: TagFormat.plainText,
         maxCount: Count.infinity,
@@ -4133,7 +5400,9 @@ var GROUPS = {
     description: "Mark chain",
     tags: [
       {
-        exportJsonKey: { solution: ["$"] },
+        exportJsonKey: {
+          "@body-inline": { type: "mark", attrs: { solution: "$" } }
+        },
         key: ConfigKey.tag_mark,
         description: "The marked content",
         maxCount: Count.infinity,
@@ -4142,6 +5411,7 @@ var GROUPS = {
           {
             key: ConfigKey.property_mark,
             jsonKey: "mark",
+            exportJsonKey: { mark: "$" },
             description: "The mark configuration",
             format: TagFormat.plainText
           },
@@ -4154,7 +5424,8 @@ var GROUPS = {
               { isExample: true, example: "$", "@bit": { isExample: true } }
             ],
             description: "An example for the marked content",
-            format: TagFormat.bitmarkText
+            format: TagFormat.bitmarkText,
+            nullable: true
           }
         ]
       }
@@ -4583,6 +5854,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
   //
@@ -4702,6 +6009,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",
@@ -4791,22 +6150,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: "$" }] }
       }
     ]
   },
@@ -4819,6 +6182,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_icon,
+        exportJsonKey: { resource: { type: "icon", icon: { src: "$" } } },
         description: "The icon resource",
         chain: [
           {
@@ -4846,12 +6210,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: [
           {
@@ -4868,6 +6250,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageLandscape,
+        exportJsonKey: { resource: { type: "image-landscape", imageLandscape: { src: "$" } } },
         description: "The landscape image resource",
         chain: [
           {
@@ -4884,6 +6267,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageEmbed,
+        exportJsonKey: { resource: { type: "image-embed", imageEmbed: { src: "$" } } },
         description: "The embedded image resource",
         chain: [
           {
@@ -5057,6 +6441,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_article,
+        exportJsonKey: { resource: { type: "article", article: { body: "$" } } },
         description: "The article resource",
         chain: [
           {
@@ -5073,6 +6458,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleEmbed,
+        exportJsonKey: { resource: { type: "article-embed", articleEmbed: { url: "$" } } },
         description: "The embedded article resource",
         chain: [
           {
@@ -5089,6 +6475,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleLink,
+        exportJsonKey: { resource: { type: "article-link", articleLink: { url: "$" } } },
         description: "The link to the article resource",
         chain: [
           {
@@ -5359,7 +6746,12 @@ var ConfigHydrator = class {
         isDefault: v.isDefault,
         sideJsonKey: v.sideJsonKey,
         sideExportJsonKey: v.sideExportJsonKey,
-        hasSideExportJsonKey: Object.prototype.hasOwnProperty.call(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;
@@ -5574,7 +6966,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -5913,7 +7306,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -6076,7 +7470,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -6227,7 +7622,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -6822,8 +8218,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
       }
     ]
   },
@@ -6862,18 +8281,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
       }
     ]
   },
   [BitType.clozeInstructionGrouped]: {
     since: "1.3.0",
     baseBitType: BitType.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.
+    ]
   },
   [BitType.clozeSolutionGrouped]: {
     since: "1.3.0",
     baseBitType: BitType.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"
+      }
+    ]
   },
   [BitType.clozeSeveral]: {
     since: "3.5.0",
@@ -6909,6 +8366,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
@@ -7075,6 +8543,7 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.group_person,
+        exportJsonKey: { partner: { name: "$" } },
         description: "Tags for the person in the conversation"
       }
     ]
@@ -7513,7 +8982,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the essay bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -7547,7 +9017,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the example bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -7633,7 +9104,19 @@ var BITS = {
   [BitType.articleAi]: {
     since: "1.3.0",
     baseBitType: BitType.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 }
+      }
+    ]
   },
   [BitType.articleAttachment]: {
     since: "1.3.0",
@@ -7958,7 +9441,19 @@ var BITS = {
   [BitType.noteAi]: {
     since: "1.3.0",
     baseBitType: BitType.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 }
+      }
+    ]
   },
   [BitType.notebookArticle]: {
     since: "1.3.0",
@@ -8083,7 +9578,19 @@ var BITS = {
   [BitType.summaryAi]: {
     since: "1.3.0",
     baseBitType: BitType.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 }
+      }
+    ]
   },
   [BitType.videoTranscript]: {
     since: "1.3.0",
@@ -8357,7 +9864,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
       }
     ]
   },
@@ -8410,10 +9917,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: "$" },
+        exportJsonKey: { images: [{ type: "image", image: { src: "$" } }] },
         minCount: 1,
         maxCount: Count.infinity
       }
@@ -8703,6 +10213,10 @@ 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: [
@@ -8770,7 +10284,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
   },
   [BitType.legend]: {
     since: "3.12.0",
@@ -8812,6 +10328,20 @@ var BITS = {
     since: "1.34.0",
     baseBitType: BitType._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
   },
   [BitType.metaSearchDefaultTerms]: {
@@ -8834,6 +10364,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
@@ -8841,7 +10383,11 @@ var BITS = {
   [BitType.flashcard1]: {
     since: "1.3.0",
     baseBitType: BitType.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
   },
   [BitType.qAndACard]: {
     since: "3.25.0",
@@ -8876,8 +10422,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
       }
     ]
   },
@@ -8887,15 +10449,8 @@ var BITS = {
     description: "Image bit, used to create images in articles or books",
     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"
-          }
-        ]
+        key: ConfigKey.group_backgroundWallpaper,
+        description: "Background wallpaper tags for images, used to define background properties for images"
       },
       {
         key: ConfigKey.group_resourceBitTags,
@@ -8998,8 +10553,15 @@ var BITS = {
   },
   [BitType.imageSeparator]: {
     since: "1.4.15",
-    baseBitType: BitType.image,
-    description: "Image separator bit, used to create separators in articles or books"
+    baseBitType: BitType._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
   },
   [BitType.imageSeparatorAlt]: {
     since: "1.16.0",
@@ -9038,15 +10600,20 @@ var BITS = {
   },
   [BitType.pageBanner]: {
     since: "1.4.3",
-    baseBitType: BitType.image,
+    baseBitType: BitType._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
   },
   [BitType.pageHero]: {
     since: "1.11.0",
@@ -9061,7 +10628,7 @@ var BITS = {
   },
   [BitType.tableImage]: {
     since: "1.5.15",
-    baseBitType: BitType.table,
+    baseBitType: BitType.tableExtended,
     description: "Table image bit, used to create images in tables in articles or books",
     tags: [
       {
@@ -9070,15 +10637,8 @@ var BITS = {
         format: TagFormat.bitmarkText
       },
       {
-        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"
-          }
-        ]
+        key: ConfigKey.group_backgroundWallpaper,
+        description: "Background wallpaper tags for images, used to define background properties for images"
       },
       {
         key: ConfigKey.group_resourceBitTags,
@@ -9221,10 +10781,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: "$" },
+        exportJsonKey: { logos: [{ type: "image", image: { src: "$" } }] },
         minCount: 1,
         maxCount: Count.infinity
       }
@@ -9234,7 +10794,17 @@ var BITS = {
   [BitType.prototypeImages]: {
     since: "1.6.1",
     baseBitType: BitType.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
+      }
+    ]
   },
   [BitType.internalLink]: {
     since: "1.3.0",
@@ -9264,6 +10834,18 @@ var BITS = {
         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
@@ -9622,6 +11204,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
       }
     ]
   },
@@ -9641,6 +11235,23 @@ var BITS = {
         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
@@ -9725,6 +11336,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
       }
     ]
   },
@@ -9746,8 +11369,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
   },
@@ -9767,8 +11402,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
       }
     ]
   },
@@ -9793,8 +11440,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
       }
     ]
   },
@@ -9814,12 +11473,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
   },
   [BitType.coachSelfReflectionMultipleResponse]: {
     since: "1.3.0",
@@ -10069,6 +11740,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: [
           {
@@ -10104,6 +11777,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: [
           {
@@ -10315,7 +11990,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the review note bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -10402,7 +12078,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example flag for the bit (boolean)",
-        format: TagFormat.plainText
+        format: TagFormat.boolean,
+        nullable: true
       }
     ],
     cardSet: CardSetConfigKey.elements,
@@ -10676,15 +12353,8 @@ var BITS = {
         format: TagFormat.bitmarkText
       },
       {
-        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"
-          }
-        ]
+        key: ConfigKey.group_backgroundWallpaper,
+        description: "Background wallpaper tags for images, used to define background properties for images"
       },
       {
         key: ConfigKey.group_resourceBitTags,
@@ -11061,16 +12731,20 @@ var BITS = {
         format: TagFormat.plainText
       },
       {
-        exportJsonKey: { choices: [{ choice: "$", isCorrect: true }] },
+        // 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",
-        format: TagFormat.plainText
+        format: TagFormat.bitmarkText
       },
       {
-        exportJsonKey: { choices: [{ choice: "$", isCorrect: false }] },
+        exportJsonKey: { statement: "$", isCorrect: false },
         key: ConfigKey.tag_false,
         description: "Tag for the false option in the true/false question",
-        format: TagFormat.plainText
+        format: TagFormat.bitmarkText
       },
       {
         // Override inherited @example from group_standardTags: boolean root
@@ -11081,14 +12755,24 @@ var BITS = {
         // 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.plainText
+        format: TagFormat.boolean,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.boolean
@@ -11112,6 +12796,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
@@ -11301,6 +12997,11 @@ var BITS = {
     baseBitType: BitType.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",
@@ -11777,7 +13478,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.23.0",
+  "version": "5.24.0",
   "author": "Get More Brain Ltd",
   "license": "ISC",
   "description": "A bitmark parser and generator using Peggy.js"
@@ -12742,6 +14443,8 @@ var NodeType = {
   stillImageFilmLink: "stillImageFilmLink",
   stripePricingTableId: "stripePricingTableId",
   stripePricingTableIdValue: "stripePricingTableIdValue",
+  stripePricingTableDescriptiveName: "stripePricingTableDescriptiveName",
+  stripePricingTableDescriptiveNameValue: "stripePricingTableDescriptiveNameValue",
   stripePublishableKey: "stripePublishableKey",
   stripePublishableKeyValue: "stripePublishableKeyValue",
   subject: "subject",
@@ -26167,6 +27870,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,
@@ -34412,6 +36121,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;
@@ -34425,6 +36135,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:
@@ -34451,6 +36162,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;
@@ -41245,6 +42957,13 @@ var ConfigBuilder = class {
       const cardSetConfig = CARDSETS[cardSetKey];
       if (!cardSetConfig) return void 0;
       const normalizedKey = normalizeCardKey(cardSetKey);
+      const variantTagEntriesTypeOrder = [
+        BitTagConfigKeyType.group,
+        BitTagConfigKeyType.tag,
+        BitTagConfigKeyType.property,
+        BitTagConfigKeyType.resource,
+        BitTagConfigKeyType.unknown
+      ];
       const sides = cardSetConfig.sides.map((side, sideIdx) => {
         const sidePath = `cardSets.${normalizedKey} / sides.${side.name ?? `[${sideIdx}]`}`;
         const variants = side.variants.map((variant, variantIdx) => {
@@ -41255,7 +42974,7 @@ var ConfigBuilder = class {
             const tagB = b[1];
             const typeA = typeFromConfigKey(tagA.key);
             const typeB = typeFromConfigKey(tagB.key);
-            const typeOrder = tagEntriesTypeOrder.indexOf(typeA) - tagEntriesTypeOrder.indexOf(typeB);
+            const typeOrder = variantTagEntriesTypeOrder.indexOf(typeA) - variantTagEntriesTypeOrder.indexOf(typeB);
             return typeOrder;
           });
           for (const [, variantTag] of variantTagEntries) {
@@ -41295,6 +43014,10 @@ var ConfigBuilder = class {
             name: sectionName,
             ...section.isDefault ? { isDefault: true } : {},
             ...cardJsonKeyField(section, "jsonKey", "exportJsonKey", sectionPath),
+            // PLAN-085: per-section cardinality. Emit only when non-default
+            // (treat `0` / undefined as "unbounded — omit").
+            ...section.minCount != null && section.minCount !== 0 ? { min: section.minCount } : {},
+            ...section.maxCount != null && section.maxCount !== 0 ? { max: section.maxCount } : {},
             sides: cardSides
           };
         });
@@ -41364,10 +43087,20 @@ var ConfigBuilder = class {
         return typeOrder;
       });
       const isInheritedFrom = bitGroupConfigKeys.has(b.bitType);
+      const indexByKey = /* @__PURE__ */ new Map();
+      const pushOrReplace = (entry) => {
+        const existing = indexByKey.get(entry.key);
+        if (existing !== void 0) {
+          tags2[existing] = entry;
+        } else {
+          indexByKey.set(entry.key, tags2.length);
+          tags2.push(entry);
+        }
+      };
       if (isInheritedFrom) {
         const resolvedGroups = resolveGroupReferences(`group-${b.bitType}`);
         for (const ref of resolvedGroups) {
-          tags2.push({
+          pushOrReplace({
             type: "group",
             key: ref.key,
             ...ref.hasExportJsonKey ? { jsonKey: ref.exportJsonKey } : {},
@@ -41380,7 +43113,7 @@ var ConfigBuilder = class {
         if (b.baseBitType) {
           const resolvedGroups = resolveGroupReferences(`group-${b.baseBitType}`);
           for (const ref of resolvedGroups) {
-            tags2.push({
+            pushOrReplace({
               type: "group",
               key: ref.key,
               ...ref.hasExportJsonKey ? { jsonKey: ref.exportJsonKey } : {},
@@ -41391,7 +43124,9 @@ var ConfigBuilder = class {
           }
         }
         for (const [_tagKey, tag] of tagEntries) {
-          tags2.push(...processTagEntries(tag, []));
+          for (const entry of processTagEntries(tag, [])) {
+            pushOrReplace(entry);
+          }
         }
       }
       let cardRef;