@gmb/bitmark-parser-generator 5.23.0 → 5.25.0

package/dist/browser/cjs/index.cjs

@@ -34,6 +34,8 @@ __export(index_exports, {
   BoundingBoxIndex: () => BoundingBoxIndex,
   Builder: () => Builder,
   CardSetVersion: () => CardSetVersion,
+  HtmlTableGenerator: () => HtmlTableGenerator2,
+  HtmlTableParser: () => HtmlTableParser2,
   InfoFormat: () => InfoFormat,
   InfoType: () => InfoType,
   Input: () => Input,
@@ -279,6 +281,7 @@ var BitType2 = {
   dangerAlt: "danger-alt",
   dangerCollapsible: "danger-collapsible",
   definitionList: "definition-list",
+  definitionListCollapsible: "definition-list-collapsible",
   definitionTerm: "definition-term",
   deleted: "deleted",
   details: "details",
@@ -559,6 +562,8 @@ var BitType2 = {
   smartStandardArticleNonNormativeCollapsible: "smart-standard-article-non-normative-collapsible",
   smartStandardArticleNormative: "smart-standard-article-normative",
   smartStandardArticleNormativeCollapsible: "smart-standard-article-normative-collapsible",
+  smartStandardDefinitionListNonNormative: "smart-standard-definition-list-non-normative",
+  smartStandardDefinitionListNormative: "smart-standard-definition-list-normative",
   smartStandardExampleNonNormative: "smart-standard-example-non-normative",
   smartStandardExampleNonNormativeCollapsible: "smart-standard-example-non-normative-collapsible",
   smartStandardExampleNormative: "smart-standard-example-normative",
@@ -609,6 +614,8 @@ var BitType2 = {
   smartStandardTableNormativeCollapsible: "smart-standard-table-normative-collapsible",
   standardArticleNonNormative: "standard-article-non-normative",
   standardArticleNormative: "standard-article-normative",
+  standardDefinitionListNonNormative: "standard-definition-list-non-normative",
+  standardDefinitionListNormative: "standard-definition-list-normative",
   standardExampleNonNormative: "standard-example-non-normative",
   standardExampleNormative: "standard-example-normative",
   standardImageFigureNonNormative: "standard-image-figure-non-normative",
@@ -778,10 +785,13 @@ var TextFormat2 = {
 var import_superenum7 = require("@ncoderz/superenum");
 var CardSetConfigKey = {
   flashcard: "flashcard",
+  flashcard1: "flashcard1",
   definitionList: "definitionList",
+  definitionListPlain: "definitionListPlain",
   elements: "elements",
   statements: "statements",
   quiz: "quiz",
+  quizResponses: "quizResponses",
   feedback: "feedback",
   questions: "questions",
   matchPairs: "matchPairs",
@@ -793,6 +803,7 @@ var CardSetConfigKey = {
   pronunciationTable: "pronunciationTable",
   botActionResponses: "botActionResponses",
   exampleBitList: "exampleBitList",
+  pageFooterSections: "pageFooterSections",
   clozeList: "clozeList",
   ingredients: "ingredients",
   // DEPRECATED - TO BE REMOVED IN THE FUTURE
@@ -1209,12 +1220,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",
@@ -1222,14 +1238,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",
@@ -1381,6 +1401,7 @@ var propertyKeys = {
   property_enforceUpdateOverUserInput: "@enforceUpdateOverUserInput",
   property_extractorExtractionTimestamp: "@extractorExtractionTimestamp",
   property_isCaseSensitive: "@isCaseSensitive",
+  property_isCollapsible: "@isCollapsible",
   property_isInfoOnly: "@isInfoOnly",
   property_isPublic: "@isPublic",
   property_isTemplate: "@isTemplate",
@@ -1506,6 +1527,7 @@ var propertyKeys = {
   property_src4x: "@src4x",
   property_srcAlt: "@srcAlt",
   property_stripePricingTableId: "@stripePricingTableId",
+  property_stripePricingTableDescriptiveName: "@stripePricingTableDescriptiveName",
   property_stripePublishableKey: "@stripePublishableKey",
   property_subject: "@subject",
   property_subtype: "@subtype",
@@ -2257,7 +2279,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "question.text",
-            exportJsonKey: { question: { text: "$" } },
+            exportJsonKey: [{ "@absent": { question: {} } }, { question: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2273,6 +2295,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
               }
             ]
           }
@@ -2283,7 +2435,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "answer.text",
-            exportJsonKey: { answer: { text: "$" } },
+            exportJsonKey: [{ "@absent": { answer: {} } }, { answer: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2299,6 +2451,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
               }
             ]
           },
@@ -2342,7 +2505,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "term.text",
-            exportJsonKey: { term: { text: "$" } },
+            exportJsonKey: [{ "@absent": { term: {} } }, { term: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2361,6 +2524,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
               }
             ]
           }
@@ -2371,7 +2545,7 @@ var CARDSETS = {
         variants: [
           {
             jsonKey: "definition.text",
-            exportJsonKey: { definition: { text: "$" } },
+            exportJsonKey: [{ "@absent": { definition: {} } }, { definition: { text: "$" } }],
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2389,6 +2563,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
               }
             ]
           },
@@ -2421,6 +2606,126 @@ var CARDSETS = {
     ]
   },
   //
+  // definition-list-plain
+  //
+  // Same shape as `definitionList`, but every variant body is rendered as
+  // plain text (string), not bitmark+ AST. Used by
+  // `meta-search-default-terms` / `meta-search-default-topics`, which need
+  // term/definition text emitted verbatim instead of as a ProseMirror tree.
+  //
+  [CardSetConfigKey.definitionListPlain]: {
+    jsonKey: "definitions",
+    exportJsonKey: { definitions: "$" },
+    sides: [
+      {
+        name: "term",
+        variants: [
+          {
+            jsonKey: "term.text",
+            exportJsonKey: [{ "@absent": { term: {} } }, { term: { text: "$" } }],
+            format: TextFormat2.plainText,
+            tags: [
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for the definition."
+              },
+              {
+                key: ConfigKey.tag_title,
+                description: "Title of the definition.",
+                format: TagFormat.plainText,
+                jsonKey: "^heading.forKeys",
+                exportJsonKey: { "@bit": { heading: { forKeys: "$" } } }
+              },
+              {
+                key: ConfigKey.group_resourceIcon,
+                description: "Icon resource for the definition.",
+                format: TagFormat.plainText,
+                jsonKey: "term.icon|resource(type=image, key=image)",
+                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
+              }
+            ]
+          }
+        ]
+      },
+      {
+        name: "definition",
+        variants: [
+          {
+            jsonKey: "definition.text",
+            exportJsonKey: [{ "@absent": { definition: {} } }, { definition: { text: "$" } }],
+            format: TextFormat2.plainText,
+            tags: [
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for the definition."
+              },
+              {
+                key: ConfigKey.tag_title,
+                description: "Title of the definition.",
+                format: TagFormat.plainText,
+                jsonKey: "^heading.forValues",
+                exportJsonKey: { "@bit": { heading: { forValues: "$" } } }
+              },
+              {
+                key: ConfigKey.group_resourceIcon,
+                description: "Icon resource for the definition.",
+                jsonKey: "definition.icon|resource(type=image, key=image)",
+                exportJsonKey: { definition: { icon: { type: "image", image: { src: "$" } } } }
+              },
+              {
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker for the definition.",
+                format: TagFormat.bitmarkText,
+                nullable: true
+              }
+            ]
+          },
+          {
+            jsonKey: "alternativeDefinitions[].text",
+            exportJsonKey: { alternativeDefinitions: [{ text: "$" }] },
+            format: TextFormat2.plainText,
+            tags: [
+              {
+                key: ConfigKey.group_standardTags,
+                description: "Standard tags for the definition."
+              },
+              {
+                exportJsonKey: { title: "$" },
+                key: ConfigKey.tag_title,
+                description: "Title of the definition."
+              },
+              {
+                key: ConfigKey.group_resourceIcon,
+                description: "Icon resource for the definition.",
+                jsonKey: "alternativeDefinitions[].icon|resource(type=image, key=image)",
+                exportJsonKey: {
+                  alternativeDefinitions: [{ icon: { type: "image", image: { src: "$" } } }]
+                }
+              }
+            ],
+            repeatCount: Count.infinity
+          }
+        ]
+      }
+    ]
+  },
+  //
   // match-pairs
   //
   [CardSetConfigKey.matchPairs]: {
@@ -2433,11 +2738,51 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
                 description: "Standard tags for the match pair."
               },
+              {
+                // Pair-level example: emit `isExample` alongside `example`
+                // (matches OLD parser's per-pair allow-list behaviour).
+                //
+                // PLAN-074: a valued cascade source (`[@example:V]` anywhere
+                // in the cardset) fills each pair's `example` with `V`
+                // once per pair from the keys-side cascade fire (single
+                // parsed_variant per pair — no per-value duplication).
+                //
+                // PLAN-076 NOTE: matchPairs (TAG 415) KEEPS `example: '$'`
+                // at the pair-object level. BPG `parseMatchPairs`
+                // (`CardContentProcessor.ts:714-723`) emits ONE example
+                // per PAIR (the `exampleCard` accumulator), placed at the
+                // pair object. Unlike matchMatrix (per-cell example),
+                // matchPairs has no nested per-cell layer, so the pair-key
+                // `[@example:V]` must double-emit as the visible field.
+                // Confirmed via `chaining` fixture: `match-solution-grouped`
+                // expects `example: "packen"` at pair-object level from
+                // `die Koffer[%1][@example:packen]`. Original PLAN-076
+                // draft applied to both keys-side tags; the matchPairs
+                // half was reverted after fixture parity testing.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  { "@keyonly": { isExample: true, "@bit": { isExample: true } } },
+                  {
+                    predicates: ["@absent", { $cascade: "*" }],
+                    rule: {
+                      isExample: true,
+                      example: "$cascade",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  { "@absent": { isExample: true } },
+                  { isExample: true, example: "$", "@bit": { isExample: true } }
+                ],
+                description: "Example marker / value on the match pair.",
+                format: TagFormat.bitmarkText,
+                nullable: true
+              },
               {
                 key: ConfigKey.tag_title,
                 description: "Title of the match pair.",
@@ -2446,9 +2791,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.",
@@ -2477,10 +2832,85 @@ var CARDSETS = {
           {
             jsonKey: "values[]",
             exportJsonKey: { values: ["$"] },
+            format: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardTags,
-                description: "Standard tags for the match pair."
+                // PLAN-084: value-side excludes item/lead/pageNumber/marginNumber.
+                // BPG `parseMatchPairs` does `delete tags.item; delete tags.lead;`
+                // for sideIdx > 0; the schema-side equivalent is to use a
+                // group_standardTags variant that omits group_standardItemLead.
+                key: ConfigKey.group_standardTagsNoItemLead,
+                description: "Standard tags for the match pair (values side, no item/lead)."
+              },
+              {
+                // PLAN-072 + ALIGN-EXAMPLE-CASCADE §3.6: cascade-fired
+                // `@example` from the bit header fills each pair's
+                // `example` with the pair's first value (mirrors BPG's
+                // `fillStringExample(pairs, __defaultExample=values[0])`).
+                //
+                // PLAN-074: the cascade-source-VALUE branch is handled by
+                // TAG 415 (keys side) which fires once per pair — keeping
+                // it here would emit `example` twice per pair (one per
+                // values-side parsed_variant) and merge them into a
+                // multi-paragraph array.
+                //
+                // PLAN-075: bare `$parent` reads the parent variant fire's
+                // source `$` value (the current `++`-iteration's value
+                // text). For single-value pairs this matches the old
+                // `$parent.values[0]`; for multi-value pairs with
+                // `[@example]` attached to a non-first value, it correctly
+                // resolves to that value.
+                //
+                // PLAN-077: dual `[@absent, { '$cascade': '*' }]` rule
+                // routes pair-key `[@example:V]` (a per-pair cascade
+                // source, bound via per-card CascadeCounters scope) and
+                // bit-header `[@example:V]` (cardset cascade) into the
+                // pair-level `example` via `$cascade`. The aggregator in
+                // `populate_variants` fires this rule ONCE per pair (BPG
+                // `parseMatchPairs` `exampleCard` precedence), avoiding
+                // per-iter pollution.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  // PLAN-084: bare `[@example]` on a values-side variant fires
+                  // once per pair (first-wins, mirrors BPG `parseMatchPairs`
+                  // `exampleCard` + `pushDownTree` set-if-null semantic).
+                  // `maxEmits: 1` enforced inside the per-pair cascade-counter
+                  // scope opened by `build_card_item`.
+                  {
+                    predicates: ["@keyonly"],
+                    maxEmits: 1,
+                    rule: {
+                      isExample: true,
+                      example: "$parent",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  {
+                    predicates: ["@absent", { $cascade: "*" }],
+                    rule: {
+                      isExample: true,
+                      example: "$cascade",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  {
+                    "@absent": {
+                      isExample: true,
+                      example: "$parent",
+                      "@bit": { isExample: true }
+                    }
+                  },
+                  // PLAN-084: same cap applies to the explicit-value `[@example:V]`
+                  // form so per-`++`-iter values-side fires also first-win.
+                  {
+                    predicates: [],
+                    maxEmits: 1,
+                    rule: { isExample: true, example: "$", "@bit": { isExample: true } }
+                  }
+                ],
+                description: "Example marker / value on the match pair (values side).",
+                format: TagFormat.bitmarkText,
+                nullable: true
               },
               {
                 key: ConfigKey.tag_title,
@@ -2490,9 +2920,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.",
@@ -2518,6 +2952,7 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2547,10 +2982,12 @@ var CARDSETS = {
           {
             jsonKey: "values[]",
             exportJsonKey: { values: ["$"] },
+            format: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardTags,
-                description: "Standard tags for the audio match pair."
+                // PLAN-084: value-side excludes item/lead/pageNumber/marginNumber.
+                key: ConfigKey.group_standardTagsNoItemLead,
+                description: "Standard tags for the audio match pair (values side, no item/lead)."
               },
               {
                 key: ConfigKey.tag_title,
@@ -2583,6 +3020,7 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardTags,
@@ -2612,10 +3050,12 @@ var CARDSETS = {
           {
             jsonKey: "values[]",
             exportJsonKey: { values: ["$"] },
+            format: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardTags,
-                description: "Standard tags for the image match pair."
+                // PLAN-084: value-side excludes item/lead/pageNumber/marginNumber.
+                key: ConfigKey.group_standardTagsNoItemLead,
+                description: "Standard tags for the image match pair (values side, no item/lead)."
               },
               {
                 key: ConfigKey.tag_title,
@@ -2648,20 +3088,49 @@ var CARDSETS = {
           {
             jsonKey: "key",
             exportJsonKey: { key: "$" },
+            format: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
                 description: "Standard tags for lead, instruction, and hint."
               },
               {
+                // PLAN-076: drop `example: '$'` from valued rule — pair-key
+                // `[@example:V]` is consumed as the per-pair cascade source.
+                // PLAN-077 R14 follow-up: investigation showed the fixture
+                // reference is INCONSISTENT — bits without a cardset-level
+                // cascade (e.g. bit 3 `[@example:Y]should be...`) expect
+                // pair-level `example: V` at pair scope, but bits WITH a
+                // cardset cascade (e.g. bit 8 `[@example:99]` in title-row
+                // PLUS pair-key `[@example:Y]`) expect NO pair-level
+                // example. Emitting `example: $` here satisfies bit 3 but
+                // breaks bit 8; dropping it satisfies bit 8 but breaks bit
+                // 3. Conditional emission would require runtime gating on
+                // the cardset cascade scope state. Left dropped pending a
+                // dedicated plan — accepted divergence on bit 3's pair-
+                // level emission (cells still get the per-cell `example`
+                // correctly via PLAN-077 §4.2 + §4.3).
                 key: ConfigKey.property_example,
                 exportJsonKey: [
-                  { "@keyonly": { isExample: true, "@bit": { isExample: true } } },
-                  { "@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,
@@ -2689,35 +3158,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: TextFormat2.plainText,
             tags: [
               {
                 key: ConfigKey.group_standardItemLeadInstructionHint,
                 description: "Standard tags for lead, instruction, and hint."
               },
               {
+                // PLAN-075: bare `$parent` reads the parent variant fire's
+                // source `$` value (the current `++`-iteration's cell text).
+                // Replaces `$parent.values[0]` which pinned to position 0
+                // regardless of which `++`-value `[@example]` was on.
+                //
+                // PLAN-077: dual `[@absent, { '$cascade': '*' }]` rule
+                // routes pair-key `[@example:V]` (a per-pair cascade
+                // source, bound via per-card CascadeCounters scope) and
+                // bit-header `[@example:V]` (cardset cascade) into the
+                // per-cell `example` via `$cascade`. The aggregator in
+                // `populate_variants` fires this rule ONCE per cell (BPG
+                // `parseMatchMatrix` `exampleSide` precedence), avoiding
+                // per-iter pollution.
+                // @card scope-shift writes matrix-row container isExample.
                 key: ConfigKey.property_example,
                 exportJsonKey: [
                   {
                     "@keyonly": {
-                      cells: { $s: { isExample: true, example: "$parent.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,
@@ -2766,6 +3296,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
@@ -2794,6 +3353,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
@@ -2819,6 +3443,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."
@@ -2839,31 +3530,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: TextFormat2.plainText,
             tags: [
               {
-                key: ConfigKey.group_standardItemLeadInstructionHint,
-                description: "Standard tags for lead, instruction, and hint."
+                // Instruction lands under reason. Hint/item/lead/etc.
+                // omitted: not exercised by any fixture and BPG's
+                // `parseFeedback` spreads only the tags actually present
+                // — adding the rest can be done lazily as fixtures
+                // require them, with the same `{reason: {…}}` wrapper.
+                key: ConfigKey.tag_instruction,
+                exportJsonKey: { reason: { instruction: "$" } },
+                description: "Instruction for the feedback reason.",
+                format: TagFormat.bitmarkText
               },
               {
                 key: ConfigKey.property_reasonableNumOfChars,
                 exportJsonKey: [
-                  { "@absent": { 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,
@@ -2927,6 +3658,39 @@ 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.
+                //
+                // BPG's `BaseBuilder.toExample` for interview questions
+                // (Builder.ts:2575,2588) uses `data.__sampleSolutionAst`
+                // as `defaultExample` — bare `[@example]` (which sets
+                // `__isDefaultExample=true, example=undefined`) emits the
+                // parsed sample-solution AST in the `example` slot. The
+                // `@keyonly` rule mirrors that runtime behaviour via
+                // `$parent.sampleSolution` — the chain-walker's post-walk
+                // retry resolves this once the sibling `[@sampleSolution]`
+                // chain has merged into the shared scope (interview's
+                // `[@example]` typically precedes `[@sampleSolution]` in
+                // source). Format coercion turns the resolved string
+                // value into a PM tree.
+                key: ConfigKey.property_example,
+                exportJsonKey: [
+                  {
+                    "@keyonly": {
+                      isExample: true,
+                      example: "$parent.sampleSolution",
+                      "@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
               }
             ]
           }
@@ -2953,14 +3717,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
@@ -2972,9 +3738,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",
@@ -3015,6 +3829,8 @@ var CARDSETS = {
               },
               {
                 key: ConfigKey.property_tableColWidth,
+                jsonKey: "^table.columnWidths[{s}]",
+                exportJsonKey: { "@bit": { table: { columnWidths: { $s: "$" } } } },
                 description: "Width for the column.",
                 format: TagFormat.number
               }
@@ -3033,7 +3849,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, $: "$" } } }
       },
@@ -3066,13 +3897,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,
@@ -3104,6 +3935,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
               }
@@ -3141,7 +3975,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
@@ -3212,14 +4047,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
               }
             ]
           }
@@ -3285,6 +4123,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]: {
@@ -3615,7 +4485,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,
@@ -3788,6 +4662,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",
@@ -3801,17 +4693,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
       }
     ]
   },
@@ -3876,8 +4796,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: [
@@ -3897,8 +4817,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: [
@@ -3922,7 +4842,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,
@@ -3941,27 +4863,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,
@@ -4010,6 +4942,99 @@ 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: [
+              {
+                "@keyonly": {
+                  isExample: true,
+                  example: "$parent.isCorrect",
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                predicates: ["@absent", { "@parent.isCorrect": true }],
+                maxEmits: 1,
+                rule: {
+                  isExample: true,
+                  example: true,
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                "@absent": {
+                  isExample: true,
+                  "@bit": { isExample: true },
+                  "@card": { isExample: true }
+                }
+              },
+              {
+                isExample: true,
+                example: "$",
+                "@bit": { isExample: true },
+                "@card": { isExample: true }
+              }
+            ],
+            description: "An example for the true/false statement/question",
+            format: TagFormat.boolean,
+            nullable: true
+          }
+        ]
+      },
+      {
+        exportJsonKey: { choices: [{ choice: "$", isCorrect: false }] },
+        key: ConfigKey.tag_false,
+        description: "False value for a true/false statement/question",
+        maxCount: Count.infinity,
+        format: TagFormat.plainText,
+        chain: [
+          {
+            key: ConfigKey.tag_true,
+            jsonKey: "choices[]|set(isCorrect=true)",
+            exportJsonKey: { choices: [{ choice: "$", isCorrect: true }] },
+            description: "True values for a true/false statement/question",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.tag_false,
+            jsonKey: "choices[]|set(isCorrect=false)",
+            exportJsonKey: { choices: [{ choice: "$", isCorrect: false }] },
+            description: "False values for a true/false statement/question",
+            maxCount: Count.infinity,
+            format: TagFormat.plainText
+          },
+          {
+            key: ConfigKey.group_standardItemLeadInstructionHint,
+            description: "Item, lead, page number, margin number, instruction and hint tags"
+          },
+          {
+            // PLAN-072 + ALIGN-EXAMPLE-CASCADE §3.2: cascade-fired
+            // `@example` on a `-` (incorrect choice) emits
+            // `isExample: true` only — no `example` (BPG fixtures show
+            // `isExample` on every choice, but `example` only on the
+            // first correct via firstCorrectOnly cascade).
+            // @card scope-shift writes choice-container isExample.
             key: ConfigKey.property_example,
             jsonKey: "example",
             exportJsonKey: [
@@ -4017,25 +5042,99 @@ 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: { choices: [{ choice: "$", isCorrect: false }] },
+        exportJsonKey: { responses: [{ response: "$", isCorrect: false }] },
         key: ConfigKey.tag_false,
         description: "False value for a true/false statement/question",
         maxCount: Count.infinity,
@@ -4043,16 +5142,16 @@ var GROUPS = {
         chain: [
           {
             key: ConfigKey.tag_true,
-            jsonKey: "choices[]|set(isCorrect=true)",
-            exportJsonKey: { choices: [{ choice: "$", isCorrect: 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: "choices[]|set(isCorrect=false)",
-            exportJsonKey: { choices: [{ choice: "$", isCorrect: 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
@@ -4062,6 +5161,7 @@ var GROUPS = {
             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: [
@@ -4069,20 +5169,333 @@ var GROUPS = {
                 "@keyonly": {
                   isExample: true,
                   example: "$parent.isCorrect",
-                  "@bit": { isExample: 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
+          }
+        ]
+      }
+    ]
+  },
+  [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
           }
         ]
       }
@@ -4095,7 +5508,11 @@ var GROUPS = {
       {
         key: ConfigKey.property_mark,
         jsonKey: "marks.mark",
-        exportJsonKey: { marks: { mark: ["$"] } },
+        // `emphasis: 'underline'` is the per-entry default for mark
+        // configs — mirrors the hardcoded default in BPG
+        // `MarkConfigChainContentProcessor.ts:55-58`. Chained
+        // `[@emphasis:…]` overrides via deep-merge into `marks[-1]`.
+        exportJsonKey: { marks: [{ mark: "$", emphasis: "underline" }] },
         description: "The mark configuration",
         format: TagFormat.plainText,
         maxCount: Count.infinity,
@@ -4119,7 +5536,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,
@@ -4128,19 +5547,30 @@ var GROUPS = {
           {
             key: ConfigKey.property_mark,
             jsonKey: "mark",
+            exportJsonKey: { mark: "$" },
             description: "The mark configuration",
             format: TagFormat.plainText
           },
           {
             key: ConfigKey.property_example,
             jsonKey: "example",
-            exportJsonKey: [
-              { "@keyonly": { isExample: true, example: true, "@bit": { isExample: true } } },
-              { "@absent": { isExample: true, example: true, "@bit": { isExample: true } } },
-              { isExample: true, example: "$", "@bit": { isExample: true } }
-            ],
+            // Per-mark `@example` is a boolean toggle. BPG's runtime
+            // `ExampleTagContentProcessor.handleDefaultOnlyExample`
+            // (lines 147-161) normalises ANY `[@example]` or
+            // `[@example:V]` on a mark body-bit to
+            // `__isDefaultExample=true, example=undefined`; the
+            // downstream `toExample(_, _, defaultExample=true)` in
+            // `BaseBuilder.ts:80-87` then emits `example: true`
+            // regardless of source. Declare a single unconditional
+            // boolean-shape rule so the exported schema matches that
+            // runtime semantic instead of the misleading `example: $`
+            // shape (which would only fire if `handleDefaultOnlyExample`
+            // were removed). `@bit: {isExample: true}` cascades the
+            // marker — but NOT the `example` value — to bit root.
+            exportJsonKey: { isExample: true, example: true, "@bit": { isExample: true } },
             description: "An example for the marked content",
-            format: TagFormat.bitmarkText
+            format: TagFormat.boolean,
+            nullable: true
           }
         ]
       }
@@ -4569,6 +5999,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
   //
@@ -4688,6 +6154,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",
@@ -4777,22 +6295,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: "$" }] }
       }
     ]
   },
@@ -4805,6 +6327,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_icon,
+        exportJsonKey: { resource: { type: "icon", icon: { src: "$" } } },
         description: "The icon resource",
         chain: [
           {
@@ -4832,12 +6355,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: [
           {
@@ -4854,6 +6395,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageLandscape,
+        exportJsonKey: { resource: { type: "image-landscape", imageLandscape: { src: "$" } } },
         description: "The landscape image resource",
         chain: [
           {
@@ -4870,6 +6412,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_imageEmbed,
+        exportJsonKey: { resource: { type: "image-embed", imageEmbed: { src: "$" } } },
         description: "The embedded image resource",
         chain: [
           {
@@ -5043,6 +6586,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_article,
+        exportJsonKey: { resource: { type: "article", article: { body: "$" } } },
         description: "The article resource",
         chain: [
           {
@@ -5059,6 +6603,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleEmbed,
+        exportJsonKey: { resource: { type: "article-embed", articleEmbed: { url: "$" } } },
         description: "The embedded article resource",
         chain: [
           {
@@ -5075,6 +6620,7 @@ var GROUPS = {
     tags: [
       {
         key: ConfigKey.resource_articleLink,
+        exportJsonKey: { resource: { type: "article-link", articleLink: { url: "$" } } },
         description: "The link to the article resource",
         chain: [
           {
@@ -5345,7 +6891,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;
@@ -5560,7 +7111,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -5899,7 +7451,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -6062,7 +7615,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -6213,7 +7767,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the bit",
-        format: TagFormat.plainText
+        format: TagFormat.plainText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -6790,6 +8345,12 @@ var BITS = {
         description: "The progress of the chapter, used for tracking reading progress",
         format: TagFormat.boolean,
         defaultValue: "true"
+      },
+      {
+        key: ConfigKey.property_isCollapsible,
+        description: "If true, the chapter is collapsible",
+        format: TagFormat.boolean,
+        defaultValue: "false"
       }
     ]
   },
@@ -6808,8 +8369,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
       }
     ]
   },
@@ -6848,18 +8432,56 @@ var BITS = {
       {
         key: ConfigKey.group_gap,
         description: "Tags for gaps in cloze bits"
+      },
+      {
+        // Override inherited @example: cloze is in OLD parser's
+        // `isTopLevelExample` allow-list, so [@example] at bit-header
+        // emits `isExample: true`.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ]
   },
   [BitType2.clozeInstructionGrouped]: {
     since: "1.3.0",
     baseBitType: BitType2.cloze,
-    description: "Cloze instruction grouped bit, used for cloze questions with grouped instructions"
+    description: "Cloze instruction grouped bit, used for cloze questions with grouped instructions",
+    tags: [
+      {
+        key: ConfigKey.property_quizCountItems,
+        description: "The number of items in the cloze quiz (instruction-grouped default: true)",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      }
+      // Note: quizStrikethroughSolutions defaults to false for instruction-grouped per OLD
+      // JsonGenerator.ts:1689-1690, which equals the Boolean natural default → no override needed.
+    ]
   },
   [BitType2.clozeSolutionGrouped]: {
     since: "1.3.0",
     baseBitType: BitType2.cloze,
-    description: "Cloze solution grouped bit, used for cloze questions with grouped solutions"
+    description: "Cloze solution grouped bit, used for cloze questions with grouped solutions",
+    tags: [
+      {
+        key: ConfigKey.property_quizCountItems,
+        description: "The number of items in the cloze quiz (solution-grouped default: true)",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      },
+      {
+        key: ConfigKey.property_quizStrikethroughSolutions,
+        description: "If the cloze solutions should be strikethrough (solution-grouped default: true)",
+        format: TagFormat.boolean,
+        defaultValue: "true"
+      }
+    ]
   },
   [BitType2.clozeSeveral]: {
     since: "3.5.0",
@@ -6895,6 +8517,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
@@ -7061,6 +8694,7 @@ var BITS = {
     tags: [
       {
         key: ConfigKey.group_person,
+        exportJsonKey: { partner: { name: "$" } },
         description: "Tags for the person in the conversation"
       }
     ]
@@ -7491,7 +9125,12 @@ var BITS = {
         maxCount: Count.infinity
       },
       {
-        // Override inherited @example from group_standardTags: string root example.
+        // Override inherited @example from group_standardTags: emits both
+        // `isExample` (bool) AND `example` (paragraph array). Declared as
+        // bitmarkText because BPG `JsonGenerator.toExample` renders the
+        // root-example value through the bit's textFormat (not this tag's
+        // declared format) — `TagFormat.plainText` here would be ignored
+        // at runtime and is misleading.
         key: ConfigKey.property_example,
         exportJsonKey: [
           { "@keyonly": { isExample: true, example: "true" } },
@@ -7499,7 +9138,8 @@ var BITS = {
           { isExample: true, example: "$" }
         ],
         description: "The example text for the essay bit",
-        format: TagFormat.plainText
+        format: TagFormat.bitmarkText,
+        nullable: true
       }
     ],
     rootExampleType: ExampleType.string
@@ -7533,7 +9173,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
@@ -7619,7 +9260,19 @@ var BITS = {
   [BitType2.articleAi]: {
     since: "1.3.0",
     baseBitType: BitType2.article,
-    description: "Article AI bit, used to create AI-generated articles"
+    description: "Article AI bit, used to create AI-generated articles",
+    tags: [
+      {
+        // Shadows the inherited @aiGenerated from the standard group: this
+        // bit type forces aiGenerated:true regardless of source value or
+        // absence. Literal `true` in the export pattern ignores `$`.
+        key: ConfigKey.property_aiGenerated,
+        description: "AI-generated flag, forced true for article-ai bits",
+        format: TagFormat.boolean,
+        defaultValue: "true",
+        exportJsonKey: { aiGenerated: true }
+      }
+    ]
   },
   [BitType2.articleAttachment]: {
     since: "1.3.0",
@@ -7944,7 +9597,19 @@ var BITS = {
   [BitType2.noteAi]: {
     since: "1.3.0",
     baseBitType: BitType2.note,
-    description: "Note AI bit, used to create AI-generated notes in articles or books"
+    description: "Note AI bit, used to create AI-generated notes in articles or books",
+    tags: [
+      {
+        // Shadows the inherited @aiGenerated from the standard group: this
+        // bit type forces aiGenerated:true regardless of source value or
+        // absence. Literal `true` in the export pattern ignores `$`.
+        key: ConfigKey.property_aiGenerated,
+        description: "AI-generated flag, forced true for article-ai bits",
+        format: TagFormat.boolean,
+        defaultValue: "true",
+        exportJsonKey: { aiGenerated: true }
+      }
+    ]
   },
   [BitType2.notebookArticle]: {
     since: "1.3.0",
@@ -8069,7 +9734,19 @@ var BITS = {
   [BitType2.summaryAi]: {
     since: "1.3.0",
     baseBitType: BitType2.summary,
-    description: "AI-generated summary bit"
+    description: "AI-generated summary bit",
+    tags: [
+      {
+        // Shadows the inherited @aiGenerated from the standard group: this
+        // bit type forces aiGenerated:true regardless of source value or
+        // absence. Literal `true` in the export pattern ignores `$`.
+        key: ConfigKey.property_aiGenerated,
+        description: "AI-generated flag, forced true for article-ai bits",
+        format: TagFormat.boolean,
+        defaultValue: "true",
+        exportJsonKey: { aiGenerated: true }
+      }
+    ]
   },
   [BitType2.videoTranscript]: {
     since: "1.3.0",
@@ -8343,7 +10020,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
       }
     ]
   },
@@ -8396,10 +10073,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
       }
@@ -8689,6 +10369,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: [
@@ -8756,7 +10440,9 @@ var BITS = {
         format: TagFormat.plainText
       }
     ],
-    cardSet: CardSetConfigKey.exampleBitList
+    // page-footer emits cards under `sections` (vs `listItems` for the
+    // sibling exampleList / assignmentList bits) — see JsonGenerator.ts.
+    cardSet: CardSetConfigKey.pageFooterSections
   },
   [BitType2.legend]: {
     since: "3.12.0",
@@ -8798,13 +10484,52 @@ var BITS = {
     since: "1.34.0",
     baseBitType: BitType2._standard,
     description: "Definition list bit, used to create lists of definitions in articles or books",
+    tags: [
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
+      }
+    ],
     cardSet: CardSetConfigKey.definitionList
   },
+  [BitType2.definitionListCollapsible]: {
+    since: "5.25.0",
+    baseBitType: BitType2.definitionList,
+    description: "Collapsible definition list bit, used to create collapsible lists of definitions in articles or books"
+  },
+  [BitType2.standardDefinitionListNormative]: {
+    since: "5.24.0",
+    baseBitType: BitType2.definitionList,
+    description: "Standard normative definition list bit, used to create normative standard definition lists in articles or books"
+  },
+  [BitType2.standardDefinitionListNonNormative]: {
+    since: "5.24.0",
+    baseBitType: BitType2.definitionList,
+    description: "Standard non-normative definition list bit, used to create non-normative standard definition lists in articles or books"
+  },
+  [BitType2.smartStandardDefinitionListNormative]: {
+    since: "5.24.0",
+    baseBitType: BitType2.standardDefinitionListNormative,
+    description: "Smart standard normative definition list bit, used to create normative smart standard definition lists in articles or books"
+  },
+  [BitType2.smartStandardDefinitionListNonNormative]: {
+    since: "5.24.0",
+    baseBitType: BitType2.standardDefinitionListNonNormative,
+    description: "Smart standard non-normative definition list bit, used to create non-normative smart standard definition lists in articles or books"
+  },
   [BitType2.metaSearchDefaultTerms]: {
     since: "3.12.0",
     baseBitType: BitType2._standard,
     description: "Meta search default terms bit, used to define default search terms in articles",
-    cardSet: CardSetConfigKey.definitionList
+    cardSet: CardSetConfigKey.definitionListPlain
   },
   [BitType2.metaSearchDefaultTopics]: {
     since: "3.12.0",
@@ -8820,6 +10545,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
@@ -8827,12 +10564,20 @@ var BITS = {
   [BitType2.flashcard1]: {
     since: "1.3.0",
     baseBitType: BitType2.flashcard,
-    description: "Flashcard 1 bit"
+    description: "Flashcard 1 bit",
+    // PLAN-085: use the flashcard1 cardset (sections.default.maxCount=1)
+    // instead of inheriting `flashcard`'s unbounded cardset, since this
+    // bit type structurally allows only a single card.
+    cardSet: CardSetConfigKey.flashcard1
   },
   [BitType2.qAndACard]: {
     since: "3.25.0",
     baseBitType: BitType2.flashcard1,
-    description: "Q&A card bit, used to create question and answer cards in articles or books"
+    description: "Q&A card bit, used to create question and answer cards in articles or books",
+    // PLAN-085: q-and-a-card permits multiple cards (some fixtures carry
+    // two). Override the inherited `flashcard1` (max=1) cardset back to
+    // the unbounded `flashcard` cardset.
+    cardSet: CardSetConfigKey.flashcard
   },
   [BitType2.focusImage]: {
     since: "1.3.0",
@@ -8862,8 +10607,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
       }
     ]
   },
@@ -8873,15 +10634,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,
@@ -8984,8 +10738,15 @@ var BITS = {
   },
   [BitType2.imageSeparator]: {
     since: "1.4.15",
-    baseBitType: BitType2.image,
-    description: "Image separator bit, used to create separators in articles or books"
+    baseBitType: BitType2._standard,
+    description: "Image separator bit, used to create separators in articles or books",
+    tags: [
+      {
+        key: ConfigKey.group_imageNoZoom,
+        description: "Image no zoom tags for images, used to define whether images should have zoom functionality"
+      }
+    ],
+    resourceAttachmentAllowed: false
   },
   [BitType2.imageSeparatorAlt]: {
     since: "1.16.0",
@@ -9024,15 +10785,20 @@ var BITS = {
   },
   [BitType2.pageBanner]: {
     since: "1.4.3",
-    baseBitType: BitType2.image,
+    baseBitType: BitType2._standard,
     description: "Page banner bit, used to create banners for pages in articles or books",
     tags: [
       {
         key: ConfigKey.property_slug,
         description: "Slug for the page banner, used to identify the banner in the system",
         format: TagFormat.plainText
+      },
+      {
+        key: ConfigKey.group_imageNoZoom,
+        description: "Image no zoom tags for images, used to define whether images should have zoom functionality"
       }
-    ]
+    ],
+    resourceAttachmentAllowed: false
   },
   [BitType2.pageHero]: {
     since: "1.11.0",
@@ -9047,7 +10813,7 @@ var BITS = {
   },
   [BitType2.tableImage]: {
     since: "1.5.15",
-    baseBitType: BitType2.table,
+    baseBitType: BitType2.tableExtended,
     description: "Table image bit, used to create images in tables in articles or books",
     tags: [
       {
@@ -9056,15 +10822,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,
@@ -9207,10 +10966,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
       }
@@ -9220,7 +10979,17 @@ var BITS = {
   [BitType2.prototypeImages]: {
     since: "1.6.1",
     baseBitType: BitType2.imagesLogoGrave,
-    description: "Prototype images bit, used to create prototype images in articles or books"
+    description: "Prototype images bit, used to create prototype images in articles or books",
+    tags: [
+      {
+        // Override inherited `logos` wrapper with `images` for this bit type.
+        key: ConfigKey.group_resourceImageNoZoom,
+        description: "Resource image tags for prototype images",
+        exportJsonKey: { images: [{ type: "image", image: { src: "$" } }] },
+        minCount: 1,
+        maxCount: Count.infinity
+      }
+    ]
   },
   [BitType2.internalLink]: {
     since: "1.3.0",
@@ -9250,6 +11019,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
@@ -9608,6 +11389,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
       }
     ]
   },
@@ -9627,6 +11420,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
@@ -9711,6 +11521,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
       }
     ]
   },
@@ -9732,8 +11554,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
   },
@@ -9753,8 +11587,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
       }
     ]
   },
@@ -9779,8 +11625,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
       }
     ]
   },
@@ -9800,12 +11658,24 @@ var BITS = {
         description: "Common quiz tags for multiple response questions"
       },
       {
-        key: ConfigKey.group_trueFalse,
+        key: ConfigKey.group_trueFalseResponses,
         description: "True/False tags for multiple response questions"
-      }
+      },
       // This is actually for multiple-response-1, but we support it here as well (as many bits are wrong)
+      {
+        // Override inherited @example: in `isTopLevelExample` allow-list.
+        key: ConfigKey.property_example,
+        exportJsonKey: [
+          { "@keyonly": { isExample: true } },
+          { "@absent": { isExample: true } },
+          { isExample: true, example: "$" }
+        ],
+        description: "The example(s) for the bit",
+        format: TagFormat.bitmarkText,
+        nullable: true
+      }
     ],
-    cardSet: CardSetConfigKey.quiz
+    cardSet: CardSetConfigKey.quizResponses
   },
   [BitType2.coachSelfReflectionMultipleResponse]: {
     since: "1.3.0",
@@ -10055,6 +11925,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: [
           {
@@ -10090,6 +11962,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: [
           {
@@ -10301,7 +12175,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
@@ -10388,7 +12263,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,
@@ -10662,15 +12538,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,
@@ -11047,16 +12916,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
@@ -11067,14 +12940,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
@@ -11098,6 +12981,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
@@ -11287,6 +13182,11 @@ var BITS = {
     baseBitType: BitType2.vendorStripePricingTable,
     description: "Stripe pricing table bit with print-on-request customer/product IDs, used to embed Stripe pricing tables tied to a specific print-on-request customer and product",
     tags: [
+      {
+        key: ConfigKey.property_stripePricingTableDescriptiveName,
+        description: "Descriptive name for the Stripe pricing table",
+        format: TagFormat.plainText
+      },
       {
         key: ConfigKey.property_printOnRequestCustomerId,
         description: "Print-on-request customer ID, used to identify the customer for the print-on-request flow",
@@ -11763,7 +13663,7 @@ var instance2 = new Config();
 // src/generated/package_info.ts
 var PACKAGE_INFO = {
   "name": "@gmb/bitmark-parser-generator",
-  "version": "5.23.0",
+  "version": "5.25.0",
   "author": "Get More Brain Ltd",
   "license": "ISC",
   "description": "A bitmark parser and generator using Peggy.js"
@@ -12409,6 +14309,8 @@ var NodeType = {
   internalPrintPdf: "internalPrintPdf",
   internalPrintPdfValue: "internalPrintPdfValue",
   isCaseSensitive: "isCaseSensitive",
+  isCollapsible: "isCollapsible",
+  isCollapsibleValue: "isCollapsibleValue",
   isCommented: "isCommented",
   isCorrect: "isCorrect",
   isEditable: "isEditable",
@@ -12728,6 +14630,8 @@ var NodeType = {
   stillImageFilmLink: "stillImageFilmLink",
   stripePricingTableId: "stripePricingTableId",
   stripePricingTableIdValue: "stripePricingTableIdValue",
+  stripePricingTableDescriptiveName: "stripePricingTableDescriptiveName",
+  stripePricingTableDescriptiveNameValue: "stripePricingTableDescriptiveNameValue",
   stripePublishableKey: "stripePublishableKey",
   stripePublishableKeyValue: "stripePublishableKeyValue",
   subject: "subject",
@@ -26153,6 +28057,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,
@@ -26639,6 +28549,12 @@ var Builder = class extends BaseBuilder {
       level: instance6.asNumber(data.level),
       toc: this.toAstProperty(bitType, ConfigKey.property_toc, data.toc, options),
       progress: this.toAstProperty(bitType, ConfigKey.property_progress, data.progress, options),
+      isCollapsible: this.toAstProperty(
+        bitType,
+        ConfigKey.property_isCollapsible,
+        data.isCollapsible,
+        options
+      ),
       anchor: data.anchor,
       reference: data.reference,
       referenceEnd: data.referenceEnd,
@@ -32185,6 +34101,7 @@ var JsonGenerator = class extends AstWalkerGenerator {
       if (instance2.isOfBitType(bitType, BitType2.chapter)) {
         if (bitJson.toc == null) bitJson.toc = true;
         if (bitJson.progress == null) bitJson.progress = true;
+        if (bitJson.isCollapsible == null) bitJson.isCollapsible = false;
         if (bitJson.level == null) bitJson.level = 1;
         if (bitJson.body == null) bitJson.body = this.bodyDefault;
       }
@@ -34380,7 +36297,9 @@ function buildCards(context, bitType, textFormat, parsedCardSet, statementV1, st
   const cardSetType = bitConfig.cardSet?.configKey;
   switch (cardSetType) {
     case CardSetConfigKey.flashcard:
+    case CardSetConfigKey.flashcard1:
     case CardSetConfigKey.definitionList:
+    case CardSetConfigKey.definitionListPlain:
       result = parseFlashcardOrDefinitionList(context, bitType, processedCardSet);
       break;
     case CardSetConfigKey.elements:
@@ -34393,6 +36312,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:
@@ -34419,6 +36339,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;
@@ -40445,7 +42366,11 @@ var InputFormat = {
   /**
    * Input is plain text
    */
-  plainText: "plainText"
+  plainText: "plainText",
+  /**
+   * Input is HTML (used by convertHtmlTable)
+   */
+  html: "html"
 };
 var BitmarkParserGenerator = class {
   constructor() {
@@ -40980,6 +42905,87 @@ var BitmarkParserGenerator = class {
     const res = generator.generate(data);
     return res;
   }
+  /**
+   * Convert between HTML tables and bitmark tables.
+   *
+   * Direction is auto-detected (override with `options.inputFormat`):
+   * - HTML input: every `<table>` is extracted and emitted as a `[.table-extended]` (or `[.table]`)
+   *   bit; output as bitmark (default), JSON, AST, or HTML (re-emit).
+   * - bitmark / JSON / AST input: each `table` / `table-extended` bit is rendered as an HTML
+   *   `<table>` fragment.
+   *
+   * Cell content is reproduced verbatim except inline conversion to bitmark marks (bold, italic,
+   * superscript, etc.), with lists and images mapped to their bitmark equivalents.
+   *
+   * @param input - HTML, bitmark, JSON or AST string; or a parsed JSON/AST value; or a file path.
+   * @param options - the conversion options
+   * @returns the converted output as a string (or object for JSON/AST), or void when writing a file
+   * @throws Error if any error occurs
+   */
+  convertHtmlTable(input, options) {
+    const opts = Object.assign({}, options);
+    if (env.isBrowser && opts.outputFile) {
+      throw new Error("Cannot write to file in browser environment");
+    }
+    let inStr = input;
+    const inputIsString = typeof input === "string";
+    if (env.isNode && inputIsString && fs.existsSync(inStr)) {
+      inStr = fs.readFileSync(inStr, { encoding: "utf8" });
+    }
+    const isHtmlString = (s) => {
+      const t = s.replace(/^\s+/, "");
+      return t.startsWith("<") && /<table/i.test(t);
+    };
+    let htmlInput;
+    if (opts.inputFormat === InputFormat.html) {
+      htmlInput = true;
+    } else if (opts.inputFormat != null) {
+      htmlInput = false;
+    } else {
+      htmlInput = inputIsString && isHtmlString(inStr);
+    }
+    if (htmlInput) {
+      const parser2 = new HtmlTableParser();
+      const bits = parser2.parse(inStr, {
+        tableFormat: opts.tableFormat ?? "table-extended",
+        keepUnknownTags: opts.keepUnknownTags,
+        onWarning: (m) => console.warn(m)
+      });
+      const outputFormat2 = opts.outputFormat ?? Output.bitmark;
+      if (outputFormat2 === "html") {
+        const json2 = this.convert(bits, { outputFormat: Output.json });
+        return this.outputHtml(new HtmlTableGenerator().generate(json2), opts);
+      }
+      return this.convert(bits, {
+        outputFormat: (0, import_superenum50.Enum)(Output).fromValue(outputFormat2),
+        outputFile: opts.outputFile,
+        fileOptions: opts.fileOptions,
+        jsonOptions: opts.jsonOptions,
+        bitmarkOptions: opts.bitmarkOptions
+      });
+    }
+    const outputFormat = opts.outputFormat ?? "html";
+    if (outputFormat !== "html") {
+      throw new Error(
+        "convertHtmlTable: non-HTML input can only be converted to HTML. Use convert() for bitmark/JSON/AST conversions."
+      );
+    }
+    const json = this.convert(inputIsString ? inStr : input, { outputFormat: Output.json });
+    return this.outputHtml(new HtmlTableGenerator().generate(json), opts);
+  }
+  /**
+   * Write an HTML string to the configured output file, or return it.
+   */
+  outputHtml(html, opts) {
+    if (opts.outputFile) {
+      const output = opts.outputFile.toString();
+      const flag = opts.fileOptions?.append ? "a" : "w";
+      fs.ensureDirSync(path.dirname(output));
+      fs.writeFileSync(output, html, { flag });
+      return;
+    }
+    return html;
+  }
   /**
    * Breakscape bitmark text.
    *
@@ -41258,6 +43264,728 @@ var BoundingBoxIndex = class _BoundingBoxIndex {
   }
 };
 
+// src/generator/html/HtmlTableGenerator.ts
+var MARK_TO_TAG = {
+  bold: "b",
+  italic: "i",
+  superscript: "sup",
+  subscript: "sub",
+  strike: "s",
+  del: "del",
+  ins: "ins",
+  underline: "u",
+  highlight: "mark",
+  code: "code"
+};
+var HtmlTableGenerator2 = class {
+  constructor() {
+    __publicField(this, "indentUnit", "  ");
+  }
+  /**
+   * Generate HTML table fragments from a string or JSON value.
+   * @returns the concatenated `<table>` fragments, blank-line separated (empty string if none).
+   */
+  generate(input) {
+    let data = input;
+    if (typeof data === "string") {
+      try {
+        data = JSON.parse(data);
+      } catch {
+        return "";
+      }
+    }
+    const bits = this.collectBits(data);
+    const fragments = [];
+    for (const bit of bits) {
+      const html = this.renderTableBit(bit);
+      if (html) fragments.push(html);
+    }
+    return fragments.join("\n\n");
+  }
+  // --- bit collection -------------------------------------------------------
+  collectBits(data) {
+    const out = [];
+    const visit = (value) => {
+      if (value == null || typeof value !== "object") return;
+      if (Array.isArray(value)) {
+        value.forEach(visit);
+        return;
+      }
+      const obj = value;
+      if ("bit" in obj && obj.bit && typeof obj.bit === "object") {
+        out.push(obj.bit);
+      } else if ("type" in obj) {
+        out.push(obj);
+      }
+    };
+    visit(data);
+    return out;
+  }
+  // --- table rendering ------------------------------------------------------
+  renderTableBit(bit) {
+    const table = bit.table;
+    if (!table) return "";
+    if (bit.type !== "table" && bit.type !== "table-extended") return "";
+    const extended = this.toExtended(table);
+    const lines = [];
+    lines.push("<table>");
+    if (bit.caption != null) {
+      const caption = this.cellContentToHtml(this.asTextAst(bit.caption));
+      if (caption) lines.push(`${this.indentUnit}<caption>${caption}</caption>`);
+    }
+    this.renderSection(lines, "thead", extended.header, "header");
+    this.renderSection(lines, "tbody", extended.body, "body");
+    this.renderSection(lines, "tfoot", extended.footer, "footer");
+    lines.push("</table>");
+    return lines.join("\n");
+  }
+  toExtended(table) {
+    const t = table;
+    if (t.header || t.body || t.footer) return table;
+    return convertBasicToExtendedTableFormat(table);
+  }
+  renderSection(lines, tag, section, key) {
+    if (!section || !section.rows || section.rows.length === 0) return;
+    lines.push(`${this.indentUnit}<${tag}>`);
+    for (const row of section.rows) {
+      lines.push(`${this.indentUnit.repeat(2)}<tr>`);
+      for (const cell of row.cells ?? []) {
+        lines.push(`${this.indentUnit.repeat(3)}${this.renderCell(cell, key)}`);
+      }
+      lines.push(`${this.indentUnit.repeat(2)}</tr>`);
+    }
+    lines.push(`${this.indentUnit}</${tag}>`);
+  }
+  renderCell(cell, _key) {
+    const tag = cell.title === true ? "th" : "td";
+    const attrs = [];
+    if (cell.rowspan && cell.rowspan > 1) attrs.push(`rowspan="${cell.rowspan}"`);
+    if (cell.colspan && cell.colspan > 1) attrs.push(`colspan="${cell.colspan}"`);
+    if (cell.scope) attrs.push(`scope="${cell.scope}"`);
+    if (cell.colwidth && cell.colwidth > 0) attrs.push(`width="${cell.colwidth}"`);
+    const open = attrs.length > 0 ? `<${tag} ${attrs.join(" ")}>` : `<${tag}>`;
+    return `${open}${this.cellContentToHtml(this.asTextAst(cell.content))}</${tag}>`;
+  }
+  // --- cell content (TextAst -> HTML) ---------------------------------------
+  asTextAst(content) {
+    if (content == null) return [];
+    if (typeof content === "string") return [{ type: "text", text: content }];
+    return content;
+  }
+  cellContentToHtml(blocks) {
+    if (blocks.length === 0) return "";
+    if (blocks.length === 1 && blocks[0].type === "paragraph") {
+      return this.inlineToHtml(blocks[0].content ?? []);
+    }
+    return blocks.map((b) => this.blockToHtml(b)).join("");
+  }
+  blockToHtml(node) {
+    switch (node.type) {
+      case "paragraph":
+        return `<p>${this.inlineToHtml(node.content ?? [])}</p>`;
+      case "bulletList":
+      case "noBulletList":
+      case "orderedList":
+      case "orderedListRoman":
+      case "orderedListRomanLower":
+      case "letteredList":
+      case "letteredListLower":
+      case "taskList":
+        return this.listToHtml(node);
+      case "image":
+      case "imageInline":
+        return this.imageToHtml(node);
+      default:
+        return this.inlineToHtml([node]);
+    }
+  }
+  inlineToHtml(nodes) {
+    return nodes.map((n) => this.inlineNodeToHtml(n)).join("");
+  }
+  inlineNodeToHtml(node) {
+    if (node.type === "hardBreak") return "<br>";
+    if (node.type === "image" || node.type === "imageInline") return this.imageToHtml(node);
+    if (node.type === "text") {
+      return this.wrapMarks(this.escapeText(node.text ?? ""), node.marks);
+    }
+    if (node.content) return this.inlineToHtml(node.content);
+    return this.escapeText(node.text ?? "");
+  }
+  wrapMarks(text, marks) {
+    if (!marks || marks.length === 0) return text;
+    let open = "";
+    let close = "";
+    for (const mark of marks) {
+      if (mark.type === "link") {
+        const href = mark.attrs?.href ?? "";
+        open += `<a href="${this.escapeAttr(href)}">`;
+        close = `</a>${close}`;
+      } else {
+        const tag = MARK_TO_TAG[mark.type];
+        if (tag) {
+          open += `<${tag}>`;
+          close = `</${tag}>${close}`;
+        }
+      }
+    }
+    return `${open}${text}${close}`;
+  }
+  // --- lists ----------------------------------------------------------------
+  listToHtml(node) {
+    const { tag, attrs } = this.listTag(node);
+    const items = (node.content ?? []).map((item) => this.listItemToHtml(item, node.type === "taskList")).join("");
+    return `<${tag}${attrs}>${items}</${tag}>`;
+  }
+  listTag(node) {
+    const start = node.attrs?.start;
+    const startAttr = typeof start === "number" && start !== 1 ? ` start="${start}"` : "";
+    switch (node.type) {
+      case "orderedList":
+        return { tag: "ol", attrs: startAttr };
+      case "orderedListRoman":
+        return { tag: "ol", attrs: ` type="I"${startAttr}` };
+      case "orderedListRomanLower":
+        return { tag: "ol", attrs: ` type="i"${startAttr}` };
+      case "letteredList":
+        return { tag: "ol", attrs: ` type="A"${startAttr}` };
+      case "letteredListLower":
+        return { tag: "ol", attrs: ` type="a"${startAttr}` };
+      case "noBulletList":
+        return { tag: "ul", attrs: ' style="list-style:none"' };
+      case "taskList":
+      case "bulletList":
+      default:
+        return { tag: "ul", attrs: "" };
+    }
+  }
+  listItemToHtml(item, task) {
+    const inner = (item.content ?? []).map((b) => {
+      if (b.type === "paragraph") return this.inlineToHtml(b.content ?? []);
+      return this.blockToHtml(b);
+    }).join("");
+    if (task) {
+      const checked = item.attrs?.checked ? " checked" : "";
+      return `<li><input type="checkbox"${checked}>${inner}</li>`;
+    }
+    return `<li>${inner}</li>`;
+  }
+  // --- images ---------------------------------------------------------------
+  imageToHtml(node) {
+    const attrs = node.attrs ?? {};
+    const parts = [];
+    const src = attrs.src;
+    parts.push(`src="${this.escapeAttr(typeof src === "string" ? src : "")}"`);
+    if (typeof attrs.alt === "string") parts.push(`alt="${this.escapeAttr(attrs.alt)}"`);
+    if (typeof attrs.title === "string") parts.push(`title="${this.escapeAttr(attrs.title)}"`);
+    if (attrs.width != null) parts.push(`width="${attrs.width}"`);
+    if (attrs.height != null) parts.push(`height="${attrs.height}"`);
+    if (typeof attrs.class === "string" && attrs.class) {
+      parts.push(`class="${this.escapeAttr(attrs.class)}"`);
+    }
+    return `<img ${parts.join(" ")}>`;
+  }
+  // --- escaping -------------------------------------------------------------
+  escapeText(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  escapeAttr(text) {
+    return this.escapeText(text).replace(/"/g, "&quot;");
+  }
+};
+
+// src/parser/html/HtmlDom.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var IMPLIED_CLOSE = {
+  li: /* @__PURE__ */ new Set(["li"]),
+  td: /* @__PURE__ */ new Set(["td", "th"]),
+  th: /* @__PURE__ */ new Set(["td", "th"]),
+  tr: /* @__PURE__ */ new Set(["td", "th", "tr"]),
+  thead: /* @__PURE__ */ new Set(["td", "th", "tr", "thead", "tbody", "tfoot"]),
+  tbody: /* @__PURE__ */ new Set(["td", "th", "tr", "thead", "tbody", "tfoot"]),
+  tfoot: /* @__PURE__ */ new Set(["td", "th", "tr", "thead", "tbody", "tfoot"]),
+  p: /* @__PURE__ */ new Set(["p"]),
+  option: /* @__PURE__ */ new Set(["option"])
+};
+var TAG_RE = /<(\/)?([a-zA-Z][a-zA-Z0-9-]*)((?:\s+(?:"[^"]*"|'[^']*'|[^<>"'])*)?)(\/)?>/g;
+var ATTR_RE = /([a-zA-Z_:][a-zA-Z0-9:._-]*)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'>]+))?/g;
+function parseAttrs(raw) {
+  const attrs = {};
+  if (!raw) return attrs;
+  ATTR_RE.lastIndex = 0;
+  let m;
+  while ((m = ATTR_RE.exec(raw)) !== null) {
+    const name = m[1].toLowerCase();
+    let value = m[2] ?? "";
+    if (value.length >= 2 && (value[0] === '"' || value[0] === "'")) {
+      value = value.slice(1, -1);
+    }
+    attrs[name] = value;
+  }
+  return attrs;
+}
+function stripNonContent(html) {
+  return html.replace(/<!--[\s\S]*?-->/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "").replace(/<!doctype[^>]*>/gi, "").replace(/<script\b[\s\S]*?<\/script>/gi, "").replace(/<style\b[\s\S]*?<\/style>/gi, "");
+}
+function tokenize(html) {
+  const tokens = [];
+  const clean = stripNonContent(html);
+  TAG_RE.lastIndex = 0;
+  let lastIndex = 0;
+  let m;
+  while ((m = TAG_RE.exec(clean)) !== null) {
+    if (m.index > lastIndex) {
+      tokens.push({ kind: "text", text: clean.slice(lastIndex, m.index) });
+    }
+    lastIndex = TAG_RE.lastIndex;
+    const isClose = m[1] === "/";
+    const name = m[2].toLowerCase();
+    if (isClose) {
+      tokens.push({ kind: "close", name });
+    } else {
+      tokens.push({
+        kind: "open",
+        name,
+        attrs: parseAttrs(m[3]),
+        selfClose: m[4] === "/"
+      });
+    }
+  }
+  if (lastIndex < clean.length) {
+    tokens.push({ kind: "text", text: clean.slice(lastIndex) });
+  }
+  return tokens;
+}
+function parseHtml(html) {
+  const root = { type: "element", name: "#root", attrs: {}, children: [] };
+  const stack = [root];
+  const top = () => stack[stack.length - 1];
+  for (const token of tokenize(html)) {
+    if (token.kind === "text") {
+      if (token.text) top().children.push({ type: "text", value: token.text });
+      continue;
+    }
+    if (token.kind === "open") {
+      const name = token.name;
+      const closes = IMPLIED_CLOSE[name];
+      if (closes) {
+        while (stack.length > 1 && closes.has(top().name)) stack.pop();
+      }
+      const el = {
+        type: "element",
+        name,
+        attrs: token.attrs ?? {},
+        children: []
+      };
+      top().children.push(el);
+      if (!token.selfClose && !VOID_ELEMENTS.has(name)) {
+        stack.push(el);
+      }
+      continue;
+    }
+    for (let i = stack.length - 1; i > 0; i--) {
+      if (stack[i].name === token.name) {
+        stack.length = i;
+        break;
+      }
+    }
+  }
+  return root.children;
+}
+function childElements(el, names) {
+  return el.children.filter((c) => c.type === "element" && names.has(c.name));
+}
+
+// src/parser/html/HtmlTableParser.ts
+var MARK_TAGS = {
+  b: "bold",
+  strong: "bold",
+  i: "italic",
+  em: "italic",
+  sup: "superscript",
+  sub: "subscript",
+  s: "strike",
+  strike: "strike",
+  del: "del",
+  ins: "ins",
+  u: "underline",
+  mark: "highlight",
+  code: "code"
+};
+var SECTION_TAGS = /* @__PURE__ */ new Set(["thead", "tbody", "tfoot"]);
+var ROW_TAGS = /* @__PURE__ */ new Set(["tr"]);
+var CELL_TAGS = /* @__PURE__ */ new Set(["td", "th"]);
+var LI_TAGS = /* @__PURE__ */ new Set(["li"]);
+var VALID_SCOPES = /* @__PURE__ */ new Set(["row", "col", "rowgroup", "colgroup"]);
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: "\xA0"
+};
+function decodeEntities(text) {
+  return text.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (whole, body) => {
+    if (body[0] === "#") {
+      const code = body[1] === "x" || body[1] === "X" ? Number.parseInt(body.slice(2), 16) : Number.parseInt(body.slice(1), 10);
+      if (Number.isFinite(code) && code >= 0 && code <= 1114111) {
+        try {
+          return String.fromCodePoint(code);
+        } catch {
+          return whole;
+        }
+      }
+      return whole;
+    }
+    return NAMED_ENTITIES[body] ?? whole;
+  });
+}
+function intAttr(value) {
+  if (value == null) return void 0;
+  const n = Number.parseInt(value, 10);
+  return Number.isInteger(n) ? n : void 0;
+}
+function isElement(node) {
+  return node.type === "element";
+}
+var HtmlTableParser2 = class {
+  constructor() {
+    __publicField(this, "keepUnknownTags", false);
+  }
+  /**
+   * Parse an HTML string and return one table bit per top-level `<table>`.
+   */
+  parse(html, options) {
+    this.keepUnknownTags = options?.keepUnknownTags ?? false;
+    const tableFormat = options?.tableFormat ?? "table-extended";
+    const onWarning = options?.onWarning;
+    const tables = this.collectTopLevelTables(parseHtml(html));
+    const bits = [];
+    for (const table of tables) {
+      const bit = this.tableToBit(table, tableFormat, onWarning);
+      if (bit) bits.push(bit);
+    }
+    return bits;
+  }
+  // --- table extraction -----------------------------------------------------
+  /** Collect every `<table>` element, NOT descending into nested tables. */
+  collectTopLevelTables(nodes) {
+    const tables = [];
+    const visit = (node) => {
+      if (!isElement(node)) return;
+      if (node.name === "table") {
+        tables.push(node);
+        return;
+      }
+      node.children.forEach(visit);
+    };
+    nodes.forEach(visit);
+    return tables;
+  }
+  tableToBit(table, tableFormat, onWarning) {
+    const header = [];
+    const body = [];
+    const footer = [];
+    let caption;
+    for (const child of table.children) {
+      if (!isElement(child)) continue;
+      if (child.name === "caption") {
+        const capContent = this.inlineNodes(child.children, []);
+        const trimmed = this.trimInline(capContent);
+        if (trimmed.length > 0) caption = trimmed;
+      } else if (SECTION_TAGS.has(child.name)) {
+        const target = child.name === "thead" ? header : child.name === "tfoot" ? footer : body;
+        for (const tr of childElements(child, ROW_TAGS)) {
+          target.push(this.rowToCells(tr));
+        }
+      } else if (ROW_TAGS.has(child.name)) {
+        body.push(this.rowToCells(child));
+      }
+    }
+    if (header.length === 0 && body.length === 0 && footer.length === 0) {
+      return void 0;
+    }
+    const tableExtended = {};
+    if (header.length > 0) tableExtended.header = { rows: header };
+    if (body.length > 0) tableExtended.body = { rows: body };
+    if (footer.length > 0) tableExtended.footer = { rows: footer };
+    let tableData = tableExtended;
+    if (tableFormat === "table") {
+      if (this.isLossyAsBasic(tableExtended)) {
+        onWarning?.(
+          "Converting an HTML table to [.table] loses rowspan/colspan/scope and multi-section structure; use --tableFormat table-extended to preserve them."
+        );
+      }
+      tableData = convertExtendedToBasicTableFormat(tableExtended);
+    }
+    const bit = {
+      type: tableFormat,
+      format: "bitmark++",
+      table: tableData
+    };
+    if (caption) bit.caption = caption;
+    return bit;
+  }
+  rowToCells(tr) {
+    const cells = [];
+    for (const cell of childElements(tr, CELL_TAGS)) {
+      cells.push(this.cellToJson(cell));
+    }
+    return { cells };
+  }
+  cellToJson(cell) {
+    const json = {
+      content: this.blockNodes(cell.children)
+    };
+    if (cell.name === "th") json.title = true;
+    const rowspan = intAttr(cell.attrs.rowspan);
+    if (rowspan != null && rowspan >= 2) json.rowspan = rowspan;
+    const colspan = intAttr(cell.attrs.colspan);
+    if (colspan != null && colspan >= 2) json.colspan = colspan;
+    const scope = cell.attrs.scope?.toLowerCase();
+    if (scope && VALID_SCOPES.has(scope)) {
+      json.scope = scope;
+    }
+    const width = this.widthFromCell(cell);
+    if (width != null) json.colwidth = width;
+    return json;
+  }
+  widthFromCell(cell) {
+    const attrWidth = intAttr(cell.attrs.width);
+    if (attrWidth != null && attrWidth > 0) return attrWidth;
+    const style = cell.attrs.style;
+    if (style) {
+      const m = style.match(/width\s*:\s*(\d+)\s*px/i);
+      if (m) {
+        const n = Number.parseInt(m[1], 10);
+        if (Number.isInteger(n) && n > 0) return n;
+      }
+    }
+    return void 0;
+  }
+  isLossyAsBasic(table) {
+    if (table.footer) return true;
+    if (table.header && table.header.rows.length > 1) return true;
+    const sections = [table.header, table.body, table.footer];
+    for (const section of sections) {
+      if (!section) continue;
+      for (const row of section.rows) {
+        for (const cell of row.cells) {
+          if (cell.rowspan || cell.colspan || cell.scope) return true;
+        }
+      }
+    }
+    return false;
+  }
+  // --- content conversion (HTML -> TextAst) ---------------------------------
+  /**
+   * Convert a cell/li's child nodes into block-level TextAst nodes (paragraphs, lists, images).
+   */
+  blockNodes(nodes) {
+    const blocks = [];
+    let inline = [];
+    const flush = () => {
+      const trimmed = this.trimInline(inline);
+      inline = [];
+      if (trimmed.length === 0) return;
+      if (trimmed.length === 1 && trimmed[0].type === "imageInline") {
+        blocks.push({ ...trimmed[0], type: "image" });
+      } else {
+        blocks.push({ type: "paragraph", content: trimmed, attrs: {} });
+      }
+    };
+    for (const node of nodes) {
+      if (!isElement(node)) {
+        inline.push(...this.inlineText(node.value, []));
+        continue;
+      }
+      const name = node.name;
+      if (name === "p") {
+        flush();
+        const content = this.trimInline(this.inlineNodes(node.children, []));
+        if (content.length > 0) {
+          blocks.push({ type: "paragraph", content, attrs: {} });
+        }
+      } else if (this.isListTag(name)) {
+        flush();
+        const list = this.listNode(node);
+        if (list) blocks.push(list);
+      } else {
+        inline.push(...this.inlineFromElement(node, []));
+      }
+    }
+    flush();
+    return blocks;
+  }
+  /** Convert child nodes to a flat list of inline TextNodes, applying the given marks. */
+  inlineNodes(nodes, marks) {
+    const out = [];
+    for (const node of nodes) {
+      if (!isElement(node)) {
+        out.push(...this.inlineText(node.value, marks));
+      } else {
+        out.push(...this.inlineFromElement(node, marks));
+      }
+    }
+    return out;
+  }
+  inlineFromElement(el, marks) {
+    const name = el.name;
+    if (name === "br") {
+      return [{ type: "hardBreak" }];
+    }
+    if (name === "img") {
+      return [this.imageNode(el, true)];
+    }
+    const markType = MARK_TAGS[name];
+    if (markType) {
+      return this.inlineNodes(el.children, [...marks, { type: markType }]);
+    }
+    if (name === "a") {
+      const linkMark = {
+        type: "link",
+        attrs: {
+          href: el.attrs.href ?? "",
+          ...el.attrs.target ? { target: el.attrs.target } : {}
+        }
+      };
+      return this.inlineNodes(el.children, [...marks, linkMark]);
+    }
+    if (this.keepUnknownTags) {
+      const open = this.serializeOpenTag(el);
+      const close = `</${name}>`;
+      return [
+        ...this.inlineText(open, marks),
+        ...this.inlineNodes(el.children, marks),
+        ...this.inlineText(close, marks)
+      ];
+    }
+    return this.inlineNodes(el.children, marks);
+  }
+  inlineText(raw, marks) {
+    const text = decodeEntities(raw).replace(/\s+/g, " ");
+    if (text === "") return [];
+    const node = { text, type: "text" };
+    if (marks.length > 0) node.marks = marks.map((m) => ({ ...m }));
+    return [node];
+  }
+  serializeOpenTag(el) {
+    const attrs = Object.entries(el.attrs).map(([k, v]) => v === "" ? ` ${k}` : ` ${k}="${v}"`).join("");
+    return `<${el.name}${attrs}>`;
+  }
+  // --- lists ----------------------------------------------------------------
+  isListTag(name) {
+    return name === "ul" || name === "ol";
+  }
+  listNode(el) {
+    const items = childElements(el, LI_TAGS);
+    if (items.length === 0) return void 0;
+    const isTask = el.name === "ul" && items.some((li) => {
+      const firstEl = li.children.find(isElement);
+      return firstEl?.name === "input" && firstEl.attrs.type?.toLowerCase() === "checkbox";
+    });
+    if (isTask) {
+      return {
+        type: "taskList",
+        content: items.map((li) => this.taskItemNode(li))
+      };
+    }
+    const type = this.listType(el);
+    const node = {
+      type,
+      content: items.map((li) => this.listItemNode(li))
+    };
+    if (el.name === "ol") {
+      const start = intAttr(el.attrs.start);
+      if (start != null) {
+        node.attrs = { start };
+      }
+    }
+    return node;
+  }
+  listType(el) {
+    if (el.name === "ol") {
+      switch (el.attrs.type) {
+        case "i":
+          return "orderedListRomanLower";
+        case "I":
+          return "orderedListRoman";
+        case "a":
+          return "letteredListLower";
+        case "A":
+          return "letteredList";
+        default:
+          return "orderedList";
+      }
+    }
+    const style = el.attrs.style ?? "";
+    if (/list-style(-type)?\s*:\s*none/i.test(style)) return "noBulletList";
+    return "bulletList";
+  }
+  listItemNode(li) {
+    let content = this.blockNodes(li.children);
+    if (content.length === 0) {
+      content = [{ type: "paragraph", content: [], attrs: {} }];
+    }
+    return { type: "listItem", content };
+  }
+  taskItemNode(li) {
+    const checkbox = li.children.find(
+      (c) => isElement(c) && c.name === "input" && c.attrs.type?.toLowerCase() === "checkbox"
+    );
+    const checked = checkbox ? "checked" in checkbox.attrs : false;
+    const rest = li.children.filter((c) => c !== checkbox);
+    let content = this.blockNodes(rest);
+    if (content.length === 0) {
+      content = [{ type: "paragraph", content: [], attrs: {} }];
+    }
+    return { type: "taskItem", attrs: { checked }, content };
+  }
+  // --- images ---------------------------------------------------------------
+  imageNode(el, inline) {
+    const attrs = { src: el.attrs.src ?? "" };
+    attrs.alt = el.attrs.alt ?? null;
+    attrs.title = el.attrs.title ?? null;
+    const width = intAttr(el.attrs.width);
+    if (width != null) attrs.width = width;
+    const height = intAttr(el.attrs.height);
+    if (height != null) attrs.height = height;
+    if (el.attrs.class) attrs.class = el.attrs.class;
+    return { type: inline ? "imageInline" : "image", attrs };
+  }
+  // --- whitespace -----------------------------------------------------------
+  /** Trim leading/trailing whitespace from inline content (edges only). */
+  trimInline(nodes) {
+    const out = nodes.slice();
+    const isWs = (n) => n.type === "text" && /^\s*$/.test(n.text ?? "");
+    while (out.length > 0 && isWs(out[0])) out.shift();
+    if (out.length > 0 && out[0].type === "text") {
+      out[0] = { ...out[0], text: (out[0].text ?? "").replace(/^\s+/, "") };
+    }
+    while (out.length > 0 && isWs(out[out.length - 1])) out.pop();
+    if (out.length > 0 && out[out.length - 1].type === "text") {
+      const last = out.length - 1;
+      out[last] = { ...out[last], text: (out[last].text ?? "").replace(/\s+$/, "") };
+    }
+    return out.filter((n) => !(n.type === "text" && n.text === ""));
+  }
+};
+
 // src/index.ts
 init();
 // Annotate the CommonJS export names for ESM import in node:
@@ -41274,6 +44002,8 @@ init();
   BoundingBoxIndex,
   Builder,
   CardSetVersion,
+  HtmlTableGenerator,
+  HtmlTableParser,
   InfoFormat,
   InfoType,
   Input,